<?xml version="1.0" encoding="UTF-8"?>
<!--  Copyright (C) 2007 The Android Open Source Project

     Licensed under the Apache License, Version 2.0 (the "License");
     you may not use this file except in compliance with the License.
     You may obtain a copy of the License at

          http://www.apache.org/licenses/LICENSE-2.0

     Unless required by applicable law or agreed to in writing, software
     distributed under the License is distributed on an "AS IS" BASIS,
     WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     See the License for the specific language governing permissions and
     limitations under the License.
 -->

<resources xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
    <string name="yes" msgid="1999566976857398962">"Sí"</string>
    <string name="no" msgid="5541738710521607130">"No"</string>
    <string name="create" msgid="986997212165228751">"Crear"</string>
    <string name="allow" msgid="3763244945363657722">"Permitir"</string>
    <string name="deny" msgid="7326117222944479942">"Rechazar"</string>
    <string name="confirmation_turn_on" msgid="2979094011928347665">"Activar"</string>
    <string name="device_info_default" msgid="1406619232867343310">"Desconocido"</string>
    <plurals name="show_dev_countdown" formatted="false" msgid="1646187747875476269">
      <item quantity="other">Estás a <xliff:g id="STEP_COUNT_1">%1$d</xliff:g> pasos de ser desarrollador.</item>
      <item quantity="one">Estás a <xliff:g id="STEP_COUNT_0">%1$d</xliff:g> paso de ser desarrollador.</item>
    </plurals>
    <string name="show_dev_on" msgid="2840850085134853754">"¡Ya eres desarrollador!"</string>
    <string name="show_dev_already" msgid="7041756429707644630">"No es necesario, ya eres programador."</string>
    <string name="dev_settings_disabled_warning" msgid="6971867026249671244">"Primero habilita las opciones para programador."</string>
    <string name="header_category_wireless_networks" msgid="303445626075235229">"Conexiones inalámbricas y redes"</string>
    <string name="header_category_system" msgid="1665516346845259058">"Sistema"</string>
    <string name="radioInfo_service_in" msgid="9088637745836646271">"En servicio"</string>
    <string name="radioInfo_service_out" msgid="1868347333892403287">"Fuera de servicio"</string>
    <string name="radioInfo_service_emergency" msgid="6838935881091760942">"Solo emergencia"</string>
    <string name="radioInfo_service_off" msgid="6184928420860868571">"Radio desactivada"</string>
    <string name="radioInfo_roaming_in" msgid="8892550453644088692">"Roaming"</string>
    <string name="radioInfo_roaming_not" msgid="3137594549464975054">"Sin roaming"</string>
    <string name="radioInfo_data_disconnected" msgid="362604130117666924">"Desconectado"</string>
    <string name="radioInfo_data_connecting" msgid="7280819598028917888">"Conectando"</string>
    <string name="radioInfo_data_connected" msgid="8816467971633020141">"Conectado"</string>
    <string name="radioInfo_data_suspended" msgid="2001254415431299603">"Suspendido"</string>
    <string name="radioInfo_unknown" msgid="2892562356748600367">"Desconocida"</string>
    <string name="sdcard_unmount" product="nosdcard" msgid="1816306320988638382">"Desmontar almacenamiento USB"</string>
    <string name="sdcard_unmount" product="default" msgid="8078570285871053815">"Desmontar la tarjeta SD"</string>
    <string name="sdcard_format" product="nosdcard" msgid="3248760426252305366">"Eliminar almacenamiento USB"</string>
    <string name="sdcard_format" product="default" msgid="3676635435136326182">"Borrar tarjeta SD"</string>
    <string name="preview_pager_content_description" msgid="3762247188224576303">"Vista previa"</string>
    <string name="preview_page_indicator_content_description" msgid="2790254666634885865">"Página <xliff:g id="CURRENT_PAGE">%1$d</xliff:g> de <xliff:g id="NUM_PAGES">%2$d</xliff:g> de la vista previa"</string>
    <string name="font_size_summary" msgid="1296835853522566260">"Aumenta o reduce el tamaño del texto en pantalla."</string>
    <string name="font_size_make_smaller_desc" msgid="4978038055549590140">"Reducir el tamaño"</string>
    <string name="font_size_make_larger_desc" msgid="5583046033381722247">"Aumentar el tamaño"</string>
    <string name="font_size_preview_text_headline" msgid="1173103737980511652">"Texto de muestra"</string>
    <string name="font_size_preview_text_title" msgid="6363561029914452382">"El maravilloso mago de Oz"</string>
    <string name="font_size_preview_text_subtitle" msgid="5806349524325544614">"Capítulo 11: La maravillosa Ciudad Esmeralda de Oz"</string>
    <string name="font_size_preview_text_body" msgid="3323732544011097199">"Aunque contaban con la protección de los lentes verdes, en un primer momento, Dorothy y sus amigos se sintieron encandilados por el brillo de la maravillosa ciudad. Las calles estaban bordeadas por hermosas casas de mármol verde y adornadas con esmeraldas brillantes. Caminaron por pavimento del mismo mármol verde y, donde se unían las calles, había filas de esmeraldas juntas que brillaban con el sol. Los vidrios de las ventanas eran verdes y hasta el cielo sobre la ciudad y los rayos del sol tenían un matiz verde. \n\nHabía muchas personas caminando: hombres, mujeres y niños, todos vestidos de verde y de piel verdosa. Miraban a Dorothy y a sus extraños acompañantes con asombro. Los niños corrían despavoridos detrás de sus madres cuando veían al León, pero nadie les hablaba. Había muchas tiendas en la calle, y Dorothy vio que todo lo que vendían era verde: caramelos verdes, palomitas de maíz verdes, zapatos verdes, sombreros verdes y ropa verde de todo tipo. En una tienda, un hombre vendía limonada verde y Dorothy observó que los niños que la compraban pagaban con monedas verdes. \n\nParecía no haber caballos ni animales de ningún tipo. Los hombres cargaban objetos en pequeñas carretas verdes que llevaban delante de ellos. Todos parecían felices, contentos y afortunados."</string>
    <string name="font_size_save" msgid="206892409190870726">"Aceptar"</string>
    <string name="sdcard_setting" product="nosdcard" msgid="6071836464978826249">"Almacenamiento USB"</string>
    <string name="sdcard_setting" product="default" msgid="3713462184783824923">"Tarjeta SD"</string>
    <string name="bluetooth" msgid="8898478620943459654">"Bluetooth"</string>
    <string name="bluetooth_is_discoverable" msgid="4798961627677790935">"Visible para todos los dispositivos Bluetooth cercanos (<xliff:g id="DISCOVERABLE_TIME_PERIOD">%1$s</xliff:g>)"</string>
    <string name="bluetooth_is_discoverable_always" msgid="8122823110652921674">"Visible para todos los dispositivos Bluetooth cercanos"</string>
    <string name="bluetooth_not_visible_to_other_devices" msgid="6181960579190879601">"No visible para otros dispositivos Bluetooth"</string>
    <string name="bluetooth_only_visible_to_paired_devices" msgid="3574936359739213455">"Solo visible para los dispositivos sincronizados"</string>
    <string name="bluetooth_visibility_timeout" msgid="7611781967900196353">"Definir visibilidad"</string>
    <string name="bluetooth_lock_voice_dialing" msgid="7405038248936935186">"Bloquear marcación por voz"</string>
    <string name="bluetooth_lock_voice_dialing_summary" msgid="4959591522483403402">"Impedir el uso de Bluetooth del dispositivo cuando la pantalla esté bloqueada."</string>
    <string name="bluetooth_devices" msgid="1063177983261608277">"Dispositivos Bluetooth"</string>
    <string name="bluetooth_device_name" msgid="1294669733490268384">"Nombre del dispositivo"</string>
    <string name="bluetooth_device_details" msgid="630702184344217832">"Configuración del dispositivo"</string>
    <string name="bluetooth_profile_details" msgid="1269419918127093325">"Configuración del perfil"</string>
    <string name="bluetooth_name_not_set" msgid="4654357917928126208">"No se ha establecido ningún nombre; se utiliza el nombre de cuenta"</string>
    <string name="bluetooth_scan_for_devices" msgid="8143654526358934069">"Buscar dispositivos"</string>
    <string name="bluetooth_rename_device" msgid="4219655243836021443">"Cambiar nombre del dispositivo"</string>
    <string name="bluetooth_rename_button" msgid="9162500408570289545">"Cambiar nombre"</string>
    <string name="bluetooth_disconnect_title" msgid="4581951246357823044">"¿Desconectar dispositivo?"</string>
    <string name="bluetooth_disconnect_all_profiles" product="default" msgid="1934297101665686854">"Tu teléfono se desconectará de <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="bluetooth_disconnect_all_profiles" product="tablet" msgid="336622948210457991">"Tu tablet se desconectará de <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="bluetooth_disconnect_all_profiles" product="device" msgid="6944790936166852428">"Tu dispositivo se desconectará de <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="bluetooth_disconnect_dialog_ok" msgid="4173740094381092185">"Desconectar"</string>
    <string name="bluetooth_empty_list_user_restricted" msgid="909734990821975673">"No tienes permiso para cambiar la configuración de Bluetooth."</string>
    <string name="bluetooth_pairing_pref_title" msgid="3497193027590444598">"Vincular dispositivo nuevo"</string>
    <string name="keywords_add_bt_device" msgid="4533191164203174011">"Bluetooth"</string>
    <string name="bluetooth_is_visible_message" msgid="3811631869768157387">"Los dispositivos cercanos podrán ver tu <xliff:g id="DEVICE_NAME">%1$s</xliff:g> si está abierta la configuración de Bluetooth."</string>
    <string name="bluetooth_footer_mac_message" product="default" msgid="4782330594323261630">"Dirección Bluetooth del teléfono: <xliff:g id="BLUETOOTH_MAC_ADDRESS">%1$s</xliff:g>"</string>
    <string name="bluetooth_footer_mac_message" product="tablet" msgid="1257226691967432025">"Dirección Bluetooth de la tablet: <xliff:g id="BLUETOOTH_MAC_ADDRESS">%1$s</xliff:g>"</string>
    <string name="bluetooth_footer_mac_message" product="device" msgid="2863536947810007600">"Dirección Bluetooth del dispositivo: <xliff:g id="BLUETOOTH_MAC_ADDRESS">%1$s</xliff:g>"</string>
    <string name="bluetooth_is_disconnect_question" msgid="777406775955421784">"¿Desconectar <xliff:g id="DEVICE_NAME">%1$s</xliff:g>?"</string>
    <string name="bluetooth_broadcasting" msgid="6379176741690311973">"Transmisión"</string>
    <string name="bluetooth_device" msgid="2217973503732544291">"Dispositivo Bluetooth sin nombre"</string>
    <string name="progress_scanning" msgid="2564746192843011826">"Buscando"</string>
    <string name="bluetooth_no_devices_found" msgid="7704539337219953182">"No se encontraron dispositivos Bluetooth cercanos."</string>
    <string name="bluetooth_notif_ticker" msgid="209515545257862858">"Solicitud de vinculación de Bluetooth"</string>
    <string name="bluetooth_notif_title" msgid="1196532269131348647">"Vinculando solicitud"</string>
    <string name="bluetooth_notif_message" msgid="5584717784198086653">"Presiona para realizar una sincronización con <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="bluetooth_show_received_files" msgid="685424727760622632">"Archivos recibidos"</string>
    <string name="bluetooth_show_files_received_via_bluetooth" msgid="7097860463458492953">"Archivos recibidos (Bluetooth)"</string>
    <string name="bluetooth_devices_card_off_title" msgid="1320149821945129127">"Bluetooth desactivado"</string>
    <string name="bluetooth_devices_card_off_summary" msgid="2276527382891105858">"Presiona para activarlo"</string>
    <string name="device_picker" msgid="2427027896389445414">"Elegir dispositivo"</string>
    <string name="bluetooth_ask_enablement" msgid="1529030199895339199">"<xliff:g id="APP_NAME">%1$s</xliff:g> quiere activar la conexión Bluetooth"</string>
    <string name="bluetooth_ask_disablement" msgid="1879788777942714761">"<xliff:g id="APP_NAME">%1$s</xliff:g> quiere desactivar la conexión Bluetooth"</string>
    <string name="bluetooth_ask_enablement_no_name" msgid="5091401961637405417">"Una app quiere activar la conexión Bluetooth"</string>
    <string name="bluetooth_ask_disablement_no_name" msgid="382299750909188822">"Una app quiere desactivar la conexión Bluetooth"</string>
    <string name="bluetooth_ask_discovery" product="tablet" msgid="1273405567801929487">"<xliff:g id="APP_NAME">%1$s</xliff:g> quiere que tu tablet sea visible para otros dispositivos Bluetooth durante <xliff:g id="TIMEOUT">%2$d</xliff:g> segundos."</string>
    <string name="bluetooth_ask_discovery" product="default" msgid="7013223328571883275">"<xliff:g id="APP_NAME">%1$s</xliff:g> quiere que tu teléfono sea visible para otros dispositivos Bluetooth durante <xliff:g id="TIMEOUT">%2$d</xliff:g> segundos."</string>
    <string name="bluetooth_ask_discovery_no_name" product="tablet" msgid="3266007454914144057">"Una app quiere que tu tablet sea visible para otros dispositivos Bluetooth durante <xliff:g id="TIMEOUT">%1$d</xliff:g> segundos."</string>
    <string name="bluetooth_ask_discovery_no_name" product="default" msgid="7989444746980501116">"Una app quiere que tu teléfono sea visible para otros dispositivos Bluetooth durante <xliff:g id="TIMEOUT">%1$d</xliff:g> segundos."</string>
    <string name="bluetooth_ask_lasting_discovery" product="tablet" msgid="6482084870735107773">"<xliff:g id="APP_NAME">%1$s</xliff:g> quiere que tu tablet sea visible para otros dispositivos Bluetooth. Puedes cambiar esta opción más tarde en la configuración de Bluetooth."</string>
    <string name="bluetooth_ask_lasting_discovery" product="default" msgid="2352494279465502950">"<xliff:g id="APP_NAME">%1$s</xliff:g> quiere que tu teléfono sea visible para otros dispositivos Bluetooth. Puedes cambiar esta opción más tarde en la configuración de Bluetooth."</string>
    <string name="bluetooth_ask_lasting_discovery_no_name" product="tablet" msgid="2732992604509910896">"Una app quiere que tu tablet sea visible para otros dispositivos Bluetooth. Puedes cambiar esta opción más tarde en la configuración de Bluetooth."</string>
    <string name="bluetooth_ask_lasting_discovery_no_name" product="default" msgid="356982103612920264">"Una app quiere que tu teléfono sea visible para otros dispositivos Bluetooth. Puedes cambiar esta opción más tarde en la configuración de Bluetooth."</string>
    <string name="bluetooth_ask_enablement_and_discovery" product="tablet" msgid="6103655179509599427">"<xliff:g id="APP_NAME">%1$s</xliff:g> quiere activar la conexión Bluetooth y que tu tablet sea visible para otros dispositivos durante <xliff:g id="TIMEOUT">%2$d</xliff:g> segundos."</string>
    <string name="bluetooth_ask_enablement_and_discovery" product="default" msgid="934276632311449337">"<xliff:g id="APP_NAME">%1$s</xliff:g> quiere activar la conexión Bluetooth y que tu teléfono sea visible para otros dispositivos durante <xliff:g id="TIMEOUT">%2$d</xliff:g> segundos."</string>
    <string name="bluetooth_ask_enablement_and_discovery_no_name" product="tablet" msgid="1284048348024444485">"Una app quiere activar la conexión Bluetooth y que tu tablet sea visible para otros dispositivos durante <xliff:g id="TIMEOUT">%1$d</xliff:g> segundos."</string>
    <string name="bluetooth_ask_enablement_and_discovery_no_name" product="default" msgid="2661614145022629454">"Una app quiere activar la conexión Bluetooth y que tu teléfono sea visible para otros dispositivos durante <xliff:g id="TIMEOUT">%1$d</xliff:g> segundos."</string>
    <string name="bluetooth_ask_enablement_and_lasting_discovery" product="tablet" msgid="8588317955400593623">"<xliff:g id="APP_NAME">%1$s</xliff:g> quiere activar la conexión Bluetooth y que tu tablet sea visible para otros dispositivos. Puedes cambiar esta opción más tarde en la configuración de Bluetooth."</string>
    <string name="bluetooth_ask_enablement_and_lasting_discovery" product="default" msgid="4047444317445386579">"<xliff:g id="APP_NAME">%1$s</xliff:g> quiere activar la conexión Bluetooth y que tu teléfono sea visible para otros dispositivos. Puedes cambiar esta opción más tarde en la configuración de Bluetooth."</string>
    <string name="bluetooth_ask_enablement_and_lasting_discovery_no_name" product="tablet" msgid="4922952478824372605">"Una app quiere activar la conexión Bluetooth y que tu tablet sea visible para otros dispositivos. Puedes cambiar esta opción más tarde en la configuración de Bluetooth."</string>
    <string name="bluetooth_ask_enablement_and_lasting_discovery_no_name" product="default" msgid="1381582950049639439">"Una app quiere activar la conexión Bluetooth y que tu teléfono sea visible para otros dispositivos. Puedes cambiar esta opción más tarde en la configuración de Bluetooth."</string>
    <string name="bluetooth_turning_on" msgid="3842613808709024730">"Activando Bluetooth..."</string>
    <string name="bluetooth_turning_off" msgid="7406309124247701148">"¿Desactivar Bluetooth?"</string>
    <string name="bluetooth_connection_permission_request" msgid="8793131019383198861">"Solicitud para establecer conexión de Bluetooth"</string>
    <string name="bluetooth_connection_notif_message" msgid="6087344980352898209">"Presiona para conectarte a \"<xliff:g id="DEVICE_NAME">%1$s</xliff:g>\"."</string>
    <string name="bluetooth_connection_dialog_text" msgid="2537152772549874391">"¿Deseas conectarte a “<xliff:g id="DEVICE_NAME">%1$s</xliff:g>”?"</string>
    <string name="bluetooth_phonebook_request" msgid="1085102844577089889">"Solicitud de acceso a agenda telefónica"</string>
    <string name="bluetooth_pb_acceptance_dialog_text" msgid="7153531868579789993">"<xliff:g id="DEVICE_NAME_0">%1$s</xliff:g> quiere acceder a tu historial de llamadas y tus contactos. ¿Quieres otorgar acceso a <xliff:g id="DEVICE_NAME_1">%2$s</xliff:g>?"</string>
    <string name="bluetooth_remember_choice" msgid="173821849670438110">"No volver a preguntar"</string>
    <string name="bluetooth_pb_remember_choice" msgid="2080511174185036562">"No volver a preguntar"</string>
    <string name="bluetooth_map_request" msgid="8664081227240707479">"Solicitud de acceso a mensajes"</string>
    <string name="bluetooth_map_acceptance_dialog_text" msgid="2647611490952377156">"%1$s quiere acceder a tus mensajes. ¿Quieres permitir el acceso a %2$s?"</string>
    <string name="bluetooth_sap_request" msgid="473439406287008397">"Solicitud de acceso a SIM"</string>
    <string name="bluetooth_sap_acceptance_dialog_text" msgid="2849083276356078655">"El dispositivo <xliff:g id="DEVICE_NAME_0">%1$s</xliff:g> quiere acceder a tu tarjeta SIM. Al otorgar el acceso a la tarjeta SIM, inhabilitarás la conectividad de datos en el dispositivo por el tiempo que dure la conexión. Otorga el acceso al dispositivo <xliff:g id="DEVICE_NAME_1">%2$s?</xliff:g>."</string>
    <string name="bluetooth_device_name_summary" msgid="8678342689845439583">"Visible como \"<xliff:g id="DEVICE_NAME">^1</xliff:g>\" para otros dispositivos"</string>
    <string name="bluetooth_off_footer" msgid="76578735660216295">"Activa el Bluetooth para establecer conexión con otros dispositivos."</string>
    <string name="bluetooth_paired_device_title" msgid="3240639218362342026">"Tus dispositivos"</string>
    <string name="bluetooth_pairing_page_title" msgid="3403981358823707692">"Vincular dispositivo nuevo"</string>
    <string name="bluetooth_pref_summary" product="tablet" msgid="3506962706611366830">"Permite que la tablet se comunique con dispositivos Bluetooth cercanos"</string>
    <string name="bluetooth_pref_summary" product="device" msgid="2192027516577675587">"Permite que el dispositivo se comunique con dispositivos Bluetooth cercanos"</string>
    <string name="bluetooth_pref_summary" product="default" msgid="768958961865499804">"Permite que el teléfono se comunique con dispositivos Bluetooth cercanos"</string>
    <string name="bluetooth_disable_a2dp_hw_offload" msgid="5942913792817797541">"No aligeramiento hardware Bluetooth A2DP"</string>
    <string name="bluetooth_disable_a2dp_hw_offload_dialog_title" msgid="8610420176339657720">"¿Reiniciar?"</string>
    <string name="bluetooth_disable_a2dp_hw_offload_dialog_message" msgid="8333029144800835996">"Debes reiniciar el dispositivo para cambiar esta opción."</string>
    <string name="bluetooth_disable_a2dp_hw_offload_dialog_confirm" msgid="3488695418187553566">"Reiniciar"</string>
    <string name="bluetooth_disable_a2dp_hw_offload_dialog_cancel" msgid="4930826928585464191">"Cancelar"</string>
    <string name="connected_device_media_device_title" msgid="3783388247594566734">"Dispositivos de medios"</string>
    <string name="connected_device_call_device_title" msgid="88732390601723608">"Dispositivos para llamar"</string>
    <string name="connected_device_other_device_title" msgid="4652120430615729193">"Otros dispositivos"</string>
    <string name="connected_device_saved_title" msgid="5607274378851905959">"Dispositivos guardados"</string>
    <string name="connected_device_add_device_summary" msgid="8671009879957120802">"Se activará el Bluetooth para vincular"</string>
    <string name="connected_device_connections_title" msgid="4164120115341579170">"Preferencias de conexión"</string>
    <string name="connected_device_previously_connected_title" msgid="605808252622814415">"Dispositivos conectados previamente"</string>
    <string name="connected_device_previously_connected_screen_title" msgid="8823331744788100605">"Conectados anteriormente"</string>
    <string name="connected_device_bluetooth_turned_on_toast" msgid="144664089794199928">"Se activó el Bluetooth"</string>
    <string name="previous_connected_see_all" msgid="7759413145713251328">"Ver todos"</string>
    <string name="date_and_time" msgid="1788358029823431692">"Fecha y hora"</string>
    <string name="choose_timezone" msgid="1450780665958642147">"Elige la zona horaria"</string>
    <!-- no translation found for intent_sender_data_label (1733806423295725392) -->
    <skip />
    <string name="intent_sender_sendbroadcast_text" msgid="3202857258557610646">"Enviar <xliff:g id="BROADCAST">broadcast</xliff:g>"</string>
    <string name="intent_sender_action_label" msgid="257853357827275530">"<xliff:g id="ACTION">Action</xliff:g>:"</string>
    <string name="intent_sender_startactivity_text" msgid="519934560779343541">"Inicio <xliff:g id="ACTIVITY">activity</xliff:g>"</string>
    <string name="intent_sender_resource_label" msgid="5087385727740280207">"<xliff:g id="RESOURCE">Resource</xliff:g>:"</string>
    <string name="intent_sender_account_label" msgid="36614006839665458">"Cuenta:"</string>
    <string name="proxy_settings_title" msgid="4201866858226087066">"Proxy"</string>
    <string name="proxy_clear_text" msgid="6529658759984031149">"Eliminar"</string>
    <string name="proxy_port_label" msgid="4647357286461712574">"Puerto del proxy"</string>
    <string name="proxy_exclusionlist_label" msgid="2598613986784917542">"Omitir proxy para"</string>
    <string name="proxy_defaultView_text" msgid="6795150505379688451">"Restaurar configuraciones predeterminadas"</string>
    <string name="proxy_action_text" msgid="1103328484441449542">"Finalizar"</string>
    <string name="proxy_hostname_label" msgid="5504327742505848063">"Nombre de host del proxy"</string>
    <string name="proxy_error" msgid="3615905975598084126">"Atención"</string>
    <string name="proxy_error_dismiss" msgid="4207430265140873078">"Aceptar"</string>
    <string name="proxy_error_invalid_host" msgid="3814412792702059247">"El nombre del host que has escrito no es válido."</string>
    <string name="proxy_error_invalid_exclusion_list" msgid="6096353559936226599">"La lista de exclusión que escribiste no está debidamente formateada. Escribe una lista de los dominios excluidos separados por comas."</string>
    <string name="proxy_error_empty_port" msgid="4250295137005082992">"Debes completar el campo de puerto."</string>
    <string name="proxy_error_empty_host_set_port" msgid="8886572276450900049">"El campo del puerto debe estar vacío si el campo de servidor está vacío."</string>
    <string name="proxy_error_invalid_port" msgid="2830054691770209166">"El puerto que has escrito no es válido."</string>
    <string name="proxy_warning_limited_support" msgid="3277104160797351942">"El navegador usa el proxy HTTP, pero tal vez las demás aplicaciones no lo usen."</string>
    <string name="proxy_url_title" msgid="3502625766036404073">"URL config. autom. proxy: "</string>
    <string name="radio_info_ping_hostname_v4" msgid="4790577760885127088">"Hacer ping a IPv4 de nombre de host (www.google.com):"</string>
    <string name="radio_info_ping_hostname_v6" msgid="8327436534663560713">"Hacer ping a IPv6 de nombre de host (www.google.com):"</string>
    <string name="radio_info_http_client_test" msgid="5673975677271544085">"Prueba de cliente HTTP:"</string>
    <string name="ping_test_label" msgid="265427033290391845">"Ejecutar prueba de ping"</string>
    <string name="sdcard_changes_instructions" msgid="2331969501845866957">"Los cambios entran en vigencia cuando se vuelve a conectar el cable USB."</string>
    <string name="sdcard_settings_screen_mass_storage_text" msgid="129059989000252994">"Activar el espacio de almacenamiento masivo USB"</string>
    <string name="sdcard_settings_total_bytes_label" msgid="5298511430610207103">"Total de bytes:"</string>
    <string name="sdcard_settings_not_present_status" product="nosdcard" msgid="6189761476582690998">"Almacenamiento USB desactivado"</string>
    <string name="sdcard_settings_not_present_status" product="default" msgid="6601962586941623203">"Sin tarjeta SD"</string>
    <string name="sdcard_settings_available_bytes_label" msgid="7721283102767669004">"Bytes disponibles:"</string>
    <string name="sdcard_settings_mass_storage_status" product="nosdcard" msgid="4878190674458263222">"USB como almacenamiento masivo"</string>
    <string name="sdcard_settings_mass_storage_status" product="default" msgid="8850227049504860012">"La tarjeta SD se usa como dispositivo de almacenamiento masivo."</string>
    <string name="sdcard_settings_unmounted_status" product="nosdcard" msgid="1053258530368541571">"Puedes extraer el almac. USB."</string>
    <string name="sdcard_settings_unmounted_status" product="default" msgid="5813940671700138561">"Ya puedes extraer la tarjeta SD."</string>
    <string name="sdcard_settings_bad_removal_status" product="nosdcard" msgid="209564009449909311">"¡El almacenamiento USB se extrajo mientras se encontraba en uso!"</string>
    <string name="sdcard_settings_bad_removal_status" product="default" msgid="6817342973919819392">"¡Se ha extraído la tarjeta SD mientras se encontraba en uso!"</string>
    <string name="sdcard_settings_used_bytes_label" msgid="5646588579332741943">"Bytes utilizados:"</string>
    <string name="sdcard_settings_scanning_status" product="nosdcard" msgid="8037280964384235345">"Explorando almacenamiento USB para obtener medios..."</string>
    <string name="sdcard_settings_scanning_status" product="default" msgid="3297316465982471437">"Explorando medios en la tarjeta SD..."</string>
    <string name="sdcard_settings_read_only_status" product="nosdcard" msgid="3444648373391629840">"USB en modo de solo lectura"</string>
    <string name="sdcard_settings_read_only_status" product="default" msgid="4338796260718910164">"La tarjeta SD se activó como un dispositivo de solo lectura."</string>
    <string name="skip_label" msgid="6380034601349015895">"Omitir"</string>
    <string name="next_label" msgid="1248293387735652187">"Siguiente"</string>
    <string name="language_picker_title" msgid="4271307478263345133">"Idiomas"</string>
    <string name="locale_remove_menu" msgid="3521546263421387474">"Quitar"</string>
    <string name="add_a_language" msgid="2126220398077503271">"Agregar un idioma"</string>
    <plurals name="dlg_remove_locales_title" formatted="false" msgid="2845515796732609837">
      <item quantity="other">¿Quitar los idiomas seleccionados?</item>
      <item quantity="one">¿Quitar el idioma seleccionado?</item>
    </plurals>
    <string name="dlg_remove_locales_message" msgid="8110560091134252067">"Se mostrará el texto en otro idioma."</string>
    <string name="dlg_remove_locales_error_title" msgid="5875503658221562572">"No se pueden quitar todos los idiomas"</string>
    <string name="dlg_remove_locales_error_message" msgid="6504279959974675302">"Debes tener al menos un idioma preferido"</string>
    <string name="locale_not_translated" msgid="5079729745235316146">"Es posible que no esté disponible en algunas apps"</string>
    <string name="action_drag_label_move_up" msgid="3392196942330705015">"Mover hacia arriba"</string>
    <string name="action_drag_label_move_down" msgid="9069518740553953426">"Mover hacia abajo"</string>
    <string name="action_drag_label_move_top" msgid="2430471023612171619">"Mover al principio"</string>
    <string name="action_drag_label_move_bottom" msgid="6266165197792827003">"Mover al final"</string>
    <string name="action_drag_label_remove" msgid="1034900377796780568">"Quitar el idioma"</string>
    <string name="activity_picker_label" msgid="351250401590691126">"Elige actividad"</string>
    <string name="display_label" msgid="3056320781191343221">"Pantalla"</string>
    <string name="sd_card_settings_label" product="nosdcard" msgid="1850505156136467106">"Almacenamiento USB"</string>
    <string name="sd_card_settings_label" product="default" msgid="8715502912796241588">"Tarjeta SD"</string>
    <string name="proxy_settings_label" msgid="6300573815025557843">"Configuración de proxy"</string>
    <string name="cancel" msgid="5780102414089664898">"Cancelar"</string>
    <string name="okay" msgid="4827099303045669054">"Aceptar"</string>
    <string name="forget" msgid="3754013654135912783">"Olvidar"</string>
    <string name="save" msgid="3125033126936493822">"Guardar"</string>
    <string name="done" msgid="7497982645646431310">"Listo"</string>
    <string name="apply" msgid="7834684883190163536">"Aplicar"</string>
    <string name="share" msgid="8502235338607613795">"Compartir"</string>
    <string name="add" msgid="8335206931421683426">"Agregar"</string>
    <string name="settings_label" msgid="943294133671632976">"Configuración"</string>
    <string name="settings_label_launcher" msgid="820982375501978609">"Configuración"</string>
    <string name="settings_shortcut" msgid="8548239727871847171">"Configuración"</string>
    <string name="airplane_mode" msgid="3196085857882526817">"Modo avión"</string>
    <string name="wireless_networks_settings_title" msgid="8557542379234105369">"Conexiones inalámbricas y redes"</string>
    <string name="radio_controls_summary" msgid="9028430178697624501">"Administrar Wi-Fi, Bluetooth, modo avión, redes móviles y VPN"</string>
    <string name="cellular_data_summary" msgid="6551434804367912367">"Permitir el uso de datos en redes móviles"</string>
    <string name="allow_data_usage_title" msgid="2645963379925196671">"Permitir usar datos en roaming"</string>
    <string name="roaming" msgid="3055365654530847985">"Roaming"</string>
    <string name="roaming_enable" msgid="7845716016861535340">"Conectar a servicios de datos en roaming"</string>
    <string name="roaming_disable" msgid="729512894708689604">"Conectar a servicios de datos en roaming"</string>
    <string name="roaming_reenable_message" msgid="5150423860521673540">"Has perdido la conectividad de los datos porque has dejado la red doméstica con roaming de datos desactivado."</string>
    <string name="roaming_turn_it_on_button" msgid="6999283810847157816">"Enciéndelo"</string>
    <string name="roaming_warning" msgid="7703647889040229013">"Es posible que se apliquen cargos de roaming."</string>
    <string name="roaming_warning_multiuser" product="tablet" msgid="5629953315019604726">"Si permites el roaming de datos, es posible que se apliquen cargos de roaming.\n\nEsa configuración afecta a todos los usuarios de esta tablet."</string>
    <string name="roaming_warning_multiuser" product="default" msgid="3693719745119874126">"Si permites el roaming de datos, es posible que se apliquen cargos de roaming.\n\nEsa configuración afecta a todos los usuarios de este teléfono."</string>
    <string name="roaming_reenable_title" msgid="770824950144026180">"¿Permitir el roaming de datos?"</string>
    <string name="networks" msgid="5184501333492775095">"Selección de operador"</string>
    <string name="sum_carrier_select" msgid="1669911795517995916">"Elegir un operador de red"</string>
    <string name="date_and_time_settings_title" msgid="2305454529709812364">"Fecha y hora"</string>
    <string name="date_and_time_settings_title_setup_wizard" msgid="1841717199409629742">"Configurar fecha y hora"</string>
    <string name="date_and_time_settings_summary" msgid="334967758944498010">"Establecer fecha, hora, zona horaria y formatos"</string>
    <string name="date_time_auto" msgid="4239202185055225869">"Establecer la hora automáticamente"</string>
    <string name="zone_auto_title" msgid="3993580453604839924">"Establecer la zona horaria automáticamente"</string>
    <string name="date_time_24hour_auto" msgid="6583078135067804252">"Usar configuración regional predeterminada"</string>
    <string name="date_time_24hour_title" msgid="1445056824481243600">"Formato de 24 horas"</string>
    <string name="date_time_24hour" msgid="286679379105653406">"Formato de 24 horas"</string>
    <string name="date_time_set_time_title" msgid="2870083415922991906">"Hora"</string>
    <string name="time_format_category_title" msgid="7108616745509689991">"Formato de hora"</string>
    <string name="date_time_set_timezone_title" msgid="790404320569600222">"Zona horaria"</string>
    <string name="date_time_set_timezone" msgid="2915125337941495746">"Zona horaria"</string>
    <string name="date_time_set_date_title" msgid="7624166157167528407">"Fecha"</string>
    <string name="date_time_search_region" msgid="1364133854952610919">"Búsqueda por región"</string>
    <string name="date_time_select_region" msgid="5449345333305056072">"Región"</string>
    <string name="date_time_select_fixed_offset_time_zones" msgid="594848300882055361">"Seleccionar desplazamiento UTC"</string>
    <string name="zone_change_to_from_dst" msgid="686451769985774294">"<xliff:g id="TIME_TYPE">%1$s</xliff:g> a partir del <xliff:g id="TRANSITION_DATE">%2$s</xliff:g>"</string>
    <string name="zone_info_exemplar_location_and_offset" msgid="2186042522225153092">"<xliff:g id="EXEMPLAR_LOCATION">%1$s</xliff:g> (<xliff:g id="OFFSET">%2$s</xliff:g>)"</string>
    <string name="zone_info_offset_and_name" msgid="3960192548990990152">"<xliff:g id="TIME_TYPE">%2$s</xliff:g> (<xliff:g id="OFFSET">%1$s</xliff:g>)"</string>
    <string name="zone_info_footer" msgid="7004693956837388129">"Zona horaria: <xliff:g id="OFFSET_AND_NAME">%1$s</xliff:g> (<xliff:g id="DST_TIME_TYPE">%2$s</xliff:g> a partir del <xliff:g id="TRANSITION_DATE">%3$s</xliff:g>)."</string>
    <string name="zone_info_footer_no_dst" msgid="8399585343328811158">"Zona horaria: <xliff:g id="OFFSET_AND_NAME">%1$s</xliff:g>. Sin horario de verano."</string>
    <string name="zone_time_type_dst" msgid="9189689342265305808">"Horario de verano"</string>
    <string name="zone_time_type_standard" msgid="6865420715430680352">"Hora estándar"</string>
    <string name="zone_menu_by_region" msgid="2963565278710225652">"Seleccionar por región"</string>
    <string name="zone_menu_by_offset" msgid="1257702747474426745">"Seleccionar por desplazamiento de UTC"</string>
    <string name="date_picker_title" msgid="646573308567782578">"Fecha"</string>
    <string name="time_picker_title" msgid="1784236407401743393">"Hora"</string>
    <string name="lock_after_timeout" msgid="8682769000437403444">"Bloquear al finalizar el tiempo de espera de pantalla"</string>
    <string name="lock_after_timeout_summary" msgid="4869265514658147304">"<xliff:g id="TIMEOUT_STRING">%1$s</xliff:g> después de que se agote tiempo de espera"</string>
    <string name="lock_immediately_summary_with_exception" msgid="40819611828339044">"Inmediatamente después de que se agote tiempo de espera, excepto cuando <xliff:g id="TRUST_AGENT_NAME">%1$s</xliff:g> mantenga la pantalla desbloqueada"</string>
    <string name="lock_after_timeout_summary_with_exception" msgid="3441806647509073124">"<xliff:g id="TIMEOUT_STRING">%1$s</xliff:g> después de que se agote el tiempo de espera, excepto cuando <xliff:g id="TRUST_AGENT_NAME">%2$s</xliff:g> mantenga la pantalla desbloqueada"</string>
    <string name="show_owner_info_on_lockscreen_label" msgid="197365342192696406">"Mostrar datos de propietario en pantalla bloqueada"</string>
    <string name="owner_info_settings_title" msgid="3555626140700093017">"Agregar texto en pant. bloqueo"</string>
    <string name="security_enable_widgets_title" msgid="676199714313423099">"Habilitar widgets"</string>
    <string name="security_enable_widgets_disabled_summary" msgid="5191637768484254146">"El administrador inhabilitó la opción"</string>
    <string name="lockdown_settings_title" msgid="8988970335658365075">"Mostrar opción de bloqueo"</string>
    <string name="lockdown_settings_summary" msgid="7422522013953398806">"Mostrar la opción del botón de encendido que desactiva Smart Lock, el desbloqueo biométrico y las notificaciones en la pantalla bloqueada"</string>
    <string name="trust_lost_locks_screen_title" msgid="4231232144565291276">"Bloquear pantalla al perder confianza"</string>
    <string name="trust_lost_locks_screen_summary" msgid="718374221849537361">"Si habilitas la opción, el dispositivo se bloqueará cuando el último agente de confianza pierda este privilegio"</string>
    <string name="owner_info_settings_summary" msgid="347238313388083297">"Ninguno"</string>
    <string name="owner_info_settings_status" msgid="7488764871758677862">"<xliff:g id="COUNT_0">%1$d</xliff:g>/<xliff:g id="COUNT_1">%2$d</xliff:g>"</string>
    <string name="owner_info_settings_edit_text_hint" msgid="841926875876050274">"Por ejemplo, Android de Juan"</string>
    <string name="show_profile_info_on_lockscreen_label" msgid="5734739022887933365">"Mostrar datos del perfil en pantalla bloqueada"</string>
    <string name="Accounts_settings_title" msgid="8434263183710375412">"Cuentas"</string>
    <string name="location_settings_title" msgid="8375074508036087178">"Ubicación"</string>
    <string name="location_settings_primary_switch_title" msgid="8849081766644685127">"Usar ubicación"</string>
    <string name="location_settings_summary_location_off" msgid="4797932754681162262">"Desactivado"</string>
    <plurals name="location_settings_summary_location_on" formatted="false" msgid="1019959038518185676">
      <item quantity="other">Encendido: <xliff:g id="COUNT_1">%1$d</xliff:g> apps tienen acceso a la ubicación</item>
      <item quantity="one">Encendido: <xliff:g id="COUNT_0">%1$d</xliff:g> app tiene acceso a la ubicación</item>
    </plurals>
    <string name="location_settings_loading_app_permission_stats" msgid="6054103701535557342">"Cargando…"</string>
    <string name="account_settings_title" msgid="9138880127246241885">"Cuentas"</string>
    <string name="security_settings_title" msgid="6710768415432791970">"Seguridad"</string>
    <string name="encryption_and_credential_settings_title" msgid="5856216318961482983">"Encriptación y credenciales"</string>
    <string name="encryption_and_credential_settings_summary" product="default" msgid="5298195959570992363">"Teléfono encriptado"</string>
    <string name="decryption_settings_summary" product="default" msgid="1742645256103613503">"Teléfono no encriptado"</string>
    <string name="encryption_and_credential_settings_summary" product="tablet" msgid="3776741531205406800">"Dispositivo encriptado"</string>
    <string name="decryption_settings_summary" product="tablet" msgid="1864963068216544631">"Dispositivo no encriptado"</string>
    <string name="lockscreen_settings_title" msgid="4086121748092341549">"Pantalla de bloqueo"</string>
    <string name="lockscreen_settings_what_to_show_category" msgid="9205490627927741254">"Qué mostrar"</string>
    <string name="security_settings_summary" msgid="1627059516127354233">"Establecer Mi ubicación, desbloqueo de pantalla, bloqueo de la tarjeta SIM, bloqueo de almacenamiento de credenciales"</string>
    <string name="cdma_security_settings_summary" msgid="2455517905101186330">"Establecer Mi ubicación, desbloqueo de pantalla, bloqueo de almacenamiento de credencial"</string>
    <string name="security_passwords_title" msgid="4154420930973818581">"Privacidad"</string>
    <string name="disabled_by_administrator_summary" msgid="5424846182313851124">"No disponible"</string>
    <string name="security_status_title" msgid="6958004275337618656">"Estado de seguridad"</string>
    <string name="security_dashboard_summary_face" msgid="4198949293847206382">"Bloqueo de pantalla, desbloqueo facial"</string>
    <string name="security_dashboard_summary" msgid="8750183806533140464">"Bloqueo de pantalla, huella digital"</string>
    <string name="security_dashboard_summary_no_fingerprint" msgid="1044589595710115123">"Bloqueo de pantalla"</string>
    <string name="multi_biometric_enroll_title" msgid="3007607723604088374">"Usa tu rostro y huella digital para desbloquear el teléfono"</string>
    <string name="multi_biometric_enroll_subtitle" msgid="8357072842904027301">"También puedes acceder a apps y confirmar pagos"</string>
    <string name="multi_biometric_enroll_setup_with" msgid="421375792889910150">"Configura el desbloqueo con:"</string>
    <string name="multi_biometric_enroll_face_unlock_title" msgid="7627564065626355692">"Desbloqueo facial"</string>
    <string name="multi_biometric_enroll_face_unlock_description" msgid="7626442550602926682">"Desbloquea el teléfono con facilidad"</string>
    <string name="multi_biometric_enroll_fingerprint_unlock_title" msgid="3839935495273854171">"Huella digital"</string>
    <string name="multi_biometric_enroll_fingerprint_unlock_description" msgid="116938134430420778">"Desbloquea el teléfono desde el bolsillo"</string>
    <string name="multi_biometric_enroll_skip" msgid="7301215196571580858">"Omitir"</string>
    <string name="multi_biometric_enroll_next" msgid="6220680618102151619">"Siguiente"</string>
    <string name="security_settings_face_preference_summary" msgid="6675126437396914838">"Se agregó el rostro"</string>
    <string name="security_settings_face_preference_summary_none" msgid="3758209126322559995">"Configurar el desbloqueo facial"</string>
    <string name="security_settings_face_preference_title" msgid="821557938243856757">"Desbloqueo facial"</string>
    <string name="security_settings_face_profile_preference_title" msgid="4618796080378248740">"Desbloqueo facial para el trabajo"</string>
    <string name="security_settings_face_enroll_education_title" msgid="8662585502032112675">"Cómo configurar el desbloqueo facial"</string>
    <string name="security_settings_face_enroll_education_title_accessibility" msgid="4632402390714441918">"Configurar el desbloqueo facial"</string>
    <string name="security_settings_face_enroll_education_title_unlock_disabled" msgid="8810954233979716906">"Usa tu rostro para autenticarte"</string>
    <string name="security_settings_face_enroll_education_message" msgid="4308030157487176799"></string>
    <string name="security_settings_face_enroll_education_start" msgid="8830924400907195590">"Iniciar"</string>
    <string name="security_settings_face_enroll_education_accessibility_dialog_message" msgid="4681495507974718824">"Si el desbloqueo facial de accesibilidad está desactivado, es posible que algunos pasos de la configuración no funcionen correctamente con TalkBack."</string>
    <string name="security_settings_face_enroll_education_accessibility_dialog_negative" msgid="7872647360361245461">"Atrás"</string>
    <string name="security_settings_face_enroll_education_accessibility_dialog_positive" msgid="3148077647572203458">"Seguir configurando"</string>
    <string name="security_settings_face_enroll_introduction_accessibility" msgid="5748221179069430975">"Usar config. de accesibilidad"</string>
    <string name="security_settings_face_enroll_introduction_accessibility_expanded" msgid="6763509014732769185"></string>
    <string name="security_settings_face_enroll_introduction_accessibility_diversity" msgid="2774962371839179206"></string>
    <string name="security_settings_face_enroll_introduction_accessibility_vision" msgid="7700394302162170363"></string>
    <string name="security_settings_face_enroll_introduction_cancel" msgid="7551159644361639436">"Cancelar"</string>
    <string name="security_settings_face_enroll_introduction_no_thanks" msgid="1820618982738898717">"No, gracias"</string>
    <string name="security_settings_face_enroll_introduction_agree" msgid="1822303197642630076">"Aceptar"</string>
    <string name="security_settings_face_enroll_introduction_more" msgid="1970820298889710532">"Más"</string>
    <string name="security_settings_face_enroll_introduction_title" msgid="7061610077237098046">"Usa tu rostro para desbloquear"</string>
    <string name="security_settings_face_enroll_introduction_title_unlock_disabled" msgid="5903924766168353113">"Usa tu rostro para autenticarte"</string>
    <string name="security_settings_face_enroll_introduction_message" msgid="3015751486939484934">"Usa tu rostro para desbloquear el teléfono, autorizar compras o acceder a las apps."</string>
    <string name="security_settings_face_enroll_introduction_message_unlock_disabled" msgid="5841976283789481311">"Usa tu rostro para desbloquear el teléfono o aprobar compras.\n\nNota: No puedes usarlo para desbloquear este dispositivo. Si quieres obtener más detalles, comunícate con el administrador de la organización."</string>
    <string name="security_settings_face_enroll_introduction_message_setup" msgid="765965418187421753">"Usa tu rostro para desbloquear el teléfono, autorizar compras o acceder a las apps"</string>
    <string name="security_settings_face_enroll_introduction_footer_part_0" msgid="908831787971630413"></string>
    <string name="security_settings_face_enroll_introduction_footer_part_1" msgid="4438129587730915782"></string>
    <string name="security_settings_face_enroll_introduction_footer_part_2" msgid="6099785970191751036"></string>
    <string name="security_settings_face_enroll_introduction_footer_part_3" msgid="8708726599723727710"></string>
    <string name="security_settings_face_enroll_repeat_title" msgid="4446229670377418717">"Centra el rostro en el círculo"</string>
    <string name="security_settings_face_enroll_enrolling_skip" msgid="5568617401632528567">"Omitir"</string>
    <string name="face_add_max" msgid="4578405795494514876">"Puedes agregar hasta <xliff:g id="COUNT">%d</xliff:g> rostros"</string>
    <string name="face_intro_error_max" msgid="2474735057709291626">"Agregaste la cantidad máxima permitida de rostros"</string>
    <string name="face_intro_error_unknown" msgid="1626057493054989995">"No se pueden agregar más rostros"</string>
    <string name="security_settings_face_enroll_error_dialog_title" msgid="2460820099922775936">"No se completó la inscripción"</string>
    <string name="security_settings_face_enroll_dialog_ok" msgid="1674650455786434426">"Aceptar"</string>
    <string name="security_settings_face_enroll_error_timeout_dialog_message" msgid="7768349698547951750">"Se alcanzó el límite de tiempo para el registro de rostros. Vuelve a intentarlo."</string>
    <string name="security_settings_face_enroll_error_generic_dialog_message" msgid="3186810411630091490">"No funcionó el registro de rostros."</string>
    <string name="security_settings_face_enroll_finish_title" msgid="5882322568359775393">"Ya terminaste. Está todo listo."</string>
    <string name="security_settings_face_enroll_done" msgid="3048687969498187442">"Listo"</string>
    <string name="security_settings_face_enroll_should_re_enroll_title" msgid="9080635904939148410">"Mejora el rendimiento del desbloqueo facial"</string>
    <string name="security_settings_face_enroll_should_re_enroll_subtitle" msgid="2318506792574194633">"Vuelve a configurar el desbloqueo facial"</string>
    <string name="security_settings_face_enroll_must_re_enroll_title" msgid="8907917317111783249">"Vuelve a configurar el desbloqueo facial"</string>
    <string name="security_settings_face_enroll_must_re_enroll_subtitle" msgid="3584740139535177961">"Mejora la seguridad y el rendimiento"</string>
    <string name="security_settings_face_enroll_improve_face_alert_title" msgid="7124713074067550039">"Configura el desbloqueo facial"</string>
    <string name="security_settings_face_enroll_improve_face_alert_body" msgid="950213874209080175">"Borra tus datos de rostro actuales para volver a configurar el desbloqueo facial.\n\nSe borrarán de manera permanente y segura los datos de rostro que usa la función. Tras eliminarlos, deberás ingresar tu PIN, patrón o contraseña para desbloquear el teléfono, acceder a apps y confirmar pagos."</string>
    <string name="security_settings_face_settings_use_face_category" msgid="2374998717426341095">"Desbloq. facial para"</string>
    <string name="security_settings_face_settings_use_face_unlock_phone" msgid="5209963876503148501">"Desbloquear teléfono"</string>
    <string name="security_settings_face_settings_use_face_for_apps" msgid="8813038341122613020">"Acceso a apps y pagos"</string>
    <string name="security_settings_face_settings_require_category" msgid="3906382658164073665">"Requisitos del desbloqueo facial"</string>
    <string name="security_settings_face_settings_require_attention" msgid="4395309855914391104">"Los ojos deben estar abiertos"</string>
    <string name="security_settings_face_settings_require_attention_details" msgid="2546230511769544074">"Para desbloquear el teléfono, debes abrir los ojos"</string>
    <string name="security_settings_face_settings_require_confirmation" msgid="6603039421004198334">"Requerir siempre confirmación"</string>
    <string name="security_settings_face_settings_require_confirmation_details" msgid="6454776517804994007">"Solicitar confirmación al usar el desbloqueo facial en apps"</string>
    <string name="security_settings_face_settings_remove_face_data" msgid="6491161841504747384">"Borrar datos faciales"</string>
    <string name="security_settings_face_settings_enroll" msgid="4656842124181309056">"Configurar el desbloqueo facial"</string>
    <string name="security_settings_face_settings_top_intro" msgid="4199311264578653665">"Usa el desbloqueo facial para desbloquear el dispositivo, acceder a apps y confirmar pagos."</string>
    <string name="security_settings_face_settings_footer" msgid="4378074697208244539">"Ten en cuenta lo siguiente:\nPuedes desbloquear el teléfono aunque no lo desees cuando lo miras.\n\nUn tercero puede desbloquear el teléfono si lo sostiene frente a tu rostro.\n\nTambién puede desbloquearlo cualquier persona que se parezca a ti, como un hermano gemelo."</string>
    <string name="security_settings_face_settings_footer_attention_not_supported" msgid="5051230351151761265">"Ten en cuenta lo siguiente:\nPuedes desbloquear el teléfono aunque no lo desees cuando lo miras.\n\nUn tercero puede desbloquear el teléfono si lo sostiene frente a tu rostro, incluso si tienes los ojos cerrados.\n\nTambién puede desbloquearlo cualquier persona que se parezca a ti, como un hermano gemelo."</string>
    <string name="security_settings_face_settings_remove_dialog_title" msgid="2596803378375165362">"¿Quieres borrar los datos faciales?"</string>
    <string name="security_settings_face_settings_remove_dialog_details" msgid="3458998128212675289">"Se borrarán los datos del rostro que usa el desbloqueo facial definitivamente y de manera segura. Tras la eliminación, deberás ingresar el PIN, el patrón o la contraseña para desbloquear el teléfono, acceder a las apps y confirmar pagos."</string>
    <string name="security_settings_face_settings_context_subtitle" msgid="9197485417007952865">"Usa tu rostro para desbloquear el teléfono"</string>
    <string name="security_settings_fingerprint_preference_title" msgid="2484965173528415458">"Huella digital"</string>
    <string name="fingerprint_manage_category_title" msgid="1249349505688268850">"Adm. huellas digitales"</string>
    <string name="fingerprint_usage_category_title" msgid="8757959085075024856">"Usar huella dig. para"</string>
    <string name="fingerprint_add_title" msgid="1837610443487902050">"Agregar una huella digital"</string>
    <string name="fingerprint_enable_keyguard_toggle_title" msgid="5451094461919440992">"bloqueo de pantalla"</string>
    <plurals name="security_settings_fingerprint_preference_summary" formatted="false" msgid="988602245530967106">
      <item quantity="other">Se configuraron <xliff:g id="COUNT_1">%1$d</xliff:g> huellas digitales</item>
      <item quantity="one">Se configuró <xliff:g id="COUNT_0">%1$d</xliff:g> huella digital</item>
    </plurals>
    <string name="security_settings_fingerprint_preference_summary_none" msgid="1044059475710838504"></string>
    <string name="security_settings_fingerprint_enroll_introduction_title" msgid="521797365974277693">"Desbloquea con tu huella digital"</string>
    <string name="security_settings_fingerprint_enroll_introduction_title_unlock_disabled" msgid="1911710308293783998">"Usa tus huellas digitales"</string>
    <string name="security_settings_fingerprint_enroll_introduction_message" msgid="1467469714658873533">"Toca el sensor de huellas digitales para desbloquear el teléfono, autorizar compras o acceder a las apps. Ten cuidado con las huellas digitales que agregas, ya que podrán realizar cualquiera de esas acciones."</string>
    <string name="security_settings_fingerprint_enroll_introduction_bottom_message" msgid="6527850754691662946">"Es posible que la huella digital sea menos segura que un patrón o PIN eficaz."</string>
    <string name="security_settings_fingerprint_enroll_introduction_message_unlock_disabled" msgid="8957789840251747092">"Usa tu huella digital para desbloquear el teléfono o aprobar compras.\n\nNota: No puedes usar tu huella digital para desbloquear este dispositivo. Para obtener más información, comunícate con el administrador de la organización."</string>
    <string name="security_settings_fingerprint_enroll_introduction_message_setup" msgid="5979556434735281585">"Usa tu huella digital para desbloquear el teléfono o aprobar compras.\n\nNota: Es posible que la huella digital no sea tan segura como un PIN o un patrón eficaz."</string>
    <string name="security_settings_fingerprint_enroll_introduction_cancel" msgid="6086532316718920562">"Cancelar"</string>
    <string name="security_settings_fingerprint_enroll_introduction_no_thanks" msgid="6104718999323591180">"No, gracias"</string>
    <string name="security_settings_fingerprint_enroll_introduction_continue" msgid="5683573189775460816">"Continuar"</string>
    <string name="security_settings_fingerprint_enroll_introduction_cancel_setup" msgid="370010932190960403">"Omitir"</string>
    <string name="security_settings_fingerprint_enroll_introduction_continue_setup" msgid="7155412679784724630">"Siguiente"</string>
    <string name="setup_fingerprint_enroll_skip_title" msgid="2473807887676247264">"¿Omitir huella digital?"</string>
    <string name="setup_fingerprint_enroll_skip_after_adding_lock_text" msgid="2412645723804450304">"La configuración de la huella digital solo toma unos minutos. Si omites este paso, puedes agregarla más tarde en la configuración."</string>
    <string name="lock_screen_intro_skip_title" msgid="342553937472568925">"¿Omitir bloqueo de la pantalla?"</string>
    <string name="lock_screen_intro_skip_dialog_text_frp" product="tablet" msgid="1570832293693405757">"No se activarán las funciones de protección del dispositivo. No podrás evitar que otras personas usen esta tablet si la pierdes, te la roban o se restablece."</string>
    <string name="lock_screen_intro_skip_dialog_text_frp" product="device" msgid="4618501606519351904">"No se activarán las funciones de protección del dispositivo. No podrás evitar que otras personas lo usen si lo pierdes, te lo roban o se restablece."</string>
    <string name="lock_screen_intro_skip_dialog_text_frp" product="default" msgid="2412426429887900241">"No se activarán las funciones de protección del dispositivo. No podrás impedir que otras personas usen este teléfono si lo pierdes, te lo roban o se restablece."</string>
    <string name="lock_screen_intro_skip_dialog_text" product="tablet" msgid="7119039592587429936">"No se activarán las funciones de protección del dispositivo. No podrás evitar que otras personas usen esta tablet si la pierdes o te la roban."</string>
    <string name="lock_screen_intro_skip_dialog_text" product="device" msgid="3365990364131398523">"No se activarán las funciones de protección del dispositivo. No podrás evitar que otras personas usen este dispositivo si lo pierdes o te lo roban."</string>
    <string name="lock_screen_intro_skip_dialog_text" product="default" msgid="4908278819257287536">"No se activarán las funciones de protección del dispositivo. No podrás impedir que otras personas usen este teléfono si lo pierdes o te lo roban."</string>
    <string name="skip_anyway_button_label" msgid="3442274117023270068">"Omitir"</string>
    <string name="go_back_button_label" msgid="6139455414099035594">"Atrás"</string>
    <string name="skip_lock_screen_dialog_button_label" msgid="641984698150020591">"Omitir"</string>
    <string name="cancel_lock_screen_dialog_button_label" msgid="1801132985957491690">"Cancelar"</string>
    <string name="security_settings_fingerprint_enroll_find_sensor_title" msgid="886085239313346000">"Toca el sensor"</string>
    <string name="security_settings_fingerprint_enroll_find_sensor_message" msgid="6160543980992596286">"Se encuentra en la parte posterior del teléfono. Usa el dedo índice."</string>
    <string name="security_settings_udfps_enroll_find_sensor_message" msgid="1181700918690345832">"Está en la pantalla. Busca la huella digital que tiene un círculo resplandeciente."</string>
    <string name="security_settings_fingerprint_enroll_find_sensor_content_description" msgid="3065850549419750523">"Ilustración del dispositivo y la ubicación del sensor de huellas digitales"</string>
    <string name="security_settings_fingerprint_enroll_dialog_name_label" msgid="7298812463228440333">"Nombre"</string>
    <string name="security_settings_fingerprint_enroll_dialog_ok" msgid="4074335979239208021">"Aceptar"</string>
    <string name="security_settings_fingerprint_enroll_dialog_delete" msgid="6027141901007342389">"Borrar"</string>
    <string name="security_settings_fingerprint_enroll_start_title" msgid="7391368057800077604">"Toca el sensor"</string>
    <string name="security_settings_fingerprint_enroll_start_message" msgid="5010227772754175346">"Coloca el dedo en el sensor y levántalo cuando sientas una vibración."</string>
    <string name="security_settings_fingerprint_enroll_repeat_title" msgid="9172202128243545021">"Levanta el dedo y vuelve a tocar"</string>
    <string name="security_settings_fingerprint_enroll_repeat_message" msgid="5382958363770893577">"Sigue levantando el dedo para agregar diferentes partes de la huella digital."</string>
    <string name="security_settings_fingerprint_enroll_finish_title" msgid="3606325177406951457">"Se agregó la huella digital"</string>
    <string name="security_settings_fingerprint_enroll_finish_message" msgid="8220458039597261933">"Cuando veas este ícono, usa tu huella digital para identificarte o aprobar compras."</string>
    <string name="security_settings_fingerprint_enroll_enrolling_skip" msgid="3004786457919122854">"Más tarde"</string>
    <string name="setup_fingerprint_enroll_enrolling_skip_title" msgid="352947044008973812">"¿Omitir configuración de huella digital?"</string>
    <string name="setup_fingerprint_enroll_enrolling_skip_message" msgid="4876965433600560365">"Decidiste usar la huella digital como una de las formas para desbloquear el teléfono. Si omites este paso, tendrás que configurarla más tarde. La configuración tarda un minuto aproximadamente."</string>
    <string name="fingerprint_lock_screen_setup_skip_dialog_text" product="tablet" msgid="6901147203720764421">"Protege la tablet con una opción de bloqueo de pantalla para que nadie pueda usarla si la pierdes o te la roban. También debes establecer una opción de bloqueo de pantalla para configurar la huella digital. Presiona Cancelar y, luego, establece un PIN, un patrón o una contraseña."</string>
    <string name="fingerprint_lock_screen_setup_skip_dialog_text" product="device" msgid="1286244133923093528">"Protege el dispositivo con una opción de bloqueo de pantalla para que nadie pueda usarlo si lo pierdes o te lo roban. También debes establecer una opción de bloqueo de pantalla para configurar la huella digital. Presiona Cancelar y, luego, establece un PIN, un patrón o una contraseña."</string>
    <string name="fingerprint_lock_screen_setup_skip_dialog_text" product="default" msgid="4810191157587317521">"Protege el teléfono con una opción de bloqueo de pantalla para que nadie pueda usarlo si lo pierdes o te lo roban. También debes establecer una opción de bloqueo de pantalla para configurar la huella digital. Presiona Cancelar y, luego, establece un PIN, un patrón o una contraseña."</string>
    <string name="face_lock_screen_setup_skip_dialog_text" product="tablet" msgid="7387535629289108475">"Si proteges tu tablet con una opción de bloqueo de pantalla, nadie podrá usarla si la pierdes o te la roban. También debes establecer una opción para configurar el desbloqueo facial. Si necesitas ir hacia atrás, presiona Cancelar."</string>
    <string name="face_lock_screen_setup_skip_dialog_text" product="device" msgid="4995287019957131123">"Si proteges tu dispositivo con una opción de bloqueo de pantalla, nadie podrá usarlo si lo pierdes o te lo roban. También debes establecer una opción para configurar el desbloqueo facial. Si necesitas ir hacia atrás, presiona Cancelar."</string>
    <string name="face_lock_screen_setup_skip_dialog_text" product="default" msgid="7086796722966738156">"Si proteges tu teléfono con una opción de bloqueo de pantalla, y lo pierdes o te lo roban, nadie podrá usarlo. También debes establecer una opción para configurar el desbloqueo facial. Si necesitas ir hacia atrás, presiona Cancelar."</string>
    <string name="biometrics_lock_screen_setup_skip_dialog_text" product="tablet" msgid="3943278149639587227">"Si proteges tu tablet con una opción de bloqueo de pantalla, nadie podrá usarla si la pierdes o te la roban. También debes establecer una opción antes de configurar el desbloqueo biométrico. Si necesitas ir hacia atrás, presiona Cancelar."</string>
    <string name="biometrics_lock_screen_setup_skip_dialog_text" product="device" msgid="5424064454068220988">"Si proteges tu dispositivo con una opción de bloqueo de pantalla, nadie podrá usarlo si lo pierdes o te lo roban. También debes establecer una opción antes de configurar el desbloqueo biométrico. Si necesitas ir hacia atrás, presiona Cancelar."</string>
    <string name="biometrics_lock_screen_setup_skip_dialog_text" product="default" msgid="5668256546179188638">"Si proteges tu teléfono con una opción de bloqueo de pantalla, nadie podrá usarlo si lo pierdes o te lo roban. También debes establecer una opción antes de configurar el desbloqueo biométrico. Si necesitas ir hacia atrás, presiona Cancelar."</string>
    <string name="lock_screen_pin_skip_title" msgid="6853866579893458111">"¿Omitir configuración del PIN?"</string>
    <string name="lock_screen_password_skip_title" msgid="8891463713793185768">"¿Omitir configuración de la contraseña?"</string>
    <string name="lock_screen_pattern_skip_title" msgid="7214938393640060932">"¿Omitir configuración del patrón?"</string>
    <string name="security_settings_fingerprint_enroll_setup_screen_lock" msgid="3538784524778508018">"Configurar bloqueo de pantalla"</string>
    <string name="security_settings_fingerprint_enroll_done" msgid="9198775984215057337">"Listo"</string>
    <string name="security_settings_fingerprint_enroll_touch_dialog_title" msgid="5742429501012827526">"Ese no es el sensor"</string>
    <string name="security_settings_fingerprint_enroll_touch_dialog_message" msgid="7172969336386036998">"Toca el sensor en la parte posterior del teléfono con el dedo índice."</string>
    <string name="security_settings_fingerprint_enroll_error_dialog_title" msgid="132085362209418770">"No se completó la inscripción"</string>
    <string name="security_settings_fingerprint_enroll_error_timeout_dialog_message" msgid="5479647886550695766">"Se alcanzó el límite de tiempo para la inscripción de huellas digitales. Vuelve a intentarlo."</string>
    <string name="security_settings_fingerprint_enroll_error_generic_dialog_message" msgid="6068935528640241271">"El registro de huellas digitales no funcionó. Vuelve a intentarlo o usa otro dedo."</string>
    <string name="fingerprint_enroll_button_add" msgid="6652490687672815760">"Agregar otra huella digital"</string>
    <string name="fingerprint_enroll_button_next" msgid="1034110123277869532">"Siguiente"</string>
    <string name="security_settings_fingerprint_enroll_disclaimer" msgid="7875826823637114097">"Además de desbloquear el teléfono, también puedes utilizar tu huella digital para autorizar compras y el acceso a aplicaciones. "<annotation id="url">"Más información"</annotation></string>
    <string name="security_settings_fingerprint_enroll_disclaimer_lockscreen_disabled" msgid="4260983700868889294">" Esta opción de bloqueo de pantalla está inhabilitada. Para obtener más información, comunícate con el administrador de tu organización. "<annotation id="admin_details">"Más información"</annotation>\n\n"Aún puedes usar tu huella digital para autorizar compras y el acceso a apps."<annotation id="url">"Más información"</annotation></string>
    <string name="security_settings_fingerprint_enroll_lift_touch_again" msgid="2590665137265458789">"Levanta el dedo y vuelve a tocar el sensor"</string>
    <string name="fingerprint_add_max" msgid="8639321019299347447">"Puedes agregar hasta <xliff:g id="COUNT">%d</xliff:g> huellas digitales"</string>
    <string name="fingerprint_intro_error_max" msgid="4431784409732135610">"Agregaste la cantidad máxima permitida de huellas digitales"</string>
    <string name="fingerprint_intro_error_unknown" msgid="877005321503793963">"No se pueden agregar más huellas digitales"</string>
    <string name="fingerprint_last_delete_title" msgid="4081475675646514726">"¿Quitar las huellas digitales?"</string>
    <string name="fingerprint_delete_title" msgid="1469865327307917858">"Quitar \"<xliff:g id="FINGERPRINT_ID">%1$s</xliff:g>\""</string>
    <string name="fingerprint_delete_message" msgid="1454995433333496541">"¿Quieres borrar esta huella digital?"</string>
    <string name="fingerprint_last_delete_message" msgid="93311579320049852">"No podrás usar tus huellas digitales para desbloquear el teléfono, autorizar compras ni acceder a las apps"</string>
    <string name="fingerprint_last_delete_message_profile_challenge" msgid="3460246522493987163">"No podrás usar tus huellas digitales para desbloquear tu perfil de trabajo, autorizar compras ni acceder a apps de trabajo"</string>
    <string name="fingerprint_last_delete_confirm" msgid="3294910995598819259">"Sí, deseo quitarlas"</string>
    <string name="crypt_keeper_settings_title" msgid="4938812137822100044">"Encriptación"</string>
    <string name="crypt_keeper_encrypt_title" product="tablet" msgid="7484150746479958376">"Encriptar Tablet"</string>
    <string name="crypt_keeper_encrypt_title" product="default" msgid="8302873664348463041">"Encriptar dispositivo"</string>
    <string name="crypt_keeper_encrypted_summary" msgid="3866488451639592071">"Encriptado"</string>
    <string name="crypt_keeper_desc" product="tablet" msgid="4103951371711323192">"Puedes encriptar las cuentas, configuración, aplicaciones descargadas y sus datos, archivos multimedia y otros archivos. Después de encriptar la tablet, si configuraste un bloqueo de pantalla (es decir, un patrón, un PIN numérico o una contraseña), tendrás que desbloquear la pantalla para desencriptar la tablet cada vez que la enciendas. La única otra forma de desencriptar es restablecer la configuración de fábrica, de manera que se borren todos los datos.\n\nLa encriptación tarda una hora o más. Para comenzar, la batería tiene que estar cargada y debes mantener la tablet conectada hasta que finalice el proceso. Si lo interrumpes, es posible que pierdas toda la información o parte de ella."</string>
    <string name="crypt_keeper_desc" product="default" msgid="6180866043921135548">"Puedes encriptar las cuentas, configuración, aplicaciones descargadas y sus datos, archivos multimedia y otros archivos. Después de encriptar el teléfono, si configuraste un bloqueo de pantalla (es decir, un patrón o un PIN numérico o una contraseña), tendrás que desbloquear la pantalla para desencriptar el teléfono cada vez que lo enciendas. La única otra forma de desencriptar es restablecer la configuración de fábrica, de manera que se borren todos los datos.\n\nLa encriptación tarda una hora o más. Para comenzar, la batería tiene que estar cargada y debes mantener el teléfono conectado hasta que finalice el proceso. Si lo interrumpes, es posible que pierdas toda la información o parte de ella."</string>
    <string name="crypt_keeper_button_text" product="tablet" msgid="5551608011810921471">"Encriptar tablet"</string>
    <string name="crypt_keeper_button_text" product="default" msgid="6370330929679426136">"Encriptar dispositivo"</string>
    <string name="crypt_keeper_low_charge_text" msgid="4920087247177024521">"Carga tu batería e inténtalo nuevamente."</string>
    <string name="crypt_keeper_unplugged_text" msgid="2709721134148651329">"Enchufa tu cargador e inténtalo nuevamente."</string>
    <string name="crypt_keeper_dialog_need_password_title" msgid="1847280235529858357">"Sin contraseña o PIN de pantalla de bloqueo"</string>
    <string name="crypt_keeper_dialog_need_password_message" msgid="7210616262954236042">"Debes configurar una contraseña o PIN de pantalla de bloqueo antes de comenzar con la encriptación."</string>
    <string name="crypt_keeper_confirm_title" msgid="8600000209722452230">"¿Encriptar?"</string>
    <string name="crypt_keeper_final_desc" product="tablet" msgid="3270587498436152259">"La encriptación es irreversible y no puede interrumpirse; de lo contrario, perderás información. La encriptación demora al menos una hora. Durante este tiempo, la tablet se reiniciará varias veces."</string>
    <string name="crypt_keeper_final_desc" product="default" msgid="3040428543349852419">"La encriptación es irreversible y no puede interrumpirse; de lo contrario, perderás información. La encriptación demora al menos una hora. Durante este tiempo, el dispositivo se reiniciará varias veces."</string>
    <string name="crypt_keeper_setup_title" msgid="3339725741305796680">"Encriptando"</string>
    <string name="crypt_keeper_setup_description" product="tablet" msgid="4417016995091289019">"Espera mientras se encripta tu tablet. <xliff:g id="PERCENT">^1</xliff:g>% completado."</string>
    <string name="crypt_keeper_setup_description" product="default" msgid="7902355422499500352">"Espera mientras se encripta tu dispositivo. <xliff:g id="PERCENT">^1</xliff:g>% completado."</string>
    <string name="crypt_keeper_setup_time_remaining" product="tablet" msgid="8348188415839917821">"Espera mientras se encripta la tablet. Tiempo restante: <xliff:g id="DURATION">^1</xliff:g>"</string>
    <string name="crypt_keeper_setup_time_remaining" product="default" msgid="8556105766597855198">"Espera mientras se encripta el teléfono. Tiempo restante: <xliff:g id="DURATION">^1</xliff:g>"</string>
    <string name="crypt_keeper_force_power_cycle" product="tablet" msgid="3832496715430327682">"Para desbloquear la tablet, apágala y vuelve a encenderla."</string>
    <string name="crypt_keeper_force_power_cycle" product="default" msgid="5070346039522135361">"Para desbloquear el teléfono, apágalo y vuelve a encenderlo."</string>
    <string name="crypt_keeper_warn_wipe" msgid="8104921337301750394">"Advertencia: Se borrarán los datos del dispositivo después de otros <xliff:g id="COUNT">^1</xliff:g> intentos fallidos para desbloquearlo."</string>
    <string name="crypt_keeper_enter_password" msgid="1274917431075529732">"Escribe la contraseña"</string>
    <string name="crypt_keeper_failed_title" msgid="8173654570682244149">"Encriptación incorrecta"</string>
    <string name="crypt_keeper_failed_summary" product="tablet" msgid="5977961188966570342">"La encriptación se interrumpió y no se puede completar. Por esta razón, ya no es posible acceder a los datos de tu tablet. \n\n Para reanudar el uso de tu tablet, debes restablecer los datos de fábrica. Cuando configures tu tablet luego de restablecer los datos de fábrica, tendrás la posibilidad de restaurar los datos de los que tengas una copia de seguridad en tu cuenta de Google."</string>
    <string name="crypt_keeper_failed_summary" product="default" msgid="1028716993071131029">"La encriptación se interrumpió y no se puede completar. Por esta razón, ya no es posible acceder a los datos de tu dispositivo. \n\nPara reanudar el uso de tu dispositivo, debes restablecer los datos de fábrica. Cuando configures tu dispositivo luego de restablecer los datos de fábrica, tendrás la posibilidad de restaurar los datos de los que tengas una copia de seguridad en tu cuenta de Google."</string>
    <string name="crypt_keeper_data_corrupt_title" msgid="5920153462176846037">"Desencriptación incorrecta"</string>
    <string name="crypt_keeper_data_corrupt_summary" product="tablet" msgid="4420666705959562753">"La contraseña que ingresaste es correcta, pero los datos están dañados. \n\nPara continuar usando la tablet, debes restablecer la configuración de fábrica. Cuando configures la tablet después del restablecimiento, podrás restaurar los datos que guardaste en una copia de seguridad en la cuenta de Google."</string>
    <string name="crypt_keeper_data_corrupt_summary" product="default" msgid="3200498792238652367">"La contraseña que ingresaste es correcta, pero los datos están dañados. \n\nPara continuar usando el teléfono, debes restablecer la configuración de fábrica. Cuando configures el teléfono después del restablecimiento, podrás restaurar los datos que guardaste en una copia de seguridad en la cuenta de Google."</string>
    <string name="crypt_keeper_switch_input_method" msgid="7712732134989470573">"Cambiar método de introducción"</string>
    <string name="suggested_lock_settings_title" msgid="7836065447159730217">"Protege tu teléfono"</string>
    <string name="suggested_lock_settings_summary" product="tablet" msgid="3213718550422761562">"Agrega un bloqueo de pantalla para proteger la tablet"</string>
    <string name="suggested_lock_settings_summary" product="device" msgid="8479766049078378225">"Agrega bloqueo de pantalla para proteger el dispositivo"</string>
    <string name="suggested_lock_settings_summary" product="default" msgid="2443273582716671033">"Agrega un bloqueo de pantalla para proteger el teléfono"</string>
    <string name="suggested_fingerprint_lock_settings_title" msgid="3140266181874137984">"Agrega una huella digital como desbloqueo"</string>
    <string name="suggested_fingerprint_lock_settings_summary" product="tablet" msgid="1040265358906410746"></string>
    <string name="suggested_fingerprint_lock_settings_summary" product="device" msgid="1040265358906410746"></string>
    <string name="suggested_fingerprint_lock_settings_summary" product="default" msgid="1040265358906410746"></string>
    <string name="lock_settings_picker_title" msgid="9219376327364915334">"Bloqueo de pantalla"</string>
    <string name="lock_settings_picker_title_profile" msgid="8377696902400733227">"Elegir bloqueo"</string>
    <string name="setup_lock_settings_picker_title" product="tablet" msgid="1276283007274778191">"Protege tu tablet"</string>
    <string name="setup_lock_settings_picker_title" product="device" msgid="3585905639045649905">"Protege tu dispositivo"</string>
    <string name="setup_lock_settings_picker_title" product="default" msgid="2758197863515864300">"Protege el teléfono"</string>
    <string name="lock_settings_picker_biometrics_added_security_message" msgid="1105247657304421299">"Para mayor seguridad, establece un bloqueo de pantalla secundario"</string>
    <string name="setup_lock_settings_picker_message" product="tablet" msgid="4870877800737248926">"Activa las funciones de protección del dispositivo para impedir que terceros usen esta tablet sin tu permiso. Elige el bloqueo de pantalla que quieres usar."</string>
    <string name="setup_lock_settings_picker_message" product="device" msgid="8961855222808442301">"Activa las funciones de protección del dispositivo para impedir que terceros lo usen sin tu permiso. Elige el bloqueo de pantalla que quieres usar."</string>
    <string name="setup_lock_settings_picker_message" product="default" msgid="8867435145945818970">"Activa las funciones de protección del dispositivo para impedir que terceros usen este teléfono sin tu permiso. Elige el bloqueo de pantalla que quieres usar."</string>
    <string name="lock_settings_picker_biometric_message" msgid="2609666443527262781">"Elige el método secundario de bloqueo de pantalla"</string>
    <string name="setup_lock_settings_options_button_label" msgid="6098297461618298505">"Opciones de bloqueo de la pantalla"</string>
    <string name="setup_lock_settings_options_dialog_title" msgid="7985107300517468569">"Opciones de bloqueo de la pantalla"</string>
    <string name="unlock_set_unlock_launch_picker_title" msgid="4981063601772605609">"Bloqueo de pantalla"</string>
    <string name="unlock_set_unlock_launch_picker_summary_lock_immediately" msgid="5799070517574360310">"<xliff:g id="UNLOCK_METHOD">%1$s</xliff:g> / inmediatamente después de la suspensión"</string>
    <string name="unlock_set_unlock_launch_picker_summary_lock_after_timeout" msgid="4572132216801894216">"<xliff:g id="UNLOCK_METHOD">%1$s</xliff:g> / <xliff:g id="TIMEOUT_STRING">%2$s</xliff:g> después de la suspensión"</string>
    <string name="unlock_set_unlock_launch_picker_title_profile" msgid="7631371082326055429">"Bloqueo del perfil"</string>
    <string name="unlock_set_unlock_launch_picker_change_title" msgid="4746783679112447948">"Cambiar pant. bloqueada"</string>
    <string name="unlock_set_unlock_launch_picker_change_summary" msgid="6023813780512501969">"Cambiar/inhab. patrón/PIN/contraseña"</string>
    <string name="unlock_set_unlock_launch_picker_enable_summary" msgid="1699993191343299179">"Elige un método para bloquear la pantalla."</string>
    <string name="unlock_set_unlock_off_title" msgid="2831957685685921667">"Ninguno"</string>
    <string name="unlock_set_unlock_off_summary" msgid="4578319976164001322"></string>
    <string name="unlock_set_unlock_none_title" msgid="2844029875174409728">"Deslizar"</string>
    <string name="unlock_set_unlock_none_summary" msgid="641298008390890152">"Sin seguridad"</string>
    <string name="unlock_set_unlock_pattern_title" msgid="8224895208452995332">"Patrón"</string>
    <string name="unlock_set_unlock_pattern_summary" msgid="4482018884090552709">"Seguridad media"</string>
    <string name="unlock_set_unlock_pin_title" msgid="5283636759362880407">"PIN"</string>
    <string name="unlock_set_unlock_pin_summary" msgid="1961863114590024945">"Nivel de seguridad medio a alto"</string>
    <string name="unlock_set_unlock_password_title" msgid="2559842616268607041">"Contraseña"</string>
    <string name="unlock_set_unlock_password_summary" msgid="7647435233968707432">"Nivel de seguridad alto"</string>
    <string name="unlock_set_do_later_title" msgid="6565575303676064364">"Ahora no"</string>
    <string name="current_screen_lock" msgid="1367883977261098017">"Bloqueo de pantalla actual"</string>
    <string name="fingerprint_unlock_set_unlock_pattern" msgid="4492334416059646032">"Huella digital y patrón"</string>
    <string name="fingerprint_unlock_set_unlock_pin" msgid="4724451168139460493">"Huella digital y PIN"</string>
    <string name="fingerprint_unlock_set_unlock_password" msgid="5614333047430835971">"Huella digital y contraseña"</string>
    <string name="fingerprint_unlock_skip_fingerprint" msgid="7631242444064287891">"Continuar sin huella digitale"</string>
    <string name="fingerprint_unlock_title" msgid="4978686534505944042">"Puedes desbloquear el teléfono con tu huella digital. Para mayor seguridad, esta opción requiere un método secundario de bloqueo de pantalla."</string>
    <string name="face_unlock_set_unlock_pattern" msgid="5991691559532427891">"Desbloqueo facial y patrón"</string>
    <string name="face_unlock_set_unlock_pin" msgid="8990569318587034610">"Desbloqueo facial y PIN"</string>
    <string name="face_unlock_set_unlock_password" msgid="8612535943511761549">"Desbloqueo facial y contraseña"</string>
    <string name="face_unlock_skip_face" msgid="7117201898540606846">"Continuar sin el desbloqueo facial"</string>
    <string name="face_unlock_title" msgid="7344830351598247267">"Puedes desbloquear tu teléfono con el reconocimiento facial. Para mayor seguridad, esta opción requiere un método secundario de bloqueo de pantalla."</string>
    <string name="biometrics_unlock_set_unlock_pattern" msgid="8871485472202659">"Datos biométricos + patrón"</string>
    <string name="biometrics_unlock_set_unlock_pin" msgid="1729940978662427512">"Datos biométricos + PIN"</string>
    <string name="biometrics_unlock_set_unlock_password" msgid="5368133215008755916">"Datos biométricos + contraseña"</string>
    <string name="biometrics_unlock_skip_biometrics" msgid="8260715582785687329">"Continuar sin configurar datos biométricos"</string>
    <string name="biometrics_unlock_title" msgid="7769374223959937435">"Puedes desbloquear el teléfono con tus datos biométricos. Por razones de seguridad, esta opción requiere un método secundario de bloqueo de pantalla."</string>
    <string name="unlock_set_unlock_disabled_summary" msgid="4022867760387966129">"Inhabilitada: admin, encriptación o credenciales"</string>
    <string name="unlock_set_unlock_mode_off" msgid="4632139864722236359">"Ninguno"</string>
    <string name="unlock_set_unlock_mode_none" msgid="5596049938457028214">"Deslizar"</string>
    <string name="unlock_set_unlock_mode_pattern" msgid="1926480143883094896">"Patrón"</string>
    <string name="unlock_set_unlock_mode_pin" msgid="9028659554829888373">"PIN"</string>
    <string name="unlock_set_unlock_mode_password" msgid="8810609692771987513">"Contraseña"</string>
    <string name="unlock_setup_wizard_fingerprint_details" msgid="5974580769186206478">"Después de configurar el bloqueo de pantalla, también puedes establecer la huella digital en Configuración &gt; Seguridad."</string>
    <string name="unlock_disable_lock_title" msgid="2564279819907932759">"Desactivar el bloqueo de pantalla"</string>
    <string name="unlock_disable_frp_warning_title" msgid="1520689401825045809">"¿Deseas quitar la protección del dispositivo?"</string>
    <string name="unlock_disable_frp_warning_title_profile" msgid="1005284289723910461">"¿Quieres quitar la protección del perfil?"</string>
    <string name="unlock_disable_frp_warning_content_pattern" msgid="669384600341275312">"Las funciones de protección del dispositivo no estarán disponibles sin el patrón."</string>
    <string name="unlock_disable_frp_warning_content_pattern_fingerprint" msgid="8160948976853039106">"Las funciones de protección del dispositivo no podrán usarse sin tu patrón.<xliff:g id="EMPTY_LINE">

</xliff:g>También se quitarán las huellas digitales guardadas del dispositivo, por lo que no podrás usarlas para desbloquear el teléfono, autorizar compras ni acceder a las apps."</string>
    <string name="unlock_disable_frp_warning_content_pin" msgid="3732073290049930632">"Las funciones de protección del dispositivo no estarán disponibles sin el PIN."</string>
    <string name="unlock_disable_frp_warning_content_pin_fingerprint" msgid="2018020861756931097">"Las funciones de protección del dispositivo no podrán usarse sin tu PIN.<xliff:g id="EMPTY_LINE">

</xliff:g>También se quitarán las huellas digitales guardadas del dispositivo, por lo que no podrás usarlas para desbloquear el teléfono, autorizar compras ni acceder a las apps."</string>
    <string name="unlock_disable_frp_warning_content_password" msgid="2130004168084396797">"Las funciones de protección del dispositivo no estarán disponibles sin la contraseña."</string>
    <string name="unlock_disable_frp_warning_content_password_fingerprint" msgid="8455564842615579472">"Las funciones de protección del dispositivo no podrán usarse sin tu contraseña.<xliff:g id="EMPTY_LINE">

</xliff:g>También se quitarán las huellas digitales guardadas del dispositivo, por lo que no podrás usarlas para desbloquear el teléfono, autorizar compras ni acceder a las apps."</string>
    <string name="unlock_disable_frp_warning_content_unknown" msgid="8903568674104115231">"Las funciones de protección del dispositivo no estarán disponibles sin el bloqueo de pantalla."</string>
    <string name="unlock_disable_frp_warning_content_unknown_fingerprint" msgid="4985095359625056279">"Las funciones de protección del dispositivo no podrán usarse sin el bloqueo de pantalla.<xliff:g id="EMPTY_LINE">

</xliff:g>También se quitarán las huellas digitales guardadas del dispositivo, por lo que no podrás usarlas para desbloquear el teléfono, autorizar compras ni acceder a las apps."</string>
    <string name="unlock_disable_frp_warning_content_pattern_profile" msgid="6850770024037691891">"Las funciones de protección del perfil no podrán usarse sin tu patrón."</string>
    <string name="unlock_disable_frp_warning_content_pattern_fingerprint_profile" msgid="313998125412427527">"Las funciones de protección del perfil no podrán usarse sin tu patrón.<xliff:g id="EMPTY_LINE">

</xliff:g>También se quitarán las huellas digitales guardadas de este perfil, por lo que no podrás usarlas para desbloquear tu perfil, autorizar compras ni acceder a las apps."</string>
    <string name="unlock_disable_frp_warning_content_pin_profile" msgid="6328378875803145738">"Las funciones de protección del perfil no podrán usarse sin tu PIN."</string>
    <string name="unlock_disable_frp_warning_content_pin_fingerprint_profile" msgid="6844729803535310058">"Las funciones de protección del perfil no podrán usarse sin tu PIN.<xliff:g id="EMPTY_LINE">

</xliff:g>También se quitarán las huellas digitales guardadas de este perfil, por lo que no podrás usarlas para desbloquear tu perfil, autorizar compras ni acceder a las apps."</string>
    <string name="unlock_disable_frp_warning_content_password_profile" msgid="6922335143823758149">"Las funciones de protección del perfil no podrán usarse sin tu contraseña."</string>
    <string name="unlock_disable_frp_warning_content_password_fingerprint_profile" msgid="5724824564583660260">"Las funciones de protección del perfil no podrán usarse sin tu contraseña.<xliff:g id="EMPTY_LINE">

</xliff:g>También se quitarán las huellas digitales guardadas de este perfil, por lo que no podrás usarlas para desbloquear tu perfil, autorizar compras ni acceder a las apps."</string>
    <string name="unlock_disable_frp_warning_content_unknown_profile" msgid="6886183964362015704">"Las funciones de protección del perfil no podrán usarse sin tu bloqueo de pantalla."</string>
    <string name="unlock_disable_frp_warning_content_unknown_fingerprint_profile" msgid="3754195701700959477">"Las funciones de protección del perfil no podrán usarse sin el bloqueo de pantalla.<xliff:g id="EMPTY_LINE">

</xliff:g>También se quitarán las huellas digitales guardadas de este perfil, por lo que no podrás usarlas para desbloquear tu perfil, autorizar compras ni acceder a las apps."</string>
    <string name="unlock_disable_frp_warning_ok" msgid="621607297961726537">"Sí, deseo quitarla"</string>
    <string name="unlock_change_lock_pattern_title" msgid="8234523589333929193">"Cambiar patrón de desbloqueo"</string>
    <string name="unlock_change_lock_pin_title" msgid="2324077520816477479">"Cambiar PIN de desbloqueo"</string>
    <string name="unlock_change_lock_password_title" msgid="873517913969091074">"Cambiar la contraseña de desbloqueo"</string>
    <string name="unlock_footer_high_complexity_requested" msgid="4471274783909915352">"<xliff:g id="APP_NAME">%1$s</xliff:g> recomienda establecer una contraseña o un patrón seguro, y es posible que no funcione como debería sin uno de estos métodos de bloqueo"</string>
    <string name="unlock_footer_medium_complexity_requested" msgid="5515870066751600640">"<xliff:g id="APP_NAME">%1$s</xliff:g> recomienda establecer un nuevo patrón o contraseña, y es posible que no funcione como debería sin uno de estos métodos de bloqueo"</string>
    <string name="unlock_footer_low_complexity_requested" msgid="2517656037576567971">"<xliff:g id="APP_NAME">%1$s</xliff:g> recomienda establecer un nuevo patrón, PIN o contraseña, y es posible que no funcione como debería sin uno de estos métodos de bloqueo"</string>
    <string name="unlock_footer_none_complexity_requested" msgid="8534900170428140529">"<xliff:g id="APP_NAME">%1$s</xliff:g> recomienda establecer un nuevo bloqueo de pantalla"</string>
    <string name="lock_failed_attempts_before_wipe" msgid="6874652886647631418">"Vuelve a intentarlo. Intento <xliff:g id="CURRENT_ATTEMPTS">%1$d</xliff:g> de <xliff:g id="TOTAL_ATTEMPTS">%2$d</xliff:g>."</string>
    <string name="lock_last_attempt_before_wipe_warning_title" msgid="7450322567217745999">"Se borrarán tus datos"</string>
    <string name="lock_last_pattern_attempt_before_wipe_device" msgid="5816668400104558952">"Si ingresas un patrón incorrecto en el próximo intento, se borrarán los datos de este dispositivo"</string>
    <string name="lock_last_pin_attempt_before_wipe_device" msgid="2815681042623708775">"Si ingresas un PIN incorrecto en el próximo intento, se borrarán los datos de este dispositivo"</string>
    <string name="lock_last_password_attempt_before_wipe_device" msgid="985126164175708507">"Si ingresas una contraseña incorrecta en el próximo intento, se borrarán los datos de este dispositivo"</string>
    <string name="lock_last_pattern_attempt_before_wipe_user" msgid="8283944727199433440">"Si ingresas un patrón incorrecto en el próximo intento, se borrará este usuario"</string>
    <string name="lock_last_pin_attempt_before_wipe_user" msgid="972834567684477451">"Si ingresas un PIN incorrecto en el próximo intento, se borrará este usuario"</string>
    <string name="lock_last_password_attempt_before_wipe_user" msgid="3797239847079686727">"Si ingresas una contraseña incorrecta en el próximo intento, se borrará este usuario"</string>
    <string name="lock_last_pattern_attempt_before_wipe_profile" msgid="2479195488386373253">"Si ingresas un patrón incorrecto en el próximo intento, se borrarán tu perfil de trabajo y sus datos"</string>
    <string name="lock_last_pin_attempt_before_wipe_profile" msgid="7086428013814722436">"Si ingresas un PIN incorrecto en el próximo intento, se borrarán tu perfil de trabajo y sus datos"</string>
    <string name="lock_last_password_attempt_before_wipe_profile" msgid="253673907244112643">"Si ingresas una contraseña incorrecta en el próximo intento, se borrarán tu perfil de trabajo y sus datos"</string>
    <string name="lock_failed_attempts_now_wiping_device" msgid="2813744895409014471">"Hubo demasiados intentos incorrectos. Se borrarán los datos de este dispositivo."</string>
    <string name="lock_failed_attempts_now_wiping_user" msgid="3958755474620948727">"Hubo demasiados intentos incorrectos. Se borrará este usuario."</string>
    <string name="lock_failed_attempts_now_wiping_profile" msgid="3171880997211568208">"Hubo demasiados intentos incorrectos. Se borrarán este perfil de trabajo y sus datos."</string>
    <string name="lock_failed_attempts_now_wiping_dialog_dismiss" msgid="170155081899679669">"Descartar"</string>
    <plurals name="lockpassword_password_too_short" formatted="false" msgid="2192234965414232157">
      <item quantity="other">Debe tener al menos <xliff:g id="COUNT_1">%d</xliff:g> caracteres</item>
      <item quantity="one">Debe tener al menos <xliff:g id="COUNT_0">%d</xliff:g> carácter</item>
    </plurals>
    <plurals name="lockpassword_pin_too_short" formatted="false" msgid="6817086810898414162">
      <item quantity="other">El PIN debe tener al menos <xliff:g id="COUNT_1">%d</xliff:g> dígitos</item>
      <item quantity="one">El PIN debe tener al menos <xliff:g id="COUNT_0">%d</xliff:g> dígito</item>
    </plurals>
    <string name="lockpassword_continue_label" msgid="2507983991979547816">"Continuar"</string>
    <plurals name="lockpassword_password_too_long" formatted="false" msgid="8118091957172967677">
      <item quantity="other">Debe tener menos de <xliff:g id="NUMBER_1">%d</xliff:g> caracteres</item>
      <item quantity="one">Debe tener menos de <xliff:g id="NUMBER_0">%d</xliff:g> carácter</item>
    </plurals>
    <plurals name="lockpassword_pin_too_long" formatted="false" msgid="8706992338720310765">
      <item quantity="other">Debe tener menos de <xliff:g id="NUMBER_1">%d</xliff:g> dígitos</item>
      <item quantity="one">Debe tener menos de <xliff:g id="NUMBER_0">%d</xliff:g> dígito</item>
    </plurals>
    <string name="lockpassword_pin_recently_used" msgid="6650277060998923465">"El administrador del dispositivo no permite el uso de un PIN reciente"</string>
    <string name="lockpassword_illegal_character" msgid="3434031212215886433">"No puede incluir un carácter no válido"</string>
    <string name="lockpassword_password_requires_alpha" msgid="721084100957669018">"Debe tener al menos una letra"</string>
    <string name="lockpassword_password_requires_digit" msgid="312518567592683795">"Debe tener al menos un dígito"</string>
    <string name="lockpassword_password_requires_symbol" msgid="6178512486154701321">"Debe tener al menos un símbolo"</string>
    <plurals name="lockpassword_password_requires_letters" formatted="false" msgid="2385916409676839024">
      <item quantity="other">Debe tener al menos <xliff:g id="COUNT">%d</xliff:g> letras</item>
      <item quantity="one">Debe tener al menos 1 letra</item>
    </plurals>
    <plurals name="lockpassword_password_requires_lowercase" formatted="false" msgid="2057467885488612701">
      <item quantity="other">Debe tener al menos <xliff:g id="COUNT">%d</xliff:g> letras en minúscula</item>
      <item quantity="one">Debe tener al menos 1 letra en minúscula</item>
    </plurals>
    <plurals name="lockpassword_password_requires_uppercase" formatted="false" msgid="4541266279643052025">
      <item quantity="other">Debe tener al menos <xliff:g id="COUNT">%d</xliff:g> letras en mayúscula</item>
      <item quantity="one">Debe tener al menos 1 letra en mayúscula</item>
    </plurals>
    <plurals name="lockpassword_password_requires_numeric" formatted="false" msgid="70617964591376248">
      <item quantity="other">Debe tener al menos <xliff:g id="COUNT">%d</xliff:g> dígitos</item>
      <item quantity="one">Debe tener al menos 1 dígito</item>
    </plurals>
    <plurals name="lockpassword_password_requires_symbols" formatted="false" msgid="7981236881269921943">
      <item quantity="other">Debe tener al menos <xliff:g id="COUNT">%d</xliff:g> símbolos especiales</item>
      <item quantity="one">Debe tener al menos 1 símbolo especial</item>
    </plurals>
    <plurals name="lockpassword_password_requires_nonletter" formatted="false" msgid="1567877061888948467">
      <item quantity="other">Debe tener al menos <xliff:g id="COUNT">%d</xliff:g> caracteres que no sean letras</item>
      <item quantity="one">Debe tener al menos 1 carácter que no sea una letra</item>
    </plurals>
    <plurals name="lockpassword_password_requires_nonnumerical" formatted="false" msgid="5056743974888384475">
      <item quantity="other">Debe tener al menos <xliff:g id="COUNT">%d</xliff:g> caracteres no numéricos</item>
      <item quantity="one">Debe tener al menos 1 carácter no numérico</item>
    </plurals>
    <string name="lockpassword_password_recently_used" msgid="5341218079730167191">"El administrador del dispositivo no permite el uso de contraseñas recientes"</string>
    <string name="lockpassword_pin_no_sequential_digits" msgid="5843639256988031272">"No se permiten secuencias de dígitos ascendentes, descendentes ni repetidas"</string>
    <string name="lockpassword_confirm_label" msgid="560897521093566777">"Confirmar"</string>
    <string name="lockpassword_cancel_label" msgid="6711112212489992112">"Cancelar"</string>
    <string name="lockpassword_clear_label" msgid="311359833434539894">"Borrar"</string>
    <string name="lockpassword_credential_changed" msgid="5934778179732392028">"Ya se cambió el bloqueo de pantalla. Vuelve a intentarlo con el nuevo bloqueo de pantalla."</string>
    <string name="lockpattern_tutorial_cancel_label" msgid="775215267818384016">"Cancelar"</string>
    <string name="lockpattern_tutorial_continue_label" msgid="1329049481210689408">"Siguiente"</string>
    <string name="lock_setup" msgid="4622999020926280737">"Se completó la configuración."</string>
    <string name="manage_device_admin" msgid="1044620606203916275">"Apps de administración"</string>
    <string name="number_of_device_admins_none" msgid="152926922020437312">"No hay apps activas"</string>
    <plurals name="number_of_device_admins" formatted="false" msgid="2528735319390151989">
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g> apps activas</item>
      <item quantity="one"><xliff:g id="COUNT_0">%d</xliff:g> app activa</item>
    </plurals>
    <string name="manage_trust_agents" msgid="6410149930029992356">"Agentes de confianza"</string>
    <string name="disabled_because_no_backup_security" msgid="4998095356607488854">"Para usarlo, debes establecer un bloqueo de pantalla"</string>
    <string name="manage_trust_agents_summary" msgid="6423843123607674286">"Ninguno"</string>
    <plurals name="manage_trust_agents_summary_on" formatted="false" msgid="5438047398376802735">
      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> agentes de confianza activos</item>
      <item quantity="one">1 agente de confianza activo</item>
    </plurals>
    <string name="bluetooth_quick_toggle_title" msgid="5955341060378240781">"Bluetooth"</string>
    <string name="bluetooth_quick_toggle_summary" msgid="5257744297562880017">"Activar Bluetooth"</string>
    <string name="bluetooth_settings" msgid="2967239493428695171">"Bluetooth"</string>
    <string name="bluetooth_settings_title" msgid="2642029095769509647">"Bluetooth"</string>
    <string name="bluetooth_settings_summary" msgid="6805458703566046784">"Administrar conexiones, establecer nombre y detección del dispositivo"</string>
    <string name="bluetooth_pairing_request" msgid="7762990650683525640">"¿Vincular con <xliff:g id="DEVICE_NAME">%1$s</xliff:g>?"</string>
    <string name="bluetooth_pairing_key_msg" msgid="1329835708475701761">"Código de vinculación Bluetooth"</string>
    <string name="bluetooth_enter_passkey_msg" msgid="5806420933599368592">"Ingresa el código de sincronización y luego presiona Intro."</string>
    <string name="bluetooth_enable_alphanumeric_pin" msgid="7256286571636950635">"El PIN contiene letras o símbolos."</string>
    <string name="bluetooth_pin_values_hint" msgid="2753202519050044670">"Por lo general, 0000 o 1234"</string>
    <string name="bluetooth_pin_values_hint_16_digits" msgid="5603928271430883558">"Debe contener 16 dígitos"</string>
    <string name="bluetooth_enter_pin_other_device" msgid="6737778699899780717">"Puede que también tengas que escribir este PIN en el otro dispositivo."</string>
    <string name="bluetooth_enter_passkey_other_device" msgid="8270426446247344709">"Puede que también tengas que escribir esta clave de acceso en otro dispositivo."</string>
    <string name="bluetooth_confirm_passkey_msg" msgid="327192310468680072">"Para vincular con&lt;br&gt;&lt;b&gt;<xliff:g id="DEVICE_NAME">%1$s</xliff:g>&lt;/b&gt;&lt;br&gt;&lt;br&gt;asegúrate de que se muestre esta clave de acceso:&lt;br&gt;&lt;b&gt;<xliff:g id="PASSKEY">%2$s</xliff:g>&lt;/b&gt;."</string>
    <string name="bluetooth_incoming_pairing_msg" msgid="1068123527866596779">"¿Desde: &lt;br&gt;&lt;b&gt;<xliff:g id="DEVICE_NAME">%1$s</xliff:g>&lt;/b&gt;&lt;br&gt;&lt;br&gt;sincronizas con este dispositivo?"</string>
    <string name="bluetooth_display_passkey_pin_msg" msgid="8672803845151786521">"Para vincular con:<xliff:g id="BOLD1_0">&lt;br&gt;&lt;b&gt;</xliff:g><xliff:g id="DEVICE_NAME">%1$s</xliff:g><xliff:g id="END_BOLD1">&lt;/b&gt;&lt;br&gt;&lt;br&gt;</xliff:g>Escribe allí:<xliff:g id="BOLD2_1">&lt;br&gt;&lt;b&gt;</xliff:g><xliff:g id="PASSKEY">%2$s</xliff:g><xliff:g id="END_BOLD2">&lt;/b&gt;</xliff:g> y luego presiona Volver o Enter."</string>
    <string name="bluetooth_pairing_shares_phonebook" msgid="4329325125260724843">"Permitir el acceso a tus contactos y al historial de llamadas"</string>
    <string name="bluetooth_error_title" msgid="2284738188253690278"></string>
    <string name="bluetooth_connecting_error_message" msgid="3941893154784152112">"No se pudo establecer conexión con <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="bluetooth_preference_scan_title" msgid="3460316252463771851">"Buscar dispositivos"</string>
    <string name="bluetooth_search_for_devices" msgid="6516902340975407648">"Actualizar"</string>
    <string name="bluetooth_searching_for_devices" msgid="6541984133657573124">"Buscando..."</string>
    <string name="bluetooth_preference_device_settings" msgid="1688662188157019998">"Configuración de dispositivos"</string>
    <string name="bluetooth_preference_paired_dialog_title" msgid="1090131276572055841">"Dispositivo sincronizado"</string>
    <string name="bluetooth_preference_paired_dialog_internet_option" msgid="4337953030661626289">"Conexión a Internet"</string>
    <string name="bluetooth_preference_paired_dialog_keyboard_option" msgid="8247634441638919886">"Teclado"</string>
    <string name="bluetooth_preference_paired_dialog_contacts_option" msgid="8194423860397844579">"Contactos e historial de llamadas"</string>
    <string name="bluetooth_pairing_dialog_title" msgid="6106058683134173178">"¿Vincular con este dispositivo?"</string>
    <string name="bluetooth_pairing_dialog_sharing_phonebook_title" msgid="5472835166206721325">"¿Compartir libreta telefónica?"</string>
    <string name="bluetooth_pairing_dialog_contants_request" msgid="7516277926581535299">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g> quiere acceder a tus contactos y al historial de llamadas."</string>
    <string name="bluetooth_pairing_dialog_paring_request" msgid="1545098121090892788">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g> quiere sincronizarse con Bluetooth. Al conectarse, podrá acceder a contactos e hist. de llamadas."</string>
    <string name="bluetooth_preference_found_media_devices" msgid="830061195998352840">"Dispositivos disponibles"</string>
    <string name="bluetooth_preference_no_found_devices" msgid="1331122763066030155">"No hay dispositivos disponibles."</string>
    <string name="bluetooth_device_context_connect" msgid="4913860372216815855">"Conectar"</string>
    <string name="bluetooth_device_context_disconnect" msgid="4464167389972513232">"Desconectar"</string>
    <string name="bluetooth_device_context_pair_connect" msgid="2406032703622371826">"Vincular y conectar"</string>
    <string name="bluetooth_device_context_unpair" msgid="7525735305244087162">"Desvincular"</string>
    <string name="bluetooth_device_context_disconnect_unpair" msgid="2001359431289794561">"Desconectar y desvincular"</string>
    <string name="bluetooth_device_context_connect_advanced" msgid="934657460643490773">"Opciones…"</string>
    <string name="bluetooth_menu_advanced" msgid="7633682234855216066">"Config. avanzada"</string>
    <string name="bluetooth_advanced_titlebar" msgid="5369701494951467257">"Bluetooth avanzado"</string>
    <string name="bluetooth_empty_list_bluetooth_off" msgid="316627049372961941">"Cuando Bluetooth está activado, permite conectarse con dispositivos cercanos"</string>
    <string name="bluetooth_scanning_on_info_message" msgid="4069064120315578780">"Cuando el Bluetooth está activado, tu dispositivo puede usarlo para comunicarse con otros dispositivos cercanos.\n\nPara mejorar la experiencia, las apps y los servicios pueden buscar dispositivos cercanos incluso cuando la conexión Bluetooth esté desactivada. Esta función puede usarse, por ejemplo, para mejorar las funciones y los servicios basados en la ubicación. Puedes cambiar esta opción en "<annotation id="link">"configuración de búsqueda"</annotation>"."</string>
    <string name="ble_scan_notify_text" msgid="1358879010396045164">"Para mejorar la precisión de la ubicación, los servicios y las aplicaciones del sistema pueden detectar dispositivos Bluetooth. Puedes cambiar esta opción en la <xliff:g id="LINK_BEGIN_0">LINK_BEGIN</xliff:g>configuración de búsqueda<xliff:g id="LINK_END_1">LINK_END</xliff:g>."</string>
    <string name="bluetooth_connect_failed" msgid="7892663424429584925">"No se pudo establecer la conexión. Vuelve a intentarlo."</string>
    <string name="device_details_title" msgid="1155622417516195481">"Detalles del dispositivo"</string>
    <string name="bluetooth_device_mac_address" msgid="4873325074786732703">"Dirección Bluetooth del dispositivo: <xliff:g id="ADDRESS">%1$s</xliff:g>"</string>
    <string name="bluetooth_unpair_dialog_title" msgid="6943633443716052995">"¿Olvidar este dispositivo?"</string>
    <string name="bluetooth_unpair_dialog_body" product="default" msgid="4730377171981539265">"El teléfono ya no estará sincronizado con <xliff:g id="DEVICE_NAME">%1$s</xliff:g>"</string>
    <string name="bluetooth_unpair_dialog_body" product="tablet" msgid="3428463407231980054">"La tablet ya no estará sincronizada con <xliff:g id="DEVICE_NAME">%1$s</xliff:g>"</string>
    <string name="bluetooth_unpair_dialog_body" product="device" msgid="5117397433721336918">"El dispositivo ya no estará sincronizado con <xliff:g id="DEVICE_NAME">%1$s</xliff:g>"</string>
    <string name="bluetooth_untethered_unpair_dialog_body" msgid="1938465582242297905">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g> ya no estará sincronizado con ningún dispositivo vinculado a esta cuenta"</string>
    <string name="bluetooth_unpair_dialog_forget_confirm_button" msgid="9184489424930549015">"Olvidar este dispositivo"</string>
    <string name="bluetooth_connect_specific_profiles_title" msgid="1323072239637864488">"Conectar a..."</string>
    <string name="bluetooth_disconnect_a2dp_profile" msgid="339103864166293612">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g> se desconectará del audio multimedia."</string>
    <string name="bluetooth_disconnect_headset_profile" msgid="7857706184371154920">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g> se desconectará del audio de manos libres."</string>
    <string name="bluetooth_disconnect_hid_profile" msgid="4794752406024916925">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g> se desconectará del dispositivo de entrada."</string>
    <string name="bluetooth_disconnect_pan_user_profile" msgid="283176886159444413">"Se desconectará el acceso a Internet a través de <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="bluetooth_disconnect_pan_nap_profile" product="tablet" msgid="733193449967330892">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g> dejará de compartir la conexión a Internet desde esta tablet."</string>
    <string name="bluetooth_disconnect_pan_nap_profile" product="default" msgid="7852265676243153982">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g> dejará de compartir la conexión a Internet desde este teléfono."</string>
    <string name="bluetooth_device_advanced_title" msgid="1181664272013729515">"Dispositivo Bluetooth sincronizado"</string>
    <string name="bluetooth_device_advanced_online_mode_title" msgid="8302236592496988747">"Conectar"</string>
    <string name="bluetooth_device_advanced_online_mode_summary" msgid="271856759516576615">"Conectar al dispositivo Bluetooth"</string>
    <string name="bluetooth_device_advanced_profile_header_title" msgid="7892879890208207223">"Utilizar para"</string>
    <string name="bluetooth_device_advanced_rename_device" msgid="4798081898389041132">"Cambiar el nombre"</string>
    <string name="bluetooth_device_advanced_enable_opp_title" msgid="7604726126703453984">"Permitir transferencias de archivos entrantes"</string>
    <string name="bluetooth_pan_user_profile_summary_connected" msgid="7851033200857999275">"Conectado para Internet"</string>
    <string name="bluetooth_pan_nap_profile_summary_connected" msgid="5563892893331988809">"Compartiendo conexión"</string>
    <string name="bluetooth_dock_settings" msgid="1709536202189755022">"Configuración de la base"</string>
    <string name="bluetooth_dock_settings_title" msgid="4872789068019972847">"Utilizar la base para el audio"</string>
    <string name="bluetooth_dock_settings_headset" msgid="5756482379574272554">"Como altavoz"</string>
    <string name="bluetooth_dock_settings_a2dp" msgid="434520221656010141">"Para música y medios"</string>
    <string name="bluetooth_dock_settings_remember" msgid="6993526033095292609">"Recordar la configuración"</string>
    <string name="bluetooth_max_connected_audio_devices_string" msgid="3114156958598821615">"Máximo de dispositivos de audio Bluetooth conectados"</string>
    <string name="bluetooth_max_connected_audio_devices_dialog_title" msgid="4056811727247312473">"Selecciona una cantidad máxima de dispositivos de audio Bluetooth conectados"</string>
    <string name="wifi_display_settings_title" msgid="6451625615274960175">"Transmitir"</string>
    <string name="keywords_wifi_display_settings" msgid="5753883229564422679">"duplicar"</string>
    <string name="wifi_display_enable_menu_item" msgid="7391841780777318134">"Habilitar pantalla inalámbrica"</string>
    <string name="wifi_display_no_devices_found" msgid="7904877793677102805">"No se encontraron dispositivos cercanos."</string>
    <string name="wifi_display_status_connecting" msgid="530880182560077334">"Conectando"</string>
    <string name="wifi_display_status_connected" msgid="2189925211258519539">"Conectado"</string>
    <string name="wifi_display_status_in_use" msgid="5904009697167947449">"En uso"</string>
    <string name="wifi_display_status_not_available" msgid="8463750208946968594">"No disponible"</string>
    <string name="wifi_display_details" msgid="2351632307998142920">"Configuración de visualización"</string>
    <string name="wifi_display_options_title" msgid="7584326966240865043">"Opciones de pantalla inalámbrica"</string>
    <string name="wifi_display_options_forget" msgid="3140558691112356024">"Borrar"</string>
    <string name="wifi_display_options_done" msgid="7608851767701954020">"Listo"</string>
    <string name="wifi_display_options_name" msgid="8181334945680312228">"Nombre"</string>
    <string name="wifi_band_24ghz" msgid="7322286660245127384">"2.4 GHz"</string>
    <string name="wifi_band_5ghz" msgid="7995204987245404797">"5 GHz"</string>
    <string name="wifi_sign_in_button_text" msgid="8483892122845654850">"Acceder"</string>
    <string name="wifi_venue_website_button_text" msgid="7749360432667175030">"Abrir sitio"</string>
    <string name="wifi_time_remaining" msgid="8503606272869846170">"Tiempo restante: <xliff:g id="REMAINING_TIME">%1$s</xliff:g>"</string>
    <string name="wifi_expiry_time" msgid="5419758551129267624">"Finalizará a las <xliff:g id="EXPIRY_TIME">%1$s</xliff:g>"</string>
    <string name="wifi_tap_to_sign_in" msgid="8658506618807549483">"Presiona aquí para acceder a la red"</string>
    <string name="tx_link_speed" msgid="3071955184703668113">"<xliff:g id="TRANSMIT_LINK_SPEED">%1$d</xliff:g> Mbps"</string>
    <string name="rx_link_speed" msgid="6292229178855567783">"<xliff:g id="RECEIVE_LINK_SPEED">%1$d</xliff:g> Mbps"</string>
    <string name="link_speed" msgid="931786745741016446">"<xliff:g id="LINK_SPEED">%1$d</xliff:g> Mbps"</string>
    <string name="wifi_ask_enable" msgid="6860056048266810769">"<xliff:g id="REQUESTER">%s</xliff:g> quiere activar la conexión Wi-Fi"</string>
    <string name="wifi_ask_disable" msgid="1663208096020309639">"<xliff:g id="REQUESTER">%s</xliff:g> quiere desactivar la conexión Wi-Fi"</string>
    <string name="art_verifier_for_debuggable_title" msgid="1926445785190030479">"Verificar bytecode de apps depurables"</string>
    <string name="art_verifier_for_debuggable_summary" msgid="4802875841862652879">"Permitir que ART verifique el bytecode de apps depurables"</string>
    <string name="show_refresh_rate" msgid="5742688821872354973">"Frec. de actualización"</string>
    <string name="show_refresh_rate_summary" msgid="3558118122374609663">"Mostrar frec. de actualización actual de pantalla"</string>
    <string name="nfc_quick_toggle_title" msgid="3607620705230351666">"NFC"</string>
    <string name="nfc_quick_toggle_summary" product="tablet" msgid="3622326550467939809">"Permitir el intercambio de datos cuando la tablet entre en contacto con un dispositivo NFC"</string>
    <string name="nfc_quick_toggle_summary" product="default" msgid="1460871052409162980">"Permitir el intercambio de datos cuando el teléfono entre en contacto con un dispositivo NFC"</string>
    <string name="nfc_disclaimer_title" msgid="3696580694485048039">"Activa NFC"</string>
    <string name="nfc_disclaimer_content" msgid="8256675597551036207">"NFC intercambia datos entre este dispositivo y otras orientaciones o dispositivos cercanos, como terminales de pago, lectores de acceso o etiquetas."</string>
    <string name="nfc_secure_settings_title" msgid="4906958426927741485">"Usar NFC solo si el dispositivo está desbloqueado"</string>
    <string name="nfc_secure_toggle_summary" product="default" msgid="4591286109299690373">"Permitir el uso de NFC en pagos y transporte público solo cuando la pantalla esté desbloqueada"</string>
    <string name="android_beam_settings_title" msgid="2797963824490671295">"Android Beam"</string>
    <string name="android_beam_on_summary" msgid="6067720758437490896">"Listo para transmitir contenido de aplicaciones por NFC"</string>
    <string name="android_beam_off_summary" msgid="5693961375631325042">"Desactivada"</string>
    <string name="nfc_disabled_summary" msgid="8737797364522502351">"No disponible porque NFC está desactivada"</string>
    <string name="android_beam_label" msgid="7168565080321110094">"Android Beam"</string>
    <string name="android_beam_explained" msgid="5684416131846701256">"Cuando esta función está activada, puedes transmitir el contenido de las aplicaciones a otro dispositivo con NFC con solo juntar los dispositivos. Por ejemplo, puedes transmitir páginas web, videos de YouTube, contactos y mucho más.\n\nSolo tienes que juntar los dispositivos (normalmente, por la parte posterior) y, a continuación, presionar la pantalla de tu dispositivo. La app determina el contenido que se transmite."</string>
    <string name="wifi_quick_toggle_title" msgid="2737097538432862807">"Wi-Fi"</string>
    <string name="wifi_quick_toggle_summary" msgid="4957267477820468553">"Activar Wi-Fi"</string>
    <string name="wifi_settings" msgid="8313301946393559700">"Wi-Fi"</string>
    <string name="wifi_settings_primary_switch_title" msgid="628360786662947258">"Usar Wi-Fi"</string>
    <string name="wifi_settings_category" msgid="3523464780563778321">"Configuración de Wi-Fi"</string>
    <string name="wifi_settings_title" msgid="3879649725059512799">"Wi-Fi"</string>
    <string name="wifi_settings_summary" msgid="784074686763572811">"Configurar y administrar los puntos de acceso de teléfonos inalámbricos"</string>
    <string name="wifi_select_network" msgid="6692897876718813259">"Seleccionar red Wi-Fi"</string>
    <string name="wifi_starting" msgid="6147022683967506341">"Activando Wi-Fi..."</string>
    <string name="wifi_stopping" msgid="4471699665741299711">"Desactivando Wi-Fi..."</string>
    <string name="wifi_error" msgid="4903954145386086899">"Error"</string>
    <string name="wifi_sap_no_channel_error" msgid="2126487622024749402">"Banda de 5 GHZ no disponible en este país"</string>
    <string name="wifi_in_airplane_mode" msgid="1235412508135267981">"En modo avión"</string>
    <string name="wifi_notify_open_networks" msgid="2610323626246818961">"Notificar si se detectan redes públicas"</string>
    <string name="wifi_notify_open_networks_summary" msgid="191058832201741013">"Notificarme cuando haya una red pública de alta calidad"</string>
    <string name="wifi_wakeup" msgid="3834327315861781611">"Activar Wi-Fi automáticamente"</string>
    <string name="wifi_wakeup_summary" msgid="5778059083790221465">"La conexión Wi-Fi se volverá a activar cerca de las redes de alta calidad guardadas, como tu red doméstica"</string>
    <string name="wifi_wakeup_summary_no_location" msgid="681323616606485096">"No se encuentra disponible porque la ubicación está desactivada. "<annotation id="link">"Actívala"</annotation>"."</string>
    <string name="wifi_wakeup_summary_scanning_disabled" msgid="1771489741850119751">"La opción no está disponible porque la búsqueda de Wi-Fi está desactivada"</string>
    <string name="wifi_wakeup_summary_scoring_disabled" msgid="3615120120960539780">"Para usar la función, selecciona un proveedor de calificación de red"</string>
    <string name="wifi_poor_network_detection" msgid="8210035875160288422">"Evitar malas conexiones"</string>
    <string name="wifi_poor_network_detection_summary" msgid="383834617032605347">"Solo usar una red Wi-Fi si ofrece una conexión a Internet estable"</string>
    <string name="wifi_avoid_poor_network_detection_summary" msgid="4993203473116721772">"Solo usar redes que tengan una conexión a Internet estable"</string>
    <string name="use_open_wifi_automatically_title" msgid="7193846454986712009">"Conectarse a redes públicas"</string>
    <string name="use_open_wifi_automatically_summary" msgid="6663890845558591023">"Conectar automáticamente a redes públicas de alta calidad"</string>
    <string name="use_open_wifi_automatically_summary_scoring_disabled" msgid="2299284032301667622">"Para usar la función, selecciona un proveedor de calificación de red"</string>
    <string name="use_open_wifi_automatically_summary_scorer_unsupported_disabled" msgid="1780306481499369913">"Para usar la función, selecciona un proveedor de calificación de red compatible"</string>
    <string name="wifi_install_credentials" msgid="5192903644606839972">"Instalar certificados"</string>
    <string name="wifi_scan_notify_text" msgid="2518097467707535013">"Para mejorar la precisión de la ubicación, las apps y los servicios aún podrán buscar redes Wi-Fi en cualquier momento, incluso cuando la conexión Wi-Fi esté desactivada. Esta función puede usarse, por ejemplo, para mejorar las funciones y los servicios basados en la ubicación, y puedes cambiarla en la <xliff:g id="LINK_BEGIN_0">LINK_BEGIN</xliff:g>configuración de búsqueda<xliff:g id="LINK_END_1">LINK_END</xliff:g>."</string>
    <string name="wifi_scan_notify_text_scanning_off" msgid="6189528915806353667">"Para mejorar la precisión de la ubicación, activa la búsqueda de Wi-Fi en la <xliff:g id="LINK_BEGIN_0">LINK_BEGIN</xliff:g>configuración de búsqueda<xliff:g id="LINK_END_1">LINK_END</xliff:g>."</string>
    <string name="wifi_scan_notify_remember_choice" msgid="8436897497968907701">"No volver a mostrar"</string>
    <string name="wifi_setting_sleep_policy_title" msgid="6285374200292675649">"Mantener Wi-Fi durante suspensión"</string>
    <string name="wifi_setting_on_during_sleep_title" msgid="8753852404141070878">"Wi‑Fi activada en suspensión"</string>
    <string name="wifi_setting_sleep_policy_error" msgid="4512566787805720422">"Hubo un problema mientras se cambiaba la configuración"</string>
    <string name="wifi_suspend_efficiency_title" msgid="3589291227092825754">"Mejorar el rendimiento"</string>
    <string name="wifi_suspend_optimizations" msgid="5840680940416640209">"Optimización de Wi-Fi"</string>
    <string name="wifi_suspend_optimizations_summary" msgid="8204170804523356781">"Minimizar el consumo de la batería con Wi-Fi activado"</string>
    <string name="wifi_limit_optimizations_summary" msgid="8461087338100462302">"Limitar batería que usa Wi-Fi"</string>
    <string name="wifi_switch_away_when_unvalidated" msgid="681353878530696197">"Cambiar a datos móviles si la red Wi-Fi pierde acceso a Internet"</string>
    <string name="wifi_cellular_data_fallback_title" msgid="2844653839490977040">"Cambiar a datos móviles automáticamente"</string>
    <string name="wifi_cellular_data_fallback_summary" msgid="7039944853033554386">"Si la conexión Wi-Fi no puede acceder a Internet, usa los datos móviles. Es posible que se apliquen cargos por el uso de datos."</string>
    <string name="wifi_add_network" msgid="4178564862173751181">"Agregar red"</string>
    <string name="wifi_configure_settings_preference_title" msgid="2536725796700696566">"Preferencias de Wi-Fi"</string>
    <string name="wifi_configure_settings_preference_summary_wakeup_on" msgid="7822368955551467382">"La conexión Wi-Fi vuelve a activarse automáticamente"</string>
    <string name="wifi_configure_settings_preference_summary_wakeup_off" msgid="5710203586018223864">"La conexión Wi-Fi no vuelve a activarse automáticamente"</string>
    <string name="wifi_access_points" msgid="5846755709207101844">"Redes Wi-Fi"</string>
    <string name="wifi_menu_more_options" msgid="1236651929987819716">"Más opciones"</string>
    <string name="wifi_menu_p2p" msgid="5234165837732940385">"Wi-Fi directo"</string>
    <string name="wifi_menu_scan" msgid="3498653582115656526">"Buscar"</string>
    <string name="wifi_menu_advanced" msgid="1940919392030994019">"Config. avanzada"</string>
    <string name="wifi_menu_configure" msgid="352423980467311427">"Configurar"</string>
    <string name="wifi_menu_connect" msgid="7824796427932811078">"Conectar a la red"</string>
    <string name="wifi_menu_remember" msgid="8639523871321603112">"Recordar red"</string>
    <string name="wifi_menu_forget" msgid="6557142984528657361">"Olvidar red"</string>
    <string name="wifi_menu_modify" msgid="7246143391161038875">"Modificar red"</string>
    <string name="wifi_empty_list_wifi_off" msgid="7697422506708419298">"Para ver las redes disponibles, activa el Wi-Fi."</string>
    <string name="wifi_empty_list_wifi_on" msgid="5043989454000825717">"Buscando redes Wi-Fi…"</string>
    <string name="wifi_empty_list_user_restricted" msgid="454861411536708709">"No tienes permiso para cambiar la red Wi‑Fi."</string>
    <string name="wifi_more" msgid="8742256421693351035">"Más"</string>
    <string name="wifi_setup_wps" msgid="4303694722593999931">"Configuración automática (WPS)"</string>
    <string name="wifi_settings_scanning_required_title" msgid="1088663325396007484">"¿Deseas activar la búsqueda de Wi‑Fi?"</string>
    <string name="wifi_settings_scanning_required_summary" msgid="4770243653675416569">"Para activar la conexión Wi-Fi automáticamente, primero debes activar la búsqueda de Wi-Fi."</string>
    <string name="wifi_settings_scanning_required_info" msgid="1473411566072565789">"La búsqueda de Wi-Fi permite que las apps y los servicios busquen redes de este tipo en cualquier momento, incluso cuando la conexión Wi-Fi está desactivada. Puedes usar esta función, por ejemplo, para mejorar las funciones y los servicios basados en la ubicación."</string>
    <string name="wifi_settings_scanning_required_turn_on" msgid="1112223196123955447">"Activar"</string>
    <string name="wifi_settings_scanning_required_enabled" msgid="4721729158927146365">"Se activó la búsqueda de Wi‑Fi"</string>
    <string name="wifi_show_advanced" msgid="2969378109942071741">"Opciones avanzadas"</string>
    <string name="wifi_advanced_toggle_description" msgid="7299179796727934885">"Lista desplegable \"Opciones avanzadas\""</string>
    <string name="wifi_advanced_toggle_description_collapsed" msgid="3615140699129928913">"expandir"</string>
    <string name="wifi_ssid" msgid="2713062130735103151">"Nombre de la red"</string>
    <string name="wifi_ssid_hint" msgid="1940577553241083524">"Ingresa el SSID"</string>
    <string name="wifi_security" msgid="9095934643631406913">"Seguridad"</string>
    <string name="wifi_hidden_network" msgid="6466834025375485596">"Red oculta"</string>
    <string name="wifi_hidden_network_warning" msgid="3937433813754746158">"Si el router no emite un ID de red, pero quieres conectarte a la red en el futuro, configúrala para que esté oculta.\n\nEs posible que esta acción implique riesgos de seguridad porque el teléfono emitirá la señal regularmente para buscar la red.\n\nSi configuras la red para que esté oculta, no se modificarán los ajustes del router."</string>
    <string name="wifi_signal" msgid="4442182285304271424">"Potencia de la señal"</string>
    <string name="wifi_status" msgid="5349199188871002778">"Estado"</string>
    <string name="tx_wifi_speed" msgid="2368986629172050673">"Velocidad enlace de transmisión"</string>
    <string name="rx_wifi_speed" msgid="5167966079215111232">"Velocidad enlace de recepción"</string>
    <string name="wifi_speed" msgid="6562147734565434513">"Velocidad del vínculo"</string>
    <string name="wifi_frequency" msgid="3120998420184702834">"Frecuencia"</string>
    <string name="wifi_ip_address" msgid="8903577251845268209">"Dirección IP"</string>
    <string name="passpoint_label" msgid="6513669696739302866">"Se guardó mediante"</string>
    <string name="passpoint_content" msgid="5219226173518418335">"Credenciales de <xliff:g id="NAME">%1$s</xliff:g>"</string>
    <string name="wifi_eap_method" msgid="3776009521349381742">"Método EAP"</string>
    <string name="please_select_phase2" msgid="577633852089847142">"Autenticación de fase 2"</string>
    <string name="wifi_eap_ca_cert" msgid="8033404008276298886">"Certificado de CA"</string>
    <string name="wifi_eap_ocsp" msgid="8713933962516871238">"Estado de certificado en línea"</string>
    <string name="wifi_eap_domain" msgid="8304301470752333203">"Dominio"</string>
    <string name="wifi_eap_user_cert" msgid="3569182430929173220">"Certificado del usuario"</string>
    <string name="wifi_eap_identity" msgid="3629406902174137028">"Identidad"</string>
    <string name="wifi_eap_anonymous" msgid="8630332141751267000">"Identidad anónima"</string>
    <string name="wifi_password" msgid="1458802324849513755">"Contraseña"</string>
    <string name="wifi_show_password" msgid="6865993988238157923">"Mostrar contraseña"</string>
    <string name="wifi_ap_band_config" msgid="1589020070150933055">"Seleccionar banda AP"</string>
    <string name="wifi_ap_choose_auto" msgid="8944442003151215691">"Automático"</string>
    <string name="wifi_ap_choose_2G" msgid="1436802195991542016">"Banda de 2.4 GHz"</string>
    <string name="wifi_ap_choose_5G" msgid="8413248472288180075">"Banda de 5.0 GHz"</string>
    <string name="wifi_ap_prefer_5G" msgid="2520628479818369902">"Banda preferida: 5.0 GHz"</string>
    <string name="wifi_ap_2G" msgid="4099628221864343015">"2.4 GHz"</string>
    <string name="wifi_ap_5G" msgid="3493942667238551207">"5.0 GHz"</string>
    <string name="wifi_ap_band_select_one" msgid="5221193733812493435">"Elige al menos una banda para el hotspot de Wi-Fi:"</string>
    <string name="wifi_ip_settings" msgid="6420498748726599133">"Configuración de IP"</string>
    <string name="wifi_privacy_settings" msgid="3283946009000725698">"Privacidad"</string>
    <string name="wifi_subscription" msgid="4432423938285430113">"Suscripción"</string>
    <string name="wifi_subscription_summary" msgid="18802471063384598">"Ver o cambiar la suscripción"</string>
    <string name="wifi_privacy_settings_ephemeral_summary" msgid="8502084692297249372">"Dirección MAC aleatoria"</string>
    <string name="wifi_dpp_add_device_to_network" msgid="6141246783457722976">"Agregar un dispositivo"</string>
    <string name="wifi_dpp_center_qr_code" msgid="5270782275746178104">"Centra el código QR debajo para agregar el dispositivo a \"<xliff:g id="SSID">%1$s</xliff:g>\""</string>
    <string name="wifi_dpp_scan_qr_code" msgid="3543923817779444434">"Escanear código QR"</string>
    <string name="wifi_dpp_scan_qr_code_join_network" msgid="969985020363459133">"Centra el código QR debajo para conectarte a \"<xliff:g id="SSID">%1$s</xliff:g>\""</string>
    <string name="wifi_dpp_scan_qr_code_join_unknown_network" msgid="3180020429793614145">"Escanea un código QR para unirte a la red Wi-Fi"</string>
    <string name="wifi_dpp_share_wifi" msgid="2431744447544057866">"Compartir Wi‑Fi"</string>
    <string name="wifi_dpp_scan_qr_code_with_another_device" msgid="6967364080214325016">"Escanea este código QR con otro dispositivo para unirte a \"<xliff:g id="SSID">%1$s</xliff:g>\""</string>
    <string name="wifi_dpp_scan_open_network_qr_code_with_another_device" msgid="5398619697898444311">"Escanea este código QR para conectarte a \"<xliff:g id="SSID">%1$s</xliff:g>\""</string>
    <string name="wifi_dpp_failure_authentication_or_configuration" msgid="847551626830740204">"Vuelve a intentarlo. Si el problema persiste, comunícate con el fabricante del dispositivo"</string>
    <string name="wifi_dpp_failure_not_compatible" msgid="4453775826337805825">"Se produjo un error"</string>
    <string name="wifi_dpp_failure_timeout" msgid="7902971341771145564">"Asegúrate de que el dispositivo se haya enchufado, cargado y encendido"</string>
    <string name="wifi_dpp_failure_generic" msgid="6559442892600448442">"Asegúrate de que el dispositivo se haya enchufado, cargado y encendido. Si el problema persiste, comunícate con el fabricante"</string>
    <string name="wifi_dpp_failure_not_supported" msgid="2908961523550486480">"No se puede agregar \"<xliff:g id="SSID">%1$s</xliff:g>\" a este dispositivo"</string>
    <string name="wifi_dpp_failure_cannot_find_network" msgid="8519567801353014036">"Acerca el dispositivo a tu punto de acceso o router Wi-Fi"</string>
    <string name="wifi_dpp_failure_enrollee_authentication" msgid="7008840843663520852">"Revisa la contraseña y vuelve a intentarlo"</string>
    <string name="wifi_dpp_failure_enrollee_rejected_configuration" msgid="982310033782652478">"Comunícate con el fabricante del dispositivo"</string>
    <string name="wifi_dpp_check_connection_try_again" msgid="6118892932595974823">"Comprueba la conexión y vuelve a intentarlo"</string>
    <string name="wifi_dpp_choose_network" msgid="3987007684129341427">"Elegir una red"</string>
    <string name="wifi_dpp_choose_network_to_connect_device" msgid="4321618376432197593">"Selecciona una red para conectar tu dispositivo"</string>
    <string name="wifi_dpp_add_device_to_wifi" msgid="5170095438763569255">"¿Agregar este dispositivo a \"<xliff:g id="SSID">%1$s</xliff:g>\"?"</string>
    <string name="wifi_dpp_wifi_shared_with_device" msgid="4484366631307204949">"Se compartió la red Wi-Fi con el dispositivo"</string>
    <string name="wifi_dpp_add_another_device" msgid="3307575293580739604">"Agregar otro dispositivo"</string>
    <string name="wifi_dpp_choose_different_network" msgid="8963625819804792157">"Seleccionar otra red"</string>
    <string name="wifi_dpp_could_not_add_device" msgid="6865710911186601933">"No se pudo agregar el dispositivo"</string>
    <string name="wifi_dpp_device_found" msgid="633646744759830603">"Se encontró el dispositivo"</string>
    <string name="wifi_dpp_sharing_wifi_with_this_device" msgid="7250369936882080107">"Compartiendo Wi-Fi con este dispositivo…"</string>
    <string name="wifi_dpp_connecting" msgid="2312769193202897589">"Conectando…"</string>
    <string name="wifi_dpp_share_hotspot" msgid="6186452780604755316">"Compartir hotspot"</string>
    <string name="wifi_dpp_lockscreen_title" msgid="4231438175617953652">"Verifica tu identidad"</string>
    <string name="wifi_dpp_wifi_password" msgid="4992986319806934381">"Contraseña de Wi-Fi: <xliff:g id="PASSWORD">%1$s</xliff:g>"</string>
    <string name="wifi_dpp_hotspot_password" msgid="688464342650820420">"Contraseña del hotspot: <xliff:g id="PASSWORD">%1$s</xliff:g>"</string>
    <string name="wifi_auto_connect_title" msgid="1890342051674657892">"Conectar automáticamente"</string>
    <string name="wifi_auto_connect_summary" msgid="1707702705345670370">"Permitir conexión a esta red al entrar en su rango"</string>
    <string name="wifi_dpp_add_device" msgid="8695656122114721335">"Agregar dispositivo"</string>
    <string name="wifi_dpp_connect_network_using_qr_code" msgid="6975258007798254937">"Usar un código QR para agregar un dispositivo a esta red"</string>
    <string name="wifi_dpp_qr_code_is_not_valid_format" msgid="5190689503019328279">"El código QR no es un formato válido"</string>
    <string name="retry" msgid="7542103800274026915">"Reintentar"</string>
    <string name="wifi_shared" msgid="8850748923537589782">"Compartir con otros usuarios del dispositivo"</string>
    <string name="wifi_unchanged" msgid="8026045290856150191">"(sin cambios)"</string>
    <string name="wifi_unspecified" msgid="4561964943472312208">"Selecciona una opción"</string>
    <string name="wifi_multiple_cert_added" msgid="2151019652853383776">"(Se agregaron varios certificados)"</string>
    <string name="wifi_use_system_certs" msgid="5587866698144996931">"Usar certificados de sistema"</string>
    <string name="wifi_do_not_provide_eap_user_cert" msgid="6336636553673065145">"No proporcionar"</string>
    <string name="wifi_do_not_validate_eap_server" msgid="4673867078988209732">"No validar"</string>
    <string name="wifi_ssid_too_long" msgid="5961719058705013875">"El nombre de la red es demasiado largo."</string>
    <string name="wifi_no_domain_warning" msgid="1452133316532366772">"Se debe especificar un dominio."</string>
    <string name="wifi_no_user_cert_warning" msgid="8466376918835248956">"Se requiere un certificado."</string>
    <string name="wifi_wps_available_first_item" msgid="5780501151792036589">"WSP disponible"</string>
    <string name="wifi_wps_available_second_item" msgid="1717024103303480804">" (WSP disponible)"</string>
    <string name="wifi_carrier_connect" msgid="4511538300946413213">"Red Wi‑Fi del proveedor"</string>
    <string name="wifi_carrier_content" msgid="2876499905644083615">"Conectarse mediante <xliff:g id="NAME">%1$s</xliff:g>"</string>
    <string name="wifi_scan_always_turnon_message" msgid="2165909441512029921">"Para mejorar la precisión de la ubicación y para otros fines, <xliff:g id="APP_NAME">%1$s</xliff:g> quiere activar la búsqueda de redes, incluso cuando la conexión Wi-Fi esté desactivada.\n\n¿Quieres permitir esto para todas las aplicaciones que deseen buscar redes?"</string>
    <string name="wifi_scan_always_turn_on_message_unknown" msgid="4903345360745717385">"Para mejorar la precisión de la ubicación y para otros fines, una app desconocida quiere activar la búsqueda de redes aunque el Wi‑Fi esté desactivado.\n\n¿Permitir que todas las apps puedan hacerlo?"</string>
    <string name="wifi_scan_always_turnoff_message" msgid="93691286302680448">"Para desactivar la opción, accede a la sección Avanzada del menú ampliado."</string>
    <string name="wifi_scan_always_confirm_allow" msgid="4154200627800959777">"Permitir"</string>
    <string name="wifi_scan_always_confirm_deny" msgid="6997087934558839256">"Denegar"</string>
    <string name="wifi_hotspot_title" msgid="1918712370697971229">"¿Acceder para conectarse?"</string>
    <string name="wifi_hotspot_message" msgid="5245614124614833169">"<xliff:g id="APP_NAME">%1$s</xliff:g> requiere acceso en línea para conectar a la red."</string>
    <string name="wifi_hotspot_connect" msgid="1916314048788438331">"CONECTAR"</string>
    <string name="no_internet_access_text" msgid="3611993143350310936">"Esta red no tiene acceso a Internet. ¿Deseas mantener la conexión?"</string>
    <string name="partial_connectivity_text" msgid="8874614799723694554">"Puede que algunas apps y servicios no funcionen debido a la conectividad limitada. ¿Usar igualmente?"</string>
    <string name="no_internet_access_remember" msgid="5113610157731269258">"No volver a preguntar para esta red"</string>
    <string name="lost_internet_access_title" msgid="9032463989950384698">"La red Wi-Fi no está conectada a Internet"</string>
    <string name="lost_internet_access_text" msgid="1535911323549496789">"Puedes cambiar a la red de datos móviles si no hay buena conexión Wi-Fi. Es posible que se apliquen cargos por el uso de datos."</string>
    <string name="lost_internet_access_switch" msgid="7935665847081706202">"Cambiar a datos móviles"</string>
    <string name="lost_internet_access_cancel" msgid="1981171269794585284">"Seguir usando Wi-Fi"</string>
    <string name="lost_internet_access_persist" msgid="6813604557672782197">"No volver a mostrar"</string>
    <string name="wifi_connect" msgid="2481467560349907397">"Conectar"</string>
    <string name="wifi_turned_on_message" msgid="8069855406962662881">"Wi-Fi activado"</string>
    <string name="wifi_connected_to_message" msgid="8976048616505112896">"Conectado a <xliff:g id="NETWORK_NAME">%1$s</xliff:g>"</string>
    <string name="wifi_connecting_to_message" msgid="3153205024060064551">"Estableciendo conexión con <xliff:g id="NETWORK_NAME">%1$s</xliff:g>"</string>
    <string name="wifi_connecting" msgid="7450277833386859724">"Conectando…"</string>
    <string name="wifi_failed_connect_message" msgid="8538000546604347894">"No se pudo establecer conexión con la red."</string>
    <string name="wifi_not_in_range_message" msgid="3885327464037574739">"Red fuera de alcance"</string>
    <string name="wifi_forget" msgid="3485573280364015620">"Olvidar"</string>
    <string name="wifi_modify" msgid="5127926476383659412">"Modificar"</string>
    <string name="wifi_failed_forget_message" msgid="8272732599235525880">"No se pudo borrar la red."</string>
    <string name="wifi_save" msgid="2312643132472226807">"Guardar"</string>
    <string name="wifi_failed_save_message" msgid="1830279872341387120">"No se pudo guardar la red."</string>
    <string name="wifi_cancel" msgid="6698897376888935410">"Cancelar"</string>
    <string name="wifi_forget_dialog_title" msgid="4363829200968563164">"¿Quieres olvidar la red?"</string>
    <string name="wifi_forget_dialog_message" msgid="8419499588321940243">"Se borrarán todas las contraseñas de esta red"</string>
    <plurals name="wifi_saved_access_points_summary" formatted="false" msgid="2802436466732147888">
      <item quantity="other">%d redes</item>
      <item quantity="one">1 red</item>
    </plurals>
    <plurals name="wifi_saved_passpoint_access_points_summary" formatted="false" msgid="5802057518058840450">
      <item quantity="other">%d suscripciones</item>
      <item quantity="one">1 suscripción</item>
    </plurals>
    <plurals name="wifi_saved_all_access_points_summary" formatted="false" msgid="5125849180309374451">
      <item quantity="other">%d redes y suscripciones</item>
      <item quantity="one">1 red y suscripción</item>
    </plurals>
    <string name="wifi_advanced_titlebar" msgid="1234150304285575798">"Config. avanzada de Wi-Fi"</string>
    <string name="wifi_advanced_ssid_title" msgid="1561437650193980185">"SSID"</string>
    <string name="wifi_advanced_device_mac_address_title" msgid="6155800851233164411">"Dirección MAC del dispositivo"</string>
    <string name="wifi_advanced_randomized_mac_address_title" msgid="3930671320234553088">"Dirección MAC aleatoria"</string>
    <string name="wifi_advanced_randomized_mac_address_disconnected_title" msgid="2755843130417523727">"Dirección MAC aleatoria (último uso)"</string>
    <string name="wifi_advanced_ip_address_title" msgid="4265355419782184514">"Dirección IP"</string>
    <string name="wifi_details_title" msgid="222735438574597493">"Detalles de la red"</string>
    <string name="wifi_details_subnet_mask" msgid="1619151769276260512">"Máscara de subred"</string>
    <string name="wifi_details_dns" msgid="273231528073312579">"DNS"</string>
    <string name="wifi_details_ipv6_address_header" msgid="1913151339341722443">"Direcciones IPv6"</string>
    <string name="wifi_saved_access_points_label" msgid="5691340724310548151">"Redes guardadas"</string>
    <string name="wifi_subscribed_access_points_tab" msgid="7224061396195667208">"Suscripciones"</string>
    <string name="wifi_saved_other_networks_tab" msgid="7942647415716557293">"Otras redes"</string>
    <string name="wifi_advanced_settings_label" msgid="5880605751602184383">"Configuración de IP"</string>
    <string name="wifi_advanced_not_available" msgid="8701003884367299092">"La configuración avanzada de Wi‑Fi no está disponible para este usuario"</string>
    <string name="wifi_ip_settings_menu_save" msgid="5190481040428567106">"Guardar"</string>
    <string name="wifi_ip_settings_menu_cancel" msgid="1757817733064004598">"Cancelar"</string>
    <string name="wifi_ip_settings_invalid_ip_address" msgid="3622891107865052307">"Escribe una dirección IP válida."</string>
    <string name="wifi_ip_settings_invalid_gateway" msgid="1174931247370931239">"Escribe una dirección de puerta de enlace válida."</string>
    <string name="wifi_ip_settings_invalid_dns" msgid="1757402215999845975">"Escribe una dirección DNS válida."</string>
    <string name="wifi_ip_settings_invalid_network_prefix_length" msgid="5980808986926987299">"Escribe una longitud de prefijo de red entre 0 y 32."</string>
    <string name="wifi_dns1" msgid="6764769531843748514">"DNS 1 (a menos que lo anule un DNS privado)"</string>
    <string name="wifi_dns2" msgid="7273133202625326148">"DNS 2 (a menos que lo anule un DNS privado)"</string>
    <string name="wifi_gateway" msgid="3699227808616416759">"Puerta de enlace"</string>
    <string name="wifi_network_prefix_length" msgid="1003365439352276622">"Longitud de prefijo de red"</string>
    <string name="wifi_p2p_settings_title" msgid="1689918226469221870">"Wi-Fi directo"</string>
    <string name="wifi_p2p_device_info" msgid="4304362679971797283">"Información del dispositivo"</string>
    <string name="wifi_p2p_persist_network" msgid="7942929491568227945">"Recordar esta conexión"</string>
    <string name="wifi_p2p_menu_search" msgid="8383306178784876840">"Buscar dispositivos"</string>
    <string name="wifi_p2p_menu_searching" msgid="3428767661028761100">"Buscando…"</string>
    <string name="wifi_p2p_menu_rename" msgid="7059994112737743336">"Cambiar el nombre del dispositivo"</string>
    <string name="wifi_p2p_peer_devices" msgid="5158559154640283546">"Otros dispositivos"</string>
    <string name="wifi_p2p_remembered_groups" msgid="5497007770930525695">"Grupos recordados"</string>
    <string name="wifi_p2p_failed_connect_message" msgid="6767831720507440027">"No se pudo establecer conexión."</string>
    <string name="wifi_p2p_failed_rename_message" msgid="1317434386267376606">"Error al cambiar nombre del dispositivo"</string>
    <string name="wifi_p2p_disconnect_title" msgid="96361896458072463">"¿Deseas desconectarte?"</string>
    <string name="wifi_p2p_disconnect_message" msgid="1208761239498807208">"Si te desconectas, tu conexión con <xliff:g id="PEER_NAME">%1$s</xliff:g> finalizará."</string>
    <string name="wifi_p2p_disconnect_multiple_message" msgid="4490648217799144078">"Si te desconectas, tu conexión con <xliff:g id="PEER_NAME">%1$s</xliff:g> y con otros <xliff:g id="PEER_COUNT">%2$s</xliff:g> dispositivos finalizará."</string>
    <string name="wifi_p2p_cancel_connect_title" msgid="8476985132989357041">"¿Quieres cancelar la invitación?"</string>
    <string name="wifi_p2p_cancel_connect_message" msgid="2409074184473879809">"¿Quieres cancelar la invitación para conectarte con <xliff:g id="PEER_NAME">%1$s</xliff:g>?"</string>
    <string name="wifi_p2p_delete_group_message" msgid="4880242270742385699">"¿Deseas borrar este grupo?"</string>
    <string name="wifi_hotspot_checkbox_text" msgid="1549663436920597006">"Hotspot de Wi-Fi"</string>
    <string name="wifi_hotspot_off_subtext" msgid="2751383134504362078">"No se está compartiendo Internet ni contenido con otros dispositivos"</string>
    <string name="wifi_hotspot_tethering_on_subtext" product="tablet" msgid="5832429443898690152">"Se está compartiendo la conexión a Internet de esta tablet mediante un hotspot"</string>
    <string name="wifi_hotspot_tethering_on_subtext" product="default" msgid="5451921191609178326">"Se está compartiendo la conexión a Internet de este teléfono mediante un hotspot"</string>
    <string name="wifi_hotspot_on_local_only_subtext" msgid="965051079784031636">"La app está compartiendo contenido. Para compartir la conexión a Internet, desactiva el hotspot y vuelve a activarlo"</string>
    <string name="wifi_hotspot_no_password_subtext" msgid="3685689196772398783">"No se configuró una contraseña"</string>
    <string name="wifi_hotspot_name_title" msgid="6633480190014369846">"Nombre del hotspot"</string>
    <string name="wifi_hotspot_name_summary_connecting" msgid="2094754115215428892">"Activando <xliff:g id="WIFI_HOTSPOT_NAME">%1$s</xliff:g>…"</string>
    <string name="wifi_hotspot_name_summary_connected" msgid="6935457127884928249">"Otros dispositivos pueden conectarse a <xliff:g id="WIFI_HOTSPOT_NAME">%1$s</xliff:g>"</string>
    <string name="wifi_hotspot_password_title" msgid="9096340919454296786">"Contraseña del hotspot"</string>
    <string name="wifi_hotspot_ap_band_title" msgid="560262446129195042">"Banda del PA"</string>
    <string name="wifi_hotspot_footer_info_regular" msgid="6620216295510397461">"Los hotspots brindan acceso a Internet mediante una conexión de datos móviles. Configura uno a fin de crear una red Wi‑Fi para otros dispositivos. Es posible que se apliquen cargos por el uso de datos móviles."</string>
    <string name="wifi_hotspot_footer_info_local_only" msgid="3813311942370920903">"Las apps pueden crear un hotspot para compartir contenido con dispositivos cercanos."</string>
    <string name="wifi_hotspot_auto_off_title" msgid="8855711787485504882">"Desactivar el hotspot de manera automática"</string>
    <string name="wifi_hotspot_auto_off_summary" msgid="8283656069997871354">"Cuando no hay dispositivos conectados"</string>
    <string name="wifi_tether_starting" msgid="8879874184033857814">"Activando hotspot…"</string>
    <string name="wifi_tether_stopping" msgid="4416492968019409188">"Desactivando hotspot…"</string>
    <string name="wifi_tether_enabled_subtext" msgid="5085002421099821056">"<xliff:g id="NETWORK_SSID">%1$s</xliff:g> está activa"</string>
    <string name="wifi_tether_failed_subtext" msgid="437190628041885500">"Error en hotspot de Wi-Fi portátil"</string>
    <string name="wifi_tether_configure_ap_text" msgid="7072559431286459122">"Configurar hotspot Wi-Fi"</string>
    <string name="wifi_hotspot_configure_ap_text" msgid="9027072969831022321">"Configuración de hotspot Wi-Fi"</string>
    <string name="wifi_hotspot_configure_ap_text_summary" msgid="1445157424926935178">"Hotspot WPA2 PSK de AndroidAP"</string>
    <string name="wifi_tether_configure_ssid_default" msgid="1709397571393179300">"Android Hotspot"</string>
    <string name="wifi_add_app_single_network_title" msgid="8911612806204065225">"¿Quieres guardar esta red?"</string>
    <string name="wifi_add_app_single_network_summary" product="default" msgid="6881712878537666626">"<xliff:g id="APPNAME">%1$s</xliff:g> quiere guardar una red en tu teléfono"</string>
    <string name="wifi_add_app_single_network_summary" product="tablet" msgid="8455616967601552440">"<xliff:g id="APPNAME">%1$s</xliff:g> quiere guardar una red en tu tablet"</string>
    <string name="wifi_add_app_single_network_saving_summary" msgid="7366337245410388895">"Guardando…"</string>
    <string name="wifi_add_app_single_network_saved_summary" msgid="7135016314713158289">"Guardada"</string>
    <string name="wifi_add_app_network_save_failed_summary" msgid="7223817782309294652">"No se puede guardar. Vuelve a intentarlo."</string>
    <string name="wifi_add_app_networks_title" msgid="4384594865433042851">"¿Quieres guardar estas redes?"</string>
    <string name="wifi_add_app_networks_summary" product="default" msgid="2670215712788515167">"<xliff:g id="APPNAME">%1$s</xliff:g> quiere guardar estas redes en tu teléfono"</string>
    <string name="wifi_add_app_networks_summary" product="tablet" msgid="2088967184512169910">"<xliff:g id="APPNAME">%1$s</xliff:g> quiere guardar estas redes en tu tablet"</string>
    <string name="wifi_add_app_networks_saving_summary" msgid="577680250954742033">"Guardando <xliff:g id="NUMBER">%d</xliff:g> redes…"</string>
    <string name="wifi_add_app_networks_saved_summary" msgid="1648417628665152905">"Redes guardadas"</string>
    <string name="wifi_calling_settings_title" msgid="264665264535884440">"Llamadas por Wi-Fi"</string>
    <string name="wifi_calling_suggestion_title" msgid="4791435106729906727">"Recibe más llamadas gracias a la red Wi‑Fi"</string>
    <string name="wifi_calling_suggestion_summary" msgid="5413024679599742858">"Activa Llamada con Wi‑Fi para extender la cobertura"</string>
    <string name="wifi_calling_mode_title" msgid="5145896168360825619">"Preferencia de llamada"</string>
    <string name="wifi_calling_mode_dialog_title" msgid="944146521898592440">"Preferencia de llamada"</string>
    <string name="wifi_calling_roaming_mode_title" msgid="7703305991991520773">"Preferencia de la itinerancia"</string>
    <!-- no translation found for wifi_calling_roaming_mode_summary (6061631305384464179) -->
    <skip />
    <string name="wifi_calling_roaming_mode_dialog_title" msgid="5382466713784067077">"Preferencia de la itinerancia"</string>
  <string-array name="wifi_calling_mode_choices_v2">
    <item msgid="6052353275413974742">"Wi-Fi"</item>
    <item msgid="8622872038388687383">"Móvil"</item>
    <item msgid="3027927219952052398">"Solo Wi-Fi"</item>
  </string-array>
  <string-array name="wifi_calling_mode_choices_v2_without_wifi_only">
    <item msgid="588620799769664461">"Wi-Fi"</item>
    <item msgid="7566603075659706590">"Móvil"</item>
  </string-array>
    <string name="wifi_calling_mode_wifi_preferred_summary" msgid="3240387177966098351">"Si no hay ninguna red Wi-Fi disponible, usa una red móvil"</string>
    <string name="wifi_calling_mode_cellular_preferred_summary" msgid="3746914244902314059">"Si la red móvil no está disponible, usa Wi-Fi"</string>
    <string name="wifi_calling_mode_wifi_only_summary" msgid="3155660680014892641">"Llamar mediante Wi-Fi. La llamada finalizará si se pierde la conexión."</string>
    <string name="wifi_calling_off_explanation" msgid="6295526820826322895">"Si está activada la función Llamada por Wi-Fi, el teléfono podrá hacer llamadas mediante redes Wi-Fi o la red de tu proveedor, según la preferencia que hayas elegido y la señal que tenga más intensidad. Antes de activar esta función, verifica el costo y otros detalles con el proveedor.<xliff:g id="ADDITIONAL_TEXT">%1$s</xliff:g>"</string>
    <string name="wifi_calling_off_explanation_2" msgid="3487475808574416183"></string>
    <string name="emergency_address_title" msgid="3490633500025717573">"Dirección de emergencia"</string>
    <string name="emergency_address_summary" msgid="3022628750270626473">"Se usa como tu ubicación cuando haces una llamada de emergencia mediante Wi-Fi"</string>
    <string name="private_dns_help_message" msgid="851221502063782306"><annotation id="url">"Más información"</annotation>" sobre las funciones de DNS privado"</string>
    <string name="private_dns_mode_on" msgid="8878679071975375696">"Activado"</string>
    <string name="wifi_calling_pref_managed_by_carrier" msgid="129524064888622179">"Configuración que administra el proveedor"</string>
    <string name="wifi_calling_settings_activation_instructions" msgid="3936067355828542266">"Habilitar Llamada por Wi-Fi"</string>
    <string name="wifi_calling_turn_on" msgid="7687886259199428823">"Activar Llamada por Wi-Fi"</string>
    <string name="wifi_calling_not_supported" msgid="3303917737849393175">"La Llamada por Wi‑Fi no es compatible con %1$s"</string>
    <string name="wifi_disconnected_from" msgid="5249576734324159708">"Desconectado de <xliff:g id="SSID">%1$s</xliff:g>"</string>
    <string name="carrier" msgid="1755020806290963951">"Proveedor"</string>
    <string name="display_settings_title" msgid="626835071804834218">"Pantalla"</string>
    <string name="sound_settings" msgid="5514582720435174014">"Sonido"</string>
    <string name="all_volume_title" msgid="6196367642878437513">"Volumen"</string>
    <string name="musicfx_title" msgid="5458574743312283473">"Efectos de la música"</string>
    <string name="ring_volume_title" msgid="4869034595079914541">"Volumen de tono y notificaciones"</string>
    <string name="vibrate_in_silent_title" msgid="5076579100685867363">"Vibrar en modo silencioso"</string>
    <string name="notification_sound_title" msgid="8747567935870133157">"Sonido de notificación predeterminado"</string>
    <string name="incoming_call_volume_title" msgid="8445408274513654261">"Tono de llamada"</string>
    <string name="notification_volume_title" msgid="328053763590888609">"Notificación"</string>
    <string name="checkbox_notification_same_as_incoming_call" msgid="1798481722572489141">"Utilizar el volumen de las llamadas entrantes para las notificaciones"</string>
    <string name="home_work_profile_not_supported" msgid="2605589489324241338">"No admite perfiles de trabajo."</string>
    <string name="notification_sound_dialog_title" msgid="7431891669251806266">"Sonido de notificación predeterminado"</string>
    <string name="media_volume_title" msgid="5209147840160985178">"Medios"</string>
    <string name="media_volume_summary" msgid="4671324482655564873">"Establecer volumen para la música y los videos"</string>
    <string name="alarm_volume_title" msgid="706302621191735343">"Alarma"</string>
    <string name="dock_settings_summary" msgid="8548721822219932359">"Configuración de audio para la base adjunta"</string>
    <string name="dtmf_tone_enable_title" msgid="2241337296249130217">"Tonos táctiles del teclado de marcado"</string>
    <string name="sound_effects_enable_title" msgid="328569690466233866">"Sonidos al presionar"</string>
    <string name="lock_sounds_enable_title" msgid="804365014499259673">"Sonido de bloqueo de pantalla"</string>
    <string name="audio_record_proc_title" msgid="486071779724181619">"Cancelación por ruido"</string>
    <string name="volume_media_description" msgid="2736061076584067204">"Música, video, juegos y otros medios"</string>
    <string name="volume_ring_description" msgid="5423168446359881864">"Tono de llamada y notificaciones"</string>
    <string name="volume_notification_description" msgid="3241009629930030492">"Notificaciones"</string>
    <string name="volume_alarm_description" msgid="156563371961039376">"Alarmas"</string>
    <string name="volume_ring_mute" msgid="1445718401945149622">"Silenciar tono y notificaciones"</string>
    <string name="volume_media_mute" msgid="1881020121757820746">"Silenciar música y otros archivos multimedia"</string>
    <string name="volume_notification_mute" msgid="2612197659377126312">"Silenciar notificaciones"</string>
    <string name="volume_alarm_mute" msgid="3730895630530980760">"Silenciar alarmas"</string>
    <string name="dock_settings" msgid="4654404127402812514">"Base"</string>
    <string name="dock_settings_title" msgid="1276956575555480214">"Configuración de la base"</string>
    <string name="dock_audio_settings_title" msgid="8294821925086965934">"Audio"</string>
    <string name="dock_audio_summary_desk" msgid="4158593887711452737">"Configuración para la base adjunta del escritorio"</string>
    <string name="dock_audio_summary_car" msgid="292911654994476080">"Configuración para la base adjunta del automóvil"</string>
    <string name="dock_audio_summary_none" product="tablet" msgid="7758416095500202500">"El tablet no está en la estación"</string>
    <string name="dock_audio_summary_none" product="default" msgid="9056359991181743485">"El dispositivo no se encuentra en la base"</string>
    <string name="dock_audio_summary_unknown" msgid="5486086330763810318">"Configuración para la base adjunta"</string>
    <string name="dock_not_found_title" msgid="4721157149003423417">"No se encontró la base"</string>
    <string name="dock_not_found_text" product="tablet" msgid="9192097687086523411">"Debes acoplar la tablet antes de configurar el audio del conector."</string>
    <string name="dock_not_found_text" product="default" msgid="2247163115146852069">"Debes acoplar el dispositivo antes de configurar el audio del conector."</string>
    <string name="dock_sounds_enable_title" msgid="2974614136344237932">"Sonido al insertar el conector"</string>
    <string name="dock_sounds_enable_summary_on" product="tablet" msgid="468592489565539336">"Reproducir sonido cuando se inserte o elimine el tablet de la base."</string>
    <string name="dock_sounds_enable_summary_on" product="default" msgid="8121670617316301768">"Reproducir sonido al insertar o retirar el dispositivo de la base."</string>
    <string name="dock_sounds_enable_summary_off" product="tablet" msgid="7833926726878567889">"No reproducir sonido cuando se inserte o elimine un tablet de la base."</string>
    <string name="dock_sounds_enable_summary_off" product="default" msgid="5560601997128422001">"No reproducir sonido al insertar o retirar el dispositivo de la base."</string>
    <string name="account_settings" msgid="255404935489127404">"Cuentas"</string>
    <string name="accessibility_category_work" msgid="5133894487353964944">"Cuentas de perfil de trabajo (<xliff:g id="MANAGED_BY">%s</xliff:g>)"</string>
    <string name="accessibility_category_personal" msgid="2228088849803484780">"Cuentas de perfil personal"</string>
    <string name="accessibility_work_account_title" msgid="7622485151217943839">"Cuenta de trabajo (<xliff:g id="MANAGED_BY">%s</xliff:g>)"</string>
    <string name="accessibility_personal_account_title" msgid="8535265881509557013">"Cuenta personal (<xliff:g id="MANAGED_BY">%s</xliff:g>)"</string>
    <string name="search_settings" msgid="7573686516434589771">"Buscar"</string>
    <string name="display_settings" msgid="7197750639709493852">"Pantalla"</string>
    <string name="accelerometer_title" msgid="7745991950833748909">"Girar automáticamente la pantalla"</string>
    <string name="color_mode_title" msgid="8666690832113906028">"Colores"</string>
    <string name="color_mode_option_natural" msgid="6192875655101283303">"Naturales"</string>
    <string name="color_mode_option_boosted" msgid="4698797857766774289">"Mejorados"</string>
    <string name="color_mode_option_saturated" msgid="3413853820158447300">"Saturados"</string>
    <string name="color_mode_option_automatic" msgid="2281217686509980870">"Automáticos"</string>
    <string name="color_mode_summary_natural" msgid="8298840714001791628">"Solo usar colores precisos"</string>
    <string name="color_mode_summary_automatic" msgid="8157885594041700275">"Ajustar entre colores vívidos y reales"</string>
    <string name="accelerometer_summary_on" product="tablet" msgid="6413384391658481700">"Cambiar la orientación automáticamente al girar el tablet"</string>
    <string name="accelerometer_summary_on" product="default" msgid="7117139542131700779">"Cambiar la orientación automáticamente al girar el dispositivo"</string>
    <string name="accelerometer_summary_off" product="tablet" msgid="3747370091309939684">"Cambiar la orientación automáticamente al girar el tablet"</string>
    <string name="accelerometer_summary_off" product="default" msgid="4451125241783158763">"Cambiar la orientación automáticamente al girar el dispositivo"</string>
    <string name="brightness" msgid="6216871641021779698">"Nivel de brillo"</string>
    <string name="brightness_title" msgid="5457874893085305155">"Brillo"</string>
    <string name="brightness_summary" msgid="6309641759293018049">"Ajustar el brillo de la pantalla"</string>
    <string name="auto_brightness_title" msgid="4239324728760986697">"Brillo automático"</string>
    <string name="auto_brightness_summary" msgid="1737148869232725883">"El brillo de la pantalla se justa al entorno"</string>
    <string name="auto_brightness_summary_on" msgid="2748088951224387004">"Activado"</string>
    <string name="auto_brightness_summary_off" msgid="8077066192887677956">"Inhabilitado"</string>
    <string name="auto_brightness_summary_very_low" msgid="2705445901659224330">"El nivel de brillo preferido es muy bajo"</string>
    <string name="auto_brightness_summary_low" msgid="1606100911112851291">"El nivel de brillo preferido es bajo"</string>
    <string name="auto_brightness_summary_default" msgid="9038441148247815684">"El nivel de brillo preferido es predeterminado"</string>
    <string name="auto_brightness_summary_high" msgid="2886260311484349010">"El nivel de brillo preferido es alto"</string>
    <string name="auto_brightness_summary_very_high" msgid="8294814315426024005">"El nivel de brillo preferido es muy alto"</string>
    <string name="auto_brightness_off_title" msgid="5156056957376839677">"Inhabilitado"</string>
    <string name="auto_brightness_very_low_title" msgid="618973599332847430">"Muy bajo"</string>
    <string name="auto_brightness_low_title" msgid="4243763334776382492">"Bajo"</string>
    <string name="auto_brightness_default_title" msgid="1776584786251120907">"Predeterminado"</string>
    <string name="auto_brightness_high_title" msgid="6472704542949390468">"Alto"</string>
    <string name="auto_brightness_very_high_title" msgid="4935132626750630713">"Muy alto"</string>
    <string name="auto_brightness_subtitle" msgid="6839449395639517870">"Tu nivel preferido de brillo"</string>
    <string name="auto_brightness_off_summary" msgid="4993150980274474226">"No ajustar según la luz disponible"</string>
    <string name="auto_brightness_very_high_summary" msgid="2784981315548144255">"Mayor uso de batería"</string>
    <string name="auto_brightness_disclaimer" msgid="1868395832774087351">"Optimiza el nivel de brillo según la luz disponible. También puedes ajustarlo temporalmente."</string>
    <string name="auto_brightness_description" msgid="6807117118142381193">"El brillo de la pantalla se ajustará automáticamente según el entorno y las actividades que hagas. Puedes mover el control deslizante para que la función de brillo automático reconozca tus preferencias."</string>
    <string name="display_white_balance_title" msgid="2624544323029364713">"Mostrar balance de blancos"</string>
    <string name="display_white_balance_summary" msgid="7625456704950209050"></string>
    <string name="peak_refresh_rate_title" msgid="1878771412897140903">"Smooth Display"</string>
    <string name="peak_refresh_rate_summary" msgid="1527087897198455042">"Aumentar automáticamente la frecuencia de actualización de 60 Hz a 90 Hz para cierto contenido. Incrementa el uso de batería"</string>
    <string name="force_high_refresh_rate_toggle" msgid="5861514655252832828">"Forzar frecuencia de actualización de 90 Hz"</string>
    <string name="force_high_refresh_rate_desc" msgid="7794566420873814875">"La máxima frecuencia de actualización mejora la respuesta táctil y la calidad de las animaciones. Incrementa el uso de batería."</string>
    <string name="adaptive_sleep_title" msgid="2987961991423539233">"Atención a la pantalla"</string>
    <string name="adaptive_sleep_summary_on" msgid="313187971631243800">"Activado: No se apagará la pantalla si estás mirándola"</string>
    <string name="adaptive_sleep_summary_off" msgid="5272156339202897523">"Desactivado"</string>
    <string name="adaptive_sleep_title_no_permission" msgid="1719759921214237016">"Se requiere acceso a la cámara"</string>
    <string name="adaptive_sleep_summary_no_permission" msgid="5107880175176848307">"Presiona para administrar los permisos de los Servicios de personalización del dispositivo"</string>
    <string name="adaptive_sleep_description" msgid="1835321775327187860">"Impide que se apague la pantalla si estás mirándola"</string>
    <string name="adaptive_sleep_privacy" msgid="7664570136417980556">"La función de atención a la pantalla usa la cámara frontal para detectar si hay alguien mirando la pantalla. Funciona en el dispositivo, y las imágenes no se almacenan ni se envían a Google."</string>
    <string name="adaptive_sleep_contextual_slice_title" msgid="7467588613212629758">"Activar la atención a la pantalla"</string>
    <string name="adaptive_sleep_contextual_slice_summary" msgid="2993867044745446094">"Mantener la pantalla encendida cuando la miras"</string>
    <string name="night_display_title" msgid="8532432776487216581">"Luz nocturna"</string>
    <string name="night_display_text" msgid="4789324042428095383">"La Luz nocturna le da un tono ámbar a la pantalla. No solo te permitirá ver o leer con luz tenue, sino que también podría ayudarte a conciliar el sueño más rápido."</string>
    <string name="night_display_auto_mode_title" msgid="5869128421470824381">"Programa"</string>
    <string name="night_display_auto_mode_never" msgid="2721729920187175239">"Ninguno"</string>
    <string name="night_display_auto_mode_custom" msgid="3938791496034086916">"Activar a una hora personalizada"</string>
    <string name="night_display_auto_mode_twilight" msgid="4291855156158833997">"Activar de atardecer a amanecer"</string>
    <string name="night_display_start_time_title" msgid="2611541851596977786">"Hora de inicio"</string>
    <string name="night_display_end_time_title" msgid="5243112480391192111">"Hora de finalización"</string>
    <string name="night_display_status_title" msgid="9006282950657941820">"Estado"</string>
    <string name="night_display_temperature_title" msgid="857248782470764263">"Intensidad"</string>
    <string name="night_display_summary_off_auto_mode_never" msgid="7406899634169354142">"Nunca se activará automáticamente"</string>
    <string name="night_display_summary_off_auto_mode_custom" msgid="6667008039080687931">"Se activará automáticamente a las <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="night_display_summary_off_auto_mode_twilight" msgid="3669132200611324994">"Se activará automáticamente al atardecer"</string>
    <string name="night_display_summary_on_auto_mode_never" msgid="832333009202889350">"Nunca se desactivará automáticamente"</string>
    <string name="night_display_summary_on_auto_mode_custom" msgid="2096677025343425755">"Se desactivará automáticamente a las <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="night_display_summary_on_auto_mode_twilight" msgid="8070517472000680361">"Se desactivará automáticamente al amanecer"</string>
    <string name="night_display_activation_on_manual" msgid="7999294858026069365">"Activar ahora"</string>
    <string name="night_display_activation_off_manual" msgid="4842907786868153218">"Desactivar ahora"</string>
    <string name="night_display_activation_on_twilight" msgid="3440889451767582067">"Activar hasta el amanecer"</string>
    <string name="night_display_activation_off_twilight" msgid="2853594955401726956">"Desactivar hasta el atardecer"</string>
    <string name="night_display_activation_on_custom" msgid="4951143503599226846">"Activar hasta la(s) <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="night_display_activation_off_custom" msgid="79965738861100371">"Desactivar hasta la(s) <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="night_display_not_currently_on" msgid="6600205753103093827">"Luz nocturna no activada ahora"</string>
    <string name="twilight_mode_location_off_dialog_message" msgid="4559150893687124801">"Se requiere la ubicación del dispositivo para determinar los horarios del amanecer y el atardecer."</string>
    <string name="twilight_mode_launch_location" msgid="7799112373591153956">"Configuración de la ubicación"</string>
    <string name="dark_ui_activation_on_manual" msgid="1541006734577325234">"Activar ahora"</string>
    <string name="dark_ui_activation_off_manual" msgid="2395333709291250065">"Desactivar ahora"</string>
    <string name="dark_ui_activation_on_auto" msgid="4824339634784765049">"Activar hasta el amanecer"</string>
    <string name="dark_ui_activation_off_auto" msgid="9136717444658505208">"Desactivar hasta el atardecer"</string>
    <string name="dark_ui_title" msgid="3373976268671557416">"Modo oscuro"</string>
    <string name="dark_ui_auto_mode_title" msgid="9027528859262295099">"Programar"</string>
    <string name="dark_ui_auto_mode_never" msgid="3980412582267787662">"Nunca"</string>
    <string name="dark_ui_auto_mode_auto" msgid="6658909029498623375">"Activar de atardecer a amanecer"</string>
    <string name="dark_ui_auto_mode_custom" msgid="3800138185265182170">"Activar a una hora personalizada"</string>
    <string name="dark_ui_status_title" msgid="3505119141437774329">"Estado"</string>
    <string name="dark_ui_summary_off_auto_mode_never" msgid="5828281549475697398">"Nunca se activará automáticamente"</string>
    <string name="dark_ui_summary_off_auto_mode_auto" msgid="6766831395970887213">"Se activará automáticamente al atardecer"</string>
    <string name="dark_ui_summary_off_auto_mode_custom" msgid="1345906088326708376">"Se activará automáticamente a la(s) <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="dark_ui_summary_on_auto_mode_never" msgid="2468597062391435521">"Nunca se desactivará automáticamente"</string>
    <string name="dark_ui_summary_on_auto_mode_auto" msgid="5553376115092648636">"Se desactivará automáticamente al amanecer"</string>
    <string name="dark_ui_summary_on_auto_mode_custom" msgid="2526935680241734784">"Se desactivará automáticamente a la(s) <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="dark_ui_activation_on_custom" msgid="1889379402860316125">"Activar hasta la(s) <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="dark_ui_activation_off_custom" msgid="2192932161592759607">"Desactivar hasta la(s) <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="dark_ui_text" msgid="4392646155331126666">"El Tema oscuro usa un fondo negro para conservar la batería durante más tiempo en algunas pantallas y se programa a fin de esperar a que se apague la pantalla para activarse."</string>
    <string name="screen_timeout" msgid="7709947617767439410">"Tiempo de espera de la pantalla"</string>
    <string name="screen_timeout_title" msgid="785134393520893049">"Cuando se apaga la pantalla"</string>
    <string name="screen_timeout_summary" msgid="5558778019594643427">"Después de <xliff:g id="TIMEOUT_DESCRIPTION">%1$s</xliff:g> de inactividad"</string>
    <string name="wallpaper_settings_title" msgid="5635129851136006383">"Fondo de pantalla"</string>
    <string name="style_and_wallpaper_settings_title" msgid="7580575814098427579">"Estilos y fondos de pantalla"</string>
    <string name="wallpaper_settings_summary_default" msgid="7569803705735001813">"Predeterminado"</string>
    <string name="wallpaper_settings_summary_custom" msgid="3174561317688848729">"Personalizado"</string>
    <string name="wallpaper_suggestion_title" msgid="3812842717939877330">"Cambiar fondo de pantalla"</string>
    <string name="wallpaper_suggestion_summary" msgid="9077061486716754784">"Personalizar tu pantalla"</string>
    <string name="wallpaper_settings_fragment_title" msgid="8445963841717633149">"Elegir fondo de pantalla"</string>
    <string name="style_suggestion_title" msgid="1213747484782364775">"Personaliza tu teléfono"</string>
    <string name="style_suggestion_summary" msgid="4271131877800968159">"Prueba diferentes estilos, fondos de pantalla y mucho más"</string>
    <string name="screensaver_settings_title" msgid="3588535639672365395">"Protector de pantalla"</string>
    <string name="screensaver_settings_summary_either_long" msgid="371949139331896271">"Mientras se carga o está conectado"</string>
    <string name="screensaver_settings_summary_either_short" msgid="2126139984738506920">"En ambos casos"</string>
    <string name="screensaver_settings_summary_sleep" msgid="6555922932643037432">"Mientras se carga"</string>
    <string name="screensaver_settings_summary_dock" msgid="6997766385189369733">"Cuando está conectado"</string>
    <string name="screensaver_settings_summary_never" msgid="4988141393040918450">"Nunca"</string>
    <string name="screensaver_settings_summary_off" msgid="8720357504939106923">"Apagado"</string>
    <string name="screensaver_settings_disabled_prompt" msgid="1166343194760238835">"Para controlar qué sucede cuando el teléfono está conectado o suspendido, activa el protector de pantalla."</string>
    <string name="screensaver_settings_when_to_dream" msgid="8145025742428940520">"Cuándo comenzar"</string>
    <string name="screensaver_settings_current" msgid="390472865895976891">"Protector de pantalla actual"</string>
    <string name="screensaver_settings_dream_start" msgid="6486360145976995856">"Comenzar ahora"</string>
    <string name="screensaver_settings_button" msgid="6159236558934930238">"Configuración"</string>
    <string name="automatic_brightness" msgid="4599827881929079513">"Brillo automático"</string>
    <string name="lift_to_wake_title" msgid="8994218158737714046">"Levantar el dispositivo para activarlo"</string>
    <string name="ambient_display_screen_title" msgid="8615947016991429325">"Pantalla Ambiente"</string>
    <string name="ambient_display_category_triggers" msgid="1216640141609270011">"Cuándo mostrar"</string>
    <string name="doze_title" msgid="1523090408230862316">"Activar pantalla para notif."</string>
    <string name="doze_summary" msgid="8252867381522942804">"La pantalla se enciende para indicar nuevas notificaciones cuando está apagada"</string>
    <string name="doze_always_on_title" msgid="7326245192352868477">"Mostrar información y hora"</string>
    <string name="doze_always_on_summary" msgid="509097829739647852">"El uso de la batería será mayor"</string>
    <string name="force_bold_text" msgid="3636373986786504634">"Texto en negrita"</string>
    <string name="title_font_size" msgid="570613010306330622">"Tamaño de fuente"</string>
    <string name="short_summary_font_size" msgid="184712645848458143">"Aumenta o reduce el tamaño del texto en pantalla"</string>
    <string name="sim_lock_settings" msgid="4493069398250139205">"Bloqueo de la tarjeta SIM"</string>
    <string name="sim_lock_settings_category" msgid="4280307997492851625">"Bloqueo de la tarjeta SIM"</string>
    <string name="sim_lock_settings_summary_off" msgid="4570941250786847095">"Inhabilitado"</string>
    <string name="sim_lock_settings_summary_on" msgid="1562184566830887925">"Bloqueado"</string>
    <string name="sim_lock_settings_title" msgid="1401619059761012696">"Bloqueo de la tarjeta SIM"</string>
    <string name="sim_pin_toggle" msgid="98754920202404425">"Bloquear la tarjeta SIM"</string>
    <string name="sim_lock_on" product="tablet" msgid="5857965768682972363">"Se requiere PIN para utilizar el tablet"</string>
    <string name="sim_lock_on" product="default" msgid="3303147192981388923">"Se requiere PIN para utilizar el dispositivo"</string>
    <string name="sim_lock_off" product="tablet" msgid="7188936582548721225">"Se requiere PIN para utilizar el tablet"</string>
    <string name="sim_lock_off" product="default" msgid="4634118006847137785">"Se requiere PIN para utilizar el dispositivo"</string>
    <string name="sim_pin_change" msgid="5978881209990507379">"Cambiar el PIN de la tarjeta SIM"</string>
    <string name="sim_enter_pin" msgid="8235202785516053253">"PIN de tarjeta SIM"</string>
    <string name="sim_enable_sim_lock" msgid="8993991669975548653">"Bloquear la tarjeta SIM"</string>
    <string name="sim_disable_sim_lock" msgid="7656447857474746157">"Desbloquear tarjeta SIM"</string>
    <string name="sim_enter_old" msgid="6882545610939674813">"PIN de tarjeta SIM anterior"</string>
    <string name="sim_enter_new" msgid="9010947802784561582">"Nuevo PIN de tarjeta SIM"</string>
    <string name="sim_reenter_new" msgid="6131418271490374263">"Volver a ingresar el nuevo PIN"</string>
    <string name="sim_change_pin" msgid="1104103818545005448">"PIN de tarjeta SIM"</string>
    <string name="sim_bad_pin" msgid="5416328363761048221">"PIN incorrecto"</string>
    <string name="sim_pins_dont_match" msgid="1540348773896609260">"Los PIN no coinciden"</string>
    <string name="sim_change_failed" msgid="316723087029061740">"No se puede cambiar el PIN.\nPIN posiblemente incorrecto."</string>
    <string name="sim_change_succeeded" msgid="3516905528149069739">"El PIN de la tarjeta SIM se ha cambiado correctamente"</string>
    <string name="sim_lock_failed" msgid="16360418201678317">"No se puede cambiar el estado de bloqueo de la tarjeta SIM.\nPIN posiblemente incorrecto."</string>
    <string name="sim_pin_disable_failed" msgid="8719890393181032837">"No se puede inhabilitar el PIN."</string>
    <string name="sim_pin_enable_failed" msgid="5156513975085380284">"No se puede habilitar el PIN."</string>
    <string name="sim_enter_ok" msgid="3401715290135787531">"Aceptar"</string>
    <string name="sim_enter_cancel" msgid="2001859323724961490">"Cancelar"</string>
    <string name="sim_multi_sims_title" msgid="4875083890014013296">"Se encontraron varias tarjetas SIM"</string>
    <string name="sim_multi_sims_summary" msgid="1711012455679332238">"Selecciona la SIM que prefieras usar para datos móviles."</string>
    <string name="sim_change_data_title" msgid="4663239438584588847">"¿Usar a <xliff:g id="CARRIER">%1$s</xliff:g> para datos móviles?"</string>
    <string name="sim_change_data_message" msgid="3046178883369645132">"Estás usando a <xliff:g id="CARRIER2_0">%2$s</xliff:g> para datos móviles. Si cambias a <xliff:g id="CARRIER1">%1$s</xliff:g>, ya no se usará a <xliff:g id="CARRIER2_1">%2$s</xliff:g> para los datos móviles."</string>
    <string name="sim_change_data_ok" msgid="4922114750417276560">"Usar <xliff:g id="CARRIER">%1$s</xliff:g>"</string>
    <string name="sim_preferred_title" msgid="7182406911552216373">"¿Actualizar tarjeta SIM?"</string>
    <string name="sim_preferred_message" msgid="6004009449266648351">"<xliff:g id="NEW_SIM">%1$s</xliff:g> es la única SIM en tu dispositivo. ¿Deseas usar esta tarjeta para datos móviles, llamadas y mensajes SMS?"</string>
    <string name="wrong_pin_code_pukked" msgid="3414172752791445033">"El código PIN de la tarjeta SIM es incorrecto. Debes comunicarte con el proveedor para desbloquear el dispositivo."</string>
    <plurals name="wrong_pin_code" formatted="false" msgid="4054088588731305475">
      <item quantity="other">El código PIN de la tarjeta SIM es incorrecto. Tienes <xliff:g id="NUMBER_1">%d</xliff:g> intentos más.</item>
      <item quantity="one">El código PIN de la tarjeta SIM es incorrecto. Tienes <xliff:g id="NUMBER_0">%d</xliff:g> intento más antes de que debas comunicarte con el proveedor para desbloquear el dispositivo.</item>
    </plurals>
    <string name="wrong_pin_code_one" msgid="6924852214263071441">"El código PIN de la tarjeta SIM es incorrecto. Te queda 1 intento antes de que debas comunicarte con tu proveedor para desbloquear el dispositivo."</string>
    <string name="pin_failed" msgid="3726505565797352255">"Error al desbloquear la tarjeta SIM con el PIN"</string>
    <string name="system_update_settings_list_item_title" msgid="3398346836439366350">"Actualiz. del sistema"</string>
    <string name="system_update_settings_list_item_summary" msgid="6703752298349642101"></string>
    <string name="firmware_version" msgid="1606901586501447275">"Versión de Android"</string>
    <string name="security_patch" msgid="4071756145347865382">"Actualización de seguridad de Android"</string>
    <string name="model_info" msgid="8997566254717810904">"Modelo"</string>
    <string name="hardware_info" msgid="7035211991066637019">"Modelo y hardware"</string>
    <string name="hardware_revision" msgid="3454709180861965025">"Versión de hardware"</string>
    <string name="fcc_equipment_id" msgid="6596668314025646129">"ID del equipo"</string>
    <string name="baseband_version" msgid="2600182227599835857">"Versión de banda base"</string>
    <string name="kernel_version" msgid="3513538109381366881">"Versión de kernel"</string>
    <string name="build_number" msgid="9009733242117579826">"Número de compilación"</string>
    <string name="module_version" msgid="1787518340082046658">"Actualización del sistema de Google Play"</string>
    <string name="device_info_not_available" msgid="4804474466616712326">"No disponible"</string>
    <string name="device_status_activity_title" msgid="1812666241137263882">"Estado"</string>
    <string name="device_status" msgid="7988547478034984649">"Estado"</string>
    <string name="device_status_summary" product="tablet" msgid="8826216824111648900">"Estado de la batería, la red y otra información"</string>
    <string name="device_status_summary" product="default" msgid="8132661857066128832">"Número de teléfono, señal, etc."</string>
    <string name="storage_settings" msgid="7472188817781592677">"Almacenamiento"</string>
    <string name="storage_settings_for_app" msgid="229425418984637483">"Almacenamiento y caché"</string>
    <string name="storage_usb_settings" msgid="7058142934214211583">"Almacenamiento"</string>
    <string name="storage_settings_title" msgid="486118156723194815">"Configuración de almacenamiento"</string>
    <string name="storage_settings_summary" product="nosdcard" msgid="3858049818577638926">"Desmontar almacenamiento USB, ver almacenamiento disponible"</string>
    <string name="storage_settings_summary" product="default" msgid="267557695753980969">"Desmontar tarjeta SD, ver espacio de almacenamiento disponible"</string>
    <string name="imei_multi_sim" msgid="71477088017585479">"IMEI (ranura de SIM %1$d)"</string>
    <string name="view_saved_network" msgid="1232387673095080910">"Elige una red guardada para verla"</string>
    <string name="status_number" product="tablet" msgid="3597945414666253183">"MDN"</string>
    <string name="status_number" product="default" msgid="8407999629121682207">"Número de teléfono"</string>
    <string name="status_number_sim_slot" product="tablet" msgid="6582203988975619529">"MDN (ranura de SIM %1$d)"</string>
    <string name="status_number_sim_slot" product="default" msgid="5724823197745786398">"Teléfono (ranura de SIM %1$d)"</string>
    <string name="status_number_sim_status" product="tablet" msgid="4239876366511743428">"MDN en SIM"</string>
    <string name="status_number_sim_status" product="default" msgid="2772745542921910086">"Número de teléfono en SIM"</string>
    <string name="status_min_number" msgid="4492899165438225714">"MIN"</string>
    <string name="status_msid_number" msgid="3871958248824595774">"MSID"</string>
    <string name="status_prl_version" msgid="9002131357502714281">"Versión de PRL"</string>
    <string name="meid_multi_sim" msgid="7645394486193991388">"MEID (ranura de SIM %1$d)"</string>
    <string name="scanning_status_text_wifi_on_ble_on" msgid="7644609329607744714">"Tanto la búsqueda de dispositivos Bluetooth como la búsqueda de redes Wi-Fi están activadas"</string>
    <string name="scanning_status_text_wifi_on_ble_off" msgid="7215007787287418186">"La búsqueda de Wi-Fi está activada; la búsqueda de dispositivos Bluetooth está desactivada"</string>
    <string name="scanning_status_text_wifi_off_ble_on" msgid="1396882599556304165">"La búsqueda de dispositivos Bluetooth está activada, la búsqueda de redes Wi-Fi está desactivada"</string>
    <string name="scanning_status_text_wifi_off_ble_off" msgid="7670694707427030537">"Tanto la búsqueda de dispositivos Bluetooth como la búsqueda de redes Wi-Fi están desactivadas"</string>
    <string name="status_meid_number" msgid="6040380838489162650">"MEID"</string>
    <string name="status_icc_id" msgid="7995690631650006970">"ICCID"</string>
    <string name="status_data_network_type" msgid="3689772955330665876">"Tipo de red de datos móviles"</string>
    <string name="status_voice_network_type" msgid="8700356693062562884">"Tipo de red de voz móvil"</string>
    <string name="status_latest_area_info" msgid="8288488664620741734">"Información del operador"</string>
    <string name="status_data_state" msgid="525196229491743487">"Estado de red móvil"</string>
    <string name="status_esim_id" msgid="5158916796362809133">"EID"</string>
    <string name="status_service_state" msgid="1693424422121058791">"Estado del servicio"</string>
    <string name="status_signal_strength" msgid="7644525712554444359">"Potencia de la señal"</string>
    <string name="status_roaming" msgid="1253597174715663778">"Roaming"</string>
    <string name="status_operator" msgid="4335640583552058491">"Red"</string>
    <string name="status_wifi_mac_address" msgid="4447611754614388914">"Dirección MAC de Wi-Fi"</string>
    <string name="status_device_wifi_mac_address" msgid="1896121694334176494">"Dirección MAC de Wi-Fi del dispositivo"</string>
    <string name="status_bt_address" msgid="6919660304578476547">"Dirección de Bluetooth"</string>
    <string name="status_serial_number" msgid="9060064164331466789">"Número de serie"</string>
    <string name="status_up_time" msgid="1274778533719495438">"Tiempo de actividad"</string>
    <string name="status_awake_time" msgid="2573925324168081586">"Hora de actividad"</string>
    <string name="internal_memory" msgid="1869518160077033848">"Almacenamiento interno"</string>
    <string name="sd_memory" product="nosdcard" msgid="5456718463397723781">"Almacenamiento USB"</string>
    <string name="sd_memory" product="default" msgid="3098344183202722455">"Tarjeta SD"</string>
    <string name="memory_available" msgid="712528795743654737">"Disponible"</string>
    <string name="memory_available_read_only" msgid="3201969221573511590">"Disponible (solo lectura)"</string>
    <string name="memory_size" msgid="2710897518522931469">"Espacio total"</string>
    <string name="memory_calculating_size" msgid="3898240439798661242">"Calculando…"</string>
    <string name="memory_apps_usage" msgid="8818570780540532952">"Aplicaciones y datos de aplicaciones"</string>
    <string name="memory_media_usage" msgid="5161308657995646963">"Medios"</string>
    <string name="memory_downloads_usage" msgid="8252462247720191179">"Descargas"</string>
    <string name="memory_dcim_usage" msgid="3568913845973164352">"Imágenes, videos"</string>
    <string name="memory_music_usage" msgid="8100634000114206429">"Audio (música, tonos de teléfono, podcasts, etc.)"</string>
    <string name="memory_media_misc_usage" msgid="7066851245178533269">"Otros archivos"</string>
    <string name="memory_media_cache_usage" msgid="780808666853685824">"Datos almacenados en caché"</string>
    <string name="sd_eject" product="nosdcard" msgid="6136102589751843304">"Desactivar alm. comp."</string>
    <string name="sd_eject" product="default" msgid="8062832622096296251">"Desmontar la tarjeta SD"</string>
    <string name="sd_eject_summary" product="nosdcard" msgid="6859940774161708871">"Desmontar el almacenamiento USB interno"</string>
    <string name="sd_eject_summary" product="default" msgid="5151243312587186226">"Desmonta la tarjeta SD para que puedas extraerla de forma segura"</string>
    <string name="sd_insert_summary" product="nosdcard" msgid="9164545135649775664">"Inserta USB"</string>
    <string name="sd_insert_summary" product="default" msgid="5949168259622002192">"Insertar una tarjeta SD para el montaje"</string>
    <string name="sd_mount" product="nosdcard" msgid="8305985249945415150">"Activar el almacenamiento USB"</string>
    <string name="sd_mount" product="default" msgid="5279813999455776169">"Montar tarjeta SD"</string>
    <string name="sd_mount_summary" product="nosdcard" msgid="2190410240845521205"></string>
    <string name="sd_mount_summary" product="default" msgid="2190410240845521205"></string>
    <string name="sd_format" product="nosdcard" msgid="8657427883364711513">"Eliminar almacenamiento USB"</string>
    <string name="sd_format" product="default" msgid="9085302892248732329">"Borrar tarjeta SD"</string>
    <string name="sd_format_summary" product="nosdcard" msgid="6179784504937189658">"Borra todos los datos del almacenamiento USB interno, como la música y las fotos"</string>
    <string name="sd_format_summary" product="default" msgid="60583152211068164">"Borra todos los datos de la tarjeta SD, como la música y las fotos"</string>
    <string name="memory_clear_cache_title" msgid="2605096903803953619">"¿Deseas borrar los datos almacenados en caché?"</string>
    <string name="memory_clear_cache_message" msgid="4759561226480906588">"Se borrarán datos en caché de las aplicaciones."</string>
    <string name="mtp_ptp_mode_summary" msgid="7969656567437639239">"La función MTP o PTP está activa."</string>
    <string name="dlg_confirm_unmount_title" product="nosdcard" msgid="7694112411895701320">"¿Desactivar almac. USB?"</string>
    <string name="dlg_confirm_unmount_title" product="default" msgid="8251329019960361646">"¿Desactivar tarjeta SD?"</string>
    <string name="dlg_confirm_unmount_text" product="nosdcard" msgid="1212025106709645023">"Si desactivas el almacenamiento USB, se detendrán algunas aplicaciones que utilices y no estarán disponibles hasta que lo vuelvas a activar."</string>
    <string name="dlg_confirm_unmount_text" product="default" msgid="3887768438615563697">"Si desactivas la tarjeta SD, algunas aplicaciones que uses se detendrán y tal vez no estén disponibles hasta que vuelvas a activarla."</string>
    <string name="dlg_error_unmount_title" product="nosdcard" msgid="2205587942165199845"></string>
    <string name="dlg_error_unmount_title" product="default" msgid="2205587942165199845"></string>
    <string name="dlg_error_unmount_text" product="nosdcard" msgid="7876201891724279436">"No se pudo desactivar el almacenamiento USB. Inténtalo de nuevo más tarde."</string>
    <string name="dlg_error_unmount_text" product="default" msgid="2185659901137961711">"No se pudo desactivar la tarjeta SD. Vuelve a intentarlo más tarde."</string>
    <string name="unmount_inform_text" product="nosdcard" msgid="5932607205977999175">"El almacenamiento USB se desmontará."</string>
    <string name="unmount_inform_text" product="default" msgid="716578785262713312">"Se desactivará la tarjeta SD."</string>
    <string name="sd_ejecting_title" msgid="1641122369013595273">"Desmontando"</string>
    <string name="sd_ejecting_summary" msgid="861928572729341132">"Desmontaje en progreso"</string>
    <string name="storage_low_title" msgid="8002650511493419567">"Poco espacio de almacenamiento"</string>
    <string name="storage_low_summary" msgid="7341022293583384506">"Es posible que algunas funciones del sistema, como la sincronización, no funcionen correctamente. Intenta eliminar o a desactivar elementos para liberar espacio (por ejemplo, aplicaciones o contenido multimedia)."</string>
    <string name="storage_menu_rename" msgid="8549835371429159336">"Cambiar nombre"</string>
    <string name="storage_menu_mount" msgid="4760531872302820569">"Activar"</string>
    <string name="storage_menu_unmount" msgid="8171552487742912282">"Expulsar"</string>
    <string name="storage_menu_format" msgid="5454870642788909443">"Formato"</string>
    <string name="storage_menu_format_public" msgid="5567214442727034630">"Formatear como almac. portátil"</string>
    <string name="storage_menu_format_private" msgid="3208326980027382079">"Formatear como almac. interno"</string>
    <string name="storage_menu_migrate" msgid="2196088149560070193">"Migrar los datos"</string>
    <string name="storage_menu_forget" msgid="5154017890033638936">"Olvidar"</string>
    <string name="storage_menu_set_up" msgid="4401074025612064744">"Configurar"</string>
    <string name="storage_menu_explore" msgid="3048031115521594488">"Explorar"</string>
    <string name="storage_menu_free" msgid="616100170298501673">"Liberar espacio"</string>
    <string name="storage_menu_manage" msgid="7465522758801346408">"Administrar el almacenamiento"</string>
    <string name="keywords_storage_menu_free" msgid="2275406357317597106">"limpiar, almacenar"</string>
    <string name="storage_title_usb" msgid="1332488715547400452">"Conexión con comput. por USB"</string>
    <string name="usb_connection_category" msgid="2288543238378907242">"Conectarse como"</string>
    <string name="usb_mtp_title" msgid="9068009584556422314">"Dispositivo multimedia (MTP)"</string>
    <string name="usb_mtp_summary" msgid="6293240861011560842">"Te permite transferir archivos multimedia en Windows o a través de la aplicación Android File Transfer en Mac (visita www.android.com/filetransfer)."</string>
    <string name="usb_ptp_title" msgid="4496529268189091846">"Cámara (PTP)"</string>
    <string name="usb_ptp_summary" msgid="8382539472311655671">"Te permite transferir fotos con el software de la cámara y archivos a computadoras que no admiten MTP."</string>
    <string name="usb_midi_title" msgid="1139558846427981761">"MIDI"</string>
    <string name="usb_midi_summary" msgid="1842457325845863840">"Permite que las aplicaciones compatibles con MIDI funcionen con software MIDI mediante USB en tu computadora."</string>
    <string name="storage_other_users" msgid="7017206190449510992">"Otros usuarios"</string>
    <string name="storage_internal_title" msgid="3265098802217660829">"Almacenamiento del dispositivo"</string>
    <string name="storage_external_title" msgid="8984075540312137135">"Almacenamiento portátil"</string>
    <string name="storage_volume_summary" msgid="7087627975196777994">"<xliff:g id="USED">%1$s</xliff:g> en uso de <xliff:g id="TOTAL">%2$s</xliff:g> disponibles"</string>
    <string name="storage_size_large" msgid="1155308277890194878">"<xliff:g id="NUMBER">^1</xliff:g>"<small><small>" <xliff:g id="UNIT">^2</xliff:g>"</small></small>""</string>
    <string name="storage_volume_used" msgid="5031288167242496837">"En uso de <xliff:g id="TOTAL">%1$s</xliff:g> disponibles"</string>
    <string name="storage_volume_used_total" msgid="283558499413754323">"Uso total de <xliff:g id="TOTAL">%1$s</xliff:g>"</string>
    <string name="storage_mount_success" msgid="393972242641313135">"Se activó <xliff:g id="NAME">%1$s</xliff:g>."</string>
    <string name="storage_mount_failure" msgid="3667915814876418011">"No se pudo activar <xliff:g id="NAME">%1$s</xliff:g>."</string>
    <string name="storage_unmount_success" msgid="6406298575402936148">"<xliff:g id="NAME">%1$s</xliff:g> se expulsó de forma segura."</string>
    <string name="storage_unmount_failure" msgid="3796912279003790607">"<xliff:g id="NAME">%1$s</xliff:g> no se pudo expulsar de forma segura."</string>
    <string name="storage_format_success" msgid="3028114521294256851">"Se formateó <xliff:g id="NAME">%1$s</xliff:g>."</string>
    <string name="storage_format_failure" msgid="2042691589726261987">"No se pudo formatear <xliff:g id="NAME">%1$s</xliff:g>."</string>
    <string name="storage_rename_title" msgid="5911285992205282312">"Renombrar almacenamiento"</string>
    <string name="storage_dialog_unmounted" msgid="1187960789775910051">"El dispositivo de almacenamiento <xliff:g id="NAME_0">^1</xliff:g> se expulsó de forma segura, pero todavía está disponible. \n\nPara usar <xliff:g id="NAME_1">^1</xliff:g>, primero debes activarlo."</string>
    <string name="storage_dialog_unmountable" msgid="1761107904296941687">"El dispositivo de almacenamiento <xliff:g id="NAME_0">^1</xliff:g> está dañado. \n\nPara usar <xliff:g id="NAME_1">^1</xliff:g>, primero debes completar la configuración."</string>
    <string name="storage_dialog_unsupported" msgid="7787241928013470089">"Este dispositivo no admite <xliff:g id="NAME_0">^1</xliff:g>. \n\nPara usar <xliff:g id="NAME_1">^1</xliff:g> en este dispositivo, primero debes configurarlo."</string>
    <string name="storage_internal_format_details" msgid="8922023528848861812">"Luego de formatear el dispositivo <xliff:g id="NAME_0">^1</xliff:g>, puedes usarlo en otros dispositivos. \n\nTodos los datos se borrarán de <xliff:g id="NAME_1">^1</xliff:g>. Primero, deberías realizar una copia de seguridad. \n\n"<b>"Realizar una copia de seguridad de las fotos y otro contenido multimedia"</b>" \nTransfiere los archivos multimedia a un medio de almacenamiento alternativo en este dispositivo o a un equipo mediante un cable USB. \n\n"<b>"Realizar una copia de seguridad de las aplicaciones"</b>" \nSe desinstalarán todas las aplicaciones guardadas en <xliff:g id="NAME_6">^1</xliff:g> y se eliminarán todos los datos relacionados. Para conservar estas aplicaciones, puedes transferirlas a un medio de almacenamiento alternativo en este dispositivo."</string>
    <string name="storage_internal_unmount_details" msgid="487689543322907311"><b>"Al expulsar este dispositivo interno <xliff:g id="NAME_0">^1</xliff:g>, las aplicaciones allí guardadas dejarán de funcionar, y los archivos multimedia almacenados no estarán disponibles hasta que vuelvas a insertarlo."</b>" \n\nEl medio de almacenamiento <xliff:g id="NAME_1">^1</xliff:g> está formateado para funcionar solo en este dispositivo; no funcionará en otro."</string>
    <string name="storage_internal_forget_details" msgid="5606507270046186691">"Para utilizar las aplicaciones, las fotos o los datos que contiene el dispositivo <xliff:g id="NAME">^1</xliff:g>, debes volver a insertarlo. \n\nDe manera alternativa, si el dispositivo no está disponible, puedes elegir borrar este almacenamiento.\n\nSi decides hacerlo, se perderán todos los datos del dispositivo de forma permanente.\n\nPodrás volver a instalar las aplicaciones en otro momento, pero se perderán los datos almacenados en este dispositivo."</string>
    <string name="storage_internal_forget_confirm_title" msgid="379238668153099015">"¿Deseas borrar <xliff:g id="NAME">^1</xliff:g>?"</string>
    <string name="storage_internal_forget_confirm" msgid="5752634604952674123">"Se perderán de forma permanente todos los datos, las fotos y las aplicaciones almacenados en <xliff:g id="NAME">^1</xliff:g>."</string>
    <string name="storage_detail_apps" msgid="5055911985540355324">"Aplicaciones"</string>
    <string name="storage_detail_images" msgid="6003883845718804371">"Imágenes"</string>
    <string name="storage_detail_videos" msgid="9079894412680404208">"Videos"</string>
    <string name="storage_detail_audio" msgid="234272983148223114">"Audio"</string>
    <string name="storage_detail_cached" msgid="4066364341463331199">"Datos almacenados en caché"</string>
    <string name="storage_detail_other" msgid="3821329310612285961">"Otro"</string>
    <string name="storage_detail_system" msgid="3797439069473271732">"Sistema"</string>
    <string name="storage_detail_explore" msgid="13782374784415466">"Explorar <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_detail_dialog_other" msgid="3359851869961609901">"En Otros se incluyen los archivos compartidos que guardan las apps, los que se descargan de Internet o mediante Bluetooth, los archivos de Android, etc. \n\nPara ver el contenido visible de <xliff:g id="NAME">^1</xliff:g>, presiona Explorar."</string>
    <string name="storage_detail_dialog_system" msgid="7461009051858709479">"El sistema incluye archivos que se usan para ejecutar la versión <xliff:g id="VERSION">%s</xliff:g> de Android."</string>
    <string name="storage_detail_dialog_user" msgid="1691219071007313226">"Es posible que <xliff:g id="USER_0">^1</xliff:g> haya guardado fotos, música, apps y otros datos que ocupan <xliff:g id="SIZE">^2</xliff:g> de almacenamiento. \n\nPara ver más detalles, cambia a <xliff:g id="USER_1">^1</xliff:g>."</string>
    <string name="storage_wizard_init_title" msgid="9036374223934708619">"Configurar el dispositivo <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_init_external_title" msgid="6540132491909241713">"Usar como medio de almacenamiento portátil"</string>
    <string name="storage_wizard_init_external_summary" msgid="5807552934494462984">"Para transferir fotos y otros archivos multimedia entre dispositivos"</string>
    <string name="storage_wizard_init_internal_title" msgid="3256355049992147270">"Usar como medio de almacenamiento interno"</string>
    <string name="storage_wizard_init_internal_summary" msgid="2283798331883929674">"Para guardar contenido solo en este dispositivo, incluidas aplicaciones y fotos. Requiere de formateo para evitar que funcione con otros dispositivos."</string>
    <string name="storage_wizard_format_confirm_title" msgid="4898014527956178762">"Formatear como almacenamiento"</string>
    <string name="storage_wizard_format_confirm_body" msgid="5514665245241830772">"Debes formatear el dispositivo <xliff:g id="NAME_0">^1</xliff:g> para que funcione de manera segura. \n\nAl finalizar, el medio de almacenamiento <xliff:g id="NAME_1">^1</xliff:g> solo funcionará en este dispositivo. \n\n"<b>"Al formatearlo, borrarás todos los datos almacenados en <xliff:g id="NAME_2">^1</xliff:g> de forma reciente."</b>" Para evitar perderlos, puedes realizar una copia de seguridad."</string>
    <string name="storage_wizard_format_confirm_public_title" msgid="649252654496577680">"Formatear como almacen. portátil"</string>
    <string name="storage_wizard_format_confirm_public_body" msgid="6219883780307218266">"Debes formatear el dispositivo <xliff:g id="NAME_0">^1</xliff:g>. \n\n"<b>"Al hacerlo, borrarás todos los datos almacenados en <xliff:g id="NAME_1">^1</xliff:g>."</b>" Para evitar perderlos, puedes crear una copia de seguridad."</string>
    <string name="storage_wizard_format_confirm_next" msgid="4412063054982084056">"Borrar y formatear"</string>
    <string name="storage_wizard_format_progress_title" msgid="9170393018855949774">"Formateando dispositivo (<xliff:g id="NAME">^1</xliff:g>)…"</string>
    <string name="storage_wizard_format_progress_body" msgid="1044024044955390417">"No extraigas <xliff:g id="NAME">^1</xliff:g> durante el proceso de formateo."</string>
    <string name="storage_wizard_migrate_title" msgid="3013711737005104623">"Transferir a almacenam. nuevo"</string>
    <string name="storage_wizard_migrate_body" msgid="1630853797296198275">"Puedes transferir las fotos, los archivos y algunas aplicaciones a la nueva unidad <xliff:g id="NAME">^1</xliff:g>. \n\nEl proceso demora aproximadamente <xliff:g id="TIME">^2</xliff:g> y liberará <xliff:g id="SIZE">^3</xliff:g> de almacenamiento interno. Algunas aplicaciones no funcionarán mientras se realiza la transferencia."</string>
    <string name="storage_wizard_migrate_now" msgid="175023718337037181">"Transferir los datos ahora"</string>
    <string name="storage_wizard_migrate_later" msgid="6573789572520980112">"Transferir los datos más tarde"</string>
    <string name="storage_wizard_migrate_confirm_title" msgid="255346780598924540">"Transferencia de datos"</string>
    <string name="storage_wizard_migrate_confirm_body" msgid="5039938578355576124"><b>"Transferir el contenido demora alrededor de <xliff:g id="TIME">^1</xliff:g>. Con esta acción, liberarás <xliff:g id="SIZE">^2</xliff:g> de <xliff:g id="NAME">^3</xliff:g>."</b></string>
    <string name="storage_wizard_migrate_confirm_next" msgid="217478540562501692">"Transferir"</string>
    <string name="storage_wizard_migrate_progress_title" msgid="462238335086734131">"Transfiriendo los datos…"</string>
    <string name="storage_wizard_migrate_details" msgid="7474061662976940407">"Al transferir el contenido: \n• No extraigas el dispositivo <xliff:g id="NAME">^1</xliff:g>. \n• Algunas aplicaciones no funcionarán de forma correcta. \n• Mantén el dispositivo cargado."</string>
    <string name="storage_wizard_ready_title" msgid="3093468548660255543">"Ya puedes usar <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_ready_external_body" msgid="45040717412844114">"El dispositivo <xliff:g id="NAME">^1</xliff:g> está listo para que lo uses con fotos y otro contenido multimedia."</string>
    <string name="storage_wizard_ready_internal_body" msgid="7734817996475607447">"El nuevo dispositivo <xliff:g id="NAME">^1</xliff:g> está funcionando. \n\nPara transferir fotos, archivos y datos de aplicaciones a este dispositivo, ve a Configuración y almacenamiento."</string>
    <string name="storage_wizard_move_confirm_title" msgid="6812469630804101590">"Transferir la aplicación <xliff:g id="APP">^1</xliff:g>"</string>
    <string name="storage_wizard_move_confirm_body" msgid="1713022828842263574">"Transferir la aplicación <xliff:g id="APP">^1</xliff:g> y los datos relacionados al dispositivo <xliff:g id="NAME_0">^2</xliff:g> solo demorará un momento. Hasta que no se complete la transferencia, no podrás usar la aplicación. \n\nNo extraigas el dispositivo <xliff:g id="NAME_1">^2</xliff:g> durante el proceso."</string>
    <string name="storage_wizard_move_unlock" msgid="14651384927767749">"Para transferir datos, debes desbloquear al usuario <xliff:g id="APP">^1</xliff:g>."</string>
    <string name="storage_wizard_move_progress_title" msgid="3912406225614672391">"Transfiriendo la aplicación <xliff:g id="APP">^1</xliff:g>…"</string>
    <string name="storage_wizard_move_progress_body" msgid="2396714553394935094">"Durante el proceso, no extraigas el dispositivo <xliff:g id="NAME">^1</xliff:g>. \n\nLa aplicación <xliff:g id="APP">^2</xliff:g> estará disponible en este dispositivo cuando se complete el proceso."</string>
    <string name="storage_wizard_move_progress_cancel" msgid="3494022998599718937">"Cancelar transferencia"</string>
    <string name="storage_wizard_slow_body" msgid="8293565076885232029">"Esta <xliff:g id="NAME_0">^1</xliff:g> funciona con lentitud. \n\nPuedes continuar, pero es posible que las aplicaciones que muevas a esta ubicación se vuelvan inestables y la transferencia de datos demore más tiempo.\n\nConsidera utilizar una <xliff:g id="NAME_1">^1</xliff:g> más rápida para mejorar el rendimiento."</string>
    <string name="storage_wizard_init_v2_title" msgid="2538630338392381113">"¿Cómo usarás <xliff:g id="NAME">^1</xliff:g>?"</string>
    <string name="storage_wizard_init_v2_internal_title" product="tablet" msgid="1884468440013151482">"Almacenamiento adicional tablet"</string>
    <string name="storage_wizard_init_v2_internal_summary" product="tablet" msgid="2907833056467441047">"Solo para apps, archivos y contenido multimedia de esta tablet"</string>
    <string name="storage_wizard_init_v2_internal_action" product="tablet" msgid="3278694259614995649">"Almacenamiento en tablet"</string>
    <string name="storage_wizard_init_v2_internal_title" product="default" msgid="5941952998075252284">"Almacenamiento adicional"</string>
    <string name="storage_wizard_init_v2_internal_summary" product="default" msgid="3022584310096954875">"Solo para apps, archivos y contenido multimedia de este teléfono"</string>
    <string name="storage_wizard_init_v2_internal_action" product="default" msgid="5645732875040797464">"Almacenamiento del teléfono"</string>
    <string name="storage_wizard_init_v2_or" msgid="5558706089661158026">"O bien"</string>
    <string name="storage_wizard_init_v2_external_title" msgid="8129096036551264207">"Almacenamiento portátil"</string>
    <string name="storage_wizard_init_v2_external_summary" msgid="6436419488235871823">"Para transferir archivos y contenido multimedia entre dispositivos"</string>
    <string name="storage_wizard_init_v2_external_action" msgid="781928899530539860">"Almacenamiento portátil"</string>
    <string name="storage_wizard_init_v2_later" msgid="5366815913892609285">"Configurar más tarde"</string>
    <string name="storage_wizard_format_confirm_v2_title" msgid="6294104100437326067">"¿Quieres formatear <xliff:g id="NAME">^1</xliff:g>?"</string>
    <string name="storage_wizard_format_confirm_v2_body" msgid="635958708974709506">"Debes formatear <xliff:g id="NAME_0">^1</xliff:g> para poder almacenar apps, archivos y contenido multimedia. \n\nEl formateo borrará todo el contenido existente en <xliff:g id="NAME_1">^2</xliff:g>. Para no perderlo, crea una copia de seguridad en otro <xliff:g id="NAME_2">^3</xliff:g> o en un dispositivo."</string>
    <string name="storage_wizard_format_confirm_v2_action" msgid="5718254101386377126">"Formatear <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_migrate_v2_title" msgid="3471564531564756698">"¿Transferir el contenido a <xliff:g id="NAME">^1</xliff:g>?"</string>
    <string name="storage_wizard_migrate_v2_body" product="tablet" msgid="4541523202790415721">"Puedes transferir archivos, contenido multimedia y determinadas apps a este <xliff:g id="NAME">^1</xliff:g>. \n\nSi lo haces, podrás liberar hasta <xliff:g id="SIZE">^2</xliff:g> de almacenamiento en tu tablet. El proceso llevará aproximadamente <xliff:g id="DURATION">^3</xliff:g>."</string>
    <string name="storage_wizard_migrate_v2_body" product="default" msgid="809730501314645325">"Puedes transferir archivos, contenido multimedia y algunas apps a este <xliff:g id="NAME">^1</xliff:g>. \n\nSi lo haces, podrás liberar hasta <xliff:g id="SIZE">^2</xliff:g> de almacenamiento en tu teléfono. El proceso llevará aproximadamente <xliff:g id="DURATION">^3</xliff:g>."</string>
    <string name="storage_wizard_migrate_v2_checklist" msgid="2618258869444553060">"Durante la transferencia:"</string>
    <string name="storage_wizard_migrate_v2_checklist_media" msgid="5867134681730723744">"No extraigas <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_migrate_v2_checklist_apps" msgid="1882077445750580783">"Algunas apps no funcionarán"</string>
    <string name="storage_wizard_migrate_v2_checklist_battery" product="tablet" msgid="6111770421449869539">"Mantén la tablet cargada"</string>
    <string name="storage_wizard_migrate_v2_checklist_battery" product="default" msgid="8826915870192535008">"Mantén el teléfono cargado"</string>
    <string name="storage_wizard_migrate_v2_now" msgid="3341460117088026966">"Transferir contenido"</string>
    <string name="storage_wizard_migrate_v2_later" msgid="6067756122853315642">"Transferir contenido más tarde"</string>
    <string name="storage_wizard_migrate_progress_v2_title" msgid="8791318509516968103">"Transfiriendo contenido…"</string>
    <string name="storage_wizard_slow_v2_title" msgid="3760766921170980221">"<xliff:g id="NAME">^1</xliff:g> tiene un funcionamiento lento"</string>
    <string name="storage_wizard_slow_v2_body" msgid="7604252106419016929">"Todavía puedes usar <xliff:g id="NAME_0">^1</xliff:g>, pero su funcionamiento podría ser lento. \n\nLas apps almacenadas en <xliff:g id="NAME_1">^2</xliff:g> podrían no funcionar correctamente y las transferencias de contenido podrían demorar mucho tiempo. \n\nIntenta usar un <xliff:g id="NAME_2">^3</xliff:g> más rápido o usa <xliff:g id="NAME_3">^4</xliff:g> como almacenamiento portátil."</string>
    <string name="storage_wizard_slow_v2_start_over" msgid="1806852287668077536">"Volver a empezar"</string>
    <string name="storage_wizard_slow_v2_continue" msgid="7469713755893007901">"Continuar"</string>
    <string name="storage_wizard_ready_v2_external_body" msgid="3896836008684280905">"Puedes transferir el contenido a <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_ready_v2_internal_body" msgid="5710665992219332454">"Para transferir el contenido a <xliff:g id="NAME">^1</xliff:g>, ve a "<b>"Configuración y almacenamiento"</b></string>
    <string name="storage_wizard_ready_v2_internal_moved_body" msgid="1269878056598666852">"Se transfirió el contenido a <xliff:g id="NAME_0">^1</xliff:g>. \n\n Para administrar tu <xliff:g id="NAME_1">^2</xliff:g>, ve a "<b>"Configuración y almacenamiento"</b>"."</string>
    <string name="battery_status_title" msgid="4661768220545945771">"Estado de batería"</string>
    <string name="battery_level_title" msgid="1371765298786083448">"Nivel de la batería"</string>
    <string name="apn_settings" msgid="4295467389400441299">"APN"</string>
    <string name="apn_edit" msgid="2003683641840248741">"Editar pto. de acceso"</string>
    <string name="apn_not_set" msgid="8246646433109750293">"No definido"</string>
    <string name="apn_name" msgid="6677695784108157953">"Nombre"</string>
    <string name="apn_apn" msgid="5812828833797458602">"APN"</string>
    <string name="apn_http_proxy" msgid="1052464912365838007">"Proxy"</string>
    <string name="apn_http_port" msgid="9138610639873966046">"Puerto"</string>
    <string name="apn_user" msgid="5831763936428279228">"Nombre de usuario"</string>
    <string name="apn_password" msgid="7435086635953953029">"Contraseña"</string>
    <string name="apn_server" msgid="6997704279138388384">"Servidor"</string>
    <string name="apn_mmsc" msgid="4985570919581927224">"MMSC"</string>
    <string name="apn_mms_proxy" msgid="6592247653258283592">"Proxy de MMS"</string>
    <string name="apn_mms_port" msgid="6500563737462966663">"Puerto MMS"</string>
    <string name="apn_mcc" msgid="4971414138516074809">"MCC"</string>
    <string name="apn_mnc" msgid="1926382406843447854">"MNC"</string>
    <string name="apn_auth_type" msgid="4234397513494356932">"Tipo de autenticación"</string>
    <string name="apn_auth_type_none" msgid="6845031410929644238">"Ninguno"</string>
    <string name="apn_auth_type_pap" msgid="9003475621032514182">"PAP"</string>
    <string name="apn_auth_type_chap" msgid="3587713509473187621">"CHAP"</string>
    <string name="apn_auth_type_pap_chap" msgid="6852124741245095775">"PAP o CHAP"</string>
    <string name="apn_type" msgid="1835573305077788773">"Tipo de APN"</string>
    <string name="apn_protocol" msgid="181529867160380010">"Protocolo APN"</string>
    <string name="apn_roaming_protocol" msgid="1645131094105362513">"Protocolo de APN en itinerancia"</string>
    <string name="carrier_enabled" msgid="664074151573150130">"Activar/Desactivar el APN"</string>
    <string name="carrier_enabled_summaryOn" msgid="5212067975273903381">"APN activado"</string>
    <string name="carrier_enabled_summaryOff" msgid="8541959867953738521">"APN inhabilitado"</string>
    <string name="bearer" msgid="3231443241639159358">"Portador"</string>
    <string name="mvno_type" msgid="4734654257494971247">"Tipo de OMV"</string>
    <string name="mvno_match_data" msgid="5213193073684321156">"Valor de OMV"</string>
    <string name="menu_delete" msgid="9199740901584348273">"Eliminar APN"</string>
    <string name="menu_new" msgid="6571230342655509006">"APN nuevo"</string>
    <string name="menu_save" msgid="6611465355127483100">"Guardar"</string>
    <string name="menu_cancel" msgid="1197826697950745335">"Cancelar"</string>
    <string name="error_title" msgid="7158648377702417716"></string>
    <string name="error_name_empty" msgid="1258275899283079142">"El campo Nombre no puede estar vacío."</string>
    <string name="error_apn_empty" msgid="7657491065443746915">"El APN no puede estar vacío."</string>
    <string name="error_mcc_not3" msgid="883659545640179094">"El campo de MCC debe contener 3 dígitos."</string>
    <string name="error_mnc_not23" msgid="7642478711158474918">"El campo MNC debe contener 2 ó 3 dígitos."</string>
    <string name="error_adding_apn_type" msgid="1324263534991467943">"El proveedor no permite que se agreguen APN del tipo %s."</string>
    <string name="restore_default_apn" msgid="6596048535642130689">"Restaurando la configuración APN predeterminada"</string>
    <string name="menu_restore" msgid="4310539620115151551">"Restablecer valores predeterminados"</string>
    <string name="restore_default_apn_completed" msgid="5167505087078340256">"Se restableció la configuración predeterminada de APN."</string>
    <string name="reset_dashboard_title" msgid="7423200250697886918">"Restablecimiento"</string>
    <string name="reset_dashboard_summary" msgid="4390780188264852956">"Se pueden restablecer las redes, las apps y los dispositivos"</string>
    <string name="reset_dashboard_summary_onlyApps" msgid="3304252260039419584">"Se pueden restablecer las apps"</string>
    <string name="reset_network_title" msgid="1395494440355807616">"Restablecer configuración de Wi-Fi, datos móviles y Bluetooth"</string>
    <string name="reset_network_desc" msgid="1112523764899788246">"Se restablecerán las opciones de configuración de todas las redes, lo que incluye:\n\n"<li>"Wi‑Fi"</li>\n<li>"Datos móviles"</li>\n<li>"Bluetooth"</li></string>
    <string name="erase_euicc_data_button" msgid="728078969563311737">"Borrar"</string>
    <string name="reset_esim_title" msgid="6152167073280852849">"Borrar tarjetas SIM descargadas"</string>
    <string name="reset_esim_desc" msgid="3662444090563399131">"Esta acción no cancelará ningún plan de servicio móvil. Para descargar tarjetas SIM de reemplazo, comunícate con tu proveedor."</string>
    <string name="reset_network_button_text" msgid="2281476496459610071">"Restablecer configuración"</string>
    <string name="reset_network_final_desc" msgid="5304365082065278425">"¿Quieres restablecer toda la configuración de red? No podrás deshacer esta acción."</string>
    <string name="reset_network_final_desc_esim" msgid="8342882682282693844">"¿Quieres restablecer toda la configuración de red y borrar las tarjetas SIM descargadas? No podrás deshacer esta acción."</string>
    <string name="reset_network_final_button_text" msgid="2433867118414000462">"Restablecer configuración"</string>
    <string name="reset_network_confirm_title" msgid="913014422184481270">"¿Restablecer?"</string>
    <string name="network_reset_not_available" msgid="1966334631394607829">"El restablecimiento de la red no está disponible para este usuario."</string>
    <string name="reset_network_complete_toast" msgid="1367872474130621115">"Se restableció la configuración de red."</string>
    <string name="reset_esim_error_title" msgid="4670073610967959597">"No se pueden borrar las tarjetas SIM"</string>
    <string name="reset_esim_error_msg" msgid="4441504470684307370">"No es posible borrar las tarjetas SIM descargadas debido a un error.\n\nReinicia el dispositivo y vuelve a intentarlo."</string>
    <string name="main_clear_title" msgid="277664302144837723">"Borrar todos los datos (restablecer la configuración de fábrica)"</string>
    <string name="main_clear_short_title" msgid="4752094765533020696">"Borrar todo (restablecer configuración de fábrica)"</string>
    <string name="main_clear_desc" product="tablet" msgid="1651178880680056849">"Esta acción borrará todos los datos del "<b>"almacenamiento interno"</b>" de tu tablet, como\n\n"<li>"Tu Cuenta de Google"</li>\n<li>"Los datos y la configuración del sistema y de las apps"</li>\n<li>"Las apps descargadas"</li></string>
    <string name="main_clear_desc" product="default" msgid="6984348811887162647">"Esta acción borrará todos los datos del "<b>"almacenamiento interno"</b>" de tu teléfono, como\n\n"<li>"Tu Cuenta de Google"</li>\n<li>"Los datos y la configuración del sistema y de las apps"</li>\n<li>"Las apps descargadas"</li></string>
    <string name="main_clear_accounts" product="default" msgid="7675859115108318537">\n\n"Accediste a las siguientes cuentas:\n"</string>
    <string name="main_clear_other_users_present" product="default" msgid="2672976674798019077">\n\n"Hay otros usuarios presentes en este dispositivo.\n"</string>
    <string name="main_clear_desc_also_erases_external" msgid="3687911419628956693"><li>"Música"</li>\n<li>"Fotos"</li>\n<li>"Otros datos del usuario"</li></string>
    <string name="main_clear_desc_also_erases_esim" msgid="4553469876411831729"><li>"eSIM"</li></string>
    <string name="main_clear_desc_no_cancel_mobile_plan" msgid="369883568059127035">\n\n"No se cancelará tu plan de servicio móvil."</string>
    <string name="main_clear_desc_erase_external_storage" product="nosdcard" msgid="4441604184663452046">\n\n"Para borrar la música, las imágenes y otros datos de usuario, debes borrar el "<b>"almacenamiento USB"</b>"."</string>
    <string name="main_clear_desc_erase_external_storage" product="default" msgid="1498514970618215728">\n\n"Para borrar música, imágenes y otros datos del usuario, debes borrar la "<b>"tarjeta SD"</b>"."</string>
    <string name="erase_external_storage" product="nosdcard" msgid="2182181846128639635">"Eliminar almacenamiento USB"</string>
    <string name="erase_external_storage" product="default" msgid="2610056855012660451">"Borrar tarjeta SD"</string>
    <string name="erase_external_storage_description" product="nosdcard" msgid="6358699244894944843">"Borra todos los datos del almacenamiento USB, como la música o las fotos."</string>
    <string name="erase_external_storage_description" product="default" msgid="3367779850546310380">"Borra todos los datos de la tarjeta SD, como música o fotos."</string>
    <string name="main_clear_button_text" product="tablet" msgid="6246087475569640671">"Borrar todos los datos"</string>
    <string name="main_clear_button_text" product="default" msgid="6246087475569640671">"Borrar todos los datos"</string>
    <string name="main_clear_final_desc" msgid="5800877928569039580">"Se borrarán las apps que hayas descargado y tu información personal. No podrás deshacer esta acción."</string>
    <string name="main_clear_final_desc_esim" msgid="440406836793824969">"Se borrará toda tu información personal, incluidas las apps y las tarjetas SIM descargadas. No podrás deshacer esta acción."</string>
    <string name="main_clear_confirm_title" msgid="6577071819657853713">"¿Quieres borrar todos los datos?"</string>
    <string name="main_clear_not_available" msgid="3433795327146684827">"El restablecimiento de la configuración de fábrica no está disponible para este usuario"</string>
    <string name="main_clear_progress_title" msgid="7239741132015617719">"Borrando"</string>
    <string name="main_clear_progress_text" msgid="4636695115176327972">"Espera…"</string>
    <string name="call_settings_title" msgid="2531072044177194164">"Configuración"</string>
    <string name="call_settings_summary" msgid="8244293779053318053">"Establecer correo de voz, desvío de llamadas, llamada en espera, identificador de llamadas"</string>
    <string name="tether_settings_title_usb" msgid="5926474044238409099">"Conexión a red por USB"</string>
    <string name="tether_settings_title_wifi" msgid="4327056146425282159">"Hotspot portátil"</string>
    <string name="tether_settings_title_bluetooth" msgid="8878813702520141084">"Conexión Bluetooth"</string>
    <string name="tether_settings_title_usb_bluetooth" msgid="4437274151658505496">"Compartir conexión"</string>
    <string name="tether_settings_title_all" msgid="6807525590937697228">"Hotspot y conexión mediante dispositivos móviles"</string>
    <string name="tether_settings_summary_hotspot_on_tether_on" msgid="6110241048260139633">"Hotspot activado, conexión mediante dispositivo móvil"</string>
    <string name="tether_settings_summary_hotspot_on_tether_off" msgid="5057598961245943644">"Hotspot activado"</string>
    <string name="tether_settings_summary_hotspot_off_tether_on" msgid="7181518138494995888">"Conexión mediante dispositivo móvil"</string>
    <string name="tether_settings_disabled_on_data_saver" msgid="9054069463426952689">"No podrán establecerse conexiones a través del dispositivo portátil ni hotspots portátiles cuando se active el modo Ahorro de datos."</string>
    <string name="tether_settings_summary_hotspot_only" msgid="8529008147731140279">"Solo hotspot"</string>
    <string name="tether_settings_summary_usb_tethering_only" msgid="6351624505239356221">"Solo USB"</string>
    <string name="tether_settings_summary_bluetooth_tethering_only" msgid="1451008625343274930">"Solo Bluetooth"</string>
    <string name="tether_settings_summary_ethernet_tethering_only" msgid="3582266687537419309">"Solo Ethernet"</string>
    <string name="tether_settings_summary_hotspot_and_usb" msgid="5999349643653265016">"Hotspot y USB"</string>
    <string name="tether_settings_summary_hotspot_and_bluetooth" msgid="810514646401708557">"Hotspot y Bluetooth"</string>
    <string name="tether_settings_summary_hotspot_and_ethernet" msgid="5489192670354277152">"Hotspot y Ethernet"</string>
    <string name="tether_settings_summary_usb_and_bluetooth" msgid="1355680331767261967">"USB y Bluetooth"</string>
    <string name="tether_settings_summary_usb_and_ethernet" msgid="2195017679820919905">"USB y Ethernet"</string>
    <string name="tether_settings_summary_bluetooth_and_ethernet" msgid="1015253926959211012">"Bluetooth y Ethernet"</string>
    <string name="tether_settings_summary_hotspot_and_usb_and_bluetooth" msgid="2949043525073791732">"Hotspot, USB y Bluetooth"</string>
    <string name="tether_settings_summary_hotspot_and_usb_and_ethernet" msgid="5178946567323581144">"Hotspot, USB y Ethernet"</string>
    <string name="tether_settings_summary_hotspot_and_bluetooth_and_ethernet" msgid="4104425838594994441">"Hotspot, Bluetooth y Ethernet"</string>
    <string name="tether_settings_summary_usb_and_bluetooth_and_ethernet" msgid="5880591133984166550">"USB, Bluetooth y Ethernet"</string>
    <string name="tether_settings_summary_all" msgid="7565193614882005775">"Hotspot, USB, Bluetooth y Ethernet"</string>
    <string name="tether_settings_summary_off" msgid="2526164899130351968">"No se comparte Internet con otros dispositivos"</string>
    <string name="tethering_interface_options" msgid="7575535888135143650">"Conexión mediante dispositivo móvil"</string>
    <string name="disable_wifi_hotspot_title" msgid="2167985468585290478">"No usar hotspot de Wi‑Fi"</string>
    <string name="disable_wifi_hotspot_when_usb_on" msgid="220439059794714583">"Solo compartir la conexión a Internet mediante USB"</string>
    <string name="disable_wifi_hotspot_when_bluetooth_on" msgid="4711723299880116345">"Solo compartir la conexión a Internet mediante Bluetooth"</string>
    <string name="disable_wifi_hotspot_when_ethernet_on" msgid="4123242400542103599">"Solo compartir mediante Ethernet"</string>
    <string name="disable_wifi_hotspot_when_usb_and_bluetooth_on" msgid="5258774769658150180">"Solo compartir la conexión a Internet mediante USB y Bluetooth"</string>
    <string name="disable_wifi_hotspot_when_usb_and_ethernet_on" msgid="7126313562907225612">"Solo compartir la conexión a Internet mediante USB y Ethernet"</string>
    <string name="disable_wifi_hotspot_when_bluetooth_and_ethernet_on" msgid="2943464651349235967">"Solo compartir la conexión a Internet mediante Bluetooth y Ethernet"</string>
    <string name="disable_wifi_hotspot_when_usb_and_bluetooth_and_ethernet_on" msgid="3934609816834760008">"Solo compartir la conexión a Internet mediante USB, Bluetooth y Ethernet"</string>
    <string name="usb_title" msgid="1157283449840612901">"USB"</string>
    <string name="usb_tethering_button_text" msgid="7364633823180913777">"Conexión a red por USB"</string>
    <string name="usb_tethering_subtext" product="default" msgid="3168636595109044213">"Compartir la conexión a Internet del teléfono mediante USB"</string>
    <string name="usb_tethering_subtext" product="tablet" msgid="1749659335004856576">"Compartir la conexión a Internet de la tablet mediante USB"</string>
    <string name="bluetooth_tether_checkbox_text" msgid="6108398414967813545">"Conexión Bluetooth"</string>
    <string name="bluetooth_tethering_subtext" product="tablet" msgid="2023654677593885805">"Compartir la conexión a Internet de la tablet mediante Bluetooth"</string>
    <string name="bluetooth_tethering_subtext" product="default" msgid="4322810060538179348">"Compartir la conexión a Internet del teléfono mediante Bluetooth"</string>
    <string name="bluetooth_tethering_off_subtext_config" msgid="6941934844527406581">"Compartiendo la conexión a Internet de <xliff:g id="DEVICE_NAME">%1$d</xliff:g> mediante Bluetooth"</string>
    <string name="bluetooth_tethering_overflow_error" msgid="5292358672240161566">"No se puede anclar a red a más de <xliff:g id="MAXCONNECTION">%1$d</xliff:g> dispositivos."</string>
    <string name="bluetooth_untether_blank" msgid="5087548945727762308">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g> ya no se anclará a red."</string>
    <string name="ethernet_tether_checkbox_text" msgid="959743110824197356">"Conexión a Ethernet"</string>
    <string name="ethernet_tethering_subtext" product="default" msgid="5998100693350351694">"Compartir la conexión a Internet del teléfono mediante Ethernet"</string>
    <string name="tethering_footer_info" msgid="6782375845587483281">"Usa la función de hotspot y conexión mediante dispositivo portátil para brindar acceso a Internet a otros dispositivos mediante tu conexión de datos móviles. Las apps también pueden crear un hotspot para compartir contenido con dispositivos cercanos."</string>
    <string name="tethering_footer_info_sta_ap_concurrency" msgid="2079039077487477676">"Usa un hotspot y una conexión mediante dispositivo móvil para brindar acceso a Internet a otros dispositivos a través de una conexión Wi-Fi o de datos móviles. Las apps también pueden crear un hotspot para compartir contenido con dispositivos cercanos."</string>
    <string name="tethering_help_button_text" msgid="2823655011510912001">"Ayuda"</string>
    <string name="network_settings_title" msgid="4663717899931613176">"Red móvil"</string>
    <string name="manage_mobile_plan_title" msgid="5616930513733409064">"Plan móvil"</string>
    <string name="sms_application_title" msgid="4791107002724108809">"SMS"</string>
    <string name="sms_change_default_dialog_title" msgid="2343439998715457307">"¿Quieres cambiar la aplicación de SMS?"</string>
    <string name="sms_change_default_dialog_text" msgid="8777606240342982531">"¿Quieres usar <xliff:g id="NEW_APP">%1$s</xliff:g> en lugar de <xliff:g id="CURRENT_APP">%2$s</xliff:g> como la aplicación de SMS?"</string>
    <string name="sms_change_default_no_previous_dialog_text" msgid="6215622785087181275">"¿Quieres usar <xliff:g id="NEW_APP">%s</xliff:g> como la aplicación de SMS?"</string>
    <string name="network_scorer_picker_title" msgid="2022922801936206195">"Proveedor de calificación de red"</string>
    <string name="network_scorer_picker_none_preference" msgid="8894034333043177807">"Ninguno"</string>
    <string name="network_scorer_change_active_dialog_title" msgid="7005220310238618141">"¿Cambiar de asistente de Wi-Fi?"</string>
    <string name="network_scorer_change_active_dialog_text" msgid="7006057749370850706">"¿Deseas usar <xliff:g id="NEW_APP">%1$s</xliff:g> en lugar de <xliff:g id="CURRENT_APP">%2$s</xliff:g> para administrar tus conexiones de red?"</string>
    <string name="network_scorer_change_active_no_previous_dialog_text" msgid="680685773455072321">"¿Deseas usar <xliff:g id="NEW_APP">%s</xliff:g> para administrar tus conexiones de red?"</string>
    <string name="mobile_unknown_sim_operator" msgid="6650422533065760963">"Operador SIM desconocido"</string>
    <string name="mobile_no_provisioning_url" msgid="609462719893503773">"<xliff:g id="OPERATOR">%1$s</xliff:g> no tiene ningún sitio web de aprovisionamiento"</string>
    <string name="mobile_insert_sim_card" msgid="3639245241283948038">"Inserta la tarjeta SIM y reinicia."</string>
    <string name="mobile_connect_to_internet" msgid="8162654404357069060">"Conéctate a Internet."</string>
    <string name="location_category_recent_location_requests" msgid="2205900488782832082">"Solicitudes de ubicaciones recientes"</string>
    <string name="location_recent_location_requests_see_all" msgid="7918405176741692524">"Ver todos"</string>
    <string name="location_category_location_services" msgid="8163798686832434284">"Servicios de ubicación"</string>
    <string name="location_title" msgid="5819154746934945021">"Mi ubicación"</string>
    <string name="managed_profile_location_switch_title" msgid="1265007506385460066">"Ubicación de perfil de trabajo"</string>
    <string name="location_app_level_permissions" msgid="45436724900423656">"Acceso de apps a la ubicación"</string>
    <string name="location_app_permission_summary_location_off" msgid="2711822936853500335">"La ubicación está desactivada"</string>
    <plurals name="location_app_permission_summary_location_on" formatted="false" msgid="8286873148858526214">
      <item quantity="other"> Apps con acceso a la ubicación: <xliff:g id="PERMITTED_LOCATION_APP_COUNT_2">%1$d</xliff:g> de <xliff:g id="TOTAL_LOCATION_APP_COUNT_3">%2$d</xliff:g></item>
      <item quantity="one"> Apps con acceso a la ubicación: <xliff:g id="PERMITTED_LOCATION_APP_COUNT_0">%1$d</xliff:g> de <xliff:g id="TOTAL_LOCATION_APP_COUNT_1">%2$d</xliff:g></item>
    </plurals>
    <string name="location_category_recent_location_access" msgid="7880996987927703141">"Acceso reciente a la ubicación"</string>
    <string name="location_recent_location_access_view_details" msgid="5803264082558504544">"Ver detalles"</string>
    <string name="location_no_recent_apps" msgid="6814206631456177033">"Ninguna aplicación solicitó la ubicación recientemente."</string>
    <string name="location_no_recent_accesses" msgid="6031735777805464247">"Ninguna app accedió recientemente a tu ubicación"</string>
    <string name="location_high_battery_use" msgid="4277318891200626524">"Uso de batería alto"</string>
    <string name="location_low_battery_use" msgid="5218950289737996431">"Uso de batería bajo"</string>
    <string name="location_scanning_screen_title" msgid="2346125609614249968">"Búsqueda por Wi‑Fi y Bluetooth"</string>
    <string name="location_scanning_wifi_always_scanning_title" msgid="5004781272733434794">"Búsqueda de Wi‑Fi"</string>
    <string name="location_scanning_wifi_always_scanning_description" msgid="6236055656376931306">"Permite que las apps y los servicios busquen redes Wi-Fi en cualquier momento, aunque la conexión Wi-Fi esté desactivada. Esta función puede usarse, por ejemplo, para mejorar las funciones y los servicios basados en la ubicación."</string>
    <string name="location_scanning_bluetooth_always_scanning_title" msgid="1809309545730215891">"Búsqueda de dispositivos Bluetooth"</string>
    <string name="location_scanning_bluetooth_always_scanning_description" msgid="5362988856388462841">"Permite que las apps y los servicios busquen dispositivos cercanos en cualquier momento, aunque la conexión Bluetooth esté desactivada. Esta función puede usarse, por ejemplo, para mejorar las funciones y los servicios basados en la ubicación."</string>
    <string name="managed_profile_location_services" msgid="8172092734138341880">"Servicios de ubicación para el trabajo"</string>
    <string name="location_time_zone_detection_screen_title" msgid="8396625087466311625">"Detección de la zona horaria de la ubicación"</string>
    <string name="location_time_zone_detection_enabled_title" msgid="1195178875042989835">"Detección de la zona horaria de la ubicación"</string>
    <string name="location_time_zone_detection_enabled_description" msgid="1064716900984397624">"Permite que la ubicación del dispositivo se utilice para detectar la zona horaria actual. Otras configuraciones de la ubicación, como la búsqueda de Wi-Fi, pueden afectar la exactitud de la detección de la zona horaria."</string>
    <string name="location_time_zone_detection_on" msgid="5514817179120761597">"Activada"</string>
    <string name="location_time_zone_detection_off" msgid="192427076195667079">"Desactivada"</string>
    <string name="location_time_zone_detection_auto_is_off" msgid="8067073548483627695">"Se inhabilitó la detección automática de la zona horaria"</string>
    <string name="location_time_zone_detection_not_applicable" msgid="6757964612836952714">"Se inhabilitó la detección de la zona horaria de la ubicación"</string>
    <string name="location_time_zone_detection_not_supported" msgid="3251181656388306501">"La detección de la zona horaria de la ubicación no es compatible"</string>
    <string name="location_time_zone_detection_not_allowed" msgid="8264525161514617051">"No se permiten los cambios de detección de la zona horaria de la ubicación"</string>
    <string name="location_network_based" msgid="5247042890080021887">"Ubicación de Wi-Fi y red móvil"</string>
    <string name="location_neighborhood_level" msgid="3668890550358558267">"Permitir que aplicaciones usen el servicio de ubicación de Google para calcular tu ubicación (se enviarán datos anónimos a Google)"</string>
    <string name="location_neighborhood_level_wifi" msgid="6227393490651891977">"Ubicación determinada por Wi-Fi"</string>
    <string name="location_gps" msgid="8783616672454701134">"Satélites de GPS"</string>
    <string name="location_street_level" product="tablet" msgid="865953107414742784">"Permitir que las aplicaciones usen el sistema GPS de tu tablet para determinar tu ubicación"</string>
    <string name="location_street_level" product="default" msgid="3813836654645896185">"Permitir que las aplicaciones usen el sistema GPS de tu dispositivo para determinar tu ubicación"</string>
    <string name="assisted_gps" msgid="1714546606018821498">"Utilizar GPS asistido"</string>
    <string name="assisted_gps_enabled" msgid="6220188450779319248">"Utilizar el servidor para asistir el GPS (anular la selección para reducir el uso de la red)"</string>
    <string name="assisted_gps_disabled" msgid="1062496503892849">"Utilizar el servidor para asistir el GPS (anula la selección para mejorar el rendimiento del GPS)"</string>
    <string name="use_location_title" msgid="1345594777162897654">"Búsqueda de Google y ubicación"</string>
    <string name="use_location_summary" msgid="377322574549729921">"Permitir que Google utilice tu ubicación para mejorar los resultados de búsqueda y otros servicios"</string>
    <string name="location_access_title" msgid="4052667453826272040">"Acceso a mi ubicación"</string>
    <string name="location_access_summary" msgid="8634100005481578143">"Permitir que las aplicaciones que solicitaron permiso usen la información de tu ubicación"</string>
    <string name="location_sources_heading" msgid="6126965815860570524">"Fuentes de ubicación"</string>
    <string name="about_settings" product="tablet" msgid="2888705054709289693">"Acerca de la tablet"</string>
    <string name="about_settings" product="default" msgid="4038626127378127613">"Acerca del dispositivo"</string>
    <string name="about_settings" product="device" msgid="9012888717090302815">"Acerca del dispositivo"</string>
    <string name="about_settings" product="emulator" msgid="2516560858771320366">"Acerca del dispositivo emulado"</string>
    <string name="about_settings_summary" msgid="4831942939227432513">"Ver información legal, estado, versión de software del tablet"</string>
    <string name="legal_information" msgid="7509900979811934843">"Información legal"</string>
    <string name="contributors_title" msgid="7965640251547037965">"Colaboradores"</string>
    <string name="manual" msgid="3651593989906084868">"Manual"</string>
    <string name="regulatory_labels" msgid="5960251403367154270">"Etiquetas reglamentarias"</string>
    <string name="safety_and_regulatory_info" msgid="8285048080439298528">"Manual sobre reglamentación y seguridad"</string>
    <string name="copyright_title" msgid="83245306827757857">"Derechos de autor"</string>
    <string name="license_title" msgid="8745742085916617540">"Licencia"</string>
    <string name="module_license_title" msgid="8705484239826702828">"Licencias de actualización del sistema de Play"</string>
    <string name="terms_title" msgid="2071742973672326073">"Términos y condiciones"</string>
    <string name="webview_license_title" msgid="5832692241345780517">"Licencia de WebView del sistema"</string>
    <string name="wallpaper_attributions" msgid="3080339190260272255">"Fondos de pantalla"</string>
    <string name="wallpaper_attributions_values" msgid="987277439026021925">"Proveedores de imágenes satelitales:\n©2014 CNES / Astrium, DigitalGlobe, Bluesky"</string>
    <string name="settings_manual_activity_title" msgid="1682978148920788484">"Manual"</string>
    <string name="settings_manual_activity_unavailable" msgid="2514549851682321576">"Se produjo un error al cargar el manual."</string>
    <string name="settings_license_activity_title" msgid="7832071619364734914">"Licencias de terceros"</string>
    <string name="settings_license_activity_unavailable" msgid="9014803774391134570">"Hay un problema para cargar las licencias."</string>
    <string name="settings_license_activity_loading" msgid="1653151990366578827">"Cargando…"</string>
    <string name="settings_safetylegal_title" msgid="1334501164265709288">"Información de seguridad"</string>
    <string name="settings_safetylegal_activity_title" msgid="2218587051061093358">"Información de seguridad"</string>
    <string name="settings_safetylegal_activity_unreachable" msgid="6571695168138207587">"No tienes conexión de datos. Para ver esta información, accede a %s desde cualquier computadora conectada a Internet."</string>
    <string name="settings_safetylegal_activity_loading" msgid="1757860124583063395">"Cargando…"</string>
    <string name="lockpassword_choose_your_screen_lock_header" msgid="7587198092214670356">"Establecer bloqueo de pantalla"</string>
    <string name="lockpassword_choose_your_password_message" msgid="4474728476383676731">"Por motivos de seguridad, establece una contraseña"</string>
    <string name="lockpassword_choose_your_password_header_for_fingerprint" msgid="3167261267229254090">"Configura la contraseña de respaldo"</string>
    <string name="lockpassword_choose_your_pattern_header_for_fingerprint" msgid="4707788269512303400">"Para usar tu huella configura un patrón"</string>
    <string name="lockpassword_choose_your_pin_message" msgid="7230665212172041837">"Por motivos de seguridad, establece un PIN"</string>
    <string name="lockpassword_choose_your_pin_header_for_fingerprint" msgid="2783879743691792556">"Configura el PIN para usar la huella"</string>
    <string name="lockpassword_choose_your_pattern_message" msgid="5815780503576680412">"Por motivos de seguridad, establece un patrón"</string>
    <string name="lockpassword_confirm_your_password_header" msgid="6132312814563023990">"Vuelve a ingresar tu contraseña"</string>
    <string name="lockpassword_confirm_your_work_password_header" msgid="4647071231702288305">"Ingresa tu contraseña de trabajo"</string>
    <string name="lockpassword_confirm_your_pattern_header" msgid="4037701363240138651">"Confirma el patrón"</string>
    <string name="lockpassword_confirm_your_work_pattern_header" msgid="2668883108969165844">"Ingresa tu patrón de trabajo"</string>
    <string name="lockpassword_confirm_your_pin_header" msgid="2241722970567131308">"Vuelve a ingresar el PIN"</string>
    <string name="lockpassword_confirm_your_work_pin_header" msgid="4229765521391960255">"Ingresa tu PIN de trabajo"</string>
    <string name="lockpassword_confirm_passwords_dont_match" msgid="2100071354970605232">"Las contraseñas no coinciden"</string>
    <string name="lockpassword_confirm_pins_dont_match" msgid="1103699575489401030">"Los PIN no coinciden"</string>
    <string name="lockpassword_draw_your_pattern_again_header" msgid="1045638030120803622">"Dibuja el patrón una vez más"</string>
    <string name="lockpassword_choose_lock_generic_header" msgid="5669348379247148696">"Desbloquear la selección"</string>
    <string name="lockpassword_password_set_toast" msgid="6615759749393973795">"Se ha configurado la contraseña."</string>
    <string name="lockpassword_pin_set_toast" msgid="5415783847198570890">"Se ha configurado el PIN."</string>
    <string name="lockpassword_pattern_set_toast" msgid="3090582314362416762">"Se ha configurado el patrón."</string>
    <string name="lockpassword_choose_your_password_header_for_face" msgid="5359649947642749079">"Establece una contraseña"</string>
    <string name="lockpassword_choose_your_pattern_header_for_face" msgid="9220480399170764760">"Establece patrón para desbloqueo facial"</string>
    <string name="lockpassword_choose_your_pin_header_for_face" msgid="2285401208117502869">"Establece PIN para desbloqueo facial"</string>
    <string name="lockpassword_choose_your_password_header_for_biometrics" msgid="9091792721166354172">"Para datos biométricos, elige contraseña"</string>
    <string name="lockpassword_choose_your_pattern_header_for_biometrics" msgid="4949972592985176347">"Para datos biométricos, elige un patrón"</string>
    <string name="lockpassword_choose_your_pin_header_for_biometrics" msgid="4215367936503271941">"Para datos biométricos, elige un PIN"</string>
    <string name="lockpassword_forgot_password" msgid="5730587692489737223">"¿Olvidaste la contraseña?"</string>
    <string name="lockpassword_forgot_pattern" msgid="1196116549051927516">"¿Olvidaste el patrón?"</string>
    <string name="lockpassword_forgot_pin" msgid="7164232234705747672">"¿Olvidaste el PIN?"</string>
    <string name="lockpassword_confirm_your_pattern_generic" msgid="7692794426682501482">"Para continuar, usa el patrón del dispositivo"</string>
    <string name="lockpassword_confirm_your_pin_generic" msgid="9206928587904701094">"Para continuar, ingresa el PIN del dispositivo"</string>
    <string name="lockpassword_confirm_your_password_generic" msgid="2616127423884477152">"Para continuar, ingresa la contraseña del dispositivo"</string>
    <string name="lockpassword_confirm_your_pattern_generic_profile" msgid="9110305410672321714">"Para continuar, usa el patrón de tu perfil de trabajo"</string>
    <string name="lockpassword_confirm_your_pin_generic_profile" msgid="6524208128570235127">"Para continuar, ingresa tu PIN de trabajo"</string>
    <string name="lockpassword_confirm_your_password_generic_profile" msgid="5918738487760814147">"Para continuar, ingresa la contraseña de tu perfil de trabajo"</string>
    <string name="lockpassword_strong_auth_required_device_pattern" msgid="113817518413715557">"Para mayor seguridad, usa el patrón de tu dispositivo"</string>
    <string name="lockpassword_strong_auth_required_device_pin" msgid="9163822166411129815">"Para mayor seguridad, ingresa el PIN de tu dispositivo"</string>
    <string name="lockpassword_strong_auth_required_device_password" msgid="8310047427464299337">"Para mayor seguridad, ingresa la contraseña de tu dispositivo"</string>
    <string name="lockpassword_strong_auth_required_work_pattern" msgid="6803652050512161140">"Para mayor seguridad, usa el patrón de tu perfil de trabajo"</string>
    <string name="lockpassword_strong_auth_required_work_pin" msgid="4208510396448713500">"Para mayor seguridad, ingresa el PIN de tu perfil de trabajo"</string>
    <string name="lockpassword_strong_auth_required_work_password" msgid="6119482061429323090">"Para mayor seguridad, ingresa la contraseña de tu perfil de trabajo"</string>
    <string name="lockpassword_confirm_your_pattern_details_frp" msgid="6351784282865851482">"Se restableció la configuración de fábrica del teléfono. Para usarlo, ingresa el patrón anterior."</string>
    <string name="lockpassword_confirm_your_pin_details_frp" msgid="2128795640346033349">"Se restableció la configuración de fábrica del teléfono. Para usarlo, ingresa el PIN anterior."</string>
    <string name="lockpassword_confirm_your_password_details_frp" msgid="4031863562975125016">"Se restableció la configuración de fábrica del teléfono. Para usarlo, ingresa contraseña anterior."</string>
    <string name="lockpassword_confirm_your_pattern_header_frp" msgid="5641858015891896427">"Verificar patrón"</string>
    <string name="lockpassword_confirm_your_pin_header_frp" msgid="8285647793164729982">"Verificar PIN"</string>
    <string name="lockpassword_confirm_your_password_header_frp" msgid="7932240547542564033">"Verificar contraseña"</string>
    <string name="lockpassword_invalid_pin" msgid="7530854476819820600">"PIN incorrecto"</string>
    <string name="lockpassword_invalid_password" msgid="1588184930542221687">"Contraseña incorrecta"</string>
    <string name="lockpattern_need_to_unlock_wrong" msgid="8109305107409924083">"Patrón incorrecto"</string>
    <string name="lock_settings_title" msgid="665707559508132349">"Seguridad del dispositivo"</string>
    <string name="lockpattern_change_lock_pattern_label" msgid="5853706275279878879">"Cambiar patrón de desbloqueo"</string>
    <string name="lockpattern_change_lock_pin_label" msgid="7327409886587802756">"Cambiar PIN de desbloqueo"</string>
    <string name="lockpattern_recording_intro_header" msgid="8325736706877916560">"Dibuja un patrón de desbloqueo"</string>
    <string name="lockpattern_recording_intro_footer" msgid="2656868858594487197">"Presiona Menú para obtener ayuda."</string>
    <string name="lockpattern_recording_inprogress" msgid="7268008332694009191">"Levanta el dedo cuando termines."</string>
    <string name="lockpattern_recording_incorrect_too_short" msgid="3351522018450593723">"Une al menos <xliff:g id="NUMBER">%d</xliff:g> puntos. Vuelve a intentarlo."</string>
    <string name="lockpattern_pattern_entered_header" msgid="7709618312713127249">"Patrón registrado"</string>
    <string name="lockpattern_need_to_confirm" msgid="6489499109451714360">"Vuelve a trazar el patrón para confirmar."</string>
    <string name="lockpattern_pattern_confirmed_header" msgid="2969990617475456153">"Patrón de desbloqueo nuevo"</string>
    <string name="lockpattern_confirm_button_text" msgid="6122815520373044089">"Confirmar"</string>
    <string name="lockpattern_restart_button_text" msgid="255339375151895998">"Revisar"</string>
    <string name="lockpattern_retry_button_text" msgid="4229668933251849760">"Borrar"</string>
    <string name="lockpattern_continue_button_text" msgid="5253269556259503537">"Continuar"</string>
    <string name="lockpattern_settings_title" msgid="9223165804553269083">"Patrón de desbloqueo"</string>
    <string name="lockpattern_settings_enable_title" msgid="7401197111303283723">"Requiere un patrón"</string>
    <string name="lockpattern_settings_enable_summary" msgid="1116467204475387886">"Debes dibujar el patrón para desbloquear la pantalla"</string>
    <string name="lockpattern_settings_enable_visible_pattern_title" msgid="3340969054395584754">"Hacer visible el patrón"</string>
    <string name="lockpattern_settings_enable_visible_pattern_title_profile" msgid="5138189101808127489">"Mostrar el patrón del perfil"</string>
    <string name="lockpattern_settings_enable_tactile_feedback_title" msgid="2273374883831956787">"Vibrar al presionar"</string>
    <string name="lockpattern_settings_enable_power_button_instantly_locks" msgid="1638619728773344099">"Botón de encendido bloquea"</string>
    <string name="lockpattern_settings_power_button_instantly_locks_summary" msgid="2202430156268094229">"Excepto cuando <xliff:g id="TRUST_AGENT_NAME">%1$s</xliff:g> mantiene la pantalla desbloqueada"</string>
    <string name="lockpattern_settings_choose_lock_pattern" msgid="2193588309557281466">"Conf. patrón de desbloq."</string>
    <string name="lockpattern_settings_change_lock_pattern" msgid="7614155083815661347">"Cambiar patrón de desbloqueo"</string>
    <string name="lockpattern_settings_help_how_to_record" msgid="2093801939046625774">"Cómo dibujar un patrón de desbloqueo"</string>
    <string name="lockpattern_too_many_failed_confirmation_attempts" msgid="7891484005551794824">"Demasiados intentos incorrectos. Vuelve a intentarlo en <xliff:g id="NUMBER">%d</xliff:g> segundos."</string>
    <string name="activity_not_found" msgid="5464331414465894254">"La aplicación no está instalada en tu dispositivo."</string>
    <string name="lock_settings_profile_title" msgid="103605580492566086">"Seguridad del perfil de trabajo"</string>
    <string name="lock_settings_profile_screen_lock_title" msgid="3776275029218681815">"Bloqueo de pantalla del perfil de trabajo"</string>
    <string name="lock_settings_profile_unification_title" msgid="5777961097706546513">"Usar un mismo bloqueo"</string>
    <string name="lock_settings_profile_unification_summary" msgid="1317553536289481654">"Usa un mismo bloqueo para el perfil de trabajo y la pantalla del dispositivo"</string>
    <string name="lock_settings_profile_unification_dialog_title" msgid="5163178097464820825">"¿Deseas usar el mismo bloqueo?"</string>
    <string name="lock_settings_profile_unification_dialog_body" msgid="1222905637428672355">"El dispositivo usará el bloqueo de pantalla de tu perfil de trabajo. Las políticas del perfil de trabajo se aplicarán a ambos bloqueos."</string>
    <string name="lock_settings_profile_unification_dialog_uncompliant_body" msgid="8844682343443755895">"Tu bloqueo del perfil de trabajo no cumple con los requisitos de seguridad de tu organización. Puedes usar el mismo bloqueo para la pantalla de tu dispositivo y tu perfil de trabajo. Se aplicarán las políticas de bloqueo del perfil de trabajo."</string>
    <string name="lock_settings_profile_unification_dialog_confirm" msgid="6276915393736137843">"Usar un mismo bloqueo"</string>
    <string name="lock_settings_profile_unification_dialog_uncompliant_confirm" msgid="8509287115116369677">"Usar un mismo bloqueo"</string>
    <string name="lock_settings_profile_unified_summary" msgid="777095092175037385">"Igual al bloqueo de pantalla del dispositivo"</string>
    <string name="manageapplications_settings_title" msgid="9198876415524237657">"Administrar aplicaciones"</string>
    <string name="manageapplications_settings_summary" msgid="848586372489062357">"Administrar y eliminar aplicaciones instaladas"</string>
    <string name="applications_settings" msgid="1941993743933425622">"Información de apps"</string>
    <string name="applications_settings_summary" msgid="8206066893744768531">"Administrar aplicaciones, configurar accesos directos de inicio rápido"</string>
    <string name="applications_settings_header" msgid="3154670675856048015">"Configuración de aplicación"</string>
    <string name="install_applications" msgid="3921609656584369901">"Fuentes desconocidas"</string>
    <string name="install_applications_title" msgid="7890233747559108106">"Permitir todas las fuentes"</string>
    <string name="recent_app_category_title" msgid="189758417804427533">"Apps abiertas recientemente"</string>
    <plurals name="see_all_apps_title" formatted="false" msgid="6864581406735745400">
      <item quantity="other">Ver todas las %1$d apps</item>
      <item quantity="one">Ver todas las apps</item>
    </plurals>
    <string name="forgot_password_title" msgid="3967873480875239885">"Comunícate con tu administrador de TI"</string>
    <string name="forgot_password_text" msgid="2583194470767613163">"Te puede ayudar a restablecer el PIN, el patrón o la contraseña"</string>
    <string name="install_all_warning" product="tablet" msgid="7010749217925069520">"Tu tablet y tus datos personales son más vulnerables a los ataques de apps desconocidas. Si instalas apps de esta fuente, serás responsable de los daños que sufra tu tablet y la pérdida de datos debido al uso de estas apps."</string>
    <string name="install_all_warning" product="default" msgid="652516435709047343">"Tu teléfono y tus datos personales son más vulnerables a los ataques de apps desconocidas. Si instalas apps de esta fuente, serás responsable de los daños que sufra tu teléfono y la pérdida de datos debido al uso de estas apps."</string>
    <string name="install_all_warning" product="device" msgid="2348262609815354500">"Tu dispositivo y tus datos personales son más vulnerables a los ataques de apps desconocidas. Si instalas apps de esta fuente, serás responsable de los daños que sufra el dispositivo o de la pérdida de datos que se pueda derivar de su uso."</string>
    <string name="advanced_settings" msgid="2368905204839169094">"Configuración avanzada"</string>
    <string name="advanced_settings_summary" msgid="1823765348195530035">"Activar más opciones de configuración"</string>
    <string name="application_info_label" msgid="1015706497694165866">"Info. de apps"</string>
    <string name="storage_label" msgid="2522307545547515733">"Almacenamiento"</string>
    <string name="auto_launch_label" msgid="4069860409309364872">"Abrir de forma predet."</string>
    <string name="auto_launch_label_generic" msgid="5033137408273064599">"Valores predeterminados"</string>
    <string name="screen_compatibility_label" msgid="7549658546078613431">"Compatibilidad de la pantalla"</string>
    <string name="permissions_label" msgid="1708927634370314404">"Permisos"</string>
    <string name="cache_header_label" msgid="2441967971921741047">"Memoria caché"</string>
    <string name="clear_cache_btn_text" msgid="8597272828928143723">"Borrar caché"</string>
    <string name="cache_size_label" msgid="313456088966822757">"Memoria caché"</string>
    <plurals name="uri_permissions_text" formatted="false" msgid="8212425823423508096">
      <item quantity="other">%d elementos</item>
      <item quantity="one">1 elemento</item>
    </plurals>
    <string name="clear_uri_btn_text" msgid="4828117421162495134">"Borrar acceso"</string>
    <string name="controls_label" msgid="8671492254263626383">"Controles"</string>
    <string name="force_stop" msgid="2681771622136916280">"Forzar la detención"</string>
    <string name="total_size_label" msgid="2052185048749658866">"Total"</string>
    <string name="application_size_label" msgid="6407051020651716729">"Tamaño de la app"</string>
    <string name="external_code_size_label" msgid="7375146402660973743">"Aplicación en el almacenamiento USB"</string>
    <string name="data_size_label" msgid="7814478940141255234">"Datos del usuario"</string>
    <string name="external_data_size_label" product="nosdcard" msgid="1054860423004751290">"Datos en el almacenamiento USB"</string>
    <string name="external_data_size_label" product="default" msgid="3370825186202856353">"Tarjeta SD"</string>
    <string name="uninstall_text" msgid="315764653029060126">"Desinstalar..."</string>
    <string name="uninstall_all_users_text" msgid="5924715251087176474">"Desinstalar en todos los usuarios"</string>
    <string name="install_text" msgid="4558333621516996473">"Instalar"</string>
    <string name="disable_text" msgid="5146002260857428005">"Inhabilitar"</string>
    <string name="enable_text" msgid="8570798764647110430">"Habilitar"</string>
    <string name="clear_user_data_text" msgid="6773186434260397947">"Liberar espacio de almacenamiento"</string>
    <string name="app_factory_reset" msgid="8974044931667015201">"Desinstalar las actualizaciones"</string>
    <string name="auto_launch_enable_text" msgid="286244432074382294">"Has elegido lanzar esta aplicación de manera predeterminada para algunas acciones."</string>
    <string name="always_allow_bind_appwidgets_text" msgid="2069415023986858324">"Decidiste permitir que esta aplicación pueda crear widgets y acceder a sus datos."</string>
    <string name="auto_launch_disable_text" msgid="502648841250936209">"No se establecieron configuraciones predeterminadas"</string>
    <string name="clear_activities" msgid="341345438786077236">"Borrar valores predeterminados"</string>
    <string name="screen_compatibility_text" msgid="5915767835411020274">"Es posible que esta aplicación no se haya diseñado para tu pantalla. Aquí puedes controlar cómo se ajusta a la pantalla."</string>
    <string name="ask_compatibility" msgid="8388397595148476565">"Preguntar cuando se lanza"</string>
    <string name="enable_compatibility" msgid="1163387233622859712">"Aplicación en escala"</string>
    <string name="unknown" msgid="8192160131923461175">"Desconocido"</string>
    <string name="sort_order_alpha" msgid="3400680865280266582">"Ordenar por nombre"</string>
    <string name="sort_order_size" msgid="7731928486199737223">"Ordenar por tamaño"</string>
    <string name="sort_order_recent_notification" msgid="1496198895330443073">"Más recientes"</string>
    <string name="sort_order_frequent_notification" msgid="4063700985742284794">"Más frecuentes"</string>
    <string name="show_running_services" msgid="8666008279959853318">"Mostrar los servicios en ejecución"</string>
    <string name="show_background_processes" msgid="5682856012453562151">"Procesos en caché"</string>
    <string name="default_emergency_app" msgid="1929974800666613803">"Aplicación de emergencia"</string>
    <string name="reset_app_preferences" msgid="8861758340732716573">"Restablecer preferencias de apps"</string>
    <string name="reset_app_preferences_title" msgid="8935136792316050759">"¿Restablecer preferencias?"</string>
    <string name="reset_app_preferences_desc" msgid="6509978724602405805">"Se restablecerán todas las preferencias de lo siguiente:\n\n"<li>"Apps inhabilitadas"</li>\n<li>"Notificaciones de apps inhabilitadas"</li>\n<li>"Apps predeterminadas para realizar acciones"</li>\n<li>"Restricciones de datos en segundo plano para apps"</li>\n<li>"Restricciones de permisos"</li>\n\n"No perderás los datos de las apps."</string>
    <string name="reset_app_preferences_button" msgid="2591318711372850058">"Restablecer apps"</string>
    <string name="manage_space_text" msgid="9013414693633572277">"Administrar el espacio"</string>
    <string name="filter" msgid="9039576690686251462">"Filtro"</string>
    <string name="filter_dlg_title" msgid="3086282431958601338">"Elegir opciones de filtro"</string>
    <string name="filter_apps_all" msgid="5705421199299914620">"Todas las apps"</string>
    <string name="filter_apps_disabled" msgid="5068011814871004105">"Apps inhabilitadas"</string>
    <string name="filter_apps_third_party" msgid="9049447784849114843">"Descargado"</string>
    <string name="filter_apps_running" msgid="535465683273284141">"En ejecución"</string>
    <string name="filter_apps_onsdcard" product="nosdcard" msgid="5140211657134608469">"Almacenamiento USB"</string>
    <string name="filter_apps_onsdcard" product="default" msgid="1774499644768369891">"En tarjeta SD"</string>
    <string name="not_installed" msgid="5074606858798519449">"No instalada para este usuario"</string>
    <string name="installed" msgid="2837449358488825884">"Instalada"</string>
    <string name="no_applications" msgid="985069304755391640">"No hay aplicaciones."</string>
    <string name="internal_storage" msgid="999496851424448809">"Almacenamiento interno"</string>
    <string name="recompute_size" msgid="1098091228370999128">"Recalculando el tamaño…"</string>
    <string name="clear_data_dlg_title" msgid="180446967743732410">"¿Borrar los datos de la app?"</string>
    <string name="clear_data_dlg_text" msgid="7870723948123690332">"Se eliminarán de forma permanente todos los datos de esta aplicación, incluidos archivos, ajustes, cuentas, bases de datos, etc."</string>
    <string name="dlg_ok" msgid="1421350367857960997">"Aceptar"</string>
    <string name="dlg_cancel" msgid="5164705061530774899">"Cancelar"</string>
    <string name="app_not_found_dlg_title" msgid="7122106240981109930"></string>
    <string name="app_not_found_dlg_text" msgid="8634675268730513704">"La aplicación no está en la lista de aplicaciones instaladas."</string>
    <string name="clear_failed_dlg_text" msgid="6866741916836125732">"No se pudo liberar espacio de almacenamiento de la app."</string>
    <string name="join_two_items" msgid="7893073836681382429">"<xliff:g id="FIRST_ITEM">%1$s</xliff:g> y <xliff:g id="SECOND_ITEM">%2$s</xliff:g>"</string>
    <string name="join_two_unrelated_items" msgid="5301233410730513655">"<xliff:g id="FIRST_ITEM">%1$s</xliff:g>, <xliff:g id="SECOND_ITEM">%2$s</xliff:g>"</string>
    <string name="computing_size" msgid="4915310659841174866">"Calculando..."</string>
    <string name="invalid_size_value" msgid="7017371543563259201">"No se pudo calcular el tamaño del paquete."</string>
    <string name="version_text" msgid="7628938665256107608">"versión <xliff:g id="VERSION_NUM">%1$s</xliff:g>"</string>
    <string name="move_app" msgid="5421158479447276791">"Mover"</string>
    <string name="move_app_to_internal" product="tablet" msgid="5799782476959541144">"Mover al tablet"</string>
    <string name="move_app_to_internal" product="default" msgid="7395498801589544372">"Mover al dispositivo"</string>
    <string name="move_app_to_sdcard" product="nosdcard" msgid="1145367822171576972">"Mover a almacenamiento USB"</string>
    <string name="move_app_to_sdcard" product="default" msgid="7161667212614143767">"Mover a la tarjeta SD"</string>
    <string name="another_migration_already_in_progress" msgid="6550546307856052261">"Hay otra migración en curso."</string>
    <string name="insufficient_storage" msgid="8115088042669030558">"No hay suficiente espacio de almacenamiento."</string>
    <string name="does_not_exist" msgid="6499163879348776120">"La aplicación no existe."</string>
    <string name="invalid_location" msgid="8013853455355520557">"La ubicación de la instalación no es válida."</string>
    <string name="system_package" msgid="7559476279008519360">"Las actualizaciones del sistema no se pueden instalar en medios externos."</string>
    <string name="move_error_device_admin" msgid="1561502976834303626">"No se puede instalar la app de administración de dispositivos en medios externos"</string>
    <string name="force_stop_dlg_title" msgid="86745852555490146">"¿Deseas forzar la detención?"</string>
    <string name="force_stop_dlg_text" msgid="1527286468544457368">"Si fuerzas la detención de una aplicación, es posible que funcione incorrectamente."</string>
    <string name="app_install_location_title" msgid="8932938164156303191">"Ubicación de instalación preferida"</string>
    <string name="app_install_location_summary" msgid="4948270795544357021">"Cambiar la ubicación de instalación preferida para nuevas aplicaciones"</string>
    <string name="app_disable_dlg_positive" msgid="1414218905322009505">"Inhabilitar la aplicación"</string>
    <string name="app_disable_dlg_text" msgid="2449382902751908916">"Si inhabilitas esta app, es posible que Android y otras apps ya no funcionen correctamente. Ten en cuenta que no puedes borrar esta app ya que vino preinstalada en el dispositivo. Si la inhabilitas, se desactivarás y se ocultará en tu dispositivo."</string>
    <string name="app_disable_notifications_dlg_title" msgid="6686569904059411780">"¿Desactivar notificaciones?"</string>
    <string name="app_install_details_group_title" msgid="1172114479073704677">"Store"</string>
    <string name="app_install_details_title" msgid="7783556181897142187">"Detalles de la app"</string>
    <string name="app_install_details_summary" msgid="2013043219249992373">"App instalada desde <xliff:g id="APP_STORE">%1$s</xliff:g>"</string>
    <string name="instant_app_details_summary" msgid="417197491598208216">"Más información en <xliff:g id="APP_STORE">%1$s</xliff:g>"</string>
    <string name="app_ops_running" msgid="6127474473137428721">"En curso"</string>
    <string name="app_ops_never_used" msgid="9038133162371204506">"(Sin utilizar)"</string>
    <string name="no_default_apps" msgid="8966319676910104570">"Sin aplicaciones predet."</string>
    <string name="storageuse_settings_title" msgid="3125650750657988194">"Uso del almacenamiento"</string>
    <string name="storageuse_settings_summary" msgid="5001621552305431831">"Ver el almacenamiento que usan las aplicaciones"</string>
    <string name="service_restarting" msgid="5104563288155809226">"Volver a comenzar"</string>
    <string name="cached" msgid="5379485147573438201">"Proceso de fondo almacenado en memoria caché"</string>
    <string name="no_running_services" msgid="9079738069349859373">"No hay nada en ejecución."</string>
    <string name="service_started_by_app" msgid="6845028506417670179">"Iniciado por aplicación"</string>
    <!-- no translation found for service_client_name (2210898622981598861) -->
    <skip />
    <string name="service_background_processes" msgid="2800539421534521948">"<xliff:g id="MEMORY">%1$s</xliff:g> libre"</string>
    <string name="service_foreground_processes" msgid="6380905887193621704">"<xliff:g id="MEMORY">%1$s</xliff:g> en uso"</string>
    <string name="memory" msgid="5253757199926592074">"RAM"</string>
    <!-- no translation found for service_process_name (7827318358399776412) -->
    <skip />
    <string name="running_process_item_user_label" msgid="1444898861984132133">"Usuario: <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="running_process_item_removed_user_label" msgid="4812732296696662613">"Usuario eliminado"</string>
    <string name="running_processes_item_description_s_s" msgid="6835918861352501671">"<xliff:g id="NUMPROCESS">%1$d</xliff:g> proceso y <xliff:g id="NUMSERVICES">%2$d</xliff:g> servicio"</string>
    <string name="running_processes_item_description_s_p" msgid="1209371773353932361">"<xliff:g id="NUMPROCESS">%1$d</xliff:g> proceso y <xliff:g id="NUMSERVICES">%2$d</xliff:g> servicios"</string>
    <string name="running_processes_item_description_p_s" msgid="8957061449107822282">"<xliff:g id="NUMPROCESS">%1$d</xliff:g> procesos y <xliff:g id="NUMSERVICES">%2$d</xliff:g> servicio"</string>
    <string name="running_processes_item_description_p_p" msgid="3292999232897469679">"<xliff:g id="NUMPROCESS">%1$d</xliff:g> procesos y <xliff:g id="NUMSERVICES">%2$d</xliff:g> servicios"</string>
    <string name="running_processes_header_title" msgid="558961782589967366">"Memoria del dispositivo"</string>
    <string name="running_processes_header_footer" msgid="2726092156680487584">"RAM usada por las aplicaciones"</string>
    <string name="running_processes_header_system_prefix" msgid="8819527769608555124">"Sistema"</string>
    <string name="running_processes_header_apps_prefix" msgid="4151874328324238133">"Aplicaciones"</string>
    <string name="running_processes_header_free_prefix" msgid="4271100378295864738">"Libre"</string>
    <string name="running_processes_header_used_prefix" msgid="5205762402234243007">"En uso"</string>
    <string name="running_processes_header_cached_prefix" msgid="839132595831993521">"En caché"</string>
    <string name="running_processes_header_ram" msgid="3014991380467004685">"<xliff:g id="RAM_0">%1$s</xliff:g> de RAM"</string>
    <string name="runningservicedetails_settings_title" msgid="1057845389092757121">"Aplicación en ejecución"</string>
    <string name="no_services" msgid="3898812785511572899">"Inactivo"</string>
    <string name="runningservicedetails_services_title" msgid="11853795112787355">"Servicios"</string>
    <string name="runningservicedetails_processes_title" msgid="5292271587797234038">"Procesos"</string>
    <string name="service_stop" msgid="5712522600201308795">"Detener"</string>
    <string name="service_manage" msgid="3896322986828332075">"Configuración"</string>
    <string name="service_stop_description" msgid="6327742632400026677">"Servicio iniciado por su aplicación. Si se detiene, se puede producir un error en la aplicación."</string>
    <string name="heavy_weight_stop_description" msgid="3086419998820881290">"Esta aplicación no puede detenerse de forma segura. Si la detienes, puedes perder parte de tu trabajo actual."</string>
    <string name="background_process_stop_description" msgid="4792038933517438037">"Es un proceso de aplicación anterior que aún se ejecuta en caso de que sea necesario nuevamente. En general, no hay razón para detenerlo."</string>
    <string name="service_manage_description" msgid="6615788996428486121">"<xliff:g id="CLIENT_NAME">%1$s</xliff:g>: Está en uso actualmente. Presiona Configuración para controlarlo."</string>
    <string name="main_running_process_description" msgid="6685973937935027773">"Proceso principal en uso."</string>
    <string name="process_service_in_use_description" msgid="4210957264507014878">"El servicio <xliff:g id="COMP_NAME">%1$s</xliff:g> está en uso."</string>
    <string name="process_provider_in_use_description" msgid="6730020083976048028">"El proveedor <xliff:g id="COMP_NAME">%1$s</xliff:g> está en uso."</string>
    <string name="runningservicedetails_stop_dlg_title" msgid="6201041461740445113">"¿Deseas detener el servicio?"</string>
    <string name="runningservicedetails_stop_dlg_text" product="tablet" msgid="2076922609580490122">"Si detienes este servicio, algunas funciones de la tablet podrían dejar de ejecutarse correctamente hasta que lo apagues y enciendas nuevamente."</string>
    <string name="runningservicedetails_stop_dlg_text" product="default" msgid="2625863973434309085">"Si detienes este servicio, algunas funciones del dispositivo podrían dejar de ejecutarse correctamente hasta que lo apagues y enciendas nuevamente."</string>
    <string name="language_input_gesture_title" msgid="3292455685728572960">"Idiomas, entrada y gestos"</string>
    <string name="language_input_gesture_summary_on_with_assist" msgid="8670153838520237089"></string>
    <string name="language_input_gesture_summary_on_non_assist" msgid="2738661322747920463"></string>
    <string name="language_input_gesture_summary_off" msgid="1604575860215661606"></string>
    <string name="language_settings" msgid="8700174277543875046">"Idiomas y entradas"</string>
    <string name="language_empty_list_user_restricted" msgid="8050367405839231863">"No tienes permiso para cambiar el idioma del dispositivo."</string>
    <string name="language_keyboard_settings_title" msgid="7934844313233544557">"Idiomas y entradas"</string>
    <string name="input_assistance" msgid="3437568284144952104">"Herramientas"</string>
    <string name="keyboard_settings_category" msgid="5392847229300117064">"Teclado y métodos de entrada"</string>
    <string name="phone_language" msgid="5986939176239963826">"Idiomas"</string>
    <string name="phone_language_summary" msgid="863041222809685325"></string>
    <string name="auto_replace" msgid="4830732960264447043">"Reemplazar automát."</string>
    <string name="auto_replace_summary" msgid="1285443414597153423">"Corregir palabras mal escritas"</string>
    <string name="auto_caps" msgid="5573583581288305355">"Uso de mayúsculas automático"</string>
    <string name="auto_caps_summary" msgid="3144141933426846665">"Escribir con mayúscula la primera letra en las oraciones"</string>
    <string name="auto_punctuate" msgid="2838809477621809507">"Puntuación automática"</string>
    <string name="hardkeyboard_category" msgid="8729780593378161071">"Configuración de teclado físico"</string>
    <string name="auto_punctuate_summary" msgid="3549190848611386748">"Presionar la tecla de espacio dos veces para insertar \".\""</string>
    <string name="show_password" msgid="7101900779571040117">"Mostrar contraseñas"</string>
    <string name="show_password_summary" msgid="9025960283785111619">"Mostrar caracteres brevemente mientras escribes"</string>
    <string name="spellchecker_security_warning" msgid="2016059050608271820">"Este corrector ortográfico puede recopilar todo el texto que escribas, incluidos los datos personales como contraseñas y números de tarjetas de crédito. Proviene de la aplicación <xliff:g id="SPELLCHECKER_APPLICATION_NAME">%1$s</xliff:g>. ¿Deseas usar este corrector ortográfico?"</string>
    <string name="spellchecker_quick_settings" msgid="6449414356743946577">"Configuración"</string>
    <string name="spellchecker_language" msgid="8905487366580285282">"Idioma"</string>
    <string name="keyboard_and_input_methods_category" msgid="5296847777802891649">"Teclados"</string>
    <string name="virtual_keyboard_category" msgid="2339505603075527212">"Teclado en pantalla"</string>
    <string name="keywords_virtual_keyboard" msgid="1494726424879503434">"Gboard"</string>
    <string name="available_virtual_keyboard_category" msgid="6930012948152749337">"Teclado en pantalla disponible"</string>
    <string name="add_virtual_keyboard" msgid="2515850206289352606">"Administrar teclados en pantalla"</string>
    <string name="keyboard_assistance_category" msgid="7320599809770932032">"Ayuda del teclado"</string>
    <string name="physical_keyboard_title" msgid="3328134097512350958">"Teclado físico"</string>
    <string name="show_ime" msgid="4334255501724746849">"Usar teclado en pantalla"</string>
    <string name="show_ime_summary" msgid="7293345791727205975">"Mantener en la pantalla cuando el teclado físico esté activo"</string>
    <string name="keyboard_shortcuts_helper" msgid="2553221039203165344">"Combinaciones de teclas"</string>
    <string name="keyboard_shortcuts_helper_summary" msgid="8649760728213630156">"Mostrar accesos directos disponibles"</string>
    <string name="language_and_input_for_work_category_title" msgid="2546950919124199743">"Teclados y herramientas del perfil de trabajo"</string>
    <string name="virtual_keyboards_for_work_title" msgid="786459157034008675">"Teclado en pantalla para el trabajo"</string>
    <string name="default_keyboard_layout" msgid="8690689331289452201">"Predeterminadas"</string>
    <string name="pointer_speed" msgid="7398649279282675718">"Velocidad del puntero"</string>
    <string name="game_controller_settings_category" msgid="8557472715034961918">"Controlador de juegos"</string>
    <string name="vibrate_input_devices" msgid="5192591087864449142">"Redireccionar vibración"</string>
    <string name="vibrate_input_devices_summary" msgid="8791680891376689823">"Enviar la vibración al controlador de juegos cuando esté conectado"</string>
    <string name="keyboard_layout_dialog_title" msgid="8770130364048089954">"Elegir el diseño de teclado"</string>
    <string name="keyboard_layout_dialog_setup_button" msgid="6546245862744626706">"Configurar diseños de teclado"</string>
    <string name="keyboard_layout_dialog_switch_hint" msgid="3303564123674979354">"Para cambiar, presiona Ctrl+espacio."</string>
    <string name="keyboard_layout_default_label" msgid="6078569989261528039">"Predeterminado"</string>
    <string name="keyboard_layout_picker_title" msgid="240504762718562906">"Diseños de teclado"</string>
    <string name="user_dict_settings_title" msgid="680410651924276991">"Diccionario personal"</string>
    <string name="user_dict_settings_for_work_title" msgid="1245315720684961770">"Diccionario personal para el trabajo"</string>
    <string name="user_dict_settings_summary" msgid="262228126041933459"></string>
    <string name="user_dict_settings_add_menu_title" msgid="8046882347281382968">"Agregar"</string>
    <string name="user_dict_settings_add_dialog_title" msgid="3485845465134083084">"Agregar al diccionario"</string>
    <string name="user_dict_settings_add_screen_title" msgid="1866408024073475379">"Frase"</string>
    <string name="user_dict_settings_add_dialog_more_options" msgid="2642928746425808108">"Más opciones"</string>
    <string name="user_dict_settings_add_dialog_less_options" msgid="100432503633458156">"Menos opciones"</string>
    <string name="user_dict_settings_add_dialog_confirm" msgid="1866751313790655088">"Aceptar"</string>
    <string name="user_dict_settings_add_word_option_name" msgid="2686051785623698231">"Palabra:"</string>
    <string name="user_dict_settings_add_shortcut_option_name" msgid="5722204336242646866">"Acceso directo:"</string>
    <string name="user_dict_settings_add_locale_option_name" msgid="2117468247460253346">"Idioma:"</string>
    <string name="user_dict_settings_add_word_hint" msgid="4560494723256242785">"Escribe una palabra"</string>
    <string name="user_dict_settings_add_shortcut_hint" msgid="6209624157217434640">"Acceso directo opcional"</string>
    <string name="user_dict_settings_edit_dialog_title" msgid="316493656442362284">"Modificar palabra"</string>
    <string name="user_dict_settings_context_menu_edit_title" msgid="4909198741914531509">"Editar"</string>
    <string name="user_dict_settings_context_menu_delete_title" msgid="651550824433043545">"Borrar"</string>
    <string name="user_dict_settings_empty_text" msgid="86562873609647919">"El diccionario del usuario no contiene ninguna palabra. Para agregar una, presiona el botón Agregar (+)."</string>
    <string name="user_dict_settings_all_languages" msgid="8563387437755363526">"Para todos los idiomas"</string>
    <string name="user_dict_settings_more_languages" msgid="5378870726809672319">"Más idiomas..."</string>
    <string name="testing" msgid="6294172343766732037">"Probando"</string>
    <string name="testing_phone_info" product="tablet" msgid="1910768200608214456">"Información del tablet"</string>
    <string name="testing_phone_info" product="default" msgid="1150527695827743906">"Información del dispositivo"</string>
    <string name="input_methods_settings_title" msgid="7796027458321225550">"Ingreso de texto"</string>
    <string name="input_method" msgid="2982805181425436775">"Método de entrada"</string>
    <string name="current_input_method" msgid="3471068842881330883">"Teclado actual"</string>
    <string name="input_method_selector" msgid="8463209725824763600">"Selector de método de entrada"</string>
    <string name="input_method_selector_show_automatically_title" msgid="6483428482089875034">"Automático"</string>
    <string name="input_method_selector_always_show_title" msgid="2479533500357556146">"Mostrar siempre"</string>
    <string name="input_method_selector_always_hide_title" msgid="807424180027384849">"Ocultar siempre"</string>
    <string name="configure_input_method" msgid="8831343065130376880">"Configurar métodos de entrada"</string>
    <string name="input_method_settings" msgid="4177883733022569830">"Configuración"</string>
    <string name="input_method_settings_button" msgid="5145039044301426311">"Configuración"</string>
    <string name="input_methods_settings_label_format" msgid="5809693308957109022">"Configuración de <xliff:g id="IME_NAME">%1$s</xliff:g>"</string>
    <string name="input_methods_and_subtype_enabler_title" msgid="8940326108334307057">"Elegir los métodos de introducción activos"</string>
    <string name="onscreen_keyboard_settings_summary" msgid="3975358507879701606">"Configuración del teclado en pantalla"</string>
    <string name="builtin_keyboard_settings_title" msgid="5096171620714179661">"Teclado físico"</string>
    <string name="builtin_keyboard_settings_summary" msgid="4332792334499933856">"Configuración de teclado físico"</string>
    <string name="gadget_picker_title" msgid="7615902510050731400">"Elegir gadget"</string>
    <string name="widget_picker_title" msgid="7641298325488989676">"Elegir control"</string>
    <string name="allow_bind_app_widget_activity_allow_bind_title" msgid="3537968409832846255">"¿Deseas crear el widget y permitir el acceso?"</string>
    <string name="allow_bind_app_widget_activity_allow_bind" msgid="5694218981358874429">"Después de crear el widget, <xliff:g id="WIDGET_HOST_NAME">%1$s</xliff:g> podrá acceder a todos los datos que muestre."</string>
    <string name="allow_bind_app_widget_activity_always_allow_bind" msgid="7268758525344468364">"Permitir siempre que <xliff:g id="WIDGET_HOST_NAME">%1$s</xliff:g> pueda crear widgets y acceder a sus datos"</string>
    <string name="usage_stats_label" msgid="6523644917803320085">"Estadísticas de uso"</string>
    <string name="testing_usage_stats" msgid="4660643799010906365">"Estadísticas de uso"</string>
    <string name="display_order_text" msgid="7120394778684605892">"Ordenar por:"</string>
    <string name="app_name_label" msgid="3809910527680143673">"Aplicación"</string>
    <string name="last_time_used_label" msgid="2639712813493534074">"Última utilización"</string>
    <string name="usage_time_label" msgid="9105343335151559883">"Hora de uso"</string>
    <string name="accessibility_settings" msgid="4713215774904704682">"Accesibilidad"</string>
    <string name="accessibility_settings_title" msgid="6739115703615065716">"Configuración de accesibilidad"</string>
    <string name="accessibility_settings_summary" msgid="2195085206729325737">"Lectores de pantalla, pantalla, controles de interacción"</string>
    <string name="vision_settings_title" msgid="8919983801864103069">"Configuración de visión"</string>
    <string name="vision_settings_description" msgid="7614894785054441991">"Puedes personalizar este dispositivo para que se adapte a tus necesidades. Cambia estas funciones de accesibilidad más tarde en Configuración."</string>
    <string name="vision_settings_suggestion_title" msgid="4689275412658803919">"Cambiar tamaño de fuente"</string>
    <string name="screen_reader_category_title" msgid="6195867428854871553">"Lectores de pantalla"</string>
    <string name="audio_and_captions_category_title" msgid="5049122378290004050">"Audio y texto en pantalla"</string>
    <string name="display_category_title" msgid="6638191682294461408">"Pantalla"</string>
    <string name="accessibility_text_and_display_title" msgid="1398507755501334961">"Texto y pantalla"</string>
    <string name="interaction_control_category_title" msgid="2696474616743882372">"Controles de interacción"</string>
    <string name="accessibility_tap_assistance_title" msgid="1459944158978398532">"Asistencia sobre presión"</string>
    <string name="accessibility_system_controls_title" msgid="6403287349518987624">"Controles del sistema"</string>
    <string name="user_installed_services_category_title" msgid="2639470729311439731">"Apps descargadas"</string>
    <string name="experimental_category_title" msgid="898904396646344152">"Experimental"</string>
    <string name="feature_flags_dashboard_title" msgid="348990373716658289">"Funciones experimentales"</string>
    <string name="talkback_title" msgid="8756080454514251327">"Talkback"</string>
    <string name="talkback_summary" msgid="5820927220378864281">"Lector de pantalla, principalmente, para personas con ceguera o visión reducida"</string>
    <string name="select_to_speak_summary" msgid="1995285446766920925">"Presiona los elementos en tu pantalla para escuchar la lectura en voz alta"</string>
    <string name="accessibility_captioning_title" msgid="4561871958958925225">"Preferencias de subtítulos"</string>
    <string name="accessibility_screen_magnification_title" msgid="1211169976144629087">"Ampliación"</string>
    <string name="accessibility_magnification_mode_title" msgid="879250866604403721">"Área de ampliación"</string>
    <string name="accessibility_magnification_area_settings_message" msgid="4821458740248772054">"Selecciona las áreas en las que quieres implementar la ampliación de pantalla al usar la función"</string>
    <string name="accessibility_magnification_area_settings_full_screen_summary" msgid="2728962784113713010">"Pantalla completa"</string>
    <string name="accessibility_magnification_area_settings_window_screen_summary" msgid="5630032596384610913">"Parte de la pantalla"</string>
    <string name="accessibility_magnification_area_settings_all_summary" msgid="5139954486886669293">"Pantalla completa y parte de la pantalla"</string>
    <string name="accessibility_magnification_area_settings_full_screen" msgid="4189574224079433280">"Ampliar toda la pantalla"</string>
    <string name="accessibility_magnification_area_settings_window_screen" msgid="7431401975447232976">"Ampliar parte de la pantalla"</string>
    <string name="accessibility_magnification_switch_shortcut_title" msgid="3671432048806533079">"¿Quieres cambiar al botón de accesibilidad?"</string>
    <string name="accessibility_magnification_switch_shortcut_message" msgid="5291166101273060742">"Cuando presionas tres veces para ampliar una parte de la pantalla, algunas acciones, como escribir, demorarán más tiempo.\n\n¿Prefieres usar el botón de accesibilidad para ampliar?"</string>
    <string name="accessibility_magnification_switch_shortcut_positive_button" msgid="2446942190957296957">"Cambiar al botón de accesibilidad"</string>
    <string name="accessibility_magnification_switch_shortcut_negative_button" msgid="5750910789717343646">"Mantener presionar tres veces para ampliar"</string>
    <string name="accessibility_magnification_service_settings_title" msgid="3531350704632316017">"Configuración de ampliación"</string>
    <string name="accessibility_screen_magnification_gestures_title" msgid="3121714118381882167">"Ampliar presionando tres veces"</string>
    <string name="accessibility_screen_magnification_navbar_title" msgid="480853328665484528">"Ampliar con gesto"</string>
    <string name="accessibility_screen_magnification_state_navbar_gesture" msgid="8067042663897802231">"Ampliar con acceso directo y presionar tres veces"</string>
    <string name="accessibility_introduction_title" msgid="8834950581512452348">"Información sobre <xliff:g id="SERVICE">%1$s</xliff:g>"</string>
    <string name="accessibility_screen_option" msgid="8465307075278878145">"Opciones"</string>
    <string name="accessibility_preference_magnification_summary" msgid="2875518904115896888">"Amplía la pantalla"</string>
    <string name="accessibility_screen_magnification_short_summary" msgid="2207048420669939150">"Presiona tres veces para ampliar"</string>
    <string name="accessibility_screen_magnification_navbar_short_summary" msgid="4885018322430052037">"Presiona un botón para ampliar"</string>
    <string name="accessibility_screen_magnification_summary" msgid="2023126829553044999">"Acerca rápidamente la pantalla si deseas ver mejor el contenido.&lt;br/&gt;&lt;br/&gt; &lt;b&gt;Para ello, haz lo siguiente:&lt;/b&gt;&lt;br/&gt; 1. Usa la combinación de teclas para comenzar la ampliación.&lt;br/&gt; 2. Presiona la pantalla.&lt;br/&gt; 3. Arrastra dos dedos para moverte por la pantalla.&lt;br/&gt; 4. Pellizca con dos dedos para ajustar el zoom.&lt;br/&gt; 5. Usa la combinación de teclas para detener la ampliación.&lt;br/&gt;&lt;br/&gt; &lt;b&gt;Para acercar de manera temporal, haz lo siguiente:&lt;/b&gt;&lt;br/&gt; 1. Usa la combinación de teclas para comenzar la ampliación.&lt;br/&gt; 2. Mantén presionada cualquier parte de la pantalla.&lt;br/&gt; 3. Arrastra el dedo para moverte por la pantalla.&lt;br/&gt; 4. Levanta el dedo para detener la ampliación."</string>
    <string name="accessibility_screen_magnification_navbar_summary" msgid="807985499898802296">"Cuando la ampliación esté activada, podrás acercar el contenido en pantalla.\n\n"<b>"Para usar el zoom"</b>", inicia la ampliación y, luego, presiona cualquier parte de la pantalla.\n"<ul><li>"Arrastra 2 o más dedos para desplazarte."</li>\n<li>"Pellizca con 2 o más dedos para ajustar el zoom."</li></ul>\n\n<b>"Para hacer zoom de manera temporal"</b>", inicia la ampliación y, luego, mantén presionada cualquier parte de la pantalla.\n"<ul><li>"Arrastra el dedo para moverte por la pantalla."</li>\n<li>"Levanta el dedo para alejar el contenido."</li></ul>\n\n"No puedes acercar con el teclado ni en la barra de navegación."</string>
    <string name="accessibility_tutorial_pager" msgid="8461939455728454061">"Página <xliff:g id="CURRENT_PAGE">%1$d</xliff:g> de <xliff:g id="NUM_PAGES">%2$d</xliff:g>"</string>
    <string name="accessibility_tutorial_dialog_title_button" msgid="4681164949716215131">"Usa el botón de accesibilidad para abrir"</string>
    <string name="accessibility_tutorial_dialog_title_volume" msgid="494810949830845234">"Mantén presionadas teclas de volumen para abrir"</string>
    <string name="accessibility_tutorial_dialog_title_triple" msgid="7089562919284464400">"Presiona tres veces para abrir el servicio"</string>
    <string name="accessibility_tutorial_dialog_title_gesture" msgid="4965810097646659332">"Usa el gesto para abrir"</string>
    <string name="accessibility_tutorial_dialog_title_gesture_settings" msgid="8485448068531147828">"Usa el nuevo gesto de accesibilidad"</string>
    <string name="accessibility_tutorial_dialog_message_button" msgid="7002398857479782303">"Para usar esta función, presiona el botón de accesibilidad <xliff:g id="ACCESSIBILITY_ICON">%s</xliff:g> ubicado en la parte inferior de la pantalla.\n\nSi quieres cambiar de función, mantén presionado el botón de accesibilidad."</string>
    <string name="accessibility_tutorial_dialog_message_volume" msgid="5033080515460519183">"Para usar esta función, mantén presionadas las teclas de volumen."</string>
    <string name="accessibility_tutorial_dialog_message_triple" msgid="5219991116201165146">"Para iniciar y detener la ampliación, presiona tres veces en cualquier parte de la pantalla."</string>
    <string name="accessibility_tutorial_dialog_message_gesture" msgid="4148062210755434854">"Para usar esta función, desliza 2 dedos hacia arriba desde la parte inferior de la pantalla.\n\nSi quieres cambiar de función, desliza 2 dedos hacia arriba y mantén presionada la pantalla."</string>
    <string name="accessibility_tutorial_dialog_message_gesture_talkback" msgid="8142847782708562793">"Para usar esta función, desliza 3 dedos hacia arriba desde la parte inferior de la pantalla.\n\nSi quieres cambiar de función, desliza 3 dedos hacia arriba y mantén presionada la pantalla."</string>
    <string name="accessibility_tutorial_dialog_message_gesture_settings" msgid="40769674586981429">"Para usar una función de accesibilidad, desliza 2 dedos hacia arriba desde la parte inferior de la pantalla.\n\nSi quieres cambiar de función, desliza 2 dedos hacia arriba y mantén presionada la pantalla."</string>
    <string name="accessibility_tutorial_dialog_message_gesture_settings_talkback" msgid="7292969929578621958">"Para usar una función de accesibilidad, desliza 3 dedos hacia arriba desde la parte inferior de la pantalla.\n\nSi quieres cambiar de función, desliza 3 dedos hacia arriba y mantén presionada la pantalla."</string>
    <string name="accessibility_tutorial_dialog_button" msgid="2031773187678948436">"Entendido"</string>
    <string name="accessibility_shortcut_title" msgid="8125867833704517463">"Combinación de teclas de <xliff:g id="SERVICE">%1$s</xliff:g>"</string>
    <string name="accessibility_shortcut_edit_summary_software" msgid="6405629977940618205">"Botón de accesibilidad"</string>
    <string name="accessibility_shortcut_edit_dialog_title_software_gesture" msgid="8078659880723370597">"Deslizar dos dedos hacia arriba"</string>
    <string name="accessibility_shortcut_edit_dialog_title_software_gesture_talkback" msgid="7422753388389160524">"Deslizar tres dedos hacia arriba"</string>
    <string name="accessibility_shortcut_edit_dialog_title_software" msgid="4796192466943479849">"Presionar el botón de accesibilidad"</string>
    <string name="accessibility_shortcut_edit_dialog_summary_software" msgid="5606196352833449600">"Presiona el botón de accesibilidad <xliff:g id="ACCESSIBILITY_ICON">%s</xliff:g> en la parte inferior de la pantalla.\n\nPara cambiar de función, mantén presionado el botón de accesibilidad."</string>
    <string name="accessibility_shortcut_edit_dialog_summary_software_gesture" msgid="8292555254353761635">"Desliza dos dedos hacia arriba desde la parte inferior de la pantalla.\n\nPara cambiar de función, desliza dos dedos hacia arriba y mantén presionada la pantalla."</string>
    <string name="accessibility_shortcut_edit_dialog_summary_software_gesture_talkback" msgid="84483464524360845">"Desliza tres dedos hacia arriba desde la parte inferior de la pantalla.\n\nPara cambiar de función, desliza tres dedos hacia arriba y mantén presionada la pantalla."</string>
    <string name="accessibility_shortcut_edit_dialog_title_hardware" msgid="2356853121810443026">"Mantener presionadas las teclas de volumen"</string>
    <string name="accessibility_shortcut_hardware_keyword" msgid="3921915304537166064">"mantener presionadas las teclas de volumen"</string>
    <string name="accessibility_shortcut_edit_dialog_summary_hardware" msgid="2503134386397991634">"Mantén presionadas ambas teclas de volumen."</string>
    <string name="accessibility_shortcut_edit_dialog_title_triple_tap" msgid="6672798007229795841">"Presionar tres veces la pantalla"</string>
    <string name="accessibility_shortcut_triple_tap_keyword" msgid="6863958573135995927">"presionar tres veces la pantalla"</string>
    <string name="accessibility_shortcut_edit_dialog_summary_triple_tap" msgid="3081710523998838305">"Presiona rápidamente la pantalla 3 veces. Esta combinación de teclas podría hacer que tu dispositivo funcione más lento."</string>
    <string name="accessibility_shortcut_edit_dialog_title_advance" msgid="4567868630655591506">"Avanzada"</string>
    <string name="accessibility_screen_magnification_navbar_configuration_warning" msgid="266736851606791552">"El botón de Accesibilidad está configurado para <xliff:g id="SERVICE">%1$s</xliff:g>. Para ampliar, mantén presionado el botón y, luego, selecciona ampliación."</string>
    <string name="accessibility_screen_magnification_gesture_navigation_warning" msgid="991017769735632046">"El gesto de accesibilidad se configuró en <xliff:g id="SERVICE">%1$s</xliff:g>. Para usar la ampliación, desliza dos dedos hacia arriba desde la parte inferior de la pantalla y mantén presionado. Luego, selecciona la ampliación."</string>
    <string name="accessibility_global_gesture_preference_title" msgid="3713636732641882959">"Combinación de teclas de volumen"</string>
    <string name="accessibility_shortcut_service_title" msgid="6842883700702723355">"Servicio de combinación de teclas"</string>
    <string name="accessibility_shortcut_settings" msgid="836783442658447995">"Configuración de combinación de teclas"</string>
    <string name="accessibility_shortcut_service_on_lock_screen_title" msgid="3923122834058574478">"Acceso directo desde pant. bloqueo"</string>
    <string name="accessibility_shortcut_description" msgid="2184693606202133549">"Permite que la combinación de teclas active las funciones desde la pantalla de bloqueo. Mantén presionadas ambas teclas de volumen durante unos segundos."</string>
    <string name="accessibility_toggle_high_text_contrast_preference_title" msgid="1830189632458752698">"Texto de alto contraste"</string>
    <string name="accessibility_toggle_screen_magnification_auto_update_preference_title" msgid="4987009529235165664">"Actualizar automáticamente la ampliación de pantalla"</string>
    <string name="accessibility_toggle_screen_magnification_auto_update_preference_summary" msgid="9034532513972547720">"Actualizar la ampliación de pantalla al cambiar de aplicaciones"</string>
    <string name="accessibility_power_button_ends_call_prerefence_title" msgid="8187306131979612144">"Cortar con el botón de encendido"</string>
    <string name="accessibility_toggle_large_pointer_icon_title" msgid="5508351959249876801">"Puntero del mouse grande"</string>
    <string name="accessibility_disable_animations" msgid="2993529829457179058">"Quitar animaciones"</string>
    <string name="accessibility_toggle_primary_mono_title" msgid="7587152099472946571">"Audio mono"</string>
    <string name="accessibility_toggle_primary_mono_summary" msgid="1935283927319407303">"Combinar canales cuando se reproduce audio"</string>
    <string name="accessibility_toggle_primary_balance_title" msgid="7332275200153366714">"Balance de audio"</string>
    <string name="accessibility_toggle_primary_balance_left_label" msgid="6415750010517682014">"Izquierda"</string>
    <string name="accessibility_toggle_primary_balance_right_label" msgid="2987443495390104935">"Derecha"</string>
    <string name="accessibility_timeout_default" msgid="1033702739376842824">"Predeterminado"</string>
    <string name="accessibility_timeout_10secs" msgid="5072577454521239794">"10 segundos"</string>
    <string name="accessibility_timeout_30secs" msgid="7814673496724760684">"30 segundos"</string>
    <string name="accessibility_timeout_1min" msgid="4804644263166961262">"1 minuto"</string>
    <string name="accessibility_timeout_2mins" msgid="7901692984522708679">"2 minutos"</string>
    <string name="accessibility_setting_item_control_timeout_title" msgid="1600516937989217899">"Tiempo de espera para realizar acción"</string>
    <string name="accessibility_control_timeout_preference_title" msgid="1443940538597464758">"Tiempo de acción"</string>
    <string name="accessibility_control_timeout_preference_summary" msgid="5283566580551714506">"Selecciona el tiempo de visualización de mensajes que requieren acciones, pero que solo se muestran temporalmente.\n\nNo todas las apps admiten esta opción."</string>
    <string name="accessibility_long_press_timeout_preference_title" msgid="5237764682976688855">"Tiempo de respuesta táctil"</string>
    <string name="accessibility_display_inversion_preference_title" msgid="5476133104746207952">"Inversión de color"</string>
    <string name="accessibility_display_inversion_switch_title" msgid="7458595722552743503">"Usar inversión de color"</string>
    <string name="accessibility_display_inversion_preference_subtitle" msgid="6955835010409034745">"La inversión de color oscurece la pantalla.&lt;br/&gt;&lt;br/&gt; Nota: &lt;ol&gt; &lt;li&gt; También puede aclararla.&lt;/li&gt; &lt;li&gt; Los colores cambiarán para el contenido multimedia y las imágenes.&lt;/li&gt; &lt;li&gt; El Tema oscuro permite mostrar un fondo oscuro y funciona solo con apps compatibles. Por otro lado, la inversión de color funciona con todas las apps.&lt;/li&gt; &lt;/ol&gt;"</string>
    <string name="accessibility_autoclick_preference_title" msgid="2703143361605555752">"Clic automático (tiempo de permanencia)"</string>
    <string name="accessibility_autoclick_description" msgid="6827042379062255307">"El clic automático funciona con un mouse conectado. Puedes configurar el cursor del mouse para que haga clic automáticamente cuando el cursor se detiene durante un período determinado."</string>
    <string name="accessibility_autoclick_default_title" msgid="752429113115293087">"Desactivado"</string>
    <string name="accessibility_autoclick_short_title" msgid="7938302504358912984">"Corto"</string>
    <string name="accessibility_autoclick_short_summary" msgid="4106953930081213514">"0.2 segundos"</string>
    <string name="accessibility_autoclick_medium_title" msgid="3134175117576834320">"Medio"</string>
    <string name="accessibility_autoclick_medium_summary" msgid="1343390686514222871">"0.6 segundos"</string>
    <string name="accessibility_autoclick_long_title" msgid="6799311820641687735">"Largo"</string>
    <string name="accessibility_autoclick_long_summary" msgid="3747153151313563637">"1 segundo"</string>
    <string name="accessibility_autoclick_custom_title" msgid="4597792235546232038">"Personalizado"</string>
    <string name="accessibility_autoclick_shorter_desc" msgid="7631013255724544348">"Más corto"</string>
    <string name="accessibility_autoclick_longer_desc" msgid="2566025502981487443">"Más largo"</string>
    <string name="accessibility_autoclick_seekbar_desc" msgid="8363959277814621118">"Tiempo de clic automático"</string>
    <string name="accessibility_vibration_settings_title" msgid="5198184603753129450">"Intensidad de la respuesta táctil y vibración"</string>
    <string name="accessibility_notification_vibration_title" msgid="6205679908785776478">"Vibración de las notificaciones"</string>
    <string name="accessibility_ring_vibration_title" msgid="4689811297654320885">"Vibración del tono"</string>
    <string name="accessibility_touch_vibration_title" msgid="533931451319110741">"Respuesta táctil"</string>
    <string name="accessibility_service_primary_switch_title" msgid="437610853412159406">"Usar <xliff:g id="ACCESSIBILITY_APP_NAME">%1$s</xliff:g>"</string>
    <string name="accessibility_service_primary_open_title" msgid="8655108684769091154">"Abrir <xliff:g id="ACCESSIBILITY_APP_NAME">%1$s</xliff:g>"</string>
    <string name="accessibility_daltonizer_primary_switch_title" msgid="32064721588910540">"Usar la corrección de colores"</string>
    <string name="accessibility_caption_primary_switch_title" msgid="8901149325574757370">"Mostrar subtítulos"</string>
    <string name="accessibility_caption_primary_switch_summary" msgid="2754071646412717674">"Solo para apps compatibles"</string>
    <string name="captioning_caption_appearance_title" msgid="4501313548541670063">"Estilo y tamaño de los subtítulos"</string>
    <string name="captioning_caption_appearance_summary" msgid="7340741178479381312">"Tamaño del texto: <xliff:g id="ACCESSIBILITY_FONT_SIZE">%1$s</xliff:g>"</string>
    <string name="captioning_more_options_title" msgid="3484496882942539652">"Más opciones"</string>
    <string name="accessibility_caption_preference_summary" msgid="1191356970836416954">"No todas las apps admiten estas preferencias de subtítulos"</string>
    <string name="accessibility_shortcut_type_software" msgid="2552732582767687515">"Botón de accesibilidad"</string>
    <string name="accessibility_shortcut_type_software_gesture" msgid="5608959693931019059">"Deslizar dos dedos hacia arriba desde la parte inferior"</string>
    <string name="accessibility_shortcut_type_hardware" msgid="4834144210432451916">"Mantén presionadas las teclas de volumen"</string>
    <string name="accessibility_shortcut_type_triple_tap" msgid="7717524216825494543">"Presionar tres veces la pantalla"</string>
    <string name="accessibility_hearingaid_instruction_continue_button" msgid="3367260988024430722">"Continuar"</string>
    <string name="accessibility_hearingaid_title" msgid="427173678199203191">"Audífonos"</string>
    <string name="accessibility_hearingaid_not_connected_summary" msgid="3371427366765435743">"No hay audífonos conectados"</string>
    <string name="accessibility_hearingaid_adding_summary" msgid="999051610528600783">"Agregar audífonos"</string>
    <string name="accessibility_hearingaid_pair_instructions_message" msgid="8913409742121315657">"Para vincular tus audífonos, busca y presiona tu dispositivo en la pantalla siguiente. Asegúrate de que tus audífonos estén en modo de vinculación."</string>
    <string name="accessibility_hearingaid_active_device_summary" msgid="509703438222873967">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g> activo"</string>
    <plurals name="show_number_hearingaid_count" formatted="false" msgid="776000580683647556">
      <item quantity="other"><xliff:g id="NUMBER_DEVICE_COUNT_1">%1$d</xliff:g> audífonos guardados</item>
      <item quantity="one"><xliff:g id="NUMBER_DEVICE_COUNT_0">%1$d</xliff:g> audífono guardado</item>
    </plurals>
    <string name="accessibility_audio_adjustment_title" msgid="1332113739136802997">"Ajuste de audio"</string>
    <string name="accessibility_summary_shortcut_enabled" msgid="4030427268146752644">"Acceso directo activado"</string>
    <string name="accessibility_summary_shortcut_disabled" msgid="564005462092499068">"Desactivada"</string>
    <string name="accessibility_summary_state_enabled" msgid="1065431632216039369">"Activado"</string>
    <string name="accessibility_summary_state_disabled" msgid="9173234532752799694">"Desactivado"</string>
    <string name="accessibility_summary_state_stopped" msgid="2343602489802623424">"No funciona. Presiona para obtener información."</string>
    <string name="accessibility_description_state_stopped" msgid="5364752492861199133">"Este servicio no funciona correctamente."</string>
    <string name="enable_quick_setting" msgid="6648073323202243604">"Mostrar en Configuración rápida"</string>
    <string name="daltonizer_type" msgid="1715154680803795947">"Modo de corrección"</string>
    <string name="daltonizer_mode_deuteranomaly_title" msgid="3811397143576433035">"Deuteronomalía"</string>
    <string name="daltonizer_mode_protanomaly_title" msgid="6787594316700223938">"Protanomalía"</string>
    <string name="daltonizer_mode_tritanomaly_title" msgid="1869867447813349033">"Tritanomalía"</string>
    <string name="daltonizer_mode_grayscale_title" msgid="152005391387952588">"Escala de grises"</string>
    <string name="daltonizer_mode_deuteranomaly_summary" msgid="791173297742998942">"Rojo-verde"</string>
    <string name="daltonizer_mode_protanomaly_summary" msgid="482834207025141433">"Rojo-verde"</string>
    <string name="daltonizer_mode_tritanomaly_summary" msgid="2837137091067433059">"Azul-amarillo"</string>
    <plurals name="accessibilty_autoclick_preference_subtitle_short_delay" formatted="false" msgid="5354221071353645263">
      <item quantity="other">Breve (<xliff:g id="CLICK_DELAY_LABEL_1">%1$s</xliff:g> segundos)</item>
      <item quantity="one">Breve (<xliff:g id="CLICK_DELAY_LABEL_0">%1$s</xliff:g> segundo)</item>
    </plurals>
    <plurals name="accessibilty_autoclick_preference_subtitle_medium_delay" formatted="false" msgid="1550891909800510628">
      <item quantity="other">Medio (<xliff:g id="CLICK_DELAY_LABEL_1">%1$s</xliff:g> segundos)</item>
      <item quantity="one">Medio (<xliff:g id="CLICK_DELAY_LABEL_0">%1$s</xliff:g> segundo)</item>
    </plurals>
    <plurals name="accessibilty_autoclick_preference_subtitle_long_delay" formatted="false" msgid="2230755548820485984">
      <item quantity="other">Largo (<xliff:g id="CLICK_DELAY_LABEL_1">%1$s</xliff:g> segundos)</item>
      <item quantity="one">Largo (<xliff:g id="CLICK_DELAY_LABEL_0">%1$s</xliff:g> segundo)</item>
    </plurals>
    <plurals name="accessibilty_autoclick_delay_unit_second" formatted="false" msgid="4537791441118261556">
      <item quantity="other"><xliff:g id="CLICK_DELAY_LABEL_2">%1$s</xliff:g> segundos</item>
      <item quantity="one"><xliff:g id="CLICK_DELAY_LABEL_0">%1$s</xliff:g> segundo</item>
    </plurals>
    <string name="accessibility_vibration_summary" msgid="27904038683405084">"Tono (<xliff:g id="SUMMARY_RING">%1$s</xliff:g>), notificación (<xliff:g id="SUMMARY_NOTIFICATION">%2$s</xliff:g>) y respuesta táctil (<xliff:g id="SUMMARY_TOUCH">%3$s</xliff:g>)"</string>
    <string name="accessibility_vibration_summary_off" msgid="7776105450117095736">"Desactivada para notificaciones y llamadas"</string>
    <string name="accessibility_vibration_summary_low" msgid="6482721005400340317">"Baja para notificaciones y llamadas"</string>
    <string name="accessibility_vibration_summary_medium" msgid="2348889320548746469">"Media para notificaciones y llamadas"</string>
    <string name="accessibility_vibration_summary_high" msgid="1764693979030913712">"Alta para notificaciones y llamadas"</string>
    <string name="accessibility_vibration_intensity_off" msgid="972159695404061944">"Desactivada"</string>
    <string name="accessibility_vibration_intensity_low" msgid="6311161118835287335">"Baja"</string>
    <string name="accessibility_vibration_intensity_medium" msgid="1734058611879392797">"Media"</string>
    <string name="accessibility_vibration_intensity_high" msgid="5982896399775212514">"Alta"</string>
    <string name="accessibility_menu_item_settings" msgid="2652637954865389271">"Configuración"</string>
    <string name="accessibility_feature_state_on" msgid="1777344331063467511">"Activado"</string>
    <string name="accessibility_feature_state_off" msgid="169119895905460512">"Desactivado"</string>
    <string name="captioning_preview_title" msgid="2888561631323180535">"Vista previa"</string>
    <string name="captioning_standard_options_title" msgid="5360264497750980205">"Opciones estándar"</string>
    <string name="captioning_locale" msgid="5533303294290661590">"Idioma"</string>
    <string name="captioning_text_size" msgid="8039448543171463017">"Tamaño del texto"</string>
    <string name="captioning_preset" msgid="4174276086501638524">"Estilo de los subtítulos"</string>
    <string name="captioning_custom_options_title" msgid="3858866498893566351">"Opciones personalizadas"</string>
    <string name="captioning_background_color" msgid="5231412761368883107">"Color de fondo"</string>
    <string name="captioning_background_opacity" msgid="6453738649182382614">"Opacidad del fondo"</string>
    <string name="captioning_window_color" msgid="1406167274530183119">"Color de ventana de subtítulos"</string>
    <string name="captioning_window_opacity" msgid="4031752812991199525">"Opacidad de ventana de subtítulos"</string>
    <string name="captioning_foreground_color" msgid="9057327228286129232">"Color del texto"</string>
    <string name="captioning_foreground_opacity" msgid="1395843080697567189">"Opacidad del texto"</string>
    <string name="captioning_edge_color" msgid="6035818279902597518">"Color del borde"</string>
    <string name="captioning_edge_type" msgid="5281259280060811506">"Tipo de borde"</string>
    <string name="captioning_typeface" msgid="285325623518361407">"Familia de fuentes"</string>
    <string name="captioning_preview_text" msgid="4973475065545995704">"Así se verán los subtítulos."</string>
    <string name="captioning_preview_characters" msgid="7854812443613580460">"Aa"</string>
    <string name="locale_default" msgid="8948077172250925164">"Predeterminado"</string>
    <string name="color_title" msgid="2511586788643787427">"Color"</string>
    <string name="color_unspecified" msgid="4102176222255378320">"Predeterminado"</string>
    <string name="color_none" msgid="3703632796520710651">"Ninguno"</string>
    <string name="color_white" msgid="1896703263492828323">"Blanco"</string>
    <string name="color_gray" msgid="8554077329905747877">"Gris"</string>
    <string name="color_black" msgid="9006830401670410387">"Negro"</string>
    <string name="color_red" msgid="5210756997426500693">"Rojo"</string>
    <string name="color_green" msgid="4400462091250882271">"Verde"</string>
    <string name="color_blue" msgid="4997784644979140261">"Azul"</string>
    <string name="color_cyan" msgid="4341758639597035927">"Cian"</string>
    <string name="color_yellow" msgid="5957551912912679058">"Amarillo"</string>
    <string name="color_magenta" msgid="8943538189219528423">"Magenta"</string>
    <string name="enable_service_title" msgid="7231533866953706788">"¿Deseas permitir que <xliff:g id="SERVICE">%1$s</xliff:g> tenga el control total de tu dispositivo?"</string>
    <string name="capabilities_list_title" msgid="1225853611983394386">"<xliff:g id="SERVICE">%1$s</xliff:g> necesita:"</string>
    <string name="touch_filtered_warning" msgid="4225815157460318241">"Debido a que una aplicación está bloqueando una solicitud de permiso, la Configuración no puede verificar tu respuesta."</string>
    <string name="enable_service_encryption_warning" msgid="931082737770453755">"Si activas <xliff:g id="SERVICE">%1$s</xliff:g>, el dispositivo no utilizará el bloqueo de pantalla para mejorar el cifrado de datos."</string>
    <string name="secure_lock_encryption_warning" msgid="669152607190123579">"Dado que activaste un servicio de accesibilidad, el dispositivo no utilizará el bloqueo de pantalla para mejorar el cifrado de datos."</string>
    <string name="enable_service_pattern_reason" msgid="6832846117817938536">"Dado que la encriptación de datos se ve afectada al activar <xliff:g id="SERVICE">%1$s</xliff:g>, debes confirmar el patrón."</string>
    <string name="enable_service_pin_reason" msgid="6040417014360237703">"Dado que la encriptación de datos se ve afectada al activar <xliff:g id="SERVICE">%1$s</xliff:g>, debes confirmar el PIN."</string>
    <string name="enable_service_password_reason" msgid="6962544350351734238">"Dado que la encriptación de datos se ve afectada al activar <xliff:g id="SERVICE">%1$s</xliff:g>, debes confirmar la contraseña."</string>
    <string name="accessibility_service_warning" msgid="6779187188736432618">"<xliff:g id="SERVICE">%1$s</xliff:g> está solicitando el control total de este dispositivo. El servicio puede leer la pantalla y realizar acciones para los usuarios que necesitan accesibilidad. Este nivel de control no es apropiado para la mayoría de las apps."</string>
    <string name="accessibility_service_warning_description" msgid="6573203795976134751">"El control total es apropiado para las apps que te ayudan con las necesidades de accesibilidad, pero no para la mayoría de las apps."</string>
    <string name="accessibility_service_screen_control_title" msgid="324795030658109870">"Ver y controlar la pantalla"</string>
    <string name="accessibility_service_screen_control_description" msgid="8431940515157990426">"Puede leer todo el contenido en la pantalla y mostrarlo sobre otras apps."</string>
    <string name="accessibility_service_action_perform_title" msgid="1449360056585337833">"Ver y realizar acciones"</string>
    <string name="accessibility_service_action_perform_description" msgid="7807832069800034738">"Puede realizar el seguimiento de tus interacciones con una app o un sensor de hardware, así como interactuar con las apps por ti."</string>
    <string name="accessibility_dialog_button_allow" msgid="8274918676473216697">"Permitir"</string>
    <string name="accessibility_dialog_button_deny" msgid="2037249860078259284">"Rechazar"</string>
    <string name="accessibility_dialog_button_stop" msgid="7295448112784528196">"Detener"</string>
    <string name="accessibility_dialog_button_cancel" msgid="4813234247237851121">"Cancelar"</string>
    <string name="disable_service_title" msgid="2909108731776956167">"¿Quieres detener <xliff:g id="SERVICE">%1$s</xliff:g>?"</string>
    <string name="disable_service_message" msgid="4814173941688548016">"Si presionas <xliff:g id="STOP">%1$s</xliff:g>, se detendrá <xliff:g id="SERVICE">%2$s</xliff:g>."</string>
    <string name="accessibility_no_services_installed" msgid="3725569493860028593">"No se instaló ningún servicio."</string>
    <string name="accessibility_no_service_selected" msgid="1310596127128379897">"No se seleccionó ningún servicio"</string>
    <string name="accessibility_service_default_description" msgid="7801435825448138526">"No se proporcionó ninguna descripción."</string>
    <string name="settings_button" msgid="2195468788019730377">"Configuración"</string>
    <string name="print_settings" msgid="8519810615863882491">"Impresión"</string>
    <string name="print_settings_summary_no_service" msgid="6721731154917653862">"Desactivado"</string>
    <plurals name="print_settings_summary" formatted="false" msgid="1034273609054146099">
      <item quantity="other"><xliff:g id="COUNT">%1$d</xliff:g> servicios de impresión activados</item>
      <item quantity="one">1 servicio de impresión activado</item>
    </plurals>
    <plurals name="print_jobs_summary" formatted="false" msgid="3933688846338306536">
      <item quantity="other"><xliff:g id="COUNT">%1$d</xliff:g> trabajos de impresión</item>
      <item quantity="one">1 trabajo de impresión</item>
    </plurals>
    <string name="print_settings_title" msgid="7680498284751129935">"Servicios de impresión"</string>
    <string name="print_no_services_installed" msgid="7554057966540602692">"No se instaló ningún servicio."</string>
    <string name="print_no_printers_found" msgid="4833082484646109486">"No se encontraron impresoras"</string>
    <string name="print_menu_item_settings" msgid="8202755044784599740">"Configuración"</string>
    <string name="print_menu_item_add_printers" msgid="7958192149202584039">"Agregar impresoras"</string>
    <string name="print_feature_state_on" msgid="7132063461008624685">"Activado"</string>
    <string name="print_feature_state_off" msgid="1466195699995209446">"Desactivado"</string>
    <string name="print_menu_item_add_service" msgid="1549091062463044676">"Agregar servicio"</string>
    <string name="print_menu_item_add_printer" msgid="8711630848324870892">"Agregar impresora"</string>
    <string name="print_menu_item_search" msgid="5989979785203603169">"Buscar"</string>
    <string name="print_searching_for_printers" msgid="5401413178028348800">"Buscando impresoras"</string>
    <string name="print_service_disabled" msgid="9185935228930987786">"Servicio desactivado"</string>
    <string name="print_print_jobs" msgid="2605944855933091183">"Trabajos de impresión"</string>
    <string name="print_print_job" msgid="8477859161886726608">"Trabajo de impresión"</string>
    <string name="print_restart" msgid="4424096106141083945">"Reiniciar"</string>
    <string name="print_cancel" msgid="7611266511967568501">"Cancelar"</string>
    <string name="print_job_summary" msgid="277210060872032969">"<xliff:g id="PRINTER">%1$s</xliff:g>\n<xliff:g id="TIME">%2$s</xliff:g>"</string>
    <string name="print_configuring_state_title_template" msgid="2887013172492183045">"Configurando <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_printing_state_title_template" msgid="7367513245156603431">"Imprimiendo <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_cancelling_state_title_template" msgid="9094795458159980190">"Cancelando <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_failed_state_title_template" msgid="4751695809935404505">"Error de impresora <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_blocked_state_title_template" msgid="3134100215188411074">"La impresora bloqueó <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>."</string>
    <string name="print_search_box_shown_utterance" msgid="6215002365360341961">"Cuadro de búsqueda visible"</string>
    <string name="print_search_box_hidden_utterance" msgid="5355387966141712567">"Cuadro de búsqueda oculto"</string>
    <string name="printer_info_desc" msgid="1206872325746154206">"Más información sobre esta impresora"</string>
    <string name="power_usage_summary_title" msgid="4198312848584882113">"Batería"</string>
    <string name="power_usage_summary" msgid="6857382582534984531">"Lo que ha utilizado la batería"</string>
    <string name="power_usage_not_available" msgid="3425302437465106036">"Sin datos de uso de batería"</string>
    <string name="power_usage_level_and_status" msgid="821521456989429593">"<xliff:g id="LEVEL">%1$s</xliff:g> - <xliff:g id="STATUS">%2$s</xliff:g>"</string>
    <string name="power_discharge_remaining" msgid="6997529817917076536">"Tiempo restante: <xliff:g id="REMAIN">%1$s</xliff:g>"</string>
    <string name="power_charge_remaining" msgid="7046064326172265116">"Carga completa en <xliff:g id="UNTIL_CHARGED">%1$s</xliff:g>"</string>
    <string name="background_activity_title" msgid="8214332017349791380">"Restricción en segundo plano"</string>
    <string name="background_activity_summary" msgid="3817376868497046016">"Permite que la app se ejecute en segundo plano"</string>
    <string name="background_activity_summary_disabled" msgid="32459916080651444">"La app no puede ejecutarse en segundo plano"</string>
    <string name="background_activity_summary_allowlisted" msgid="6240154358657454651">"No se puede restringir el uso en segundo plano"</string>
    <string name="background_activity_warning_dialog_title" msgid="3449566823290744823">"¿Limitar actividad en segundo plano?"</string>
    <string name="background_activity_warning_dialog_text" msgid="8202776985767701095">"Si limitas la actividad en segundo plano de una app, es posible que no funcione correctamente"</string>
    <string name="background_activity_disabled_dialog_text" msgid="4053170297325882494">"Como no se configuró la app para optimizar la batería, no puedes restringirla.\n\nPrimero, activa optimización de batería."</string>
    <string name="device_screen_usage" msgid="1011630249648289909">"Uso de la pantalla desde carga completa"</string>
    <string name="power_usage_list_summary" msgid="3237540201918492925">"Uso de la batería desde la última carga completa"</string>
    <string name="screen_usage_summary" msgid="1393184943010909471">"Tiempo que estuvo encendida la pantalla desde la última carga completa"</string>
    <string name="device_usage_list_summary" msgid="242243537371697285">"Uso del dispositivo desde la última carga completa"</string>
    <string name="battery_since_unplugged" msgid="6991509383429936921">"Uso de la batería desde que se desconectó"</string>
    <string name="battery_since_reset" msgid="2930376112877476562">"Uso de la batería desde que se restableció"</string>
    <string name="battery_stats_on_battery" msgid="1553011980384645514">"<xliff:g id="TIME">%1$s</xliff:g> de uso de la batería"</string>
    <string name="battery_stats_duration" msgid="6918768703070999743">"<xliff:g id="TIME">%1$s</xliff:g> desde que se desconectó"</string>
    <string name="battery_stats_charging_label" msgid="6204814386861342145">"Cargando"</string>
    <string name="battery_stats_screen_on_label" msgid="8989312180491200138">"Pantalla encendida"</string>
    <string name="battery_stats_gps_on_label" msgid="5626424078405382686">"GPS activado"</string>
    <string name="battery_stats_camera_on_label" msgid="555635201416769359">"Cámara activada"</string>
    <string name="battery_stats_flashlight_on_label" msgid="1621027969559427783">"Linterna activada"</string>
    <string name="battery_stats_wifi_running_label" msgid="6461551370010379049">"Wi-Fi"</string>
    <string name="battery_stats_wake_lock_label" msgid="8115041205778441548">"Activa"</string>
    <string name="battery_stats_phone_signal_label" msgid="679649411998679555">"Señal de la red de celulares"</string>
    <!-- no translation found for battery_stats_last_duration (3088100394725340600) -->
    <skip />
    <string name="awake" msgid="5405871714019268978">"Hora de activación del dispositivo"</string>
    <string name="wifi_on_time" msgid="3880778525760926066">"Wi-Fi a tiempo"</string>
    <string name="bluetooth_on_time" msgid="8424625554628450028">"Wi-Fi a tiempo"</string>
    <string name="advanced_battery_title" msgid="3005993394776555079">"Uso de la batería"</string>
    <string name="history_details_title" msgid="8628584613889559355">"Detalles del historial"</string>
    <!-- no translation found for advanced_battery_preference_title (6518802648205311326) -->
    <skip />
    <string name="battery_details_title" msgid="4531369291819754178">"Uso de la batería"</string>
    <string name="details_subtitle" msgid="2550872569652785527">"Detalles de uso"</string>
    <string name="controls_subtitle" msgid="3759606830916441564">"Ajustar el uso de energía"</string>
    <string name="packages_subtitle" msgid="8687690644931499428">"Paquetes incluidos"</string>
    <string name="battery_tip_summary_title" msgid="321127485145626939">"Las apps se ejecutan con normalidad"</string>
    <string name="battery_tip_summary_summary" product="default" msgid="6077959765904507849">"El consumo de batería en segundo plano del teléfono es normal"</string>
    <string name="battery_tip_summary_summary" product="tablet" msgid="5063158368808711973">"El consumo de batería en segundo plano de la tablet es normal"</string>
    <string name="battery_tip_summary_summary" product="device" msgid="4242899844618910548">"El consumo de batería en segundo plano del dispositivo es normal"</string>
    <string name="battery_tip_low_battery_title" msgid="7789690720316830767">"Capacidad de batería baja"</string>
    <string name="battery_tip_low_battery_summary" msgid="357649681960300945">"La batería no tiene una buena duración"</string>
    <string name="battery_tip_smart_battery_title" product="default" msgid="2903272443772298636">"Mejora la duración de batería del teléfono"</string>
    <string name="battery_tip_smart_battery_title" product="tablet" msgid="6813017377960004819">"Mejora la duración de batería de la tablet"</string>
    <string name="battery_tip_smart_battery_title" product="device" msgid="4805599360437606335">"Mejora la duración de batería del dispositivo"</string>
    <string name="battery_tip_smart_battery_summary" msgid="3592965553502362965">"Activa el administrador de batería"</string>
    <string name="battery_tip_early_heads_up_title" msgid="4411387863476629452">"Activar el Ahorro de batería"</string>
    <string name="battery_tip_early_heads_up_summary" msgid="578523794827443977">"La batería podría agotarse antes de lo habitual"</string>
    <string name="battery_tip_early_heads_up_done_title" msgid="4413270905575486715">"El Ahorro de batería está activado"</string>
    <string name="battery_tip_early_heads_up_done_summary" msgid="7858923105760361208">"Es posible que algunas funciones estén limitadas"</string>
    <string name="battery_tip_high_usage_title" product="default" msgid="2375953293196088319">"El teléfono se usó más de lo habitual"</string>
    <string name="battery_tip_high_usage_title" product="tablet" msgid="8515903411746145740">"La tablet se usó más de lo habitual"</string>
    <string name="battery_tip_high_usage_title" product="device" msgid="6577086402173910457">"El dispositivo se usó más de lo habitual"</string>
    <string name="battery_tip_high_usage_summary" msgid="5356399389711499862">"La batería podría agotarse antes de lo habitual"</string>
    <string name="battery_tip_limited_temporarily_title" msgid="7152799456221596915">"Optimizando el estado de la batería"</string>
    <string name="battery_tip_limited_temporarily_summary" msgid="6837061824463128857">"Batería limitada temporalmente. Presiona para obtener más información."</string>
    <string name="battery_tip_dialog_message" product="default" msgid="4681734836472195966">"El teléfono se usó más de lo habitual. Es posible que la batería se agote antes de lo esperado.\n\nEstas son las apps que más batería consumen:"</string>
    <string name="battery_tip_dialog_message" product="tablet" msgid="3934298305232120382">"La tablet se usó más de lo habitual. Es posible que la batería se agote antes de lo esperado.\n\nEstas son las apps que más batería consumen:"</string>
    <string name="battery_tip_dialog_message" product="device" msgid="2620789680336796054">"El dispositivo se usó más de lo habitual. Es posible que la batería se agote antes de lo esperado.\n\nEstas son las apps que más batería consumen:"</string>
    <string name="battery_tip_dialog_message_footer" msgid="986542164372177504">"Incluye actividad en segundo plano de alta potencia"</string>
    <plurals name="battery_tip_restrict_title" formatted="false" msgid="3108195491484891588">
      <item quantity="other">Restringir %1$d apps</item>
      <item quantity="one">Restringir %1$d app</item>
    </plurals>
    <plurals name="battery_tip_restrict_handled_title" formatted="false" msgid="5862649927574803958">
      <item quantity="other">Se restringieron recientemente %2$d apps</item>
      <item quantity="one">Se restringió recientemente %1$s</item>
    </plurals>
    <plurals name="battery_tip_restrict_summary" formatted="false" msgid="3328499737453686910">
      <item quantity="other">%2$d apps consumen mucho en segundo plano</item>
      <item quantity="one">%1$s consume mucho en segundo plano</item>
    </plurals>
    <plurals name="battery_tip_restrict_handled_summary" formatted="false" msgid="3036853535034350991">
      <item quantity="other">Estas apps no se pueden ejecutar en segundo plano</item>
      <item quantity="one">Esta app no se puede ejecutar en segundo plano</item>
    </plurals>
    <plurals name="battery_tip_restrict_app_dialog_title" formatted="false" msgid="7897944678619251740">
      <item quantity="other">¿Restringir %1$d apps?</item>
      <item quantity="one">¿Restringir la app?</item>
    </plurals>
    <string name="battery_tip_restrict_app_dialog_message" msgid="137856003724730751">"Para ahorrar batería, detén el consumo en segundo plano de <xliff:g id="APP">%1$s</xliff:g>. Es posible que esta app no funcione correctamente y que se retrasen las notificaciones."</string>
    <string name="battery_tip_restrict_apps_less_than_5_dialog_message" msgid="5894648804112181324">"Para ahorrar batería, detén el consumo en segundo plano de estas apps. Es posible que las apps restringidas no funcionen correctamente y que se retrasen las notificaciones.\n\nApps:"</string>
    <string name="battery_tip_restrict_apps_more_than_5_dialog_message" msgid="4546838397423565138">"Para ahorrar batería, detén el consumo en segundo plano de estas apps. Es posible que las apps restringidas no funcionen correctamente y que se retrasen las notificaciones.\n\nApps:\n<xliff:g id="APP_LIST">%1$s</xliff:g>."</string>
    <string name="battery_tip_restrict_app_dialog_ok" msgid="7025027696689301916">"Restringir"</string>
    <string name="battery_tip_unrestrict_app_dialog_title" msgid="5501997201160532301">"¿Quitar restricción?"</string>
    <string name="battery_tip_unrestrict_app_dialog_message" msgid="215449637818582819">"Esta app podrá usar la batería en segundo plano. La batería podría agotarse antes de lo esperado."</string>
    <string name="battery_tip_unrestrict_app_dialog_ok" msgid="7940183167721998470">"Quitar"</string>
    <string name="battery_tip_unrestrict_app_dialog_cancel" msgid="4968135709160207507">"Cancelar"</string>
    <string name="battery_tip_dialog_summary_message" product="default" msgid="6097167058237891756">"Tus apps consumen una cantidad normal de batería. Si consumen demasiada batería, el teléfono te recomendará acciones.\n\nSi tienes poca batería, también puedes activar el Ahorro de batería."</string>
    <string name="battery_tip_dialog_summary_message" product="tablet" msgid="573297655597451123">"Tus apps consumen una cantidad normal de batería. Si consumen demasiada batería, la tablet te recomendará acciones.\n\nSi tienes poca batería, también puedes activar el Ahorro de batería."</string>
    <string name="battery_tip_dialog_summary_message" product="device" msgid="8222461068860745749">"Tus apps consumen una cantidad normal de batería. Si consumen demasiada batería, el dispositivo te recomendará acciones.\n\nSi tienes poca batería, también puedes activar el Ahorro de batería."</string>
    <string name="smart_battery_manager_title" msgid="3677620516657920364">"Administrador de batería"</string>
    <string name="smart_battery_title" msgid="9095903608520254254">"Administra apps automáticamente"</string>
    <string name="smart_battery_summary" product="default" msgid="1492277404000064998">"Limitar el consumo de batería de las apps que no uses con frecuencia"</string>
    <string name="smart_battery_footer" msgid="8407121907452993645">"Si el administrador de batería detecta que hay apps que agotan la batería, podrás restringirlas, aunque es posible que no funcionen correctamente y que se retrasen las notificaciones."</string>
    <string name="restricted_app_title" msgid="6585080822121007436">"Apps restringidas"</string>
    <plurals name="restricted_app_summary" formatted="false" msgid="6059772951505411003">
      <item quantity="other">Limitando el uso de batería de %1$d apps</item>
      <item quantity="one">Limitando el uso de batería de %1$d app</item>
    </plurals>
    <string name="restricted_app_time_summary" msgid="3097721884155913252">"Restringida <xliff:g id="TIME">%1$s</xliff:g>"</string>
    <string name="restricted_app_detail_footer" msgid="3683577206409650564">"Estas apps consumen batería en segundo plano. Es posible que las apps restringidas no funcionen correctamente y que se retrasen las notificaciones."</string>
    <string name="battery_auto_restriction_title" msgid="827206218118093357">"Usar el administrador de batería"</string>
    <string name="battery_auto_restriction_summary" msgid="2140896101984815711">"Detectar cuando las apps agotan la batería"</string>
    <string name="battery_manager_on" product="default" msgid="3197525907390349054">"Activado: detectando cuando las apps agotan la batería"</string>
    <string name="battery_manager_off" msgid="673547668722420924">"Desactivado"</string>
    <plurals name="battery_manager_app_restricted" formatted="false" msgid="6714534362166394848">
      <item quantity="other">%1$d apps restringidas</item>
      <item quantity="one">%1$d app restringida</item>
    </plurals>
    <string name="battery_header_title_alternate" msgid="8371821625994616659">"<xliff:g id="NUMBER">^1</xliff:g>"<small>" "<font size="20">"<xliff:g id="UNIT">%</xliff:g>"</font></small>""</string>
    <string name="battery_missing_message" msgid="5202575301365811053">"Problema al leer el medidor de batería"</string>
    <string name="battery_missing_help_message" msgid="4583322687535428926">"Ocurrió un problema al leer el medidor de batería; presiona para "<annotation id="url">"obtener más información"</annotation></string>
    <string name="dialog_stop_title" msgid="5972757101865665655">"¿Quieres detener la app?"</string>
    <string name="dialog_stop_message" product="default" msgid="2063536418875183799">"Tu teléfono no puede administrar el uso de la batería con normalidad porque <xliff:g id="APP">%1$s</xliff:g> lo mantiene activo.\n\nPara solucionar este problema, detén la app.\n\nSi el problema persiste, es posible que debas desinstalarla para mejorar el rendimiento de la batería."</string>
    <string name="dialog_stop_message" product="tablet" msgid="426862716783569739">"Tu tablet no puede administrar el uso de la batería con normalidad porque <xliff:g id="APP">%1$s</xliff:g> la mantiene activa.\n\nPara solucionar este problema, detén la app.\n\nSi el problema persiste, es posible que debas desinstalarla para mejorar el rendimiento de la batería."</string>
    <string name="dialog_stop_message" product="device" msgid="4252335402634772603">"Tu dispositivo no puede administrar el uso de la batería con normalidad porque <xliff:g id="APP">%1$s</xliff:g> lo mantiene activo.\n\nPara solucionar este problema, detén la app.\n\nSi el problema persiste, es posible que debas desinstalarla para mejorar el rendimiento de la batería."</string>
    <string name="dialog_stop_message_wakeup_alarm" product="default" msgid="604462000476810125">"Tu teléfono no puede administrar el uso de la batería con normalidad porque <xliff:g id="APP_0">%1$s</xliff:g> lo mantiene activo.\n\nPara solucionar este problema, detén <xliff:g id="APP_1">%1$s</xliff:g>.\n\nSi el problema persiste, es posible que debas desinstalar la app para mejorar el rendimiento de la batería."</string>
    <string name="dialog_stop_message_wakeup_alarm" product="tablet" msgid="7737426241260791605">"Tu tablet no puede administrar el uso de la batería con normalidad porque <xliff:g id="APP_0">%1$s</xliff:g> la mantiene activa.\n\nPara solucionar este problema, detén <xliff:g id="APP_1">%1$s</xliff:g>.\n\nSi el problema persiste, es posible que debas desinstalar la app para mejorar el rendimiento de la batería."</string>
    <string name="dialog_stop_message_wakeup_alarm" product="device" msgid="1820679795932901383">"Tu dispositivo no puede administrar el uso de la batería con normalidad porque <xliff:g id="APP_0">%1$s</xliff:g> lo mantiene activo.\n\nPara solucionar este problema, detén <xliff:g id="APP_1">%1$s</xliff:g>.\n\nSi el problema persiste, es posible que debas desinstalar la app para mejorar el rendimiento de la batería."</string>
    <string name="dialog_stop_ok" msgid="1171516542217183180">"Detener la app"</string>
    <string name="dialog_background_check_title" msgid="8571605969100408762">"¿Desactivar el uso en segundo plano y detener la app?"</string>
    <string name="dialog_background_check_message" product="default" msgid="6203374578970183277">"Tu teléfono no puede administrar el uso de la batería con normalidad porque <xliff:g id="APP_0">%1$s</xliff:g> lo mantiene activo.\n\nPara solucionar este problema, detén <xliff:g id="APP_1">%1$s</xliff:g> y evita que se ejecute en segundo plano."</string>
    <string name="dialog_background_check_message" product="tablet" msgid="1282389215667916176">"Tu tablet no puede administrar el uso de la batería con normalidad porque <xliff:g id="APP_0">%1$s</xliff:g> la mantiene activa.\n\nPara solucionar este problema, detén <xliff:g id="APP_1">%1$s</xliff:g> y evita que se ejecute en segundo plano."</string>
    <string name="dialog_background_check_message" product="device" msgid="8005524265739819577">"Tu dispositivo no puede administrar el uso de la batería con normalidad porque <xliff:g id="APP_0">%1$s</xliff:g> lo mantiene activo.\n\nPara solucionar este problema, detén <xliff:g id="APP_1">%1$s</xliff:g> y evita que se ejecute en segundo plano."</string>
    <string name="dialog_background_check_ok" msgid="5792934035264144797">"Desactivar"</string>
    <string name="dialog_location_title" msgid="1323400468370901875">"¿Quieres desactivar la ubicación?"</string>
    <string name="dialog_location_message" product="default" msgid="5597959072209122057">"Tu teléfono no puede administrar el uso de la batería con normalidad porque <xliff:g id="APP">%1$s</xliff:g> solicita tu ubicación incluso cuando no estás usando la app.\n\nPara solucionar el problema, desactiva la ubicación en esta app."</string>
    <string name="dialog_location_message" product="tablet" msgid="7165269165194599595">"Tu tablet no puede administrar el uso de la batería con normalidad porque <xliff:g id="APP">%1$s</xliff:g> solicita tu ubicación incluso cuando no estás usando la app.\n\nPara solucionar el problema, desactiva la ubicación en esta app."</string>
    <string name="dialog_location_message" product="device" msgid="4606829479989940464">"Tu dispositivo no puede administrar el uso de la batería con normalidad porque <xliff:g id="APP">%1$s</xliff:g> solicita tu ubicación incluso cuando no estás usando la app.\n\nPara solucionar el problema, desactiva la ubicación en esta app."</string>
    <string name="dialog_location_ok" msgid="6338680851382069716">"Desactivar"</string>
    <string name="power_screen" msgid="4596900105850963806">"Pantalla"</string>
    <string name="power_flashlight" msgid="8993388636332573202">"Linterna"</string>
    <string name="power_camera" msgid="4778315081581293923">"Cámara"</string>
    <string name="power_wifi" msgid="4614007837288250325">"Wi-Fi"</string>
    <string name="power_bluetooth" msgid="5085900180846238196">"Bluetooth"</string>
    <string name="power_cell" msgid="5507921058696341513">"Red móvil en modo de espera"</string>
    <string name="power_phone" msgid="2768396619208561670">"Llamadas de voz"</string>
    <string name="power_idle" product="tablet" msgid="4689321599298911021">"Tablet ausente"</string>
    <string name="power_idle" product="default" msgid="9132502722499465252">"Teléfono inactivo"</string>
    <string name="power_unaccounted" msgid="2160811497426475703">"Varios"</string>
    <string name="power_overcounted" msgid="3681101460287472876">"Sobrecalculada"</string>
    <string name="usage_type_cpu" msgid="8544148642836549011">"CPU total"</string>
    <string name="usage_type_cpu_foreground" msgid="6120871498122604239">"Primer plano de la CPU"</string>
    <string name="usage_type_wake_lock" msgid="3442487584173668904">"Mantener en funcionamiento"</string>
    <string name="usage_type_gps" msgid="4118035982288964651">"GPS"</string>
    <string name="usage_type_wifi_running" msgid="5573404832197356206">"Wi-Fi en funcionamiento"</string>
    <string name="usage_type_phone" product="tablet" msgid="4527092861928972130">"Tablet"</string>
    <string name="usage_type_phone" product="default" msgid="4149330237181984782">"Teléfono"</string>
    <string name="usage_type_data_send" msgid="4375755152437282184">"Paquetes móviles enviados"</string>
    <string name="usage_type_data_recv" msgid="7821924049621005218">"Paquetes móviles recibidos"</string>
    <string name="usage_type_radio_active" msgid="1876069445855950097">"Radio activada"</string>
    <string name="usage_type_data_wifi_send" msgid="6154038607322769558">"Paquetes Wi‑Fi enviados"</string>
    <string name="usage_type_data_wifi_recv" msgid="4821128213012023100">"Paquetes Wi‑Fi recibidos"</string>
    <string name="usage_type_audio" msgid="1100651355357912864">"Audio"</string>
    <string name="usage_type_video" msgid="1068481638906679035">"Video"</string>
    <string name="usage_type_camera" msgid="3999579307204257822">"Cámara"</string>
    <string name="usage_type_flashlight" msgid="5629235220169383309">"Linterna"</string>
    <string name="usage_type_on_time" msgid="104642441471272535">"Tiempo de activación"</string>
    <string name="usage_type_no_coverage" msgid="1385712176630900103">"Tiempo sin una señal"</string>
    <string name="usage_type_total_battery_capacity" msgid="3878234027503885998">"Capacidad total de la batería"</string>
    <string name="usage_type_computed_power" msgid="5191902025833668752">"Uso de energía computado"</string>
    <string name="usage_type_actual_power" msgid="1221358930299037926">"Uso de energía observado"</string>
    <string name="battery_action_stop" msgid="6998228610098034316">"Forzar la detención"</string>
    <string name="battery_action_app_details" msgid="7201369216798227707">"Info. de apps"</string>
    <string name="battery_action_app_settings" msgid="2437124469335488464">"Configuración de aplicación"</string>
    <string name="battery_action_display" msgid="6515712081248863749">"Configuraciones de pantalla"</string>
    <string name="battery_action_wifi" msgid="1829212604573932607">"Configuración de Wi-Fi"</string>
    <string name="battery_action_bluetooth" msgid="4723692623358386789">"Config. de Bluetooth"</string>
    <string name="battery_desc_voice" msgid="6900799826084022585">"La batería está siendo utilizada por llamadas de voz"</string>
    <string name="battery_desc_standby" product="tablet" msgid="5818742458684767043">"La batería se utiliza cuando el tablet está inactivo"</string>
    <string name="battery_desc_standby" product="default" msgid="2543075041964578103">"La batería se utiliza cuando el dispositivo está inactivo"</string>
    <string name="battery_desc_radio" msgid="454677140485133914">"La batería está siendo utilizada por la radio celular"</string>
    <string name="battery_sugg_radio" msgid="5476234634503535270">"Cambiar a modo avión para ahorrar batería en áreas sin cobertura celular"</string>
    <string name="battery_desc_flashlight" msgid="6694895513133361404">"Batería utilizada por la linterna"</string>
    <string name="battery_desc_camera" msgid="6152712271731518018">"Batería que usa la cámara"</string>
    <string name="battery_desc_display" msgid="7175017688954602685">"La batería está siendo utilizada por la pantalla y la luz de fondo"</string>
    <string name="battery_sugg_display" msgid="3102137296547788111">"Reduce el brillo y el tiempo de espera de la pantalla"</string>
    <string name="battery_desc_wifi" msgid="5276669172548928768">"Batería utilizada por Wi-Fi"</string>
    <string name="battery_sugg_wifi" msgid="359757575108350109">"Desactiva Wi-Fi cuando no lo utilices o cuando no esté disponible."</string>
    <string name="battery_desc_bluetooth" msgid="2237947137783306282">"Batería utilizada por Bluetooth"</string>
    <string name="battery_sugg_bluetooth_basic" msgid="8943564578546832037">"Desactiva Bluetooth cuando no lo utilices."</string>
    <string name="battery_sugg_bluetooth_headset" msgid="6495519793211758353">"Intentar conectarse a un dispositivo Bluetooth diferente"</string>
    <string name="battery_desc_apps" msgid="4187483940383266017">"Batería usada por la aplicación"</string>
    <string name="battery_sugg_apps_info" msgid="4796917242296658454">"Detener o desinstalar la aplicación"</string>
    <string name="battery_sugg_apps_gps" msgid="7221335088647925110">"Selecciona el modo de ahorro de batería."</string>
    <string name="battery_sugg_apps_settings" msgid="6527223370162382166">"La aplicación podrá ofrecer una configuración para reducir el uso de la batería."</string>
    <string name="battery_desc_users" msgid="1959428568888686847">"Batería utilizada por el usuario"</string>
    <string name="battery_desc_unaccounted" msgid="1649497860893660763">"Uso de energía variado"</string>
    <string name="battery_msg_unaccounted" msgid="5647345548624995064">"El uso de la batería es un cálculo aproximado del uso de energía y no incluye todas las fuentes de consumo de batería. El uso variado es la diferencia entre el uso de energía variado computado y el consumo real observado en la batería."</string>
    <string name="battery_desc_overcounted" msgid="5982079150027267539">"Uso de potencia sobrecalculada"</string>
    <string name="mah" msgid="3604527474433227780">"<xliff:g id="NUMBER">%d</xliff:g> mAh"</string>
    <string name="battery_used_for" msgid="6401552215008504483">"Se usó durante <xliff:g id="TIME">^1</xliff:g>"</string>
    <string name="battery_active_for" msgid="4416277218863232476">"Activa durante <xliff:g id="TIME">^1</xliff:g>"</string>
    <string name="battery_screen_usage" msgid="90008745183187461">"Uso de la pantalla: <xliff:g id="TIME">^1</xliff:g>"</string>
    <string name="battery_used_by" msgid="6457305178016189330">"<xliff:g id="PERCENT">%1$s</xliff:g> usado por <xliff:g id="APP">%2$s</xliff:g>"</string>
    <string name="battery_overall_usage" msgid="8940140259734182014">"<xliff:g id="PERCENT">%1$s</xliff:g> de la batería total"</string>
    <string name="battery_detail_since_full_charge" msgid="5650946565524184582">"Desglose desde la última carga completa"</string>
    <string name="battery_last_full_charge" msgid="8308424441475063956">"Última carga completa"</string>
    <string name="battery_full_charge_last" msgid="465146408601016923">"La carga completa dura aproximadamente"</string>
    <string name="battery_footer_summary" msgid="9125397752380281832">"Los datos sobre la duración de la batería son aproximados y pueden cambiar en función del uso"</string>
    <string name="battery_detail_foreground" msgid="3312280147931093967">"Durante el uso activo"</string>
    <string name="battery_detail_background" msgid="3333915023706228000">"Mientras se ejecuta en segundo plano"</string>
    <string name="battery_detail_power_usage" msgid="1492926471397355477">"Uso de la batería"</string>
    <string name="battery_detail_info_title" msgid="5896661833554333683">"Desde la última carga completa"</string>
    <string name="battery_detail_manage_title" msgid="7910805419446927887">"Administrar el uso de la batería"</string>
    <string name="advanced_battery_graph_subtext" msgid="6816737986172678550">"El cálculo de batería restante se basa en el uso del dispositivo"</string>
    <string name="estimated_time_left" msgid="948717045180211777">"Tiempo restante estimado"</string>
    <string name="estimated_charging_time_left" msgid="2287135413363961246">"Para completar la carga"</string>
    <string name="estimated_time_description" msgid="211058785418596009">"La estimación puede cambiar en función del uso"</string>
    <string name="menu_stats_unplugged" msgid="7125297366200634285">"<xliff:g id="UNPLUGGED">%1$s</xliff:g> desde que se desconectó"</string>
    <string name="menu_stats_last_unplugged" msgid="230678127178268655">"Durante la última desconexión para <xliff:g id="UNPLUGGED">%1$s</xliff:g>"</string>
    <string name="menu_stats_total" msgid="2713445396954503670">"Total de usos"</string>
    <string name="menu_stats_refresh" msgid="6727628139586938835">"Actualizar"</string>
    <string name="process_mediaserver_label" msgid="6135260215912215092">"Servidor de medios"</string>
    <string name="process_dex2oat_label" msgid="1190208677726583153">"Optimización de las aplicaciones"</string>
    <string name="battery_saver" msgid="7737147344510595864">"Ahorro de batería"</string>
    <string name="battery_saver_auto_title" msgid="6789753787070176144">"Activar automáticamente"</string>
    <string name="battery_saver_auto_no_schedule" msgid="5123639867350138893">"Sin programa"</string>
    <string name="battery_saver_auto_routine" msgid="4656495097900848608">"Según tu rutina"</string>
    <string name="battery_saver_auto_percentage" msgid="558533724806281980">"Según el porcentaje"</string>
    <string name="battery_saver_auto_routine_summary" msgid="3913145448299472628">"Se activará el Ahorro de batería si es probable que tu batería esté por agotarse antes de la hora en que sueles cargarla"</string>
    <string name="battery_saver_auto_percentage_summary" msgid="6190884450723824287">"Se activará cuando quede <xliff:g id="PERCENT">%1$s</xliff:g>"</string>
    <string name="battery_saver_schedule_settings_title" msgid="3688019979950082237">"Establecer un programa"</string>
    <string name="battery_saver_turn_on_summary" msgid="1433919417587171160">"Extender la duración de la batería"</string>
    <string name="battery_saver_sticky_title_new" msgid="5942813274115684599">"Desactivar después de la carga"</string>
    <string name="battery_saver_sticky_description_new" product="default" msgid="4969508893424116609">"El Ahorro de batería se desactiva cuando el teléfono tiene más del <xliff:g id="PERCENT">%1$s</xliff:g> de carga"</string>
    <string name="battery_saver_sticky_description_new" product="tablet" msgid="6613068787945311001">"El Ahorro de batería se desactiva cuando la tablet tiene más del <xliff:g id="PERCENT">%1$s</xliff:g> de carga"</string>
    <string name="battery_saver_sticky_description_new" product="device" msgid="8707774542183385479">"El Ahorro de batería se desactiva cuando el dispositivo tiene más del <xliff:g id="PERCENT">%1$s</xliff:g> de carga"</string>
    <!-- no translation found for battery_saver_seekbar_title (3712266470054006641) -->
    <skip />
    <string name="battery_saver_seekbar_title_placeholder" msgid="7141264642540687540">"Activar"</string>
    <string name="battery_saver_master_switch_title" msgid="3474312070095834915">"Usar la función Ahorro de batería"</string>
    <string name="battery_saver_turn_on_automatically_title" msgid="7857393318205740864">"Activar automáticamente"</string>
    <string name="battery_saver_turn_on_automatically_never" msgid="6194649389871448663">"Nunca"</string>
    <string name="battery_saver_turn_on_automatically_pct" msgid="4294335680892392449">"con <xliff:g id="PERCENT">%1$s</xliff:g> de batería"</string>
    <string name="battery_percentage" msgid="1779934245963043490">"Porcentaje de batería"</string>
    <string name="battery_percentage_description" msgid="2321465139126125541">"Mostrar el porcentaje de la batería en la barra de estado"</string>
    <string name="process_stats_summary_title" msgid="502683176231281732">"Estadísticas de procesos"</string>
    <string name="process_stats_summary" msgid="522842188571764699">"Estadísticas para geeks sobre procesos activos"</string>
    <string name="app_memory_use" msgid="7559666138324410666">"Uso de memoria"</string>
    <string name="process_stats_total_duration" msgid="3898635541254636618">"Se usaron <xliff:g id="USEDRAM">%1$s</xliff:g> de <xliff:g id="TOTALRAM">%2$s</xliff:g> durante el último <xliff:g id="TIMEDURATION">%3$s</xliff:g>."</string>
    <string name="process_stats_total_duration_percentage" msgid="4391502694312709148">"Se usaron <xliff:g id="PERCENT">%1$s</xliff:g> de RAM durante <xliff:g id="TIMEDURATION">%2$s</xliff:g>."</string>
    <string name="process_stats_type_background" msgid="4094034441562453522">"En segundo plano"</string>
    <string name="process_stats_type_foreground" msgid="5043049335546793803">"En primer plano"</string>
    <string name="process_stats_type_cached" msgid="129788969589599563">"En caché"</string>
    <string name="process_stats_os_label" msgid="2096501347732184886">"Sistema operativo Android"</string>
    <string name="process_stats_os_native" msgid="794547105037548539">"Nativo"</string>
    <string name="process_stats_os_kernel" msgid="5626269994512354996">"Kernel"</string>
    <string name="process_stats_os_zram" msgid="3067278664868354143">"Zram"</string>
    <string name="process_stats_os_cache" msgid="4753163023524305711">"Memorias caché"</string>
    <string name="process_stats_ram_use" msgid="5966645638783509937">"Uso de RAM"</string>
    <string name="process_stats_bg_ram_use" msgid="3572439697306771461">"Uso de RAM (en segundo plano)"</string>
    <string name="process_stats_run_time" msgid="8631920944819076418">"Tiempo de ejecución"</string>
    <string name="processes_subtitle" msgid="5791138718719605724">"Procesos"</string>
    <string name="services_subtitle" msgid="9136741140730524046">"Servicios"</string>
    <string name="menu_proc_stats_duration" msgid="1249684566371309908">"Duración"</string>
    <string name="mem_details_title" msgid="8064756349669711949">"Detalles de la memoria"</string>
    <string name="menu_duration_3h" msgid="9202635114831885878">"3 horas"</string>
    <string name="menu_duration_6h" msgid="2843895006519153126">"6 horas"</string>
    <string name="menu_duration_12h" msgid="9206922888181602565">"12 horas"</string>
    <string name="menu_duration_1d" msgid="8538390358158862330">"1 día"</string>
    <string name="menu_show_system" msgid="3780310384799907818">"Mostrar sistema"</string>
    <string name="menu_hide_system" msgid="5197937451381420622">"Ocultar sistema"</string>
    <string name="menu_show_percentage" msgid="6143205879027928330">"Mostrar porcentajes"</string>
    <string name="menu_use_uss" msgid="1663914348353623749">"Usar USS"</string>
    <string name="menu_proc_stats_type" msgid="5048575824389855689">"Tipo de estadística"</string>
    <string name="menu_proc_stats_type_background" msgid="6796434633192284607">"En segundo plano"</string>
    <string name="menu_proc_stats_type_foreground" msgid="9011432748521890803">"En primer plano"</string>
    <string name="menu_proc_stats_type_cached" msgid="1351321959600144622">"En caché"</string>
    <string name="voice_input_output_settings" msgid="1055497319048272051">"Entrada y salida de voz"</string>
    <string name="voice_input_output_settings_title" msgid="6449454483955543064">"Configuración entrada y salida de voz"</string>
    <string name="voice_search_settings_title" msgid="228743187532160069">"Búsqueda por voz"</string>
    <string name="keyboard_settings_title" msgid="2199286020368890114">"Teclado de Android"</string>
    <string name="voice_input_settings" msgid="105821652985768064">"Configuración de entrada de voz"</string>
    <string name="voice_input_settings_title" msgid="3708147270767296322">"Entrada de voz"</string>
    <string name="voice_service_preference_section_title" msgid="4807795449147187497">"Servicios de entrada de voz"</string>
    <string name="voice_interactor_preference_summary" msgid="3942881638813452880">"Interacción y palabra clave completa"</string>
    <string name="voice_recognizer_preference_summary" msgid="9195427725367463336">"Voz a texto simple"</string>
    <string name="voice_interaction_security_warning" msgid="7962884055885987671">"Este servicio de entrada de voz puede supervisar que siempre esté activada la voz y controlar en tu nombre las aplicaciones que pueden utilizar la entrada de voz. Procede de <xliff:g id="VOICE_INPUT_SERVICE_APP_NAME">%s</xliff:g>. ¿Quieres habilitar el uso de este servicio?"</string>
    <string name="tts_engine_preference_title" msgid="7808775764174571132">"Motor preferido"</string>
    <string name="tts_engine_settings_title" msgid="1298093555056321577">"Configuración del motor"</string>
    <string name="tts_sliders_title" msgid="6901146958648426181">"Velocidad y tono de la voz"</string>
    <string name="tts_engine_section_title" msgid="5115035218089228451">"Motor"</string>
    <string name="tts_install_voice_title" msgid="5133545696447933812">"Voces"</string>
    <string name="tts_spoken_language" msgid="4652894245474520872">"Idioma de voz"</string>
    <string name="tts_install_voices_title" msgid="6505257816336165782">"Instalar voces"</string>
    <string name="tts_install_voices_text" msgid="902408506519246362">"Continúa a la app <xliff:g id="TTS_APP_NAME">%s</xliff:g> para instalar voces"</string>
    <string name="tts_install_voices_open" msgid="919034855418197668">"Abrir app"</string>
    <string name="tts_install_voices_cancel" msgid="5179154684379560628">"Cancelar"</string>
    <string name="tts_reset" msgid="9047681050813970031">"Restablecer"</string>
    <string name="tts_play" msgid="2945513377250757221">"Reproducir"</string>
    <string name="vpn_settings_title" msgid="9131315656202257272">"VPN"</string>
    <string name="adaptive_connectivity_title" msgid="7464959640138428192">"Conectividad Adaptable"</string>
    <string name="adaptive_connectivity_summary" msgid="3648731530666326885">"Extiende la duración de batería y mejora el rendimiento del dispositivo, ya que administra automáticamente las conexiones de red"</string>
    <string name="credentials_title" msgid="7535942196886123656">"Almacenamiento de credenciales"</string>
    <string name="credentials_install" msgid="3933218407598415827">"Instala un certificado"</string>
    <string name="credentials_install_summary" product="nosdcard" msgid="6644116499934553975">"Instalar certificados desde el almacenamiento"</string>
    <string name="credentials_install_summary" product="default" msgid="8161351950524166012">"Instalar certificados desde la tarjeta SD"</string>
    <string name="credentials_reset" msgid="4246628389366452655">"Borrar credenciales"</string>
    <string name="credentials_reset_summary" msgid="5400585520572874255">"Quitar todos los certificados"</string>
    <string name="trusted_credentials" msgid="2522784976058244683">"Credenciales de confianza"</string>
    <string name="trusted_credentials_summary" msgid="345822338358409468">"Mostrar certificados de CA de confianza"</string>
    <string name="user_credentials" msgid="4044405430790970775">"Credenciales de usuario"</string>
    <string name="user_credentials_summary" msgid="686471637627271856">"Ver y modificar las credenciales guardadas"</string>
    <string name="advanced_security_title" msgid="7117581975877192652">"Configuración avanzada"</string>
    <string name="credentials_settings_not_available" msgid="7433088409177429600">"Las credenciales no están disponibles para este usuario."</string>
    <string name="credential_for_vpn_and_apps" msgid="2208229692860871136">"Se instaló para redes VPN y apps"</string>
    <string name="credential_for_wifi" msgid="1963335263280604998">"Se instaló para redes Wi-Fi"</string>
    <string name="credentials_reset_hint" msgid="4054601857203464867">"¿Quieres quitar todas las credenciales?"</string>
    <string name="credentials_erased" msgid="9121052044566053345">"Credenciales borradas"</string>
    <string name="credentials_not_erased" msgid="3611058412683184031">"Imposible borrar almac credenc"</string>
    <string name="usage_access_title" msgid="1580006124578134850">"Acceso a datos de uso"</string>
    <string name="ca_certificate" msgid="3076484307693855611">"Certificado de CA"</string>
    <string name="user_certificate" msgid="6897024598058566466">"Cert. de usuario de app y VPN"</string>
    <string name="wifi_certificate" msgid="8461905432409380387">"Certificado de Wi‑Fi"</string>
    <string name="ca_certificate_warning_title" msgid="7951148441028692619">"Tus datos no serán privados"</string>
    <string name="ca_certificate_warning_description" msgid="3386740654961466569">"Los Certificados de CA permiten que los sitios web, las apps y las VPN puedan encriptar datos. Instala solo Certificados de CA de organizaciones que sean de confianza. \n\n Si instalas un Certificado de CA, el propietario podrá acceder a los datos (como contraseñas y detalles de tarjetas de crédito) que ingreses en sitios web que visites o apps que uses, incluso aunque la información esté encriptada."</string>
    <string name="certificate_warning_dont_install" msgid="3794366420884560605">"No instalar"</string>
    <string name="certificate_warning_install_anyway" msgid="4633118283407228740">"Instalar de todas formas"</string>
    <string name="cert_not_installed" msgid="6725137773549974522">"No se instaló el certificado"</string>
    <string name="request_manage_credentials_title" msgid="4524504926699928916">"¿Deseas permitir que <xliff:g id="APP_NAME">%s</xliff:g> instale certificados en este dispositivo?"</string>
    <string name="request_manage_credentials_description" msgid="4969609158022551952">"Estos certificados te identificarán en las siguientes apps y URL"</string>
    <string name="request_manage_credentials_dont_allow" msgid="3630610197644877809">"No permitir"</string>
    <string name="request_manage_credentials_allow" msgid="4910940118408348245">"Permitir"</string>
    <string name="request_manage_credentials_more" msgid="6101210283534101582">"Mostrar más"</string>
    <string name="certificate_management_app" msgid="8086699498358080826">"App administrada de certificados"</string>
    <string name="no_certificate_management_app" msgid="3025739370424406717">"Ninguna"</string>
    <string name="certificate_management_app_description" msgid="7257420502179110164">"Los certificados que instaló esta app te identifican con las siguientes aplicaciones y URL"</string>
    <string name="remove_credential_management_app" msgid="6879631067380232928">"Quitar"</string>
    <string name="emergency_tone_title" msgid="6673118505206685168">"Indicador de marcado de emergencia"</string>
    <string name="emergency_tone_summary" msgid="2519776254708767388">"Establecer el comportamiento cuando se establece una llamada de emergencia"</string>
    <string name="privacy_settings_title" msgid="6437057228255974577">"Copia de seguridad"</string>
    <string name="backup_summary_state_on" msgid="9018954639693085240">"Activado"</string>
    <string name="backup_summary_state_off" msgid="5341339397224835909">"Desactivado"</string>
    <string name="backup_section_title" msgid="6539706829848457794">"Crear copia de seguridad y Restablecer"</string>
    <string name="personal_data_section_title" msgid="6368610168625722682">"Datos personales"</string>
    <string name="backup_data_title" msgid="507663517227498525">"Hacer una copia de seguridad de mis datos"</string>
    <string name="backup_data_summary" msgid="8054551085241427531">"Crear copias de seguridad de los datos de distintas aplicaciones, de contraseñas Wi-Fi y de otros parámetros de configuración en los servidores de Google"</string>
    <string name="backup_configure_account_title" msgid="8574055186903658842">"Cuenta de copia de seguridad"</string>
    <string name="backup_data_management_title" msgid="6596830198441939702">"Administrar la cuenta de la copia de seguridad"</string>
    <string name="include_app_data_title" msgid="2969603876620594523">"Incluir datos de aplicación"</string>
    <string name="auto_restore_title" msgid="4124345897936637561">"Restaurar automáticamente"</string>
    <string name="auto_restore_summary" msgid="6830198851045584001">"Al reinstalar se restablece la configuración con copia de seguridad."</string>
    <string name="backup_inactive_title" msgid="6753265378043349277">"Servicio de copia de seguridad inactivo"</string>
    <string name="backup_configure_account_default_summary" msgid="5323225330966306690">"Ninguna cuenta está almacenando datos con copia de seguridad."</string>
    <string name="backup_erase_dialog_title" msgid="5892431263348766484"></string>
    <string name="backup_erase_dialog_message" msgid="2250872501409574331">"¿Quieres dejar de crear copias de seguridad de las contraseñas Wi-Fi, los favoritos, otros parámetros de configuración y los datos de distintas aplicaciones, además de eliminar todas las copias de los servidores de Google?"</string>
    <string name="fullbackup_erase_dialog_message" msgid="2379053988557486162">"¿Deseas dejar de crear copias de seguridad de los datos del dispositivo (como las contraseñas de Wi-Fi y el historial de llamadas) y de los datos de las aplicaciones (como las opciones de configuración y los archivos que guardaron las aplicaciones), y borrar todas las copias en servidores remotos?"</string>
    <string name="fullbackup_data_summary" msgid="971587401251601473">"Crear una copia de seguridad automática y remota de los datos del dispositivo (por ejemplo, contraseñas de Wi-Fi e historial de llamadas) y de los datos de las aplicaciones (por ejemplo, archivos y opciones de configuración que guardan las aplicaciones)\n\nCuando activas la copia de seguridad automática, los datos del dispositivo y las aplicaciones se guardan periódicamente de forma remota. Los datos de las aplicaciones pueden ser cualquier dato que guardó una aplicación (según la configuración del programador), incluso datos potencialmente confidenciales, como los contactos, los mensajes y las fotos."</string>
    <string name="device_admin_settings_title" msgid="31392408594557070">"Configuración del administrador del dispositivo"</string>
    <string name="active_device_admin_msg" msgid="7744106305636543184">"App de administración del dispositivo"</string>
    <string name="remove_device_admin" msgid="3143059558744287259">"Desactivar esta app de administración del dispositivo"</string>
    <string name="uninstall_device_admin" msgid="4481095209503956916">"Desinstalar app"</string>
    <string name="remove_and_uninstall_device_admin" msgid="707912012681691559">"Desactivar y desinstalar"</string>
    <string name="select_device_admin_msg" msgid="5501360309040114486">"Apps del dispositivo del administrador"</string>
    <string name="no_device_admins" msgid="8888779888103079854">"No hay apps de administración de dispositivo disponibles"</string>
    <string name="no_trust_agents" msgid="8659098725864191600">"No hay agentes de confianza disponibles."</string>
    <string name="add_device_admin_msg" msgid="7730006568970042119">"¿Activar la app de administración?"</string>
    <string name="add_device_admin" msgid="6252128813507932519">"Activar la app de administración de este dispositivo"</string>
    <string name="device_admin_add_title" msgid="6087481040932322289">"Administrador del dispositivo"</string>
    <string name="device_admin_warning" msgid="1889160106787280321">"Si activas esta app de administración, la app <xliff:g id="APP_NAME">%1$s</xliff:g> podrá realizar las siguientes operaciones:"</string>
    <string name="device_admin_warning_simplified" msgid="2715756519899116115">"<xliff:g id="APP_NAME">%1$s</xliff:g> administrará y supervisará este dispositivo."</string>
    <string name="device_admin_status" msgid="6332571781623084064">"Esta app de administración está activa y permite que la app <xliff:g id="APP_NAME">%1$s</xliff:g> realice las siguientes operaciones:"</string>
    <string name="profile_owner_add_title" msgid="2774489881662331549">"¿Activar el Administrador de perfiles?"</string>
    <string name="profile_owner_add_title_simplified" msgid="2320828996993774182">"¿Quieres permitir la supervisión?"</string>
    <string name="adding_profile_owner_warning" msgid="6868275476058020513">"Si continúas, el administrador controlará tu usuario y podrá almacenar datos asociados, además de tus datos personales.\n\nEl administrador puede controlar y administrar la configuración, el acceso, las apps, y los datos asociados con este usuario, incluida la información acerca de la actividad de red y la ubicación de tu dispositivo."</string>
    <string name="admin_disabled_other_options" msgid="8122039047419172139">"El administrador inhabilitó algunas opciones"</string>
    <string name="admin_more_details" msgid="6698424974827333973">"Más información"</string>
    <string name="notification_log_title" msgid="2812594935014664891">"Registro de notificaciones"</string>
    <string name="notification_history_title" msgid="8821060912502593309">"Historial de notificaciones"</string>
    <string name="notification_history_today" msgid="5828496957208237230">"Últimas 24 horas"</string>
    <string name="notification_history_snooze" msgid="3980568893290512257">"Se pospusieron"</string>
    <string name="notification_history_dismiss" msgid="6180321217375722918">"Se descartaron recientemente"</string>
    <plurals name="notification_history_count" formatted="false" msgid="1859304685071321991">
      <item quantity="other"><xliff:g id="NUMBER_1">%d</xliff:g> notificaciones</item>
      <item quantity="one"><xliff:g id="NUMBER_0">%d</xliff:g> notificación</item>
    </plurals>
    <string name="sound_category_call_ringtone_vibrate_title" msgid="9090693401915654528">"Vibración y tono de llamada"</string>
    <string name="wifi_setup_detail" msgid="2012898800571616422">"Detalles de la red"</string>
    <string name="accessibility_sync_enabled" msgid="5308864640407050209">"Sincronización habilitada"</string>
    <string name="accessibility_sync_disabled" msgid="5507600126380593611">"Sincronización inhabilitada"</string>
    <string name="accessibility_sync_in_progress" msgid="3229428197779196660">"Sincronizando ahora"</string>
    <string name="accessibility_sync_error" msgid="7248490045013170437">"Error de sincronización"</string>
    <string name="sync_failed" msgid="3806495232114684984">"Error de sincronización"</string>
    <string name="sync_active" msgid="5787407579281739975">"Sincronización activada"</string>
    <string name="account_sync_settings_title" msgid="2684888109902800966">"Sincronización"</string>
    <string name="sync_is_failing" msgid="6738004111400633331">"En este momento la sincronización experimenta problemas. Volverá en breve."</string>
    <string name="add_account_label" msgid="7134707140831385869">"Agregar cuenta"</string>
    <string name="managed_profile_not_available_label" msgid="7500578232182547365">"El perfil de trabajo aún no está disponible."</string>
    <string name="work_mode_label" msgid="1001415270126064436">"Perfil de trabajo"</string>
    <string name="work_mode_on_summary" msgid="2042885311126239961">"Administrado por tu organización"</string>
    <string name="work_mode_off_summary" msgid="4044568753909036134">"Las apps y las notificaciones están desactivadas"</string>
    <string name="remove_managed_profile_label" msgid="1294933737673830431">"Eliminar perfil de trabajo"</string>
    <string name="background_data" msgid="321903213000101158">"Datos de fondo"</string>
    <string name="background_data_summary" msgid="6572245922513522466">"Las aplicaciones pueden sincronizar, enviar y recibir datos."</string>
    <string name="background_data_dialog_title" msgid="1692005302993229867">"¿Deseas desactivar los datos en segundo plano?"</string>
    <string name="background_data_dialog_message" msgid="7760280837612824670">"Si inhabilitas los datos en segundo plano, aumenta la duración de la batería y se reduce el uso de datos. Algunas aplicaciones tal vez sigan usando la conexión de datos en segundo plano."</string>
    <string name="sync_automatically" msgid="4874122892765430304">"Autosincronizar datos de aplic."</string>
    <string name="sync_enabled" msgid="5794103781356455043">"Sincronización activada"</string>
    <string name="sync_disabled" msgid="1636223106968593391">"Sincronización desactivada"</string>
    <string name="sync_error" msgid="846923369794727644">"Error de sincronización"</string>
    <string name="last_synced" msgid="1527008461298110443">"Última sincronización: <xliff:g id="LAST_SYNC_TIME">%1$s</xliff:g>"</string>
    <string name="sync_in_progress" msgid="6200093151211458977">"Sincronizando…"</string>
    <string name="settings_backup" msgid="5357973563989458049">"Hacer una copia de seguridad de configuraciones"</string>
    <string name="settings_backup_summary" msgid="6803046376335724034">"Realizar copia de seguridad de mi configuración"</string>
    <string name="sync_menu_sync_now" msgid="3948443642329221882">"Sincronizar ahora"</string>
    <string name="sync_menu_sync_cancel" msgid="2422994461106269813">"Cancelar sincronización"</string>
    <string name="sync_one_time_sync" msgid="8114337154112057462">"Presiona para sincronizar ahora<xliff:g id="LAST_SYNC_TIME">
%1$s</xliff:g>"</string>
    <string name="sync_gmail" msgid="228561698646018808">"Gmail"</string>
    <string name="sync_calendar" msgid="4603704438090387251">"Calendario"</string>
    <string name="sync_contacts" msgid="2376465611511325472">"Contactos"</string>
    <string name="sync_plug" msgid="7956982719077985381"><font fgcolor="#ffffffff">"Te damos la bienvenida a Google Sync"</font>"  \nCon este software de Google, puedes sincronizar tus datos y acceder a tus contactos, citas y más desde cualquier lugar."</string>
    <string name="header_application_sync_settings" msgid="7427706834875419243">"Conf. de sincronización de aplicación"</string>
    <string name="header_data_and_synchronization" msgid="453920312552838939">"Sincronización y datos"</string>
    <string name="preference_change_password_title" msgid="5465821666939825972">"Cambiar contraseña"</string>
    <string name="header_account_settings" msgid="1189339410278750008">"Configuración de la cuenta"</string>
    <string name="remove_account_label" msgid="4169490568375358010">"Quitar cuenta"</string>
    <string name="header_add_an_account" msgid="3919151542338822661">"Agregar cuenta"</string>
    <string name="really_remove_account_title" msgid="253097435885652310">"¿Deseas eliminar la cuenta?"</string>
    <string name="really_remove_account_message" product="tablet" msgid="8893801622174947887">"Si eliminas esta cuenta, se borrarán todos sus mensajes, contactos y otros datos de la tablet."</string>
    <string name="really_remove_account_message" product="default" msgid="1217810840427479274">"Si eliminas esta cuenta, se borrarán todos sus mensajes, contactos y otros datos del dispositivo."</string>
    <string name="really_remove_account_message" product="device" msgid="5241756807386611084">"Si quitas esta cuenta, se borrarán todos sus mensajes, contactos y otros datos del dispositivo."</string>
    <string name="remove_account_failed" msgid="3709502163548900644">"El administrador no permite este cambio"</string>
    <string name="cant_sync_dialog_title" msgid="2613000568881139517">"No se puede sincronizar manualmente"</string>
    <string name="cant_sync_dialog_message" msgid="7612557105054568581">"La sincronización de este elemento actualmente está desactivada. Para cambiar tu configuración, activa momentáneamente los datos en segundo plano y la sincronización automática."</string>
    <string name="enter_password" msgid="6327051330258595331">"Para iniciar el dispositivo Android, ingresa la contraseña."</string>
    <string name="enter_pin" msgid="1029287617551232681">"Para iniciar el dispositivo Android, ingresa el PIN."</string>
    <string name="enter_pattern" msgid="1747316785866742960">"Para iniciar el dispositivo Android, dibuja el patrón."</string>
    <string name="cryptkeeper_wrong_pattern" msgid="340747269176120242">"Patrón incorrecto"</string>
    <string name="cryptkeeper_wrong_password" msgid="7295607881887114486">"Contraseña incorrecta"</string>
    <string name="cryptkeeper_wrong_pin" msgid="2347961593970714201">"PIN incorrecto"</string>
    <string name="checking_decryption" msgid="6111642972615688237">"Comprobando…"</string>
    <string name="starting_android" msgid="6694154070215356186">"Iniciando Android…"</string>
    <string name="delete" msgid="8330605554706263775">"Borrar"</string>
    <string name="misc_files" msgid="6598066985800749585">"Archivos variados"</string>
    <string name="misc_files_selected_count" msgid="5597802791672749532">"Se seleccionaron <xliff:g id="NUMBER">%1$d</xliff:g> de entre <xliff:g id="TOTAL">%2$d</xliff:g>."</string>
    <string name="misc_files_selected_count_bytes" msgid="7622766714974500289">"<xliff:g id="NUMBER">%1$s</xliff:g> de <xliff:g id="TOTAL">%2$s</xliff:g>"</string>
    <string name="select_all" msgid="7898929601615536401">"Seleccionar todo"</string>
    <string name="data_usage_summary_title" msgid="394067070764360142">"Uso de datos"</string>
    <string name="data_usage_app_summary_title" msgid="4933742247928064178">"Wi-Fi y datos móviles"</string>
    <string name="data_usage_accounting" msgid="6832015632699116754">"La forma en que el proveedor contabiliza los datos puede variar en tu dispositivo."</string>
    <string name="data_usage_app" msgid="6367974637783240699">"Uso de aplicaciones"</string>
    <string name="data_usage_app_info_label" msgid="3542220416056122841">"INFO. DE LA APLICACIÓN"</string>
    <string name="data_usage_cellular_data" msgid="1917226172511825849">"Datos móviles"</string>
    <string name="data_usage_data_limit" msgid="1120291692444009289">"Establecer límite de datos"</string>
    <string name="data_usage_cycle" msgid="6875568429140150029">"Ciclo de uso de datos"</string>
    <string name="data_usage_app_items_header_text" msgid="7513812163443595033">"Uso de aplicaciones"</string>
    <string name="data_usage_menu_roaming" msgid="6864561338842056939">"Roaming de datos"</string>
    <string name="data_usage_menu_restrict_background" msgid="1414574366645086133">"Restringir datos en 2.º plano"</string>
    <string name="data_usage_menu_allow_background" msgid="6242931073390680432">"Permitir datos 2.º plano"</string>
    <string name="data_usage_menu_split_4g" msgid="3391899816926640583">"Uso aparte de datos móviles 4G"</string>
    <string name="data_usage_menu_show_wifi" msgid="6380926350184939975">"Mostrar Wi-Fi"</string>
    <string name="data_usage_menu_hide_wifi" msgid="4694889089278302691">"Ocultar Wi-Fi"</string>
    <string name="data_usage_menu_show_ethernet" msgid="4401026240876938859">"Mostrar uso de Ethernet"</string>
    <string name="data_usage_menu_hide_ethernet" msgid="7792365022467586772">"Ocultar uso de Ethernet"</string>
    <string name="data_usage_menu_metered" msgid="4279260736172851951">"Restricciones de red"</string>
    <string name="data_usage_menu_auto_sync" msgid="2632694000068175025">"Sincronizar datos automáticamente"</string>
    <string name="data_usage_menu_sim_cards" msgid="8966135605336735887">"Tarjetas SIM"</string>
    <string name="data_usage_cellular_data_summary" msgid="8139993171126153316">"Pausado en el límite"</string>
    <string name="account_settings_menu_auto_sync" msgid="1660484779001900562">"Sincronización automática"</string>
    <string name="account_settings_menu_auto_sync_personal" msgid="2905595464540145671">"Sincronizar datos personales"</string>
    <string name="account_settings_menu_auto_sync_work" msgid="8561102487795657789">"Sincronizar datos de trabajo"</string>
    <string name="data_usage_change_cycle" msgid="4501026427365283899">"Cambiar el ciclo..."</string>
    <string name="data_usage_pick_cycle_day" msgid="3548922497494790123">"Día del mes para restablecer el ciclo de uso de datos:"</string>
    <string name="data_usage_empty" msgid="5619908658853726866">"Ninguna aplicación usó datos durante este período."</string>
    <string name="data_usage_label_foreground" msgid="8782117644558473624">"Primer plano"</string>
    <string name="data_usage_label_background" msgid="8862781660427421859">"Segundo plano"</string>
    <string name="data_usage_app_restricted" msgid="312065316274378518">"Restringido"</string>
    <string name="data_usage_disable_mobile" msgid="6183809500102606801">"¿Deseas desactivar los datos móviles?"</string>
    <string name="data_usage_disable_mobile_limit" msgid="1370147078938479538">"Establecer límite datos móviles"</string>
    <string name="data_usage_disable_4g_limit" msgid="3084868504051520840">"Establecer límite de datos en 4G"</string>
    <string name="data_usage_disable_3g_limit" msgid="8867555130268898044">"Establecer límite de datos 2G-3G"</string>
    <string name="data_usage_disable_wifi_limit" msgid="7222459951785404241">"Limitar datos de Wi-Fi"</string>
    <string name="data_usage_tab_wifi" msgid="801667863336456787">"Wi-Fi"</string>
    <string name="data_usage_tab_ethernet" msgid="2951873059375493878">"Ethernet"</string>
    <string name="data_usage_tab_mobile" msgid="952231704205870928">"Móvil"</string>
    <string name="data_usage_tab_4g" msgid="3265237821331861756">"4 GB"</string>
    <string name="data_usage_tab_3g" msgid="6111070409752123049">"2 GB - 3 GB"</string>
    <string name="data_usage_list_mobile" msgid="3738130489722964291">"Celulares"</string>
    <string name="data_usage_list_none" msgid="2091924522549134855">"Ninguna"</string>
    <string name="data_usage_enable_mobile" msgid="1996943748103310201">"Datos móviles"</string>
    <string name="data_usage_enable_3g" msgid="2818189799905446932">"Datos de 2 GB - 3 GB"</string>
    <string name="data_usage_enable_4g" msgid="1526584080251993023">"Datos de 4 GB"</string>
    <string name="data_roaming_enable_mobile" msgid="5745287603577995977">"Roaming"</string>
    <string name="data_usage_forground_label" msgid="5762048187044975428">"En primer plano:"</string>
    <string name="data_usage_background_label" msgid="5363718469293175279">"En segundo plano:"</string>
    <string name="data_usage_app_settings" msgid="5693524672522122485">"Configuración de la aplicación"</string>
    <string name="data_usage_app_restrict_background" msgid="5728840276368097276">"Datos en segundo plano"</string>
    <string name="data_usage_app_restrict_background_summary" msgid="2997942775999602794">"Habilitar el uso de datos móviles en segundo plano"</string>
    <string name="data_usage_app_restrict_background_summary_disabled" msgid="8213268097024597864">"Para restringir datos en 2.° plano aquí, limita datos móviles."</string>
    <string name="data_usage_app_restrict_dialog_title" msgid="5383874438677899255">"¿Restringir el uso de datos en segundo plano?"</string>
    <string name="data_usage_app_restrict_dialog" msgid="5534272311979978297">"Esta función puede hacer que deje de funcionar una aplicación que tenga que utilizar datos en segundo plano cuando solo estén disponibles redes móviles.\n\nPuedes encontrar controles de uso de datos más adecuados en las opciones de configuración disponibles en la aplicación."</string>
    <string name="data_usage_restrict_denied_dialog" msgid="8599940395497268584">"Solo se pueden restringir los datos en segundo plano si estableciste un límite de datos móviles."</string>
    <string name="data_usage_auto_sync_on_dialog_title" msgid="2048411447974361181">"¿Activar sinc. automática?"</string>
    <string name="data_usage_auto_sync_on_dialog" product="tablet" msgid="6387714350903085918">"Cualquier cambio que realices en tus cuentas en la Web se copiará automáticamente en la tablet.\n\nAlgunas cuentas también podrían copiar de forma automática en la Web los cambios que realices en la tablet. Una cuenta de Google funciona de esta manera."</string>
    <string name="data_usage_auto_sync_on_dialog" product="default" msgid="6457107552266187107">"Cualquier cambio que realices en tus cuentas en la Web se copiará automáticamente en el teléfono.\n\nAlgunas cuentas también podrían copiar de forma automática en la Web los cambios que realices en el teléfono. Una cuenta de Google funciona de esta manera."</string>
    <string name="data_usage_auto_sync_off_dialog_title" msgid="1783917145440587470">"¿Desactivar sinc. automática?"</string>
    <string name="data_usage_auto_sync_off_dialog" msgid="6523112583569674837">"Así ahorrarás datos y batería, pero tendrás que sincronizar cada cuenta manualmente para obtener información reciente y no recibirás notificaciones cuando haya actualizaciones."</string>
    <string name="data_usage_cycle_editor_title" msgid="2019035830921480941">"Elige el día de inicio de cada ciclo"</string>
    <string name="data_usage_cycle_editor_subtitle" msgid="1026234456777365545">"Día de cada mes:"</string>
    <string name="data_usage_cycle_editor_positive" msgid="6110165528024717527">"Configurar"</string>
    <string name="data_usage_warning_editor_title" msgid="5252748452973120016">"Configurar advertencia de uso de datos"</string>
    <string name="data_usage_limit_editor_title" msgid="8826855902435008518">"Configurar límite de uso de datos"</string>
    <string name="data_usage_limit_dialog_title" msgid="2053134451707801439">"Limitar el uso de datos"</string>
    <string name="data_usage_limit_dialog_mobile" product="tablet" msgid="6000062970083379466">"La tablet desactivará los datos móviles cuando alcance el límite especificado.\n\nRecuerda que los datos registrados por la tablet y el proveedor pueden ser diferentes. Trata de establecer un límite prudente."</string>
    <string name="data_usage_limit_dialog_mobile" product="default" msgid="4942895670789168024">"El teléfono desactivará los datos móviles cuando alcance el límite especificado.\n\nRecuerda que los datos registrados por el teléfono y el proveedor pueden ser diferentes. Trata de establecer un límite prudente."</string>
    <string name="data_usage_restrict_background_title" msgid="2745551538820692821">"¿Restringir el uso de datos en segundo plano?"</string>
    <string name="data_usage_restrict_background" msgid="1893102079135282794">"Si restringes los datos móviles en segundo plano, algunas apps y servicios no funcionarán a menos que te conectes a una red Wi-Fi."</string>
    <string name="data_usage_restrict_background_multiuser" product="tablet" msgid="5588623586867665419">"Si restringes los datos móviles en segundo plano, algunas apps y servicios no funcionarán a menos que te conectes a una red Wi-Fi.\n\nEsta configuración afecta a todos los usuarios de esta tablet."</string>
    <string name="data_usage_restrict_background_multiuser" product="default" msgid="6402714504088590463">"Si restringes los datos móviles en segundo plano, algunas apps y servicios no funcionarán a menos que te conectes a una red Wi-Fi.\n\nEsta configuración afecta a todos los usuarios de este teléfono."</string>
    <string name="data_usage_sweep_warning" msgid="2072854703184614828"><font size="18">"<xliff:g id="NUMBER">^1</xliff:g>"</font><font size="9">"<xliff:g id="UNIT">^2</xliff:g>"</font>\n<font size="12">"advertencia"</font></string>
    <string name="data_usage_sweep_limit" msgid="6947019190890086284"><font size="18">"<xliff:g id="NUMBER">^1</xliff:g>"</font>" "<font size="9">"<xliff:g id="UNIT">^2</xliff:g>"</font>\n<font size="12">"límite"</font></string>
    <string name="data_usage_uninstalled_apps" msgid="9065885396147675694">"Aplicaciones eliminadas"</string>
    <string name="data_usage_uninstalled_apps_users" msgid="1262228664057122983">"Aplicaciones y usuarios eliminados"</string>
    <string name="data_usage_received_sent" msgid="1486740779864806124">"<xliff:g id="RECEIVED">%1$s</xliff:g> recibidos, <xliff:g id="SENT">%2$s</xliff:g> enviados"</string>
    <string name="data_usage_total_during_range" msgid="2695893609573024612">"<xliff:g id="RANGE">%2$s</xliff:g>: se usaron unos <xliff:g id="TOTAL">%1$s</xliff:g>."</string>
    <string name="data_usage_total_during_range_mobile" product="tablet" msgid="45300375132284265">"<xliff:g id="RANGE">%2$s</xliff:g>: se usaron unos <xliff:g id="TOTAL">%1$s</xliff:g> según tu tablet. La medición de tu proveedor puede diferir."</string>
    <string name="data_usage_total_during_range_mobile" product="default" msgid="3183594094081558193">"<xliff:g id="RANGE">%2$s</xliff:g>: se usaron unos <xliff:g id="TOTAL">%1$s</xliff:g> según tu teléfono. La medición de tu proveedor puede diferir."</string>
    <string name="data_usage_metered_title" msgid="6421347352444253058">"Restricciones de red"</string>
    <string name="data_usage_metered_body" msgid="1206840367501998582">"Las redes medidas se consideran redes móviles cuando se restringen los datos en segundo plano. Es posible que las apps muestren una advertencia antes de usar estas redes para descargas de gran tamaño."</string>
    <string name="data_usage_metered_mobile" msgid="3514227339274396401">"Redes móviles"</string>
    <string name="data_usage_metered_wifi" msgid="4807465959110473407">"Redes Wi‑Fi medidas"</string>
    <string name="data_usage_metered_wifi_disabled" msgid="4664158157415362613">"Para seleccionar redes medidas, activa el Wi-Fi."</string>
    <string name="data_usage_metered_auto" msgid="1560514082131687116">"Automático"</string>
    <string name="wifi_metered_title" msgid="6623732965268033931">"Uso de red"</string>
    <string name="data_usage_metered_yes" msgid="4262598072030135223">"De uso medido"</string>
    <string name="data_usage_metered_no" msgid="1685828958417926268">"Sin uso medido"</string>
    <string name="data_usage_disclaimer" msgid="3271450299386176770">"La forma en que el proveedor calcula los datos puede variar en tu dispositivo."</string>
    <string name="cryptkeeper_emergency_call" msgid="8369322820475703306">"Llamada de emergencia"</string>
    <string name="cryptkeeper_return_to_call" msgid="3857250752781151232">"Regresar a llamada"</string>
    <string name="vpn_name" msgid="3806456074909253262">"Nombre"</string>
    <string name="vpn_type" msgid="5533202873260826663">"Tipo"</string>
    <string name="vpn_server" msgid="2908816134941973935">"Dirección del servidor"</string>
    <string name="vpn_mppe" msgid="7366657055055114239">"Encriptación de PPP (MPPE)"</string>
    <string name="vpn_l2tp_secret" msgid="2356744369959140121">"L2TP secreto"</string>
    <string name="vpn_ipsec_identifier" msgid="8511842694369254801">"Identificador IPSec"</string>
    <string name="vpn_ipsec_secret" msgid="532007567355505963">"Clave de IPSec compartida previamente"</string>
    <string name="vpn_ipsec_user_cert" msgid="2714372103705048405">"Certificado de usuario IPSec"</string>
    <string name="vpn_ipsec_ca_cert" msgid="5558498943577474987">"Certificado de CA de IPSec"</string>
    <string name="vpn_ipsec_server_cert" msgid="1411390470454731396">"Certificado de servidor IPSec"</string>
    <string name="vpn_show_options" msgid="6105437733943318667">"Mostrar opciones avanzadas"</string>
    <string name="vpn_search_domains" msgid="1973799969613962440">"Dominios de búsqueda de DNS"</string>
    <string name="vpn_dns_servers" msgid="6505263074417737107">"Servidores DNS (por ejemplo, 8.8.8.8)"</string>
    <string name="vpn_routes" msgid="1218707725375594862">"Rutas de reenvío (por ejemplo, 10.0.0.0/8)"</string>
    <string name="vpn_username" msgid="8671768183475960068">"Nombre de usuario"</string>
    <string name="vpn_password" msgid="1183746907642628127">"Contraseña"</string>
    <string name="vpn_save_login" msgid="5986762519977472618">"Guardar información de la cuenta"</string>
    <string name="vpn_not_used" msgid="7229312881336083354">"(No se utiliza)"</string>
    <string name="vpn_no_ca_cert" msgid="3687379414088677735">"(no verificar el servidor)"</string>
    <string name="vpn_no_server_cert" msgid="8106540968643125407">"(recibido desde el servidor)"</string>
    <string name="vpn_always_on_invalid_reason_type" msgid="4699113710248872972">"Este tipo de VPN no puede permanecer conectada todo el tiempo"</string>
    <string name="vpn_always_on_invalid_reason_server" msgid="2635347740046212693">"VPN siempre activada solo es compatible con direcciones de servidor numéricas"</string>
    <string name="vpn_always_on_invalid_reason_no_dns" msgid="3980357762395272467">"Debe especificarse un servidor DNS para VPN siempre activada"</string>
    <string name="vpn_always_on_invalid_reason_dns" msgid="3934369594591801587">"Las direcciones de servidor DNS deben ser numéricas para VPN siempre activada"</string>
    <string name="vpn_always_on_invalid_reason_other" msgid="4571905303713233321">"La información ingresada no es compatible con VPN siempre activada"</string>
    <string name="vpn_cancel" msgid="5929410618112404383">"Cancelar"</string>
    <string name="vpn_done" msgid="5137858784289564985">"Ignorar"</string>
    <string name="vpn_save" msgid="683868204634860888">"Guardar"</string>
    <string name="vpn_connect" msgid="7102335248484045354">"Conectar"</string>
    <string name="vpn_replace" msgid="1533147558671640341">"Reemplazar"</string>
    <string name="vpn_edit" msgid="5862301148429324911">"Editar perfil de VPN"</string>
    <string name="vpn_forget" msgid="2913950864877236737">"Olvidar"</string>
    <string name="vpn_connect_to" msgid="216709261691085594">"Conectar a <xliff:g id="PROFILE">%s</xliff:g>"</string>
    <string name="vpn_disconnect_confirm" msgid="6356789348816854539">"¿Deseas desconectar esta VPN?"</string>
    <string name="vpn_disconnect" msgid="7753808961085867345">"Desconectar"</string>
    <string name="vpn_version" msgid="41856553718304367">"Versión <xliff:g id="VERSION">%s</xliff:g>"</string>
    <string name="vpn_forget_long" msgid="729132269203870205">"Borrar VPN"</string>
    <string name="vpn_replace_vpn_title" msgid="3994226561866340280">"¿Reemplazar VPN existente?"</string>
    <string name="vpn_set_vpn_title" msgid="1667539483005810682">"¿Configurar la VPN siempre activa?"</string>
    <string name="vpn_first_always_on_vpn_message" msgid="2769478310633047870">"Si activas esta opción de configuración, no tendrás conexión a Internet hasta que se conecte la VPN"</string>
    <string name="vpn_replace_always_on_vpn_enable_message" msgid="9154843462740876652">"Se reemplazará la VPN actual y no tendrás conexión a Internet hasta que se conecte la nueva VPN"</string>
    <string name="vpn_replace_always_on_vpn_disable_message" msgid="4299175336198481106">"Ya estás conectado a una VPN siempre activa. Si te conectas a otra, se reemplazará la VPN actual y se desactivará el modo siempre activo."</string>
    <string name="vpn_replace_vpn_message" msgid="1094297700371463386">"Ya estás conectado a una VPN. Si te conectas a otra, se reemplazará la VPN actual."</string>
    <string name="vpn_turn_on" msgid="3568307071295211187">"Activar"</string>
    <string name="vpn_cant_connect_title" msgid="5670787575925519386">"No se puede establecer conexión con <xliff:g id="VPN_NAME">%1$s</xliff:g>"</string>
    <string name="vpn_cant_connect_message" msgid="2139148820719163694">"Esta app no es compatible con VPN siempre activada"</string>
    <string name="vpn_title" msgid="3068868814145870274">"VPN"</string>
    <string name="vpn_create" msgid="7546073242936894638">"Agregar perfil VPN"</string>
    <string name="vpn_menu_edit" msgid="5100387853773792379">"Modificar perfil"</string>
    <string name="vpn_menu_delete" msgid="4455966182219039928">"Borrar perfil"</string>
    <string name="vpn_menu_lockdown" msgid="5284041663859541007">"VPN siempre activada"</string>
    <string name="vpn_no_vpns_added" msgid="7387080769821533728">"No se agregó ninguna VPN"</string>
    <string name="vpn_always_on_summary" msgid="2171252372476858166">"Mantente siempre conectado a una VPN"</string>
    <string name="vpn_always_on_summary_not_supported" msgid="9084872130449368437">"La opción no es compatible con esta app"</string>
    <string name="vpn_always_on_summary_active" msgid="2532123735674813569">"La opción Siempre activa está habilitada"</string>
    <string name="vpn_require_connection" msgid="1027347404470060998">"Bloquear conexiones sin VPN"</string>
    <string name="vpn_require_connection_title" msgid="4186758487822779039">"¿Requerir una conexión VPN?"</string>
    <string name="vpn_lockdown_summary" msgid="4700625960550559029">"Selecciona el perfil de la VPN con la que deseas establecer una conexión ininterrumpida. El tráfico de red solo se permitirá cuando estés conectado a esta VPN."</string>
    <string name="vpn_lockdown_none" msgid="455915403560910517">"Ninguna"</string>
    <string name="vpn_lockdown_config_error" msgid="1992071316416371316">"La VPN siempre activada requiere una dirección IP tanto para el servidor como para el DNS."</string>
    <string name="vpn_no_network" msgid="7187593680049843763">"No hay conexión de red. Inténtalo de nuevo más tarde."</string>
    <string name="vpn_disconnected" msgid="7694522069957717501">"Desconectado de la VPN"</string>
    <string name="vpn_disconnected_summary" msgid="721699709491697712">"Ninguna"</string>
    <string name="vpn_missing_cert" msgid="5397309964971068272">"Falta un certificado. Edita el perfil."</string>
    <string name="trusted_credentials_system_tab" msgid="675362923690364722">"Sistema"</string>
    <string name="trusted_credentials_user_tab" msgid="4978365619630094339">"Usuario"</string>
    <string name="trusted_credentials_disable_label" msgid="6649583220519447947">"Inhabilitar"</string>
    <string name="trusted_credentials_enable_label" msgid="5551204878588237991">"Activar"</string>
    <string name="trusted_credentials_remove_label" msgid="8975881053042174913">"Eliminar"</string>
    <string name="trusted_credentials_trust_label" msgid="4841047312274452474">"Confiar"</string>
    <string name="trusted_credentials_enable_confirmation" msgid="6686528499458144754">"¿Deseas activar el certificado de CA del sistema?"</string>
    <string name="trusted_credentials_disable_confirmation" msgid="5131642563381656676">"¿Deseas desactivar el certificado de CA del sistema?"</string>
    <string name="trusted_credentials_remove_confirmation" msgid="3420345440353248381">"¿Deseas eliminar de forma permanente el certificado de CA del usuario?"</string>
    <string name="credential_contains" msgid="407972262032275476">"Esta entrada contiene lo siguiente:"</string>
    <string name="one_userkey" msgid="4417212932385103517">"una clave de usuario"</string>
    <string name="one_usercrt" msgid="1865069301105101370">"un certificado de usuario"</string>
    <string name="one_cacrt" msgid="7467796501404158399">"un Certificado de CA"</string>
    <string name="n_cacrts" msgid="5886462550192731627">"%d Certificados de CA"</string>
    <string name="user_credential_title" msgid="4686178602575567298">"Detalles de las credenciales"</string>
    <string name="user_credential_removed" msgid="4087675887725394743">"Credencial quitada: <xliff:g id="CREDENTIAL_NAME">%s</xliff:g>"</string>
    <string name="user_credential_none_installed" msgid="918620912366836994">"No se instalaron credenciales de usuario"</string>
    <string name="spellcheckers_settings_title" msgid="2799021700580591443">"Corrector ortográfico"</string>
    <string name="spellcheckers_settings_for_work_title" msgid="6471603934176062893">"Corrector ortográfico para el trabajo"</string>
    <string name="current_backup_pw_prompt" msgid="4962276598546381140">"Escribe tu contraseña actual de copia de seguridad completa aquí."</string>
    <string name="new_backup_pw_prompt" msgid="4884439230209419503">"Escribe una nueva contraseña para copias de seguridad completas."</string>
    <string name="confirm_new_backup_pw_prompt" msgid="5753796799743881356">"Vuelve a escribir aquí tu nueva contraseña de copia de seguridad completa."</string>
    <string name="backup_pw_set_button_text" msgid="8892357974661340070">"Definir contraseña de copia de seguridad"</string>
    <string name="backup_pw_cancel_button_text" msgid="2244399819018756323">"Cancelar"</string>
    <string name="additional_system_update_settings_list_item_title" msgid="7230385345152138051">"Actualizaciones del sistema adicionales"</string>
    <string name="ssl_ca_cert_warning" msgid="3898387588657346106">"Es posible que la red esté supervisada"</string>
    <string name="done_button" msgid="6269449526248267">"Listo"</string>
    <plurals name="ssl_ca_cert_dialog_title" formatted="false" msgid="5491460811755938449">
      <item quantity="other">Confiar o quitar certificados</item>
      <item quantity="one">Confiar o quitar certificado</item>
    </plurals>
    <plurals name="ssl_ca_cert_info_message_device_owner" formatted="false" msgid="2788832560436163252">
      <item quantity="other"><xliff:g id="MANAGING_DOMAIN_1">%s</xliff:g> instaló autoridades de certificación en tu dispositivo que permiten controlar la actividad de red en él, lo que incluye los correos electrónicos, las apps y los sitios web seguros.\n\nComunícate con el administrador para obtener más información sobre las certificaciones.</item>
      <item quantity="one"><xliff:g id="MANAGING_DOMAIN_0">%s</xliff:g> instaló una autoridad de certificación en tu dispositivo que permite controlar la actividad de red en él, lo que incluye los correos electrónicos, las apps y los sitios web seguros.\n\nComunícate con el administrador para obtener más información sobre la certificación.</item>
    </plurals>
    <plurals name="ssl_ca_cert_info_message" formatted="false" msgid="3989916958347169622">
      <item quantity="other"><xliff:g id="MANAGING_DOMAIN_1">%s</xliff:g> instaló autoridades de certificación para tu perfil de trabajo que permiten controlar la actividad de tu red de trabajo, lo que incluye los correos electrónicos, las apps y los sitios web seguros.\n\nComunícate con el administrador para obtener más información sobre las certificaciones.</item>
      <item quantity="one"><xliff:g id="MANAGING_DOMAIN_0">%s</xliff:g> instaló una autoridad de certificación para tu perfil de trabajo que permite controlar la actividad de tu red de trabajo, lo que incluye los correos electrónicos, las apps y los sitios web seguros.\n\nComunícate con el administrador para obtener más información sobre la certificación.</item>
    </plurals>
    <string name="ssl_ca_cert_warning_message" msgid="4374052724815563051">"Un tercero puede supervisar tu actividad en la red, incluido el correo electrónico, las aplicaciones y los sitios web seguros.\n\nEsto ocurre porque hay una credencial de confianza instalada en el dispositivo."</string>
    <plurals name="ssl_ca_cert_settings_button" formatted="false" msgid="125941406175485894">
      <item quantity="other">Revisar certificados</item>
      <item quantity="one">Revisar certificado</item>
    </plurals>
    <string name="user_settings_title" msgid="6550866465409807877">"Varios usuarios"</string>
    <string name="user_settings_footer_text" product="device" msgid="7523914344521302179">"Agrega nuevos usuarios para compartir tu dispositivo. Cada usuario tendrá un espacio propio en el dispositivo con pantalla principal, cuentas, apps y opciones de configuración personalizadas, y mucho más."</string>
    <string name="user_settings_footer_text" product="tablet" msgid="3730074318510244552">"Agrega nuevos usuarios para compartir tu tablet. Cada usuario tendrá un espacio propio en la tablet con pantalla principal, cuentas, apps y opciones de configuración personalizadas, y mucho más."</string>
    <string name="user_settings_footer_text" product="default" msgid="4420915712050349125">"Agrega nuevos usuarios para compartir tu teléfono. Cada usuario tendrá un espacio propio en el teléfono con pantalla principal, cuentas, apps y opciones de configuración personalizadas, y mucho más."</string>
    <string name="user_list_title" msgid="1387379079186123404">"Usuarios y perfiles"</string>
    <string name="user_add_user_or_profile_menu" msgid="305851380425838287">"Agregar usuario o perfil"</string>
    <string name="user_add_user_menu" msgid="6395904234221724625">"Agregar usuario"</string>
    <string name="user_summary_restricted_profile" msgid="451650609582185813">"Perfil restringido"</string>
    <string name="user_summary_not_set_up" msgid="4602868481732886115">"No configurado"</string>
    <string name="user_summary_restricted_not_set_up" msgid="1658946988920104613">"Sin configurar - Perfil restringido"</string>
    <string name="user_summary_managed_profile_not_set_up" msgid="5739207307082458746">"Sin configurar: perfil de trabajo"</string>
    <string name="user_admin" msgid="4024553191395768119">"Administrador"</string>
    <string name="user_you" msgid="3070562015202859996">"Tú (<xliff:g id="NAME">%s</xliff:g>)"</string>
    <string name="user_add_max_count" msgid="5739771048517070983">"Puedes agregar hasta <xliff:g id="USER_COUNT">%1$d</xliff:g> usuarios"</string>
    <string name="user_cannot_manage_message" product="tablet" msgid="3405022988077682357">"Solo los propietarios de la tablet pueden administrar los usuarios."</string>
    <string name="user_cannot_manage_message" product="default" msgid="6434662649769855494">"Solo los propietarios del dispositivo pueden administrar los usuarios."</string>
    <string name="user_cannot_add_accounts_message" msgid="2351326078338805337">"Los perfiles restringidos no pueden agregar cuentas."</string>
    <string name="user_remove_user_menu" msgid="2183714948094429367">"Borrar a <xliff:g id="USER_NAME">%1$s</xliff:g> del disp."</string>
    <string name="user_lockscreen_settings" msgid="4596612658981942092">"Configuración de pantalla bloqueada"</string>
    <string name="user_add_on_lockscreen_menu" msgid="2539059062034644966">"Agregar usuarios desde la pantalla de bloqueo"</string>
    <string name="user_confirm_remove_self_title" msgid="926265330805361832">"¿Deseas borrarte a ti mismo?"</string>
    <string name="user_confirm_remove_title" msgid="3626559103278006002">"¿Borrar este usuario?"</string>
    <string name="user_profile_confirm_remove_title" msgid="3131574314149375354">"¿Eliminar este perfil?"</string>
    <string name="work_profile_confirm_remove_title" msgid="6229618888167176036">"¿Eliminar perfil trabajo?"</string>
    <string name="user_confirm_remove_self_message" product="tablet" msgid="439222554798995592">"Perderás tu espacio y tus datos en esta tablet. No puedes deshacer esta acción."</string>
    <string name="user_confirm_remove_self_message" product="default" msgid="5991495192044543230">"Perderás tu espacio y tus datos en este dispositivo. No puedes deshacer esta acción."</string>
    <string name="user_confirm_remove_message" msgid="362545924965977597">"Se borrarán todas las aplicaciones y todos los datos."</string>
    <string name="work_profile_confirm_remove_message" msgid="1037294114103024478">"Si continúas, se borrarán todas las aplicaciones y los datos en este perfil."</string>
    <string name="user_profile_confirm_remove_message" msgid="3641289528179850718">"Se borrarán todas las aplicaciones y todos los datos."</string>
    <string name="user_adding_new_user" msgid="7439602720177181412">"Agregando usuario nuevo..."</string>
    <string name="user_delete_user_description" msgid="7764153465503821011">"Borrar usuario"</string>
    <string name="user_delete_button" msgid="3833498650182594653">"Borrar"</string>
    <string name="user_guest" msgid="4545590092001460388">"Invitado"</string>
    <string name="user_clear_guest_menu" msgid="4864362688187480452">"Borrar datos de invitado"</string>
    <string name="user_exit_guest_menu" msgid="5064400453222497734">"Finalizar sesión de invitado"</string>
    <string name="user_exit_guest_confirm_title" msgid="7526978959527761497">"¿Quieres finalizar la sesión de invitado?"</string>
    <string name="user_exit_guest_confirm_message" msgid="8995296853928816554">"Se eliminarán las aplicaciones y los datos de esta sesión."</string>
    <string name="user_exit_guest_dialog_remove" msgid="8095094235815676847">"Finalizar sesión"</string>
    <string name="user_enable_calling" msgid="264875360626905535">"Activar llamadas de teléfono"</string>
    <string name="user_enable_calling_sms" msgid="8546430559552381324">"Activar llamadas telefónicas y SMS"</string>
    <string name="user_remove_user" msgid="8468203789739693845">"Borrar usuario"</string>
    <string name="user_enable_calling_confirm_title" msgid="7868894792723368364">"¿Activar llamadas telefónicas?"</string>
    <string name="user_enable_calling_confirm_message" msgid="4924965198409050155">"Se compartirá el historial de llamadas con este usuario."</string>
    <string name="user_enable_calling_and_sms_confirm_title" msgid="4041510268838725520">"¿Activar llamadas telefónicas y SMS?"</string>
    <string name="user_enable_calling_and_sms_confirm_message" msgid="367792286597449922">"Se compartirá el historial de llamadas y SMS con este usuario."</string>
    <string name="emergency_info_title" msgid="8233682750953695582">"Información de emergencia"</string>
    <string name="emergency_info_summary" msgid="8463622253016757697">"Información y contactos de <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="application_restrictions" msgid="276179173572729205">"Permitir aplicaciones y contenido"</string>
    <string name="apps_with_restrictions_header" msgid="5277698582872267931">"Aplicaciones con restricciones"</string>
    <string name="apps_with_restrictions_settings_button" msgid="2648355133416902221">"Expandir config. a aplicación"</string>
    <string name="nfc_payment_settings_title" msgid="2043139180030485500">"Pagos sin contacto"</string>
    <string name="nfc_payment_how_it_works" msgid="3658253265242662010">"Cómo funciona"</string>
    <string name="nfc_payment_no_apps" msgid="6840001883471438798">"Paga en las tiendas con tu teléfono"</string>
    <string name="nfc_payment_default" msgid="3769788268378614608">"App de pagos predeterminada"</string>
    <string name="nfc_payment_default_not_set" msgid="6471905683119084622">"Sin establecer"</string>
    <string name="nfc_payment_app_and_desc" msgid="2607417639227030398">"<xliff:g id="APP">%1$s</xliff:g>: <xliff:g id="DESCRIPTION">%2$s</xliff:g>"</string>
    <string name="nfc_payment_use_default" msgid="788899906312142803">"Utilizar la aplicación predeterminada"</string>
    <string name="nfc_payment_favor_default" msgid="4508491832174644772">"Siempre"</string>
    <string name="nfc_payment_favor_open" msgid="8554643344050373346">"Excepto cuando esté abierta otra app de pagos"</string>
    <string name="nfc_payment_pay_with" msgid="3001320460566523453">"En una terminal para pagar sin contacto, utilizar:"</string>
    <string name="nfc_how_it_works_title" msgid="1363791241625771084">"Cómo pagar en la terminal"</string>
    <string name="nfc_how_it_works_content" msgid="1141382684788210772">"Configura una aplicación para efectuar pagos. A continuación, solo tienes que sostener la parte posterior del teléfono sobre cualquier terminal con el símbolo de pago sin contacto."</string>
    <string name="nfc_how_it_works_got_it" msgid="4717868843368296630">"Entendido"</string>
    <string name="nfc_more_title" msgid="1041094244767216498">"Más…"</string>
    <string name="nfc_payment_set_default_label" msgid="7395939287766230293">"Establecer app de pagos predeterminada"</string>
    <string name="nfc_payment_update_default_label" msgid="8201975914337221246">"Actualizar app de pagos predeterminada"</string>
    <string name="nfc_payment_set_default" msgid="4101484767872365195">"En una terminal para pagar sin contacto, usar <xliff:g id="APP">%1$s</xliff:g>"</string>
    <string name="nfc_payment_set_default_instead_of" msgid="565237441045013280">"En una terminal para pagar sin contacto, usa <xliff:g id="APP_0">%1$s</xliff:g>.\n\nEsto reemplazará a <xliff:g id="APP_1">%2$s</xliff:g> como la app de pagos predeterminada."</string>
    <string name="nfc_payment_btn_text_set_deault" msgid="1821065137209590196">"Establecer como predeterminada"</string>
    <string name="nfc_payment_btn_text_update" msgid="5159700960497443832">"Actualizar"</string>
    <string name="restriction_settings_title" msgid="4293731103465972557">"Restricciones"</string>
    <string name="restriction_menu_reset" msgid="92859464456364092">"Eliminar restricciones"</string>
    <string name="restriction_menu_change_pin" msgid="2505923323199003718">"Cambiar PIN"</string>
    <string name="help_label" msgid="2896538416436125883">"Ayuda y comentarios"</string>
    <string name="support_summary" msgid="1034146931237148885">"Artículos de ayuda, teléfono y chat, comenzar"</string>
    <string name="user_account_title" msgid="6389636876210834864">"Cuenta para contenido"</string>
    <string name="user_picture_title" msgid="7176437495107563321">"ID de foto"</string>
    <string name="extreme_threats_title" msgid="1098958631519213856">"Amenazas extremas"</string>
    <string name="extreme_threats_summary" msgid="3560742429496902008">"Recibir alertas de amenazas extremas contra la vida y propiedad"</string>
    <string name="severe_threats_title" msgid="8962959394373974324">"Amenazas graves"</string>
    <string name="severe_threats_summary" msgid="4982256198071601484">"Recibir alertas de amenazas graves contra la vida y la propiedad"</string>
    <string name="amber_alerts_title" msgid="5238275758191804575">"Alertas AMBER"</string>
    <string name="amber_alerts_summary" msgid="5755221775246075883">"Recibir boletines sobre secuestros de menores"</string>
    <string name="repeat_title" msgid="8676570486899483606">"Repetir"</string>
    <string name="call_manager_enable_title" msgid="1214301265395158720">"Habilitar el Administrador de llamadas"</string>
    <string name="call_manager_enable_summary" msgid="7362506369604163030">"Permitir que este servicio administre la forma de hacer llamadas"</string>
    <string name="call_manager_title" msgid="3397433159509629466">"Administrador de llamadas"</string>
    <!-- no translation found for call_manager_summary (2558839230880919191) -->
    <skip />
    <string name="cell_broadcast_settings" msgid="2416980110093867199">"Alertas de emergencia inalámbricas"</string>
    <string name="network_operators_settings" msgid="5105453353329748954">"Proveedores de red"</string>
    <string name="access_point_names" msgid="5768430498022188057">"Nombres de puntos de acceso"</string>
    <string name="enhanced_4g_lte_mode_title" msgid="6624700245232361149">"VoLTE"</string>
    <string name="enhanced_4g_lte_mode_title_advanced_calling" msgid="7066009898031465265">"Llamadas avanzadas"</string>
    <string name="enhanced_4g_lte_mode_title_4g_calling" msgid="7445853566718786195">"Llamadas mediante 4G"</string>
    <string name="enhanced_4g_lte_mode_summary" msgid="6776190202179584104">"Usa servicios de LTE para mejorar comunicaciones de voz y otras (recomendado)"</string>
    <string name="enhanced_4g_lte_mode_summary_4g_calling" msgid="7814006095552641136">"Usar servicios 4G para mejorar comunicaciones de voz y otras (recomendado)"</string>
    <string name="contact_discovery_opt_in_title" msgid="8708034790649773814">"Enviar contactos al proveedor"</string>
    <string name="contact_discovery_opt_in_summary" msgid="6539010458256667300">"Enviar los números de teléfono de tus contactos para brindar funciones mejoradas"</string>
    <string name="contact_discovery_opt_in_dialog_title" msgid="2230536282911854114">"¿Quieres enviar los contactos a <xliff:g id="CARRIER">%1$s</xliff:g>?"</string>
    <string name="contact_discovery_opt_in_dialog_title_no_carrier_defined" msgid="2028983133745990320">"¿Quieres enviar los contactos a tu proveedor?"</string>
    <string name="contact_discovery_opt_in_dialog_message" msgid="8818310894782757538">"Se enviarán regularmente a <xliff:g id="CARRIER">%1$s</xliff:g> los números de teléfono de tus contactos.<xliff:g id="EMPTY_LINE">

</xliff:g>Esta información te avisa si tus contactos pueden usar determinadas funciones, como videollamadas o mensajes."</string>
    <string name="contact_discovery_opt_in_dialog_message_no_carrier_defined" msgid="1914894516552445911">"Se enviarán regularmente a tu proveedor los números de teléfono de tus contactos.<xliff:g id="EMPTY_LINE">

</xliff:g>Esta información te avisa si tus contactos pueden usar determinadas funciones, como videollamadas o mensajes."</string>
    <string name="preferred_network_type_title" msgid="812509938714590857">"Tipo de red preferido"</string>
    <string name="preferred_network_type_summary" msgid="8786291927331323061">"LTE (recomendado)"</string>
    <string name="mms_message_title" msgid="6624505196063391964">"Mensajes MMS"</string>
    <string name="mms_message_summary" msgid="2855847140141698341">"Enviar y recibir con los datos móviles desactivados"</string>
    <string name="data_during_calls_title" msgid="3940276893360429144">"Uso de datos durante llamadas"</string>
    <string name="data_during_calls_summary" msgid="2289050189544214759">"Permitir el uso de esta SIM con datos móviles solo durante llamadas"</string>
    <string name="work_sim_title" msgid="8999872928646924429">"SIM de trabajo"</string>
    <string name="user_restrictions_title" msgid="4068914244980335993">"Acceso a aplicaciones y contenido"</string>
    <string name="user_rename" msgid="8735940847878484249">"CAMBIAR NOMBRE"</string>
    <string name="app_restrictions_custom_label" msgid="6949268049087435132">"Definir restricciones de aplicación"</string>
    <string name="user_restrictions_controlled_by" msgid="2821526006742851624">"Controladas por <xliff:g id="APP">%1$s</xliff:g>"</string>
    <string name="app_sees_restricted_accounts" msgid="3526008344222566318">"Esta aplicación puede acceder a tus cuentas."</string>
    <string name="app_sees_restricted_accounts_and_controlled_by" msgid="8338520379923447143">"Esta aplicación puede acceder a tus cuentas. Controlada por <xliff:g id="APP">%1$s</xliff:g>"</string>
    <string name="restriction_wifi_config_title" msgid="2630656989926554685">"Wi‑Fi y red de celulares"</string>
    <string name="restriction_wifi_config_summary" msgid="920419010472168694">"Permitir modificar la configuración de la red Wi‑Fi y de la red de celulares"</string>
    <string name="restriction_bluetooth_config_title" msgid="220586273589093821">"Bluetooth"</string>
    <string name="restriction_bluetooth_config_summary" msgid="7558879931011271603">"Permitir modificar la sincronización y configuración de Bluetooth"</string>
    <string name="restriction_nfc_enable_title" msgid="525512312298242911">"NFC"</string>
    <string name="restriction_nfc_enable_summary_config" msgid="8065688740509581028">"Permitir intercambio de datos cuando el dispositivo <xliff:g id="DEVICE_NAME">%1$s</xliff:g> toque otro dispositivo con NFC"</string>
    <string name="restriction_nfc_enable_summary" product="tablet" msgid="6397567147629410131">"Permitir el intercambio de datos cuando la tablet toque otro dispositivo"</string>
    <string name="restriction_nfc_enable_summary" product="default" msgid="3331800894734678808">"Permitir el intercambio de datos cuando el teléfono toque otro dispositivo"</string>
    <string name="restriction_location_enable_title" msgid="4872281754836538066">"Ubicación"</string>
    <string name="restriction_location_enable_summary" msgid="7139292323897390221">"Permitir que las aplicaciones usen la información de tu ubicación"</string>
    <string name="wizard_back" msgid="8257697435061870191">"Atrás"</string>
    <string name="wizard_next" msgid="3884832431439072471">"Siguiente"</string>
    <string name="wizard_finish" msgid="4220258401946825946">"Finalizar"</string>
    <string name="regulatory_info_text" msgid="1154461023369976667"></string>
    <string name="sim_setup_wizard_title" msgid="3945520353564138219">"Tarjetas SIM"</string>
    <string name="sim_settings_title" msgid="8392862852842113531">"Tarjetas SIM"</string>
    <string name="sim_settings_summary" msgid="5777472623476930332">"<xliff:g id="SIM_NAME">%1$s</xliff:g> (<xliff:g id="SIM_NUMBER">%2$s</xliff:g>)"</string>
    <string name="sim_cards_changed_message" msgid="7726897488921853655">"Las tarjetas SIM cambiaron."</string>
    <string name="sim_cards_changed_message_summary" msgid="7338082681445213621">"Presiona para establecer actividades"</string>
    <string name="sim_cellular_data_unavailable" msgid="4653591727755387534">"Datos móviles no disponibles"</string>
    <string name="sim_cellular_data_unavailable_summary" msgid="6505871722911347881">"Presiona para seleccionar una SIM de datos"</string>
    <string name="sim_calls_always_use" msgid="967857230039768111">"Usar siempre para llamadas"</string>
    <string name="select_sim_for_data" msgid="1577092784244587369">"Seleccionar SIM para datos"</string>
    <string name="select_sim_for_sms" msgid="5335510076282673497">"Selecciona una SIM para los SMS"</string>
    <string name="data_switch_started" msgid="6292759843974720112">"Cambiando SIM de datos. Este proceso puede demorar unos minutos…"</string>
    <string name="select_sim_for_calls" msgid="7843107015635189868">"Llamar con"</string>
    <string name="sim_select_card" msgid="1226182454109919045">"Seleccionar una tarjeta SIM"</string>
    <string name="sim_card_number_title" msgid="4728780444646439845">"SIM <xliff:g id="CARD_NUMBER">%1$d</xliff:g>"</string>
    <string name="sim_editor_name" msgid="5900178038499314621">"Nombre de SIM"</string>
    <string name="sim_name_hint" msgid="8231524869124193119">"Ingresar nombre de tarjeta SIM"</string>
    <string name="sim_editor_title" msgid="918655391915256859">"Ranura de SIM %1$d"</string>
    <string name="sim_editor_carrier" msgid="2424593350691002557">"Proveedor"</string>
    <string name="sim_editor_number" msgid="3209002966895156006">"Número"</string>
    <string name="sim_editor_color" msgid="9067029630083892961">"Color de SIM"</string>
    <string name="sim_card_select_title" msgid="8146523005929848793">"Seleccionar tarjeta SIM"</string>
    <string name="color_orange" msgid="216547825489739010">"Naranja"</string>
    <string name="color_purple" msgid="6603701972079904843">"Púrpura"</string>
    <string name="sim_no_inserted_msg" msgid="7272710974813741735">"No se insertó ninguna tarjeta SIM."</string>
    <string name="sim_status_title" msgid="6188770698037109774">"Estado de SIM"</string>
    <string name="sim_status_title_sim_slot" msgid="4932996839194493313">"Estado de SIM (ranura de SIM %1$d)"</string>
    <string name="sim_call_back_title" msgid="4274099761123657464">"Devolver la llamada desde la tarjeta SIM predeterminada"</string>
    <string name="sim_outgoing_call_title" msgid="7759080345748128897">"Tarjeta SIM para llamadas salientes"</string>
    <string name="sim_other_call_settings" msgid="5956308869284958883">"Otras configuraciones de llamada"</string>
    <string name="preferred_network_offload_title" msgid="6453199586512609557">"Aliger. de red preferido"</string>
    <string name="preferred_network_offload_header" msgid="4842188794016376899">"Inhab. mostrar nombre red"</string>
    <string name="preferred_network_offload_footer" msgid="374984523082849648">"Inhabilitar la opción para mostrar el nombre de red previene el acceso de terceros a su información."</string>
    <string name="preferred_network_offload_popup" msgid="3949937898807213370">"Inhabilitar la opción para mostrar el nombre de red previene la conexión automática a redes ocultas."</string>
    <string name="sim_signal_strength" msgid="6351052821700294501">"<xliff:g id="DBM">%1$d</xliff:g> dBm y <xliff:g id="ASU">%2$d</xliff:g> asu"</string>
    <string name="sim_notification_title" msgid="584752983048661108">"Tarjetas SIM modificadas"</string>
    <string name="sim_notification_summary" msgid="5593339846307029991">"Presiona para configurar"</string>
    <string name="sim_calls_ask_first_prefs_title" msgid="3077694594349657933">"Preguntar siempre"</string>
    <string name="sim_selection_required_pref" msgid="231437651041498359">"Selección requerida"</string>
    <string name="sim_selection_channel_title" msgid="3193666315607572484">"Selección de SIM"</string>
    <string name="dashboard_title" msgid="5660733037244683387">"Configuración"</string>
    <plurals name="settings_suggestion_header_summary_hidden_items" formatted="false" msgid="6585075562837786847">
      <item quantity="other">Mostrar %d elementos ocultos</item>
      <item quantity="one">Mostrar %d elemento oculto</item>
    </plurals>
    <string name="network_dashboard_title" msgid="788543070557731240">"Internet y redes"</string>
    <string name="network_dashboard_summary_mobile" msgid="4020746665765996480">"red móvil"</string>
    <string name="network_dashboard_summary_data_usage" msgid="2531133412846140766">"uso de datos"</string>
    <string name="network_dashboard_summary_hotspot" msgid="3798394197274240682">"hotspot"</string>
    <string name="connected_devices_dashboard_title" msgid="19868275519754895">"Dispositivos conectados"</string>
    <string name="connected_devices_dashboard_summary" msgid="6927727617078296491">"Bluetooth, En automóvil, NFC"</string>
    <string name="connected_devices_dashboard_no_nfc_summary" msgid="8424794257586524040">"Bluetooth, En automóvil"</string>
    <string name="connected_devices_dashboard_no_driving_mode_summary" msgid="7155882619333726331">"Bluetooth, NFC"</string>
    <string name="connected_devices_dashboard_no_driving_mode_no_nfc_summary" msgid="1175254057213044560">"Bluetooth"</string>
    <string name="connected_devices_dashboard_android_auto_summary" msgid="8179090809275818804">"Bluetooth, Android Auto, modo en automóvil, NFC"</string>
    <string name="connected_devices_dashboard_android_auto_no_nfc_summary" msgid="2532811870469405527">"Bluetooth, Android Auto, modo en automóvil"</string>
    <string name="connected_devices_dashboard_android_auto_no_driving_mode_summary" msgid="6426996842202276640">"Bluetooth, Android Auto, NFC"</string>
    <string name="connected_devices_dashboard_android_auto_no_nfc_no_driving_mode" msgid="1672426693308438634">"Bluetooth, Android Auto"</string>
    <string name="nfc_and_payment_settings_payment_off_nfc_off_summary" msgid="7132040463607801625">"No disponible porque la NFC está desactivada"</string>
    <string name="nfc_and_payment_settings_no_payment_installed_summary" msgid="4879818114908207465">"Para usar esta opción, debes instalar una app de pagos"</string>
    <string name="app_and_notification_dashboard_title" msgid="2861781687031832943">"Apps y notificaciones"</string>
    <string name="app_and_notification_dashboard_summary" msgid="8047683010984186106">"Apps recientes y predeterminadas"</string>
    <string name="notification_settings_work_profile" msgid="6076211850526353975">"Las apps del perfil de trabajo no tienen acceso a las notificaciones."</string>
    <string name="account_dashboard_title" msgid="2735150283267749852">"Cuentas"</string>
    <string name="account_dashboard_default_summary" msgid="2025250151574540063">"No se agregó ninguna cuenta"</string>
    <string name="app_default_dashboard_title" msgid="4071015747629103216">"Apps predeterminadas"</string>
    <string name="system_dashboard_summary" msgid="7400745270362833832">"Idiomas, gestos, hora, copia de seguridad"</string>
    <string name="search_results_title" msgid="3360639917793022533">"Configuración"</string>
    <string name="keywords_wifi" msgid="8156528242318351490">"Wi-Fi, wi-fi, conexión de red, Internet, inalámbrico, datos, wifi"</string>
    <string name="keywords_wifi_notify_open_networks" msgid="6580896556389306636">"notificación de Wi-Fi, notificación de wifi"</string>
    <string name="keywords_wifi_data_usage" msgid="4718555409695862085">"uso de datos"</string>
    <string name="keywords_vibrate_on_touch" msgid="8379369786860641429">"Detener vibración, presionar, teclado"</string>
    <string name="keywords_time_format" msgid="5384803098766166820">"Usar formato de 24 horas"</string>
    <string name="keywords_storage_files" msgid="4509695858659705198">"Descarga"</string>
    <string name="keywords_app_default" msgid="8977706259156428770">"Abrir con"</string>
    <string name="keywords_applications_settings" msgid="999926810912037792">"Apps"</string>
    <string name="keywords_time_zone" msgid="6402919157244589055">"zona horaria"</string>
    <string name="keywords_draw_overlay" msgid="3170036145197260392">"burbuja de chat, sistema, alerta, ventana, diálogo, mostrar, sobre otras apps, dibujo"</string>
    <string name="keywords_flashlight" msgid="2133079265697578183">"Linterna, luz"</string>
    <string name="keywords_change_wifi_state" msgid="7573039644328488165">"Wi-Fi, activar o desactivar, control"</string>
    <string name="keywords_more_mobile_networks" msgid="5041272719326831744">"celular, móvil, operador de telefonía celular, inalámbrico, datos, 4G, 3G, 2G, LTE"</string>
    <string name="keywords_wifi_calling" msgid="4319184318421027136">"wifi, wi-fi, llamar, llamada"</string>
    <string name="keywords_display" msgid="874738809280751745">"pantalla, pantalla táctil"</string>
    <string name="keywords_display_brightness_level" msgid="850742707616318056">"atenuar pantalla, pantalla táctil, batería, brillo"</string>
    <string name="keywords_display_night_display" msgid="4711054330804250058">"atenuar pantalla, luz nocturna, tono, modo nocturno, brillo, color de pantalla, color, colores"</string>
    <string name="keywords_display_wallpaper" msgid="8478137541939526564">"fondo, personalizar, personalizar pantalla"</string>
    <string name="keywords_display_font_size" msgid="3593317215149813183">"tamaño del texto"</string>
    <string name="keywords_display_cast_screen" msgid="2572331770299149370">"proyectar, transmitir, duplicar pantalla, compartir pantalla, duplicar pantalla compartida, transmitir pantalla"</string>
    <string name="keywords_storage" msgid="3004667910133021783">"espacio, disco, disco duro, uso de dispositivo"</string>
    <string name="keywords_battery" msgid="7040323668283600530">"uso de energía, carga"</string>
    <string name="keywords_spell_checker" msgid="5148906820603481657">"ortografía, diccionario, corrector ortográfico, corrección automática"</string>
    <string name="keywords_voice_input" msgid="7534900094659358971">"herramienta de reconocimiento, entrada, voz, hablar, idioma, manos libres, mano libre, reconocimiento, ofensiva, palabra, historial, audio, auriculares Bluetooth"</string>
    <string name="keywords_text_to_speech_output" msgid="6728080502619011668">"tarifa, idioma, predeterminado, hablar, texto a voz, accesibilidad, lector de pantalla, ciego"</string>
    <string name="keywords_date_and_time" msgid="4402136313104901312">"reloj, horario militar"</string>
    <string name="keywords_network_reset" msgid="4075670452112218042">"restablecer, configuración de fábrica"</string>
    <string name="keywords_factory_data_reset" msgid="4979623326958976773">"borrar, eliminar, restaurar, quitar, restablecer a la configuración de fábrica"</string>
    <string name="keywords_printing" msgid="3528250034669909466">"impresora"</string>
    <string name="keywords_sounds" msgid="1850691834585575875">"sonido de la bocina, bocina, volumen, silenciar, silencio, audio, música"</string>
    <string name="keywords_sounds_and_notifications_interruptions" msgid="1500312884808362467">"no interrumpir, interrumpir, interrupción, descanso"</string>
    <string name="keywords_app" msgid="7983814237980258061">"RAM"</string>
    <string name="keywords_location" msgid="8016374808099706213">"nearby, ubicación, historial, informe, GPS"</string>
    <string name="keywords_accounts" msgid="3482052586502133909">"cuenta, agregar una cuenta, perfil de trabajo, agregar cuenta"</string>
    <string name="keywords_users" msgid="3497517660077620843">"restricción, restringir, restringido"</string>
    <string name="keywords_keyboard_and_ime" msgid="4741098648730042570">"corrección de texto, corregir, sonido, vibrar, automático, idioma, gesto, sugerir, sugerencia, tema, ofensivo, palabra, tipo, emoji, internacional"</string>
    <string name="keywords_reset_apps" msgid="8254315757754930862">"restablecer, preferencias, predeterminadas"</string>
    <string name="keywords_all_apps" msgid="9016323378609007166">"apps, descarga, aplicaciones, sistema"</string>
    <string name="keywords_app_permissions" msgid="2061773665663541610">"apps, permisos, seguridad"</string>
    <string name="keywords_default_apps" msgid="4601664230800605416">"apps, predeterminado"</string>
    <string name="keywords_ignore_optimizations" msgid="8967142288569785145">"ignorar optimizaciones, descanso, app standby"</string>
    <string name="keywords_color_mode" msgid="1193896024705705826">"vibrante, RGB, sRGB, color, natural, estándar"</string>
    <string name="keywords_color_temperature" msgid="8159539138837118453">"color, temperatura, D65, D73, blanco, amarillo, azul, cálido, frío"</string>
    <string name="keywords_lockscreen" msgid="3656926961043485797">"desliza para desbloquear, contraseña, patrón, PIN"</string>
    <string name="keywords_app_pinning" msgid="1564144561464945019">"fijar pantalla"</string>
    <string name="keywords_profile_challenge" msgid="5135555521652143612">"desafíos de trabajo, trabajo, perfil"</string>
    <string name="keywords_unification" msgid="2677472004971453468">"perfil de trabajo, perfil administrado, unificar, unificación, trabajo, perfil"</string>
    <string name="keywords_gesture" msgid="3456930847450080520">"gestos"</string>
    <string name="keywords_cards_passes" msgid="4798102029412153067">"tarjetas, pases"</string>
    <string name="keywords_device_controls" msgid="8962494082504033651">"controles de dispositivos, controles"</string>
    <string name="keywords_payment_settings" msgid="6268791289277000043">"pagar, presionar, pagos"</string>
    <string name="keywords_backup" msgid="707735920706667685">"copia de seguridad, copia"</string>
    <string name="keywords_assist_gesture_launch" msgid="7710762655355161924">"gesto"</string>
    <string name="keywords_face_unlock" msgid="545338452730885392">"rostro, desbloqueo, autorización, acceder"</string>
    <string name="keywords_imei_info" msgid="8848791606402333514">"imei, meid, min, versión de prl, imei sv"</string>
    <string name="keywords_sim_status" msgid="8784456547742075508">"red, estado de la red móvil, estado del servicio, potencia de la señal, tipo de red móvil, roaming, iccid, eid"</string>
    <string name="keywords_model_and_hardware" msgid="4723665865709965044">"número de serie, versión de hardware"</string>
    <string name="keywords_android_version" msgid="1629882125290323070">"nivel de parche de seguridad de android, versión de banda base, versión de kernel"</string>
    <string name="keywords_dark_ui_mode" msgid="6465231409128452489">"tema, claro, oscuro, modo"</string>
    <string name="keywords_systemui_theme" msgid="6341194275296707801">"tema oscuro"</string>
    <string name="keywords_device_feedback" msgid="5489930491636300027">"error"</string>
    <string name="keywords_ambient_display_screen" msgid="661492302323274647">"Pantalla Ambiente, pantalla bloqueada"</string>
    <string name="keywords_lock_screen_notif" msgid="6363144436467429932">"notificación en pantalla bloqueada, notificaciones"</string>
    <string name="keywords_face_settings" msgid="1360447094486865058">"rostro"</string>
    <string name="keywords_fingerprint_settings" msgid="7345121109302813358">"huella digital, agregar huella digital"</string>
    <string name="keywords_display_auto_brightness" msgid="7162942396941827998">"atenuar pantalla, pantalla táctil, batería, brillo inteligente, brillo dinámico, brillo automático"</string>
    <string name="keywords_display_adaptive_sleep" msgid="8003895686008403685">"atenuar pantalla, suspender, batería, tiempo de espera de la pantalla, atención a la pantalla, pantalla, inactividad"</string>
    <string name="keywords_auto_rotate" msgid="7914655570000378975">"rotar, girar, rotación, retrato, paisaje, orientación, vertical, horizontal"</string>
    <string name="keywords_system_update_settings" msgid="5769003488814164931">"actualizar, Android"</string>
    <string name="keywords_zen_mode_settings" msgid="7810203406522669584">"no interrumpir, programar, notificaciones, bloquear, silenciar, vibrar, suspender, trabajar, enfocar, sonido, silencio, día, día de la semana, fin de semana, noche de la semana, evento"</string>
    <string name="keywords_screen_timeout" msgid="8921857020437540572">"pantalla, tiempo de bloqueo, tiempo de espera de la pantalla, bloqueo de pantalla"</string>
    <string name="keywords_storage_settings" msgid="6018856193950281898">"memoria, caché, datos, eliminar, borrar, liberar, espacio"</string>
    <string name="keywords_bluetooth_settings" msgid="2588159530959868188">"conectado, dispositivo, audífonos, auriculares, bocina, inalámbrico, vincular, auricular, música, multimedia"</string>
    <string name="keywords_wallpaper" msgid="6712776876474488023">"fondo, pantalla, pantalla bloqueada, tema"</string>
    <string name="keywords_styles" msgid="6312134005271042434">"forma del ícono, color destacado, fuente"</string>
    <string name="keywords_assist_input" msgid="3086289530227075593">"predeterminado, asistente"</string>
    <string name="keywords_default_payment_app" msgid="5162298193637362104">"pago, predeterminado"</string>
    <string name="keywords_ambient_display" msgid="3149287105145443697">"notificación entrante"</string>
    <string name="keywords_hotspot_tethering" msgid="3688439689671232627">"conexión USB, conexión Bluetooth, hotspot de Wi-Fi"</string>
    <string name="keywords_touch_vibration" msgid="1125291201902251273">"tecnología háptica, vibrar, pantalla, sensibilidad"</string>
    <string name="keywords_ring_vibration" msgid="1736301626537417541">"háptica, vibrar, teléfono, llamada, sensibilidad, tono"</string>
    <string name="keywords_notification_vibration" msgid="9162262178415439951">"háptica, vibrar, sensibilidad"</string>
    <string name="keywords_battery_saver_sticky" msgid="1646191718840975110">"ahorro de batería, fijo, permanente, ahorro de energía, batería"</string>
    <string name="keywords_battery_saver_schedule" msgid="8240483934368455930">"rutina, programa, ahorro de batería, ahorro de energía, batería, automático, porcentaje"</string>
    <string name="keywords_enhance_4g_lte" msgid="658889360486800978">"volte, llamadas avanzadas, llamadas mediante 4G"</string>
    <string name="keywords_add_language" msgid="1882751300359939436">"agregar idioma, agregar un idioma"</string>
    <string name="keywords_font_size" msgid="336803136451166298">"tamaño del texto"</string>
    <string name="default_sound" msgid="6604374495015245195">"Sonido predeterminado"</string>
    <string name="sound_settings_summary" msgid="944761906531715109">"Volumen de tono y notificaciones al <xliff:g id="PERCENTAGE">%1$s</xliff:g>"</string>
    <string name="sound_dashboard_summary" msgid="6574444810552643312">"Volumen, vibración, No interrumpir"</string>
    <string name="sound_settings_summary_vibrate" msgid="7192223433295988890">"Timbre en vibración"</string>
    <string name="sound_settings_summary_silent" msgid="746662794579344761">"Timbre en silencio"</string>
    <string name="sound_settings_example_summary" msgid="8125110691864707925">"Volumen de tono y notificaciones al 80%"</string>
    <string name="media_volume_option_title" msgid="5966569685119475630">"Volumen multimedia"</string>
    <string name="remote_media_volume_option_title" msgid="8760846743943305764">"Volumen de transmisión"</string>
    <string name="call_volume_option_title" msgid="1461105986437268924">"Volumen de llamada"</string>
    <string name="alarm_volume_option_title" msgid="6398641749273697140">"Volumen de alarma"</string>
    <string name="ring_volume_option_title" msgid="1520802026403038560">"Volumen de tono y notificaciones"</string>
    <string name="notification_volume_option_title" msgid="4838818791683615978">"Volumen de notificación"</string>
    <string name="ringtone_title" msgid="3271453110387368088">"Tono de llamada"</string>
    <string name="notification_ringtone_title" msgid="6924501621312095512">"Sonido predeterminado"</string>
    <string name="notification_unknown_sound_title" msgid="1319708450698738980">"Sonido que proporcionó la app"</string>
    <string name="notification_sound_default" msgid="8630353701915294299">"Sonido de notificaciones predeterminado"</string>
    <string name="alarm_ringtone_title" msgid="6680761007731764726">"Sonido de alarma predeterminado"</string>
    <string name="vibrate_when_ringing_title" msgid="3436203665622843196">"Vibrar para llamadas"</string>
    <string name="keywords_vibrate_for_calls" msgid="1019870409730074899">"Vibración"</string>
    <string name="vibrate_when_ringing_option_never_vibrate" msgid="6518980907289156517">"Nunca vibrar"</string>
    <string name="vibrate_when_ringing_option_always_vibrate" msgid="968652667232075466">"Siempre vibrar"</string>
    <string name="vibrate_when_ringing_option_ramping_ringer" msgid="2798848945803840348">"Primero vibrar, luego sonar gradualmente"</string>
    <string name="other_sound_settings" msgid="5468360269346162072">"Otros sonidos"</string>
    <string name="dial_pad_tones_title" msgid="3536945335367914892">"Tonos del teclado"</string>
    <string name="screen_locking_sounds_title" msgid="5695030983872787321">"Sonido de bloqueo de pantalla"</string>
    <string name="charging_sounds_title" msgid="5261683808537783668">"Vibración y sonidos de carga"</string>
    <string name="docking_sounds_title" msgid="5341616179210436159">"Sonidos al conectar"</string>
    <string name="touch_sounds_title" msgid="2200734041857425078">"Sonidos de teclas y botones"</string>
    <string name="vibrate_on_touch_title" msgid="9105544449810547716">"Vibración táctil"</string>
    <string name="vibrate_on_touch_summary" msgid="664831333409399440">"Respuesta táctil al presionar, usar el teclado y más"</string>
    <string name="dock_audio_media_title" msgid="6474579339356398330">"Reprod. parlantes conector"</string>
    <string name="dock_audio_media_disabled" msgid="8499927008999532341">"Todo el audio"</string>
    <string name="dock_audio_media_enabled" msgid="4039126523653131281">"Solo audio multimedia"</string>
    <string name="emergency_tone_silent" msgid="5048069815418450902">"Silencio"</string>
    <string name="emergency_tone_alert" msgid="1977698889522966589">"Tonos"</string>
    <string name="emergency_tone_vibrate" msgid="6282296789406984698">"Vibraciones"</string>
    <string name="boot_sounds_title" msgid="5033062848948884111">"Activar los sonidos"</string>
    <string name="live_caption_title" msgid="8617086825712756983">"Subtitulado instantáneo"</string>
    <string name="live_caption_summary" msgid="2898451867595161809">"Subtitular automáticamente"</string>
    <string name="zen_mode_settings_schedules_summary" msgid="2047688589286811617">"{count,plural, =0{Ninguno}=1{Se estableció 1 programa}other{Se establecieron # programas}}"</string>
    <string name="zen_mode_settings_title" msgid="682676757791334259">"No interrumpir"</string>
    <string name="zen_mode_settings_summary" msgid="6040862775514495191">"Solo recibe notificaciones de las personas y apps que más te interesan"</string>
    <string name="zen_mode_slice_subtitle" msgid="6849372107272604160">"Limitar las interrupciones"</string>
    <string name="zen_mode_settings_turn_on_dialog_title" msgid="7500702838426404527">"Activar No interrumpir"</string>
    <string name="zen_mode_behavior_alarms_only" msgid="2956938533859578315">"Los sonidos multimedia y las alarmas pueden interrumpir"</string>
    <string name="zen_mode_automation_settings_title" msgid="3709324184191870926">"Programaciones"</string>
    <string name="zen_mode_delete_automatic_rules" msgid="5020468289267191765">"Borrar programas"</string>
    <string name="zen_mode_schedule_delete" msgid="5383420576833765114">"Borrar"</string>
    <string name="zen_mode_rule_name_edit" msgid="1053237022416700481">"Editar"</string>
    <string name="zen_mode_automation_settings_page_title" msgid="6217433860514433311">"Programas"</string>
    <string name="zen_mode_automatic_rule_settings_page_title" msgid="5264835276518295033">"Programa"</string>
    <string name="zen_mode_schedule_category_title" msgid="1381879916197350988">"Programa"</string>
    <string name="zen_mode_automation_suggestion_title" msgid="7776129050500707960">"Silenciar en ciertos momentos"</string>
    <string name="zen_mode_automation_suggestion_summary" msgid="1946750790084170826">"Definir reglas de No interrumpir"</string>
    <string name="zen_mode_schedule_title" msgid="7064866561892906613">"Programa"</string>
    <string name="zen_mode_use_automatic_rule" msgid="733850322530002484">"Usar programa"</string>
    <string name="zen_mode_summary_combination" msgid="5944689309915947828">"<xliff:g id="MODE">%1$s</xliff:g>: <xliff:g id="EXIT_CONDITION">%2$s</xliff:g>"</string>
    <string name="zen_mode_settings_category" msgid="3794956668816783447">"Habilitar interrupciones con sonido"</string>
    <string name="zen_mode_visual_interruptions_settings_title" msgid="7806181124566937214">"Bloquear alteraciones visuales"</string>
    <string name="zen_mode_visual_signals_settings_subtitle" msgid="7433077540895876672">"Permitir señales visuales"</string>
    <string name="zen_mode_restrict_notifications_title" msgid="4169952466106040297">"Opciones de visualización de notificaciones ocultas"</string>
    <string name="zen_mode_restrict_notifications_category" msgid="5870944770935394566">"Cuando se activa No interrumpir"</string>
    <string name="zen_mode_restrict_notifications_mute" msgid="6692072837485018287">"Notificaciones sin sonido"</string>
    <string name="zen_mode_restrict_notifications_mute_summary" msgid="966597459849580949">"Verás las notificaciones en la pantalla"</string>
    <string name="zen_mode_restrict_notifications_mute_footer" msgid="2152115038156049608">"El teléfono no sonará ni vibrará cuando recibas notificaciones."</string>
    <string name="zen_mode_restrict_notifications_hide" msgid="5997930361607752541">"Notificaciones sin sonido ni elementos visuales"</string>
    <string name="zen_mode_restrict_notifications_hide_summary" msgid="6005445725686969583">"No verás ni oirás notificaciones"</string>
    <string name="zen_mode_restrict_notifications_hide_footer" msgid="4314772315731485747">"Tu teléfono no mostrará notificaciones nuevas o existentes, ni tampoco vibrará ni sonará por ellas. Ten en cuenta que se seguirán mostrando las notificaciones importantes sobre la actividad y el estado del teléfono.\n\nCuando desactives No interrumpir, desliza el dedo hacia abajo desde la parte superior de la pantalla para ver las notificaciones que te perdiste."</string>
    <string name="zen_mode_restrict_notifications_custom" msgid="5469078057954463796">"Personalizada"</string>
    <string name="zen_mode_restrict_notifications_enable_custom" msgid="4303255634151330401">"Habilitar configuración personalizada"</string>
    <string name="zen_mode_restrict_notifications_disable_custom" msgid="5062332754972217218">"Quitar configuración personalizada"</string>
    <string name="zen_mode_restrict_notifications_summary_muted" msgid="4750213316794189968">"Notificaciones sin sonido"</string>
    <string name="zen_mode_restrict_notifications_summary_custom" msgid="3918461289557316364">"Parcialmente ocultas"</string>
    <string name="zen_mode_restrict_notifications_summary_hidden" msgid="636494600775773296">"Notificaciones sin sonido ni elementos visuales"</string>
    <string name="zen_mode_what_to_block_title" msgid="5692710098205334164">"Restricciones personalizadas"</string>
    <string name="zen_mode_block_effects_screen_on" msgid="8780668375194500987">"Cuando la pantalla esté encendida"</string>
    <string name="zen_mode_block_effects_screen_off" msgid="2291988790355612826">"Cuando la pantalla esté apagada"</string>
    <string name="zen_mode_block_effect_sound" msgid="7929909410442858327">"Silenciar el sonido y la vibración"</string>
    <string name="zen_mode_block_effect_intent" msgid="7621578645742903531">"No activar la pantalla"</string>
    <string name="zen_mode_block_effect_light" msgid="1997222991427784993">"No encender luz intermitente"</string>
    <string name="zen_mode_block_effect_peek" msgid="2525844009475266022">"No mostrar notificaciones en pantalla"</string>
    <string name="zen_mode_block_effect_status" msgid="5765965061064691918">"Ocultar íconos de la barra de estado de la parte superior"</string>
    <string name="zen_mode_block_effect_badge" msgid="332151258515152429">"Ocultar puntos de notificación en íconos de apps"</string>
    <string name="zen_mode_block_effect_ambient" msgid="1247740599476031543">"No activar la pantalla con las notificaciones"</string>
    <string name="zen_mode_block_effect_list" msgid="7549367848660137118">"Ocultar del panel desplegable"</string>
    <string name="zen_mode_block_effect_summary_none" msgid="6688519142395714659">"Nunca"</string>
    <string name="zen_mode_block_effect_summary_screen_off" msgid="6989818116297061488">"Cuando la pantalla está apagada"</string>
    <string name="zen_mode_block_effect_summary_screen_on" msgid="4876016548834916087">"Cuando la pantalla está encendida"</string>
    <string name="zen_mode_block_effect_summary_sound" msgid="1559968890497946901">"Sonido y vibración"</string>
    <string name="zen_mode_block_effect_summary_some" msgid="2730383453754229650">"Sonido, vibración y algunos signos visuales de notificaciones"</string>
    <string name="zen_mode_block_effect_summary_all" msgid="3131918059492425222">"Sonido, vibración y signos visuales de notificaciones"</string>
    <string name="zen_mode_blocked_effects_footer" msgid="1115914818435434668">"Nunca se ocultarán las notificaciones necesarias sobre el estado y las actividades básicas del teléfono."</string>
    <string name="zen_mode_no_exceptions" msgid="1580136061336585873">"Nada"</string>
    <string name="zen_mode_other_options" msgid="3399967231522580421">"otras opciones"</string>
    <string name="zen_mode_add" msgid="8789024026733232566">"Agregar"</string>
    <string name="zen_mode_enable_dialog_turn_on" msgid="1971034397501675078">"Activar"</string>
    <string name="zen_mode_button_turn_on" msgid="6583862599681052347">"Activar ahora"</string>
    <string name="zen_mode_button_turn_off" msgid="2060862413234857296">"Desactivar ahora"</string>
    <string name="zen_mode_settings_dnd_manual_end_time" msgid="8251503918238985549">"El modo \"No interrumpir\" estará activado hasta la(s) <xliff:g id="FORMATTED_TIME">%s</xliff:g>"</string>
    <string name="zen_mode_settings_dnd_manual_indefinite" msgid="1436568478062106132">"El modo \"No interrumpir\" permanecerá activado hasta que lo desactives"</string>
    <string name="zen_mode_settings_dnd_automatic_rule" msgid="1958092329238152236">"Una acción programada (<xliff:g id="RULE_NAME">%s</xliff:g>) activó automáticamente el modo No interrumpir"</string>
    <string name="zen_mode_settings_dnd_automatic_rule_app" msgid="3401685760954156067">"Una app (<xliff:g id="APP_NAME">%s</xliff:g>) activó el modo \"No interrumpir\" automáticamente"</string>
    <string name="zen_mode_settings_dnd_custom_settings_footer" msgid="6566115866660865385">"El modo No interrumpir está activado para <xliff:g id="RULE_NAMES">%s</xliff:g> con opciones de configuración personalizadas."</string>
    <string name="zen_mode_settings_dnd_custom_settings_footer_link" msgid="2310353944697868606"><annotation id="link">"Ver configuración personalizada"</annotation></string>
    <string name="zen_interruption_level_priority" msgid="4854123502362861192">"Solo prioridad"</string>
    <string name="zen_mode_and_condition" msgid="8580896862841920031">"<xliff:g id="ZEN_MODE">%1$s</xliff:g>. <xliff:g id="EXIT_CONDITION">%2$s</xliff:g>"</string>
    <string name="zen_mode_sound_summary_on_with_info" msgid="4803606180235742003">"Activado/<xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="zen_mode_sound_summary_on" msgid="9077659040104989899">"Activado"</string>
    <string name="zen_mode_duration_summary_always_prompt" msgid="7658172853423383037">"Preguntar siempre"</string>
    <string name="zen_mode_duration_summary_forever" msgid="5551992961329998606">"Hasta que lo desactives"</string>
    <string name="zen_mode_duration_summary_time_hours" msgid="2602655749780428308">"{count,plural, =1{1 hora}other{# horas}}"</string>
    <string name="zen_mode_duration_summary_time_minutes" msgid="5755536844016835693">"{count,plural, =1{1 minuto}other{# minutos}}"</string>
    <string name="zen_mode_sound_summary_off" msgid="7350437977839985836">"{count,plural, =0{Desactivada}=1{Desactivada/1 programa se puede activar automáticamente}other{Desactivada/# programas se pueden activar automáticamente}}"</string>
    <string name="zen_category_behavior" msgid="3214056473947178507">"Pueden suspender la función No interrumpir:"</string>
    <string name="zen_category_people" msgid="8252926021894933047">"Personas"</string>
    <string name="zen_category_apps" msgid="1167374545618451925">"Apps"</string>
    <string name="zen_category_exceptions" msgid="1316097981052752811">"Alarmas y otras interrupciones"</string>
    <string name="zen_category_schedule" msgid="2003707171924226212">"Programas"</string>
    <string name="zen_category_duration" msgid="7515850842082631460">"Duración para la Configuración rápida"</string>
    <string name="zen_sound_footer" msgid="4090291351903631977">"Si activas el modo No interrumpir, se silenciarán el sonido y la vibración, excepto para los elementos que habilites arriba."</string>
    <string name="zen_custom_settings_dialog_title" msgid="4613603772432720380">"Configuración personalizada"</string>
    <string name="zen_custom_settings_dialog_review_schedule" msgid="4674671820584759928">"Revisar programa"</string>
    <string name="zen_custom_settings_dialog_ok" msgid="8842373418878278246">"Entendido"</string>
    <string name="zen_custom_settings_notifications_header" msgid="7635280645171095398">"Notificaciones"</string>
    <string name="zen_custom_settings_duration_header" msgid="5065987827522064943">"Duración"</string>
    <string name="zen_msg_event_reminder_title" msgid="5362025129007417554">"Mensajes, eventos y recordatorios"</string>
    <string name="zen_msg_event_reminder_footer" msgid="2700459146293750387">"Si activas el modo No interrumpir, se silenciarán los mensajes, recordatorios y eventos, excepto los elementos que habilites arriba. También puedes ajustar la configuración de los mensajes para permitir que amigos, familiares y otros contactos se comuniquen contigo."</string>
    <string name="zen_onboarding_ok" msgid="8764248406533833392">"Listo"</string>
    <string name="zen_onboarding_settings" msgid="2815839576245114342">"Configuración"</string>
    <string name="zen_onboarding_new_setting_title" msgid="8813308612916316657">"Notificaciones sin sonido ni elementos visuales"</string>
    <string name="zen_onboarding_current_setting_title" msgid="5024603685220407195">"Notificaciones sin sonido"</string>
    <string name="zen_onboarding_new_setting_summary" msgid="7695808354942143707">"No verás ni oirás notificaciones. Sí se permiten las llamadas de contactos destacados y emisores repetidos."</string>
    <string name="zen_onboarding_current_setting_summary" msgid="8864567406905990095">"(Configuración actual)"</string>
    <string name="zen_onboarding_dnd_visual_disturbances_header" msgid="8639698336231314609">"¿Quieres cambiar la configuración de notificaciones de No interrumpir?"</string>
    <string name="sound_work_settings" msgid="752627453846309092">"Sonidos del perfil de trabajo"</string>
    <string name="work_use_personal_sounds_title" msgid="7729428677919173609">"Usa los sonidos del perfil personal"</string>
    <string name="work_use_personal_sounds_summary" msgid="4482832555278975008">"Los sonidos de los perfiles de trabajo y personal son iguales"</string>
    <string name="work_ringtone_title" msgid="4810802758746102589">"Tono del teléfono laboral"</string>
    <string name="work_notification_ringtone_title" msgid="2955312017013255515">"Sonido predeterminado para notificaciones de trabajo"</string>
    <string name="work_alarm_ringtone_title" msgid="3369293796769537392">"Sonido predeterminado para alarmas de trabajo"</string>
    <string name="work_sound_same_as_personal" msgid="1836913235401642334">"Igual al del perfil personal"</string>
    <string name="work_sync_dialog_title" msgid="2359563902332046231">"¿Deseas reemplazar los sonidos?"</string>
    <string name="work_sync_dialog_yes" msgid="9161415252411868574">"Reemplazar"</string>
    <string name="work_sync_dialog_message" msgid="1328692374812258546">"Se usarán los sonidos de tu perfil personal para el perfil de trabajo"</string>
    <string name="ringtones_install_custom_sound_title" msgid="3885712267015760638">"¿Deseas agregar un sonido personalizado?"</string>
    <string name="ringtones_install_custom_sound_content" msgid="5844996763705884979">"Se copiará este archivo a la carpeta <xliff:g id="FOLDER_NAME">%s</xliff:g>"</string>
    <string name="ringtones_category_preference_title" msgid="26680768777533727">"Tonos"</string>
    <string name="other_sound_category_preference_title" msgid="8182757473602586634">"Otros sonidos y vibraciones"</string>
    <string name="configure_notification_settings" msgid="1492820231694314376">"Notificaciones"</string>
    <string name="recent_notifications" msgid="1105631022180160436">"Enviadas recientemente"</string>
    <string name="recent_notifications_see_all_title" msgid="3087299996651692987">"Ver todas las de los últimos 7 días"</string>
    <string name="advanced_section_header" msgid="6003255455888626056">"Avanzada"</string>
    <string name="profile_section_header" msgid="4970209372372610799">"Notificaciones de trabajo"</string>
    <string name="smart_notifications_title" msgid="8995288376897952015">"Notificaciones adaptables"</string>
    <string name="asst_capability_prioritizer_title" msgid="1181272430009156556">"Prioridad de notificación adaptable"</string>
    <string name="asst_capability_prioritizer_summary" msgid="954988212366568737">"Configurar automáticamente las notificaciones de menor prioridad a silenciosas"</string>
    <string name="asst_capability_ranking_title" msgid="312998580233257581">"Clasificación de notificaciones adaptables"</string>
    <string name="asst_capability_ranking_summary" msgid="2293524677144599450">"Clasificar las notificaciones automáticamente por relevancia"</string>
    <string name="asst_feedback_indicator_title" msgid="5169801869752395354">"Comentarios sobre notificaciones adaptables"</string>
    <string name="asst_feedback_indicator_summary" msgid="5862082842073307900">"Indica los ajustes realizados a las notificaciones y muestra la opción para enviar comentarios al sistema"</string>
    <string name="asst_importance_reset_title" msgid="6191265591976440115">"Restablece la prioridad de notificaciones"</string>
    <string name="asst_importance_reset_summary" msgid="684794589254282667">"Restablece la configuración de importancia cambiada por el usuario y permite que el asistente de notificaciones establezca las prioridades"</string>
    <string name="asst_capabilities_actions_replies_title" msgid="4392470465646394289">"Respuestas y acciones sugeridas"</string>
    <string name="asst_capabilities_actions_replies_summary" msgid="416234323365645871">"Mostrar automáticamente respuestas y acciones sugeridas"</string>
    <string name="notification_history_summary" msgid="5434741516307706892">"Visualiza notificaciones recientes y pospuestas"</string>
    <string name="notification_history" msgid="8663811361243456201">"Historial de notificaciones"</string>
    <string name="notification_history_toggle" msgid="9093762294928569030">"Usar el historial de notificaciones"</string>
    <string name="notification_history_off_title_extended" msgid="853807652537281601">"El historial de notificaciones está desactivado"</string>
    <string name="notification_history_off_summary" msgid="671359587084797617">"Activa el historial de notificaciones para ver las notificaciones recientes y las pospuestas"</string>
    <string name="history_toggled_on_title" msgid="4518001110492652830">"No hay notificaciones recientes"</string>
    <string name="history_toggled_on_summary" msgid="9034278971358282728">"Las notificaciones recientes y pospuestas aparecerán aquí"</string>
    <string name="notification_history_view_settings" msgid="5269317798670449002">"ver configuración de notificaciones"</string>
    <string name="notification_history_open_notification" msgid="2655071846911258371">"notificación abierta"</string>
    <string name="snooze_options_title" msgid="2109795569568344617">"Permitir posponer alarmas"</string>
    <string name="hide_silent_icons_title" msgid="5951392023601167577">"Ocultar íconos de las notificaciones silenciosas"</string>
    <string name="hide_silent_icons_summary" msgid="623763437631637232">"Los íconos de las notificaciones silenciosas no se muestran en la barra de estado"</string>
    <string name="notification_badging_title" msgid="5469616894819568917">"Punto de notificación en ícono de app"</string>
    <string name="notification_people_strip_title" msgid="1185857822541001139">"Mostrar la barra de conversaciones recientes"</string>
    <string name="notification_bubbles_title" msgid="5681506665322329301">"Burbujas"</string>
    <string name="bubbles_feature_education" msgid="4088275802688887634">"Algunas notificaciones y otro contenido pueden aparecer como burbujas en la pantalla. Para abrir una burbuja, presiónala. Para descartarla, arrástrala hacia el extremo inferior de la pantalla."</string>
    <string name="bubbles_app_toggle_title" msgid="5319021259954576150">"Burbujas"</string>
    <string name="bubbles_conversation_app_link" msgid="5468779786387915337">"Todas las configuraciones de Burbujas"</string>
    <string name="bubbles_conversation_toggle_title" msgid="5225039214083311316">"Poner esta conversación en una Burbuja"</string>
    <string name="bubbles_conversation_toggle_summary" msgid="720229032254323578">"Mostrar ícono flotante sobre las apps"</string>
    <string name="bubbles_app_toggle_summary" msgid="1574515698567947948">"Permitir que <xliff:g id="APP_NAME">%1$s</xliff:g> muestre algunas notificaciones como burbujas"</string>
    <string name="bubbles_feature_disabled_dialog_title" msgid="1794193899792284007">"¿Quieres activar las burbujas para el dispositivo?"</string>
    <string name="bubbles_feature_disabled_dialog_text" msgid="5275666953364031055">"Si activas las burbujas para esta app, también se activarán para el dispositivo.\n\nEsto afecta otras apps o conversaciones que pueden crear burbujas."</string>
    <string name="bubbles_feature_disabled_button_approve" msgid="2042628067101419871">"Activar"</string>
    <string name="bubbles_feature_disabled_button_cancel" msgid="8963409459448350600">"Cancelar"</string>
    <string name="notifications_bubble_setting_on_summary" msgid="4641572377430901196">"Burbujas activadas: Las conversaciones pueden aparecer como elementos flotantes"</string>
    <string name="notifications_bubble_setting_title" msgid="8287649393774855268">"Permitir que las apps muestren burbujas"</string>
    <string name="notifications_bubble_setting_description" msgid="7336770088735025981">"Algunas conversaciones aparecerán como elementos flotantes encima de otras apps"</string>
    <string name="bubble_app_setting_all" msgid="312524752846978277">"Se pueden crear burbujas de todas las conversaciones"</string>
    <string name="bubble_app_setting_selected" msgid="4324386074198040675">"Se pueden crear burbujas de las conversaciones seleccionadas"</string>
    <string name="bubble_app_setting_none" msgid="8643594711863996418">"No se pueden crear burbujas"</string>
    <string name="bubble_app_setting_selected_conversation_title" msgid="3060958976857529933">"Conversaciones"</string>
    <string name="bubble_app_setting_excluded_conversation_title" msgid="324818960338773945">"Todas las conversaciones pueden crear burbujas, excepto"</string>
    <string name="bubble_app_setting_unbubble_conversation" msgid="1769789500566080427">"Desactiva las burbujas para esta conversación"</string>
    <string name="bubble_app_setting_bubble_conversation" msgid="1461981680982964285">"Activa las burbujas para esta conversación"</string>
    <string name="swipe_direction_title" msgid="4260320464727178413">"Acciones al deslizar el dedo"</string>
    <string name="swipe_direction_ltr" msgid="5137180130142633085">"Desliza el dedo hacia la derecha para cerrar la notificación o hacia la izquierda para mostrar el menú"</string>
    <string name="swipe_direction_rtl" msgid="1707391213940663992">"Desliza el dedo hacia la izquierda para cerrar la notificación y hacia la derecha para mostrar el menú"</string>
    <string name="gentle_notifications_title" msgid="2793492905132530991">"Notificaciones discretas"</string>
    <string name="gentle_notifications_also_display" msgid="8617545395880297691">"También mostrar en"</string>
    <string name="gentle_notifications_display_status" msgid="7410244447768694856">"Barra de estado"</string>
    <string name="gentle_notifications_display_lock" msgid="1914245082527924144">"Pantalla de bloqueo"</string>
    <string name="gentle_notifications_education" msgid="5957509621826384362">"Las notificaciones discretas siempre son silenciosas y aparecen en el banner desplegable"</string>
    <string name="gentle_notifications_display_summary_shade" msgid="7616926954719310445">"Mostrar solo en banner desplegable"</string>
    <string name="gentle_notifications_display_summary_shade_lock" msgid="3936088046873705625">"Mostrar en banner desplegable y pantalla bloqueada"</string>
    <string name="gentle_notifications_display_summary_shade_status" msgid="3363137853729359907">"Mostrar en banner desplegable y barra de estado"</string>
    <string name="gentle_notifications_display_summary_shade_status_lock" msgid="2068738866725616212">"Mostrar en banner desplegable, barra de estado y pantalla bloqueada"</string>
    <string name="silent_notifications_status_bar" msgid="6113307620588767516">"Ocultar las notificaciones silenciosas en la barra de estado"</string>
    <string name="notification_pulse_title" msgid="8013178454646671529">"Luz intermitente"</string>
    <string name="lock_screen_notifications_title" msgid="3063951257121435570">"Notificaciones en pantalla de bloqueo"</string>
    <string name="lockscreen_bypass_title" msgid="6519964196744088573">"Omitir pantalla de bloqueo"</string>
    <string name="lockscreen_bypass_summary" msgid="6688592486830491144">"Después del desbloqueo facial, ir a la última pantalla usada"</string>
    <string name="keywords_lockscreen_bypass" msgid="41035425468915498">"Pantalla bloqueada, bloqueo de pantalla, omitir, omisión"</string>
    <string name="locked_work_profile_notification_title" msgid="279367321791301499">"Si perfil de trabajo bloqueado"</string>
    <string name="lock_screen_notifs_title" msgid="3412042692317304449">"Notificaciones en la pantalla de bloqueo"</string>
    <string name="lock_screen_notifs_show_all" msgid="1300418674456749664">"Mostrar conversaciones predeterminadas y silenciosas"</string>
    <string name="lock_screen_notifs_show_alerting" msgid="6584682657382684566">"Ocultar conversaciones y notificaciones silenciadas"</string>
    <string name="lock_screen_notifs_show_none" msgid="1941044980403067101">"No mostrar notificaciones"</string>
    <string name="lock_screen_notifs_redact" msgid="9024158855454642296">"Notificaciones confidenciales"</string>
    <string name="lock_screen_notifs_redact_summary" msgid="1395483766035470612">"Mostrar contenido confidencial cuando el dispositivo esté bloqueado"</string>
    <string name="lock_screen_notifs_redact_work" msgid="3833920196569208430">"Notificaciones confidenciales del perfil de trabajo"</string>
    <string name="lock_screen_notifs_redact_work_summary" msgid="3238238380405430156">"Mostrar contenido confidencial del perfil de trabajo cuando el dispositivo esté bloqueado"</string>
    <string name="lock_screen_notifications_summary_show" msgid="6540443483088311328">"Mostrar todas las notificaciones"</string>
    <string name="lock_screen_notifications_summary_hide" msgid="7837303171531166789">"Mostrar contenido sensible solo al desbloquear"</string>
    <string name="lock_screen_notifications_summary_disable" msgid="3388290397947365744">"No mostrar notificaciones"</string>
    <string name="lock_screen_notifications_interstitial_message" msgid="4688399629301178487">"¿Cómo quieres que se muestre la pantalla bloqueada?"</string>
    <string name="lock_screen_notifications_interstitial_title" msgid="1360388192096354315">"Pantalla de bloqueo"</string>
    <string name="lock_screen_notifications_summary_show_profile" msgid="8373401288962523946">"Mostrar el contenido de notificaciones de trabajo"</string>
    <string name="lock_screen_notifications_summary_hide_profile" msgid="2183455323048921579">"Ocultar contenido de trabajo confidencial"</string>
    <string name="lock_screen_notifications_interstitial_message_profile" msgid="1456262034599029028">"¿Cómo deseas ver las notificaciones de perfil cuando esté bloqueado el dispositivo?"</string>
    <string name="lock_screen_notifications_interstitial_title_profile" msgid="6950124772255324448">"Notificaciones de perfil"</string>
    <string name="notifications_title" msgid="4221655533193721131">"Notificaciones"</string>
    <string name="app_notifications_title" msgid="248374669037385148">"Notificaciones de apps"</string>
    <string name="notification_channel_title" msgid="8859880871692797611">"Categoría de notificaciones"</string>
    <string name="notification_group_title" msgid="7525666535695631538">"Categoría del grupo de notificaciones"</string>
    <string name="notification_importance_title" msgid="1545158655988342703">"Comportamiento"</string>
    <string name="notification_importance_unspecified" msgid="1543165530748339700">"Permitir sonido"</string>
    <string name="notification_importance_blocked" msgid="4933285639639899394">"No mostrar notificaciones"</string>
    <string name="conversations_category_title" msgid="5586541340846847798">"Conversaciones"</string>
    <string name="conversation_category_title" msgid="6777135786004214149">"Conversación"</string>
    <string name="conversation_section_switch_title" msgid="3332885377659473775">"Sección de conversaciones"</string>
    <string name="conversation_section_switch_summary" msgid="6123587625929439674">"Permite que la app use la sección de conversaciones"</string>
    <string name="demote_conversation_title" msgid="6355383023376508485">"No es una conversación"</string>
    <string name="demote_conversation_summary" msgid="4319929331165604112">"Quitar de la sección de conversaciones"</string>
    <string name="promote_conversation_title" msgid="4731148769888238722">"Esta es una conversación"</string>
    <string name="promote_conversation_summary" msgid="3890724115743515035">"Agregar a la sección de conversaciones"</string>
    <string name="manage_conversations" msgid="4440289604887824337">"Administra las conversaciones"</string>
    <string name="priority_conversation_count_zero" msgid="3862289535537564713">"No hay conversaciones prioritarias"</string>
    <plurals name="priority_conversation_count" formatted="false" msgid="4229447176780862649">
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g> conversaciones prioritarias</item>
      <item quantity="one"><xliff:g id="COUNT_0">%d</xliff:g> conversación prioritaria</item>
    </plurals>
    <string name="important_conversations" msgid="1233893707189659401">"Conversaciones prioritarias"</string>
    <string name="important_conversations_summary_bubbles" msgid="614327166808117644">"Se muestran en la parte superior de la sección de conversaciones como burbujas flotantes."</string>
    <string name="important_conversations_summary" msgid="3184022761562676418">"Se mostrarán en la parte superior de la sección de conversaciones"</string>
    <string name="other_conversations" msgid="551178916855139870">"Conversaciones no prioritarias"</string>
    <string name="other_conversations_summary" msgid="3487426787901236273">"Conversaciones que modificaste"</string>
    <string name="recent_conversations" msgid="471678228756995274">"Conversaciones recientes"</string>
    <string name="conversation_settings_clear_recents" msgid="4246342656145488662">"Borrar recientes"</string>
    <string name="clear" msgid="5092178335409471100">"Borrar"</string>
    <string name="important_bubble" msgid="7911698275408390846">"Guardar conversaciones prioritarias en burbujas"</string>
    <string name="important_conversation_behavior_summary" msgid="1845064084071107732">"Las conversaciones prioritarias se muestran en la parte superior del panel desplegable. También puedes configurarlas para que aparezcan como burbujas y que suspendan la función No interrumpir."</string>
    <string name="conversation_onboarding_title" msgid="5194559958353468484">"Las conversaciones prioritarias y modificadas aparecerán aquí"</string>
    <string name="conversation_onboarding_summary" msgid="2484845363368486941">"Las conversaciones que marques como prioritarias o modifiques aparecerán aquí. \n\nPara cambiar la configuración de las conversaciones, haz lo siguiente: \nDesliza el dedo hacia abajo desde la parte superior de la pantalla para abrir el panel desplegable y mantén presionada una conversación."</string>
    <string name="notification_importance_min" msgid="4609688642942787774">"Mostrar en silencio y minimizar"</string>
    <string name="notification_importance_low" msgid="7562535765919565273">"Mostrar sin emitir sonido"</string>
    <string name="notification_importance_default" msgid="7483906490369073043">"Emitir sonido"</string>
    <string name="notification_importance_high" msgid="8453789143477210550">"Emitir sonido y mostrar en pantalla"</string>
    <string name="notification_importance_high_silent" msgid="8977232884004607985">"Mostrar en la pantalla"</string>
    <string name="notification_importance_min_title" msgid="7676541266705442501">"Minimizar"</string>
    <string name="notification_importance_low_title" msgid="658158049378796947">"Media"</string>
    <string name="notification_importance_default_title" msgid="8875198696330289686">"Alta"</string>
    <string name="notification_importance_high_title" msgid="394129291760607808">"Mostrar en la pantalla"</string>
    <string name="notification_block_title" msgid="7392909527700971673">"Bloquear"</string>
    <string name="notification_silence_title" msgid="4085829874452944989">"Silenciada"</string>
    <string name="notification_alert_title" msgid="1632401211722199217">"Predeterminada"</string>
    <string name="allow_interruption" msgid="5237201780159482716">"Permitir interrupciones"</string>
    <string name="allow_interruption_summary" msgid="9044131663518112543">"Permite que la app emita sonidos, vibre y muestre notificaciones en pantalla"</string>
    <string name="notification_priority_title" msgid="5554834239080425229">"Prioritaria"</string>
    <string name="notification_channel_summary_priority" msgid="7225362351439076913">"Aparece en la parte superior de la sección de conversaciones, en forma de burbuja flotante, y muestra la foto de perfil en la pantalla de bloqueo."</string>
    <string name="convo_not_supported_summary" msgid="4285471045268268048">"<xliff:g id="APP_NAME">%1$s</xliff:g> no es compatible con la mayoría de las funciones de conversaciones. No podrás establecer una conversación como prioritaria y las conversaciones no aparecerán como burbujas flotantes."</string>
    <string name="notification_channel_summary_min" msgid="8823399508450176842">"En el panel desplegable, mostrar las notificaciones en una línea"</string>
    <string name="notification_channel_summary_low" msgid="5549662596677692000">"Sin sonido ni vibración"</string>
    <string name="notification_conversation_summary_low" msgid="6352818857388412326">"No suena ni vibra, y aparece en la parte inferior de la sección de conversaciones."</string>
    <string name="notification_channel_summary_default" msgid="3674057458265438896">"Puede sonar o vibrar en función de la configuración del teléfono."</string>
    <string name="notification_channel_summary_high" msgid="3411637309360617621">"Con el dispositivo desbloqueado, mostrar notificaciones como banner en la parte superior de la pantalla"</string>
    <string name="notification_switch_label" msgid="8029371325967501557">"Todas las notificaciones de \"<xliff:g id="APP_NAME">%1$s</xliff:g>\""</string>
    <string name="notification_app_switch_label" msgid="4422902423925084193">"Todas las notificaciones de <xliff:g id="APP_NAME">%1$s</xliff:g>"</string>
    <string name="default_notification_assistant" msgid="243718059890346442">"Notificaciones adaptables"</string>
    <plurals name="notifications_sent_daily" formatted="false" msgid="1479283620504341566">
      <item quantity="other">Aproximadamente <xliff:g id="NUMBER_1">%d</xliff:g> notificaciones por día</item>
      <item quantity="one">Aproximadamente <xliff:g id="NUMBER_0">%d</xliff:g> notificación por día</item>
    </plurals>
    <plurals name="notifications_sent_weekly" formatted="false" msgid="4913443431857170519">
      <item quantity="other">Aproximadamente <xliff:g id="NUMBER_1">%d</xliff:g> notificaciones por semana</item>
      <item quantity="one">Aproximadamente <xliff:g id="NUMBER_0">%d</xliff:g> notificación por semana</item>
    </plurals>
    <string name="notifications_sent_never" msgid="9081278709126812062">"Nunca"</string>
    <string name="manage_notification_access_title" msgid="4714320299084782521">"Acceso a notificaciones"</string>
    <string name="work_profile_notification_access_blocked_summary" msgid="8643809206612366067">"El acceso a las notificaciones del perfil de trabajo está bloqueado"</string>
    <string name="manage_notification_access_summary_zero" msgid="7528633634628627431">"Las aplicaciones no pueden leer las notificaciones."</string>
    <plurals name="manage_notification_access_summary_nonzero" formatted="false" msgid="3703008881487586312">
      <item quantity="other">%d aplicaciones pueden leer notificaciones.</item>
      <item quantity="one">%d aplicación puede leer notificaciones.</item>
    </plurals>
    <string name="notification_assistant_title" msgid="6983941403582134437">"Notificaciones adaptables"</string>
    <string name="no_notification_assistant" msgid="2533323397091834096">"Ninguna"</string>
    <string name="no_notification_listeners" msgid="2839354157349636000">"Ninguna aplicación instalada solicitó acceso a las notificaciones."</string>
    <string name="notification_access_detail_switch" msgid="46386786409608330">"Permitir acceso a las notificaciones"</string>
    <string name="notification_assistant_security_warning_title" msgid="2972346436050925276">"¿Quieres permitir que <xliff:g id="SERVICE">%1$s</xliff:g> tenga acceso a las notificaciones?"</string>
    <string name="notification_assistant_security_warning_summary" msgid="7362924206925040510">"<xliff:g id="NOTIFICATION_ASSISTANT_NAME">%1$s</xliff:g> podrá leer todas las notificaciones, incluidas las que contienen información personal, como los nombres de los contactos y el texto de los mensajes que recibes. Esta app también podrá descartar notificaciones y realizar acciones en botones de notificaciones (por ejemplo, para responder llamadas). \n\nAdemás, podrá activar y desactivar No interrumpir y cambiar la configuración relacionada."</string>
    <string name="notification_listener_security_warning_title" msgid="5791700876622858363">"¿Deseas permitir que <xliff:g id="SERVICE">%1$s</xliff:g> tenga acceso a las notificaciones?"</string>
    <string name="notification_listener_security_warning_summary" msgid="1658213659262173405">"<xliff:g id="NOTIFICATION_LISTENER_NAME">%1$s</xliff:g> podrá leer todas las notificaciones, incluidas las que contienen información personal, como los nombres de los contactos y el texto de los mensajes que recibas. Esta app también podrá descartar notificaciones y realizar acciones en botones de notificaciones (por ejemplo, para responder llamadas). \n\nAdemás, podrá activar y desactivar No interrumpir y cambiar la configuración relacionada."</string>
    <string name="notification_listener_disable_warning_summary" msgid="8373396293802088961">"Si desactivas el acceso a las notificaciones de <xliff:g id="NOTIFICATION_LISTENER_NAME">%1$s</xliff:g>, es posible que también se desactive el modo No interrumpir."</string>
    <string name="notification_listener_disable_warning_confirm" msgid="841492108402184976">"Desactivar"</string>
    <string name="notification_listener_disable_warning_cancel" msgid="8802784105045594324">"Cancelar"</string>
    <string name="notification_listener_type_title" msgid="2791552789364336733">"Tipos de notificaciones permitidas"</string>
    <string name="notif_type_ongoing" msgid="2295338067608686711">"Notificaciones constantes importantes"</string>
    <string name="notif_type_conversation" msgid="3014259738224129504">"Notificaciones de conversaciones"</string>
    <string name="notif_type_alerting" msgid="2300039323822104165">"Notificaciones de alerta"</string>
    <string name="notif_type_silent" msgid="2514763073653979199">"Notificaciones silenciosas"</string>
    <string name="vr_listeners_title" msgid="4960357292472540964">"Servicio de ayuda de RV"</string>
    <string name="no_vr_listeners" msgid="8442646085375949755">"Ninguna app instalada solicitó que se la ejecutara como servicio de ayuda de RV."</string>
    <string name="vr_listener_security_warning_title" msgid="7026351795627615177">"¿Quieres permitir que el servicio de RV acceda a <xliff:g id="SERVICE">%1$s</xliff:g>?"</string>
    <string name="vr_listener_security_warning_summary" msgid="1888843557687017791">"<xliff:g id="VR_LISTENER_NAME">%1$s</xliff:g> se podrá ejecutar cuando uses aplicaciones en modo de realidad virtual."</string>
    <string name="display_vr_pref_title" msgid="4850474436291113569">"Cuando el dispositivo está en modo RV"</string>
    <string name="display_vr_pref_low_persistence" msgid="7039841277157739871">"Reducir desenfoque (recomendado)"</string>
    <string name="display_vr_pref_off" msgid="4008841566387432721">"Reducir parpadeo"</string>
    <string name="picture_in_picture_title" msgid="9001594281840542493">"Pantalla en pantalla"</string>
    <string name="picture_in_picture_empty_text" msgid="9123600661268731579">"Ninguna de las apps instaladas es compatible con el modo Pantalla en pantalla"</string>
    <string name="picture_in_picture_keywords" msgid="3605379820551656253">"imagen en imagen"</string>
    <string name="picture_in_picture_app_detail_title" msgid="4442235098255164650">"Pantalla en pantalla"</string>
    <string name="picture_in_picture_app_detail_switch" msgid="8544190716075624017">"Permitir Pantalla en pantalla"</string>
    <string name="picture_in_picture_app_detail_summary" msgid="2503211101305358849">"Permite que esta app cree una ventana de Pantalla en pantalla mientras esté abierta o después de que hayas salido de ella (por ejemplo, para seguir viendo un video). Esta ventana se muestra sobre otras apps que estés usando."</string>
    <string name="interact_across_profiles_title" msgid="7285906999927669971">"Apps personales y de trabajo conectadas"</string>
    <string name="interact_across_profiles_summary_allowed" msgid="1365881452153799092">"Conectada"</string>
    <string name="interact_across_profiles_summary_not_allowed" msgid="5802674212788171790">"No conectada"</string>
    <string name="interact_across_profiles_empty_text" msgid="419061031064397168">"No hay apps conectadas"</string>
    <string name="interact_across_profiles_keywords" msgid="5996472773111665049">"apps personales y de trabajo conectadas al perfil sincronizado"</string>
    <string name="interact_across_profiles_app_detail_title" msgid="7776184211173575648">"Apps personales y de trabajo conectadas"</string>
    <string name="interact_across_profiles_switch_enabled" msgid="7294719120282287495">"Conectadas"</string>
    <string name="interact_across_profiles_switch_disabled" msgid="4312196170211463988">"Conectar estas apps"</string>
    <string name="interact_across_profiles_summary_1" msgid="6093976896137600231">"Las apps conectadas comparten permisos y cada una puede acceder a los datos de la otra."</string>
    <string name="interact_across_profiles_summary_2" msgid="505748305453633885">"Solo conecta apps si confías en que no compartirán datos personales con tu administrador de TI."</string>
    <string name="interact_across_profiles_summary_3" msgid="444428694843299854">"Puedes desconectar apps cuando quieras en la configuración de privacidad del dispositivo."</string>
    <string name="interact_across_profiles_consent_dialog_title" msgid="8530621211216508681">"¿Quieres confiarle tus datos personales a la app de trabajo <xliff:g id="NAME">%1$s</xliff:g>?"</string>
    <string name="interact_across_profiles_consent_dialog_summary" msgid="3949870271562055048">"Solo conecta apps si confías en que no compartirán datos personales con tu administrador de TI."</string>
    <string name="interact_across_profiles_consent_dialog_app_data_title" msgid="8436318876213958940">"Datos de apps"</string>
    <string name="interact_across_profiles_consent_dialog_app_data_summary" msgid="6057019384328088311">"Esta app puede acceder a los datos de tu app personal de <xliff:g id="NAME">%1$s</xliff:g>."</string>
    <string name="interact_across_profiles_consent_dialog_permissions_title" msgid="2316852600280487055">"Permisos"</string>
    <string name="interact_across_profiles_consent_dialog_permissions_summary" msgid="995051542847604039">"Esta app puede usar los permisos de tu app personal de <xliff:g id="NAME">%1$s</xliff:g>, como el acceso a la ubicación, el almacenamiento o los contactos."</string>
    <string name="interact_across_profiles_number_of_connected_apps_none" msgid="8573289199942092964">"No hay apps conectadas"</string>
    <plurals name="interact_across_profiles_number_of_connected_apps" formatted="false" msgid="6991750455661974772">
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g> apps conectadas</item>
      <item quantity="one"><xliff:g id="COUNT_0">%d</xliff:g> app conectada</item>
    </plurals>
    <string name="interact_across_profiles_install_work_app_title" msgid="2821669067014436056">"Para conectar estas apps, instala <xliff:g id="NAME">%1$s</xliff:g> en tu perfil de trabajo"</string>
    <string name="interact_across_profiles_install_personal_app_title" msgid="4790651223324866344">"Para conectar estas apps, instala <xliff:g id="NAME">%1$s</xliff:g> en tu perfil personal"</string>
    <string name="interact_across_profiles_install_app_summary" msgid="7715324358034968657">"Presiona para descargar la app"</string>
    <string name="manage_zen_access_title" msgid="1562322900340107269">"Acceso en No interrumpir"</string>
    <string name="zen_access_detail_switch" msgid="4183681772666138993">"Permitir opción No interrumpir"</string>
    <string name="zen_access_empty_text" msgid="3779921853282293080">"Ninguna aplicación instalada solicitó acceso en No interrumpir."</string>
    <string name="loading_notification_apps" msgid="5139471829295287945">"Cargando apps…"</string>
    <string name="app_notifications_off_desc" msgid="6691342160980435901">"Como lo solicitaste, Android bloquea las notificaciones de esta app para que no se muestren en el dispositivo"</string>
    <string name="channel_notifications_off_desc" msgid="6202042207121633488">"Como lo solicitaste, Android bloquea esta categoría de notificaciones para que no se muestren en el dispositivo"</string>
    <string name="channel_group_notifications_off_desc" msgid="9096417708500595424">"Como lo solicitaste, Android bloquea este grupo de notificaciones para que no se muestren en el dispositivo"</string>
    <string name="notification_channels" msgid="1502969522886493799">"Categorías"</string>
    <string name="notification_channels_other" msgid="18159805343647908">"Otros"</string>
    <plurals name="notification_group_summary" formatted="false" msgid="483490958130993160">
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g> categorías</item>
      <item quantity="one"><xliff:g id="COUNT_0">%d</xliff:g> categoría</item>
    </plurals>
    <string name="no_channels" msgid="4716199078612071915">"Esta app no publicó ninguna notificación"</string>
    <string name="app_settings_link" msgid="6725453466705333311">"Opciones de configuración adicionales de la app"</string>
    <string name="notification_screen_summary" msgid="5984915275134654822">"Historial de notificaciones, burbujas, enviadas recientemente"</string>
    <string name="app_notification_listing_summary_zero" msgid="2988400013221120744">"Activadas para todas las apps"</string>
    <plurals name="app_notification_listing_summary_others" formatted="false" msgid="1506127395400503717">
      <item quantity="other">Desactivadas para <xliff:g id="COUNT_1">%d</xliff:g> apps</item>
      <item quantity="one">Desactivadas para <xliff:g id="COUNT_0">%d</xliff:g> app</item>
    </plurals>
    <plurals name="deleted_channels" formatted="false" msgid="5963473421547029532">
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g> categorías borradas</item>
      <item quantity="one"><xliff:g id="COUNT_0">%d</xliff:g> categoría borrada</item>
    </plurals>
    <string name="notification_toggle_on" msgid="1624283327379059003">"Activado"</string>
    <string name="notification_toggle_off" msgid="3295373308338024844">"Inhabilitado"</string>
    <string name="app_notification_block_title" msgid="3880322745749900296">"Bloquear todos"</string>
    <string name="app_notification_block_summary" msgid="1804611676339341551">"No mostrar estas notificaciones"</string>
    <string name="notification_content_block_title" msgid="6689085826061361351">"Mostrar notificaciones"</string>
    <string name="notification_content_block_summary" msgid="329171999992248925">"No mostrar notificaciones en el panel ni en dispositivos periféricos"</string>
    <string name="notification_badge_title" msgid="6854537463548411313">"Permitir punto de notificación"</string>
    <string name="notification_channel_badge_title" msgid="6505542437385640049">"Mostrar punto de notificación"</string>
    <string name="app_notification_override_dnd_title" msgid="3769539356442226691">"Anular No interrumpir"</string>
    <string name="app_notification_override_dnd_summary" msgid="4894641191397562920">"Permitir que se muestren estas notificaciones cuando No interrumpir esté activado"</string>
    <string name="app_notification_visibility_override_title" msgid="7778628150022065920">"Pantalla de bloqueo"</string>
    <string name="app_notification_row_banned" msgid="4513523107019706924">"Bloqueadas"</string>
    <string name="app_notification_row_priority" msgid="8100777138078316446">"Prioridad"</string>
    <string name="app_notification_row_sensitive" msgid="7374688948587174964">"Personal"</string>
    <string name="app_notifications_dialog_done" msgid="573716608705273004">"Listo"</string>
    <string name="app_notification_importance_title" msgid="8293193440040799998">"Importancia"</string>
    <string name="notification_show_lights_title" msgid="5564315979007438583">"Luz intermitente"</string>
    <string name="notification_vibrate_title" msgid="1422330728336623351">"Vibración"</string>
    <string name="notification_channel_sound_title" msgid="9018031231387273476">"Sonido"</string>
    <string name="notification_conversation_important" msgid="4365437037763608045">"Prioritaria"</string>
    <string name="notification_conversation_add_to_home" msgid="8136269431130231389">"Agregar al hogar"</string>
    <string name="zen_mode_rule_delete_button" msgid="7642063606919058862">"Borrar"</string>
    <string name="zen_mode_rule_rename_button" msgid="4158377587795511144">"Cambiar nombre"</string>
    <string name="zen_mode_rule_name" msgid="7303080427006917702">"Nombre"</string>
    <string name="zen_mode_rule_name_hint" msgid="7029432803855827697">"Ingresar el nombre"</string>
    <string name="zen_mode_rule_name_warning" msgid="1244435780807634954">"El nombre ya está en uso"</string>
    <string name="zen_mode_add_rule" msgid="4217731747959400770">"Agregar más"</string>
    <string name="zen_mode_add_event_rule" msgid="9179404395950854471">"Agregar programa del evento"</string>
    <string name="zen_mode_add_time_rule" msgid="2621320450155364432">"Agregar programa de hora"</string>
    <string name="zen_mode_delete_rule" msgid="5419296431989891130">"Borrar programa"</string>
    <string name="zen_mode_choose_rule_type" msgid="7656308563653982975">"Elege el tipo de programa"</string>
    <string name="zen_mode_delete_rule_confirmation" msgid="6195069346439736688">"¿Quieres borrar la regla \"<xliff:g id="RULE">%1$s</xliff:g>\"?"</string>
    <string name="zen_mode_delete_rule_button" msgid="8328729110756882244">"Borrar"</string>
    <string name="zen_mode_rule_type_unknown" msgid="7819162569994282316">"Desconocido"</string>
    <string name="zen_mode_app_set_behavior" msgid="4319517270279704677">"No se puede cambiar la configuración en este momento. Una app (<xliff:g id="APP_NAME">%1$s</xliff:g>) activó el modo \"No interrumpir\" automáticamente con comportamiento personalizado."</string>
    <string name="zen_mode_unknown_app_set_behavior" msgid="8544413884273894104">"No se puede cambiar la configuración en este momento. Una app activó el modo \"No interrumpir\" automáticamente con comportamiento personalizado."</string>
    <string name="zen_mode_qs_set_behavior" msgid="3805244555649172848">"No se puede cambiar la configuración en este momento. Se activó el modo \"No interrumpir\" de forma manual con comportamiento personalizado."</string>
    <string name="zen_schedule_rule_type_name" msgid="8071428540221112090">"Hora"</string>
    <string name="zen_schedule_rule_enabled_toast" msgid="6534402316741678208">"Se configuró la regla automática para activar No interrumpir durante los horarios especificados."</string>
    <string name="zen_event_rule_type_name" msgid="1921166617081971754">"Evento"</string>
    <string name="zen_event_rule_enabled_toast" msgid="4943723266121388395">"Se configuró la regla automática para activar No interrumpir durante los eventos especificados."</string>
    <string name="zen_mode_event_rule_calendar" msgid="6279460374929508907">"Durante los eventos de"</string>
    <string name="zen_mode_event_rule_summary_calendar_template" msgid="3065013489987409864">"Durante eventos de <xliff:g id="CALENDAR">%1$s</xliff:g>"</string>
    <string name="zen_mode_event_rule_summary_any_calendar" msgid="8395450413356855311">"cualquier calendario"</string>
    <string name="zen_mode_event_rule_summary_reply_template" msgid="7786137431469077008">"Cuando la respuesta es <xliff:g id="REPLY">%1$s</xliff:g>."</string>
    <string name="zen_mode_event_rule_calendar_any" msgid="5152139705998281205">"Cualquier calendario"</string>
    <string name="zen_mode_event_rule_reply" msgid="6099405414361340225">"Cuando la respuesta es"</string>
    <string name="zen_mode_event_rule_reply_any_except_no" msgid="4672746760505346596">"Sí, Quizás o Sin respuesta"</string>
    <string name="zen_mode_event_rule_reply_yes_or_maybe" msgid="6584448788100186574">"Sí o Quizás"</string>
    <string name="zen_mode_event_rule_reply_yes" msgid="7812120982734551236">"Sí"</string>
    <string name="zen_mode_rule_not_found_text" msgid="5303667326973891036">"No se encontró la regla."</string>
    <string name="zen_mode_rule_summary_enabled_combination" msgid="1183604368083885789">"Activado/<xliff:g id="MODE">%1$s</xliff:g>"</string>
    <string name="zen_mode_rule_summary_provider_combination" msgid="785343032708491365">"<xliff:g id="PACKAGE">%1$s</xliff:g>\n<xliff:g id="SUMMARY">%2$s</xliff:g>"</string>
    <string name="zen_mode_schedule_rule_days" msgid="8633770815307716351">"Días"</string>
    <string name="zen_mode_schedule_rule_days_none" msgid="5636604196262227070">"Ninguno"</string>
    <string name="zen_mode_schedule_rule_days_all" msgid="1583884351893245169">"Todos los días"</string>
    <string name="zen_mode_schedule_alarm_title" msgid="305237266064819345">"La alarma puede anular la hora de finalización"</string>
    <string name="zen_mode_schedule_alarm_summary" msgid="9162760856136645133">"Cuando suena la alarma, se desactiva el programa"</string>
    <string name="zen_mode_custom_behavior_title" msgid="92525364576358085">"Comportamiento del modo No interrumpir"</string>
    <string name="zen_mode_custom_behavior_summary_default" msgid="3259312823717839148">"Usar configuración predeterminada"</string>
    <string name="zen_mode_custom_behavior_summary" msgid="5390522750884328843">"Crear opciones de configuración personalizadas"</string>
    <string name="zen_mode_custom_behavior_category_title" msgid="7815612569425733764">"Durante \"<xliff:g id="SCHEDULE_NAME">%1$s</xliff:g>\""</string>
    <string name="summary_divider_text" msgid="8836285171484563986">", "</string>
    <string name="summary_range_symbol_combination" msgid="8447490077794415525">"<xliff:g id="START">%1$s</xliff:g> - <xliff:g id="END">%2$s</xliff:g>"</string>
    <string name="summary_range_verbal_combination" msgid="6022314482293187463">"De <xliff:g id="START">%1$s</xliff:g> a <xliff:g id="END">%2$s</xliff:g>"</string>
    <string name="zen_mode_conversations_title" msgid="5491912973456026379">"Conversaciones"</string>
    <string name="zen_mode_conversations_section_title" msgid="666809483050936026">"Conversaciones que pueden interrumpir"</string>
    <string name="zen_mode_from_all_conversations" msgid="3447000451361857061">"Todas las conversaciones"</string>
    <string name="zen_mode_from_important_conversations" msgid="528050873364229253">"Conversaciones prioritarias"</string>
    <string name="zen_mode_from_no_conversations" msgid="3924593219855567165">"Ninguna"</string>
    <string name="zen_mode_conversations_count" msgid="3199310723073707153">"{count,plural, =0{Ninguna}=1{1 conversación}other{# conversaciones}}"</string>
    <string name="zen_mode_people_calls_messages_section_title" msgid="6815202112413762206">"Quiénes pueden interrumpir"</string>
    <string name="zen_mode_calls_title" msgid="2078578043677037740">"Llamadas"</string>
    <string name="zen_mode_calls" msgid="7653245854493631095">"Llamadas"</string>
    <string name="zen_mode_calls_list" msgid="5044730950895749093">"llamadas"</string>
    <string name="zen_mode_calls_header" msgid="8379225445095856726">"Llamadas que pueden interrumpir"</string>
    <string name="zen_mode_calls_footer" msgid="2008079711083701243">"A fin de asegurarte de que el dispositivo suene cuando recibes llamadas permitidas, verifica que esté configurado para emitir un sonido"</string>
    <string name="zen_mode_custom_calls_footer" msgid="6521283204577441053">"Se bloquearán las llamadas entrantes durante \"<xliff:g id="SCHEDULE_NAME">%1$s</xliff:g>\". Puedes ajustar la configuración para permitir que tus amigos, familia y otros contactos se comuniquen contigo."</string>
    <string name="zen_mode_starred_contacts_title" msgid="630299631659575589">"Contactos destacados"</string>
    <string name="zen_mode_starred_contacts_summary_contacts" msgid="1629467178444895094">"{count,plural,offset:2 =0{Ninguno}=1{{contact_1}}=2{{contact_1} y {contact_2}}=3{{contact_1}, {contact_2} y {contact_3}}other{{contact_1}, {contact_2} y # más}}"</string>
    <string name="zen_mode_starred_contacts_empty_name" msgid="2906404745550293688">"(Sin nombre)"</string>
    <string name="zen_mode_messages" msgid="7315084748885170585">"Mensajes"</string>
    <string name="zen_mode_messages_list" msgid="5431014101342361882">"mensajes"</string>
    <string name="zen_mode_messages_title" msgid="1777598523485334405">"Mensajes"</string>
    <string name="zen_mode_messages_header" msgid="253721635061451577">"Mensajes que pueden interrumpir"</string>
    <string name="zen_mode_messages_footer" msgid="6002468050854126331">"A fin de asegurarte de que el dispositivo suene cuando recibas mensajes permitidos, verifica que esté configurado para emitir un sonido"</string>
    <string name="zen_mode_custom_messages_footer" msgid="7545180036949550830">"Se bloquearán los mensajes entrantes durante \"<xliff:g id="SCHEDULE_NAME">%1$s</xliff:g>\". Puedes ajustar la configuración para permitir que tus amigos, familiares y otros contactos se comuniquen contigo."</string>
    <string name="zen_mode_all_messages_summary" msgid="3756267858343104554">"Puedes recibir todos los mensajes"</string>
    <string name="zen_mode_all_calls_summary" msgid="7337907849083824698">"Puedes recibir todas las llamadas"</string>
    <string name="zen_mode_contacts_count" msgid="6568631261119795799">"{count,plural, =0{Ninguno}=1{1 contacto}other{# contactos}}"</string>
    <string name="zen_mode_from_anyone" msgid="6027004263046694174">"Cualquier usuario"</string>
    <string name="zen_mode_from_contacts" msgid="2989933306317064818">"Contactos"</string>
    <string name="zen_mode_from_starred" msgid="8616516644241652287">"Contactos destacados"</string>
    <string name="zen_calls_summary_starred_repeat" msgid="8078759939219244001">"De contactos destacados y emisores repetidos"</string>
    <string name="zen_calls_summary_contacts_repeat" msgid="2276432091940405376">"De contactos y emisores repetidos"</string>
    <string name="zen_calls_summary_repeat_only" msgid="7748352153193832632">"Solo de emisores repetidos"</string>
    <string name="zen_mode_none_calls" msgid="2047166006414016327">"Ninguna"</string>
    <string name="zen_mode_none_messages" msgid="1386626352943268342">"Ninguno"</string>
    <string name="zen_mode_alarms" msgid="5989343060100771099">"Alarmas"</string>
    <string name="zen_mode_alarms_summary" msgid="3388679177457223967">"De temporizadores, alarmas, sistemas de seguridad y otras apps"</string>
    <string name="zen_mode_alarms_list" msgid="334782233067365405">"alarmas"</string>
    <string name="zen_mode_alarms_list_first" msgid="2780418316613576610">"Alarmas"</string>
    <string name="zen_mode_media" msgid="885017672250984735">"Sonidos multimedia"</string>
    <string name="zen_mode_media_summary" msgid="7174081803853351461">"Sonidos de videos, juegos y otro contenido multimedia"</string>
    <string name="zen_mode_media_list" msgid="2006413476596092020">"contenido multimedia"</string>
    <string name="zen_mode_media_list_first" msgid="7824427062528618442">"Contenido multimedia"</string>
    <string name="zen_mode_system" msgid="7301665021634204942">"Sonidos de teclas y botones"</string>
    <string name="zen_mode_system_summary" msgid="7225581762792177522">"Sonidos del teclado y otros botones"</string>
    <string name="zen_mode_system_list" msgid="2256218792042306434">"Sonidos de teclas y botones"</string>
    <string name="zen_mode_system_list_first" msgid="8590078626001067855">"Sonidos de teclas y botones"</string>
    <string name="zen_mode_reminders" msgid="1970224691551417906">"Recordatorios"</string>
    <string name="zen_mode_reminders_summary" msgid="3961627037429412382">"De tareas y recordatorios"</string>
    <string name="zen_mode_reminders_list" msgid="3133513621980999858">"recordatorios"</string>
    <string name="zen_mode_reminders_list_first" msgid="1130470396012190814">"Recordatorios"</string>
    <string name="zen_mode_events" msgid="7425795679353531794">"Eventos del calendario"</string>
    <string name="zen_mode_events_summary" msgid="3241903481309766428">"De próximos eventos del calendario"</string>
    <string name="zen_mode_events_list" msgid="7191316245742097229">"eventos"</string>
    <string name="zen_mode_events_list_first" msgid="7425369082835214361">"Eventos"</string>
    <string name="zen_mode_bypassing_apps" msgid="625309443389126481">"Permitir que las apps anulen No interrumpir"</string>
    <string name="zen_mode_bypassing_apps_header" msgid="60083006963906906">"Apps que pueden interrumpir"</string>
    <string name="zen_mode_bypassing_apps_add_header" msgid="3201829605075172536">"Seleccionar más apps"</string>
    <string name="zen_mode_bypassing_apps_none" msgid="7944221631721778096">"No se seleccionó ninguna app"</string>
    <string name="zen_mode_bypassing_apps_subtext_none" msgid="5128770411598722200">"Ninguna app puede interrumpir"</string>
    <string name="zen_mode_bypassing_apps_add" msgid="5031919618521327102">"Agregar apps"</string>
    <string name="zen_mode_bypassing_apps_summary_all" msgid="4684544706511555744">"Todas las notificaciones"</string>
    <string name="zen_mode_bypassing_apps_summary_some" msgid="5315750826830358230">"Algunas notificaciones"</string>
    <string name="zen_mode_bypassing_apps_footer" msgid="1454862989340760124">"Las personas seleccionadas podrán comunicarse contigo, incluso si no permites que las apps causen interrupciones"</string>
    <string name="zen_mode_bypassing_apps_subtext" msgid="5258652366929842710">"{count,plural,offset:2 =0{Ninguna app puede interrumpir}=1{{app_1} puede interrumpir}=2{{app_1} y {app_2} pueden interrumpir}=3{{app_1}, {app_2} y {app_3} pueden interrumpir}other{{app_1}, {app_2} y # más pueden interrumpir}}"</string>
    <string name="zen_mode_bypassing_apps_title" msgid="371050263563164059">"Apps"</string>
    <string name="zen_mode_bypassing_apps_all_summary" msgid="5197566190120503132">"Todas las notificaciones"</string>
    <string name="zen_mode_bypassing_apps_some_summary" msgid="1514572070650411509">"Algunas notificaciones"</string>
    <string name="zen_mode_bypassing_app_channels_header" msgid="4011017798712587373">"Notificaciones que pueden interrumpir"</string>
    <string name="zen_mode_bypassing_app_channels_toggle_all" msgid="1449462656358219116">"Permitir todas las notificaciones"</string>
    <string name="zen_mode_other_sounds_summary" msgid="8784400697494837032">"{count,plural,offset:2 =0{Nada puede interrumpir}=1{{sound_category_1} puede interrumpir}=2{{sound_category_1} y {sound_category_2} pueden interrumpir}=3{{sound_category_1}, {sound_category_2} y {sound_category_3} pueden interrumpir}other{{sound_category_1}, {sound_category_2} y # más pueden interrumpir}}"</string>
    <string name="zen_mode_sounds_none" msgid="6557474361948269420">"Nada puede interrumpir"</string>
    <string name="zen_mode_people_none" msgid="4613147461974255046">"Ninguna persona puede interrumpir"</string>
    <string name="zen_mode_people_some" msgid="9101872681298810281">"Algunas personas pueden interrumpir"</string>
    <string name="zen_mode_people_all" msgid="311036110283015205">"Cualquier persona puede interrumpir"</string>
    <string name="zen_mode_repeat_callers" msgid="2270356100287792138">"Llamadas repetidas"</string>
    <string name="zen_mode_repeat_callers_title" msgid="8016699240338264781">"Permitir llamadas repetidas de un mismo emisor"</string>
    <string name="zen_mode_all_callers" msgid="8104755389401941875">"cualquiera"</string>
    <string name="zen_mode_contacts_callers" msgid="5429267704011896833">"contactos"</string>
    <string name="zen_mode_starred_callers" msgid="1002370699564211178">"contactos destacados"</string>
    <string name="zen_mode_repeat_callers_list" msgid="181819778783743847">"emisores repetidos"</string>
    <!-- no translation found for zen_mode_calls_summary_one (1928015516061784276) -->
    <skip />
    <string name="zen_mode_calls_summary_two" msgid="6351563496898410742">"<xliff:g id="CALLER_TYPE_0">%1$s</xliff:g> y <xliff:g id="CALLER_TYPE_1">%2$s</xliff:g>"</string>
    <string name="zen_mode_repeat_callers_summary" msgid="4121054819936083025">"Si la misma persona llama por segunda vez en un plazo de <xliff:g id="MINUTES">%d</xliff:g> minuto(s)"</string>
    <string name="zen_mode_behavior_summary_custom" msgid="3126805555852783860">"Personalizado"</string>
    <string name="zen_mode_when" msgid="5710214762051824755">"Activar automáticam."</string>
    <string name="zen_mode_when_never" msgid="2537537280091840672">"Nunca"</string>
    <string name="zen_mode_when_every_night" msgid="9018738747936038166">"Todas las noches"</string>
    <string name="zen_mode_when_weeknights" msgid="531342225633264368">"Noches entre semana"</string>
    <string name="zen_mode_start_time" msgid="1252665038977523332">"Hora de inicio"</string>
    <string name="zen_mode_end_time" msgid="223502560367331706">"Hora de finalización"</string>
    <string name="zen_mode_end_time_next_day_summary_format" msgid="419683704068360804">"<xliff:g id="FORMATTED_TIME">%s</xliff:g> el día siguiente"</string>
    <string name="zen_mode_summary_alarms_only_indefinite" msgid="910047326128154945">"Cambiar a solo alarmas de forma indefinida"</string>
    <plurals name="zen_mode_summary_alarms_only_by_minute" formatted="false" msgid="1900512966361163390">
      <item quantity="other">Cambiar a solo alarmas durante <xliff:g id="DURATION">%1$d</xliff:g> minutos hasta la hora <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g></item>
      <item quantity="one">Cambiar a solo alarmas durante un minuto hasta la hora <xliff:g id="FORMATTEDTIME_0">%2$s</xliff:g></item>
    </plurals>
    <plurals name="zen_mode_summary_alarms_only_by_hour" formatted="false" msgid="955991428001659124">
      <item quantity="other">Cambiar a solo alarmas durante <xliff:g id="DURATION">%1$d</xliff:g> horas hasta la hora <xliff:g id="FORMATTEDTIME_1">%2$s</xliff:g></item>
      <item quantity="one">Cambiar a solo alarmas durante una hora hasta la hora <xliff:g id="FORMATTEDTIME_0">%2$s</xliff:g></item>
    </plurals>
    <string name="zen_mode_summary_alarms_only_by_time" msgid="8140619669703968810">"Cambiar a solo alarmas hasta la(s) <xliff:g id="FORMATTEDTIME">%1$s</xliff:g>"</string>
    <string name="zen_mode_summary_always" msgid="722093064250082317">"Cambiar a interrumpir siempre"</string>
    <string name="zen_mode_screen_on" msgid="7312758100468915319">"Cuando se enciende la pantalla"</string>
    <string name="zen_mode_screen_on_summary" msgid="510055058460316698">"Permite que las notificaciones silenciadas por No interrumpir aparezcan en la pantalla y muestren un ícono en la barra de estado"</string>
    <string name="zen_mode_screen_off" msgid="7069798697669366075">"Cuando se apaga la pantalla"</string>
    <string name="zen_mode_screen_off_summary" msgid="4698018253505406152">"Permitir que las notificaciones silenciadas por el modo \"No interrumpir\" activen la pantalla y hagan parpadear la luz"</string>
    <string name="zen_mode_screen_off_summary_no_led" msgid="1958271859408992636">"Permitir que las notificaciones silenciadas por el modo \"No interrumpir\" activen la pantalla"</string>
    <string name="notification_app_settings_button" msgid="4692549882609342128">"Configuración de notificaciones"</string>
    <string name="suggestion_button_text" msgid="4370673818678692873">"Aceptar"</string>
    <string name="suggestion_button_close" msgid="6865170855573283759">"Cerrar"</string>
    <string name="device_feedback" msgid="5351614458411688608">"Enviar comentarios del dispositivo"</string>
    <string name="restr_pin_enter_admin_pin" msgid="4435410646541671918">"Ingresa el PIN de administrador"</string>
    <string name="switch_on_text" msgid="5664542327776075105">"Activada"</string>
    <string name="switch_off_text" msgid="1315547447393646667">"Desactivado"</string>
    <string name="screen_pinning_title" msgid="6927227272780208966">"Fijar apps"</string>
    <string name="app_pinning_intro" msgid="6409063008733004245">"Al fijar una app, esta se mantiene visible hasta que dejas de fijarla. Esta función se puede utilizar, por ejemplo, para dejar que alguien de confianza juegue un juego específico."</string>
    <string name="screen_pinning_description" msgid="7289730998890213708">"Si fijas una app, esta podrá abrir otras apps y acceder a tus datos personales. \n\nPara usar la fijación de apps, sigue estos pasos: 	\n1.	Activa la fijación de apps. 	\n2.	Abre Recientes. 	\n3.	Presiona el icono de la app que se encuentra en la parte superior de la pantalla y, luego, Fijar."</string>
    <string name="screen_pinning_guest_user_description" msgid="5826264265872938958">"Si fijas una app, esta podrá abrir otras apps y acceder a tus datos personales. \n\nSi quieres compartir tu dispositivo con alguien de forma segura, usa un perfil de invitado. \n\nPara usar la fijación de apps, sigue estos pasos: 	\n1.	Activa la fijación de apps. 	\n2.	Abre Recientes. 	\n3.	Presiona el icono de la app que se encuentra en la parte superior de la pantalla y, luego, Fijar."</string>
    <string name="screen_pinning_dialog_message" msgid="8144925258679476654">"Cuando fijas una app, puede ocurrir lo siguiente: \n\n•		Esta podrá acceder a datos personales (como contactos y contenido de los correos electrónicos). \n•	 Es posible que las apps fijadas abran otras apps.		 \n\nUsa la función para fijar apps solo con personas de confianza.\n"</string>
    <string name="screen_pinning_unlock_pattern" msgid="1345877794180829153">"Solicitar desbloqueo para quitar fijación"</string>
    <string name="screen_pinning_unlock_pin" msgid="8716638956097417023">"Solicitar PIN para quitar fijación"</string>
    <string name="screen_pinning_unlock_password" msgid="4957969621904790573">"Solicitar contraseña para quitar fijación"</string>
    <string name="screen_pinning_unlock_none" msgid="2474959642431856316">"Bloquear dispositivo al quitar fijación"</string>
    <string name="confirm_sim_deletion_title" msgid="9199369003530237871">"Confirmar eliminación de SIM"</string>
    <string name="confirm_sim_deletion_description" msgid="8937609409607338516">"Verifica que tu identidad antes de borrar una SIM descargada"</string>
    <string name="opening_paragraph_delete_profile_unknown_company" msgid="2951348192319498135">"La siguiente aplicación administra este perfil de trabajo:"</string>
    <string name="managing_admin" msgid="2633920317425356619">"Administrado por <xliff:g id="ADMIN_APP_LABEL">%s</xliff:g>"</string>
    <string name="experimental_preference" msgid="869354050717870055">"(Experimental)"</string>
    <string name="encryption_interstitial_header" msgid="4418014339568737685">"Inicio seguro"</string>
    <string name="encryption_continue_button" msgid="3591796237625134622">"Continuar"</string>
    <string name="encryption_interstitial_message_pin" msgid="1413575143234269985">"Puedes solicitar el PIN del dispositivo antes de iniciarlo para aumentar la protección. Mientras el dispositivo se inicia, no puede recibir llamadas, mensajes ni notificaciones, incluidas las alarmas. \n\nEsta opción ayuda a proteger los datos en dispositivos perdidos o robados. ¿Deseas solicitar el PIN para iniciar el dispositivo?"</string>
    <string name="encryption_interstitial_message_pattern" msgid="726550613252236854">"Puedes solicitar el patrón del dispositivo antes de iniciarlo para aumentar la protección. Mientras el dispositivo se inicia, no puede recibir llamadas, mensajes ni notificaciones, incluidas las alarmas. \n\nEsta opción ayuda a proteger los datos en dispositivos perdidos o robados. ¿Deseas solicitar el patrón para iniciar el dispositivo?"</string>
    <string name="encryption_interstitial_message_password" msgid="6051054565294909975">"Puedes solicitar la contraseña del dispositivo antes de iniciarlo para aumentar la protección. Mientras el dispositivo se inicia, no puede recibir llamadas, mensajes ni notificaciones, incluidas las alarmas. \n\nEsta opción ayuda a proteger los datos en dispositivos perdidos o robados. ¿Deseas solicitar contraseña para iniciar el dispositivo?"</string>
    <string name="encryption_interstitial_message_pin_for_fingerprint" msgid="7152770518093102916">"Además de usar tu huella digital para desbloquear el dispositivo, puedes solicitar el PIN antes de iniciarlo para aumentar la protección. Mientras el dispositivo se inicia, no puede recibir llamadas, mensajes, ni notificaciones, incluidas las alarmas. \n\nEsta opción ayuda a proteger los datos en dispositivos perdidos o robados. ¿Deseas solicitar el PIN para iniciar el dispositivo?"</string>
    <string name="encryption_interstitial_message_pattern_for_fingerprint" msgid="6257856552043740490">"Además de usar tu huella digital para desbloquear el dispositivo, puedes solicitar el patrón antes de iniciarlo para aumentar la protección. Mientras el dispositivo se inicia, no puede recibir llamadas, mensajes ni notificaciones, incluidas las alarmas. \n\nEsta opción ayuda a proteger los datos en dispositivos perdidos o robados. ¿Deseas solicitar el patrón para iniciar el dispositivo?"</string>
    <string name="encryption_interstitial_message_password_for_fingerprint" msgid="7710804822643612867">"Además de usar tu huella digital para desbloquear el dispositivo, puedes solicitar una contraseña antes de iniciarlo para aumentar la protección. Mientras el dispositivo se inicia, no puede recibir llamadas, mensajes ni notificaciones, incluidas las alarmas.\n\nEsta opción ayuda a proteger los datos en dispositivos perdidos o robados. ¿Deseas solicitar la contraseña para iniciar el dispositivo?"</string>
    <string name="encryption_interstitial_message_pin_for_face" msgid="8577135499926738241">"Además de usar el reconocimiento facial para desbloquear el dispositivo, puedes solicitar un PIN antes de iniciarlo para mayor protección. Mientras se enciende el dispositivo, no puede recibir llamadas, mensajes, ni notificaciones, incluidas las alarmas.\n\nEsta opción protege los datos en dispositivos perdidos o robados. ¿Quieres solicitar un PIN para iniciar el dispositivo?"</string>
    <string name="encryption_interstitial_message_pattern_for_face" msgid="5851725964283239644">"Además de usar el reconocimiento facial para desbloquear el dispositivo, puedes solicitar un patrón antes de iniciarlo para mayor protección. Mientras se enciende el dispositivo, no puede recibir llamadas, mensajes ni notificaciones, incluidas las alarmas.\n\nEsta opción protege los datos en dispositivos perdidos o robados. ¿Quieres solicitar un patrón para iniciar el dispositivo?"</string>
    <string name="encryption_interstitial_message_password_for_face" msgid="3553329272456428461">"Además de usar el reconocimiento facial para desbloquear el dispositivo, puedes solicitar una contraseña antes de iniciarlo para mayor protección. Mientras se enciende el dispositivo, no puede recibir llamadas, mensajes ni notificaciones, incluidas las alarmas.\n\nEsta opción protege los datos en dispositivos perdidos o robados. ¿Quieres solicitar una contraseña para iniciar el dispositivo?"</string>
    <string name="encryption_interstitial_message_pin_for_biometrics" msgid="4590004045791674901">"Además de usar tus datos biométricos para desbloquear el dispositivo, puedes solicitar un PIN antes de iniciarlo a fin de aumentar la protección. Mientras el dispositivo se inicia, no puede recibir llamadas, mensajes ni notificaciones, incluidas las alarmas.\n\nEsta opción ayuda a proteger los datos en dispositivos perdidos o robados. ¿Quieres solicitar un PIN para iniciar el dispositivo?"</string>
    <string name="encryption_interstitial_message_pattern_for_biometrics" msgid="2697768285995352576">"Además de usar tus datos biométricos para desbloquear el dispositivo, puedes solicitar un patrón antes de iniciarlo a fin de aumentar la protección. Mientras el dispositivo se inicia, no puede recibir llamadas, mensajes ni notificaciones, incluidas las alarmas.\n\nEsta opción ayuda a proteger los datos en dispositivos perdidos o robados. ¿Quieres solicitar un patrón para iniciar el dispositivo?"</string>
    <string name="encryption_interstitial_message_password_for_biometrics" msgid="1895561539964730123">"Además de usar tus datos biométricos para desbloquear el dispositivo, puedes solicitar una contraseña antes de iniciarlo a fin de aumentar la protección. Mientras el dispositivo se inicia, no puede recibir llamadas, mensajes ni notificaciones, incluidas las alarmas.\n\nEsta opción ayuda a proteger los datos en dispositivos perdidos o robados. ¿Quieres solicitar una contraseña para iniciar el dispositivo?"</string>
    <string name="encryption_interstitial_yes" msgid="1948016725089728181">"Sí"</string>
    <string name="encryption_interstitial_no" msgid="3352331535473118487">"No"</string>
    <string name="restricted_true_label" msgid="612852292488747564">"Restringida"</string>
    <string name="restricted_false_label" msgid="2837053797913490628">"App no restringida"</string>
    <string name="encrypt_talkback_dialog_require_pin" msgid="8974156384205924887">"¿Solicitar PIN?"</string>
    <string name="encrypt_talkback_dialog_require_pattern" msgid="1587587568721873184">"¿Solicitar patrón?"</string>
    <string name="encrypt_talkback_dialog_require_password" msgid="2701793623210531836">"¿Solicitar contraseña?"</string>
    <string name="encrypt_talkback_dialog_message_pin" msgid="4482887117824444481">"Cuando ingreses el PIN para iniciar el dispositivo, los servicios de accesibilidad, como <xliff:g id="SERVICE">%1$s</xliff:g>, aún no estarán disponibles."</string>
    <string name="encrypt_talkback_dialog_message_pattern" msgid="5156321541636018756">"Cuando ingreses el patrón para iniciar el dispositivo, los servicios de accesibilidad, como <xliff:g id="SERVICE">%1$s</xliff:g>, aún no estarán disponibles."</string>
    <string name="encrypt_talkback_dialog_message_password" msgid="1917287751192953034">"Cuando ingreses la contraseña para iniciar el dispositivo, los servicios de accesibilidad, como <xliff:g id="SERVICE">%1$s</xliff:g>, aún no estarán disponibles."</string>
    <string name="direct_boot_unaware_dialog_message" msgid="5766006106305996844">"Nota: Si reinicias el teléfono y tienes configurado un bloqueo de pantalla, no podrá iniciarse la app hasta que lo desbloquees"</string>
    <string name="imei_information_title" msgid="8703564992893669514">"Información de IMEI"</string>
    <string name="imei_information_summary" msgid="4763358372990258786">"Información relacionada con IMEI"</string>
    <string name="slot_number" msgid="2663789411468530397">"(Ranura <xliff:g id="SLOT_NUM">%1$d</xliff:g>)"</string>
    <string name="launch_by_default" msgid="892824422067985734">"Abrir de forma predet."</string>
    <string name="app_launch_domain_links_title" msgid="6702041169676128550">"Abrir vínculos"</string>
    <string name="app_launch_open_domain_urls_title" msgid="4805388403977096285">"Abrir vínculos admitidos"</string>
    <string name="app_launch_open_domain_urls_summary" msgid="3609156836041234957">"Abrir sin preguntar"</string>
    <string name="app_launch_supported_domain_urls_title" msgid="5088779668667217369">"Vínculos admitidos"</string>
    <string name="app_launch_other_defaults_title" msgid="3296350563585863885">"Otras configuraciones predeterminadas"</string>
    <string name="storage_summary_format" msgid="5721782272185284276">"<xliff:g id="SIZE">%1$s</xliff:g> en uso en <xliff:g id="STORAGE_TYPE">%2$s</xliff:g>"</string>
    <string name="storage_type_internal" msgid="979243131665635278">"almacenamiento interno"</string>
    <string name="storage_type_external" msgid="125078274000280821">"almacenamiento externo"</string>
    <string name="data_summary_format" msgid="8802057788950096650">"<xliff:g id="SIZE">%1$s</xliff:g> desde el <xliff:g id="DATE">%2$s</xliff:g>"</string>
    <string name="storage_used" msgid="2591194906751432725">"Almacenamiento utilizado"</string>
    <string name="change" msgid="273206077375322595">"Cambiar"</string>
    <string name="change_storage" msgid="8773820275624113401">"Cambiar almacenamiento"</string>
    <string name="notifications_label" msgid="8471624476040164538">"Notificaciones"</string>
    <string name="notifications_enabled" msgid="7743168481579361019">"Activadas"</string>
    <string name="notifications_enabled_with_info" msgid="1808946629277684308">"<xliff:g id="NOTIFICATIONS_SENT">%1$s</xliff:g>/<xliff:g id="NOTIFICATIONS_CATEGORIES_OFF">%2$s</xliff:g>"</string>
    <string name="notifications_disabled" msgid="5603160425378437143">"No"</string>
    <string name="notifications_partly_blocked" msgid="5738239705473445725">"<xliff:g id="COUNT_0">%1$d</xliff:g> de <xliff:g id="COUNT_1">%2$d</xliff:g> categorías desactivadas"</string>
    <string name="notifications_silenced" msgid="2673798575466545098">"Silenciada"</string>
    <string name="notifications_redacted" msgid="8820993927920208612">"Sin contenido sensible en la pantalla bloqueada"</string>
    <string name="notifications_hidden" msgid="2415415452913806859">"No se muestran en la pantalla bloqueada"</string>
    <string name="notifications_priority" msgid="9068574646650663837">"Anulan \"No interrumpir\""</string>
    <string name="notifications_summary_divider" msgid="6877149909390030983">" / "</string>
    <string name="notification_summary_level" msgid="4074326972839105652">"Nivel %d"</string>
    <string name="notification_summary_channel" msgid="8459033623057872803">"<xliff:g id="CHANNEL_NAME">%1$s</xliff:g> • <xliff:g id="GROUP_NAME">%2$s</xliff:g>"</string>
    <plurals name="notifications_categories_off" formatted="false" msgid="1385401442703692986">
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g> categorías desactivadas</item>
      <item quantity="one"><xliff:g id="COUNT_0">%d</xliff:g> categoría desactivada</item>
    </plurals>
    <plurals name="permissions_summary" formatted="false" msgid="5015472550875144481">
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g> permisos otorgados</item>
      <item quantity="one"><xliff:g id="COUNT_0">%d</xliff:g> permiso otorgado</item>
    </plurals>
    <plurals name="runtime_permissions_summary" formatted="false" msgid="2091022049141391855">
      <item quantity="other"><xliff:g id="COUNT_2">%d</xliff:g> permisos de <xliff:g id="COUNT_3">%d</xliff:g> otorgados</item>
      <item quantity="one"><xliff:g id="COUNT_0">%d</xliff:g> permiso de <xliff:g id="COUNT_1">%d</xliff:g> otorgado</item>
    </plurals>
    <plurals name="runtime_permissions_additional_count" formatted="false" msgid="5888624648943937645">
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g> permisos adicionales</item>
      <item quantity="one"><xliff:g id="COUNT_0">%d</xliff:g> permiso adicional</item>
    </plurals>
    <string name="runtime_permissions_summary_no_permissions_granted" msgid="7456745929035665029">"No se otorgaron permisos"</string>
    <string name="runtime_permissions_summary_no_permissions_requested" msgid="7174876170116073356">"No se solicitaron permisos"</string>
    <string name="runtime_permissions_summary_control_app_access" msgid="3744591396348990500">"Controla el acceso de apps a tus datos"</string>
    <string name="filter_all_apps" msgid="6645539744080251371">"Todas las apps"</string>
    <string name="filter_enabled_apps" msgid="8868356616126759124">"Apps instaladas"</string>
    <string name="filter_instant_apps" msgid="2292108467020380068">"Apps instantáneas"</string>
    <string name="filter_notif_all_apps" msgid="2764590815789208306">"Apps: Todas"</string>
    <string name="filter_notif_blocked_apps" msgid="1065653868850012325">"Desactivadas"</string>
    <string name="filter_notif_urgent_channels" msgid="875381675739324318">"Categoría: Urgente"</string>
    <string name="filter_notif_low_channels" msgid="2163005243095264537">"Categoría: Poca importancia"</string>
    <string name="filter_notif_blocked_channels" msgid="1131444963543380495">"Categoría: Desactivadas"</string>
    <string name="filter_notif_dnd_channels" msgid="13445325087914932">"Categoría: Con interrupciones"</string>
    <string name="advanced_apps" msgid="7643010673326578815">"Avanzado"</string>
    <string name="configure_apps" msgid="5468359087126598115">"Configurar apps"</string>
    <string name="unknown_app" msgid="2027248925719898714">"Aplicación desconocida"</string>
    <string name="app_permissions" msgid="8666537659217653626">"Administrador de permisos"</string>
    <string name="app_permissions_summary" msgid="2709819220672938860">"Apps que usan <xliff:g id="APPS">%1$s</xliff:g>"</string>
    <string name="app_permissions_summary_more" msgid="6247952473615352350">"Apps que usan <xliff:g id="APPS">%1$s</xliff:g> y más"</string>
    <string name="tap_to_wake" msgid="3313433536261440068">"Presionar para activar"</string>
    <string name="tap_to_wake_summary" msgid="6641039858241611072">"Presiona dos veces en cualquier lugar de la pantalla para activar el dispositivo."</string>
    <string name="domain_urls_title" msgid="7012209752049678876">"Abrir vínculos"</string>
    <string name="domain_urls_summary_none" msgid="1132578967643384733">"No abrir los vínculos admitidos"</string>
    <string name="domain_urls_summary_one" msgid="3312008753802762892">"Abrir el dominio <xliff:g id="DOMAIN">%s</xliff:g>"</string>
    <string name="domain_urls_summary_some" msgid="1197692164421314523">"Abrir <xliff:g id="DOMAIN">%s</xliff:g> y otras URL"</string>
    <string name="domain_urls_apps_summary_off" msgid="2534980824850890416">"Ninguna app puede abrir los vínculos compatibles"</string>
    <plurals name="domain_urls_apps_summary_on" formatted="false" msgid="7864816862441985323">
      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> apps que abren vínculos compatibles</item>
      <item quantity="one">1 app que abre vínculos compatibles</item>
    </plurals>
    <string name="app_link_open_always" msgid="9167065494930657503">"Permitir que la app abra vínculos compatibles"</string>
    <string name="app_link_open_ask" msgid="2422450109908936371">"Preguntar siempre"</string>
    <string name="app_link_open_never" msgid="5299808605386052350">"No permitir que la app abra vínculos compatible"</string>
    <plurals name="app_link_open_always_summary" formatted="false" msgid="1816161439007251694">
      <item quantity="other">La app indica que procesa <xliff:g id="COUNT_1">%d</xliff:g> vínculos</item>
      <item quantity="one">La app indica que procesa <xliff:g id="COUNT_0">%d</xliff:g> vínculo</item>
    </plurals>
    <string name="open_supported_links_footer" msgid="3188808142432787933">"La app indica que procesa los siguientes vínculos:"</string>
    <string name="default_apps_title" msgid="6943471331817718664">"Predeterminada"</string>
    <string name="default_for_work" msgid="537558180548617528">"Predeterminada para el trabajo"</string>
    <string name="assist_and_voice_input_title" msgid="6317935163145135914">"Asistencia y entrada de voz"</string>
    <string name="default_assist_title" msgid="1182435129627493758">"App de asistente digital"</string>
    <string name="default_digital_assistant_title" msgid="5654663086385490838">"App de asistente digital pred."</string>
    <string name="assistant_security_warning_title" msgid="6444187332360938730">"¿Deseas que <xliff:g id="ASSISTANT_APP_NAME">%s</xliff:g> sea tu asistente?"</string>
    <string name="assistant_security_warning" msgid="5623237187748811070">"El asistente podrá leer información sobre las aplicaciones en uso en el sistema, incluida la información visible en la pantalla o accesible en las aplicaciones."</string>
    <string name="assistant_security_warning_agree" msgid="9013334158753473359">"Aceptar"</string>
    <string name="assistant_security_warning_disagree" msgid="1539182108068356410">"Rechazar"</string>
    <string name="choose_voice_input_title" msgid="4855506199101586943">"Elegir la entrada de voz"</string>
    <string name="default_browser_title" msgid="8342074390782390458">"Navegador"</string>
    <string name="default_browser_title_none" msgid="4691907418284764833">"No hay un navegador predeterminado."</string>
    <string name="default_phone_title" msgid="7616730756650803827">"Teléfono"</string>
    <string name="default_app" msgid="445053777504688596">"(Predeterminada)"</string>
    <string name="system_app" msgid="1863291702508355041">"(Sistema)"</string>
    <string name="system_default_app" msgid="2647834628622214931">"(Predeterminada de sistema)"</string>
    <string name="apps_storage" msgid="643866814746927111">"Almacenamiento de apps"</string>
    <string name="usage_access" msgid="5487993885373893282">"Acceso a datos de uso"</string>
    <string name="permit_usage_access" msgid="179630895262172674">"Apps con acceso de uso"</string>
    <string name="app_usage_preference" msgid="7062447555623339120">"Preferencias de uso de la aplicación"</string>
    <string name="time_spent_in_app_pref_title" msgid="25327097913383330">"Tiempo de uso"</string>
    <string name="usage_access_description" msgid="8547716253713890707">"El acceso a los datos de uso permite que una aplicación controle qué otras aplicaciones utilizas y con qué frecuencia, así como el operador, la configuración de idioma y otros detalles."</string>
    <string name="memory_settings_title" msgid="6582588646363308430">"Memoria"</string>
    <string name="memory_details_title" msgid="3048107441540417799">"Detalles de la memoria"</string>
    <string name="always_running" msgid="9012705720688200252">"Siempre en ejecución (<xliff:g id="PERCENTAGE">%s</xliff:g>)"</string>
    <string name="sometimes_running" msgid="7954947311082655448">"A veces en ejecución (<xliff:g id="PERCENTAGE">%s</xliff:g>)"</string>
    <string name="rarely_running" msgid="2704869567353196798">"Casi nunca en ejecución (<xliff:g id="PERCENTAGE">%s</xliff:g>)"</string>
    <string name="memory_max_use" msgid="8721866158069974846">"Máximo"</string>
    <string name="memory_avg_use" msgid="4620476409349875703">"Promedio"</string>
    <string name="memory_max_desc" msgid="6966923521720393526">"Máximo de <xliff:g id="MEMORY">%1$s</xliff:g>"</string>
    <string name="memory_avg_desc" msgid="2632995851138152303">"Promedio de <xliff:g id="MEMORY">%1$s</xliff:g>"</string>
    <string name="memory_use_running_format" msgid="4376086847362492613">"<xliff:g id="MEMORY">%1$s</xliff:g>/<xliff:g id="RUNNING">%2$s</xliff:g>"</string>
    <string name="process_format" msgid="4239069158701023623">"<xliff:g id="APP_NAME">%1$s</xliff:g> (<xliff:g id="COUNT">%2$d</xliff:g>)"</string>
    <string name="high_power_apps" msgid="5623152700992102510">"Optimización de la batería"</string>
    <string name="additional_battery_info" msgid="3104208543623068714">"Alertas de uso"</string>
    <string name="show_all_apps" msgid="4490719452453223082">"Mostrar uso completo del dispositivo"</string>
    <string name="hide_extra_apps" msgid="7313907836289865123">"Mostrar uso de apps"</string>
    <plurals name="power_high_usage_summary" formatted="false" msgid="573433136005336970">
      <item quantity="other"><xliff:g id="NUMBER">%2$d</xliff:g> apps no funcionan correctamente</item>
      <item quantity="one"><xliff:g id="APP">%1$s</xliff:g> no funciona correctamente</item>
    </plurals>
    <plurals name="power_high_usage_title" formatted="false" msgid="8013115866788425817">
      <item quantity="other"> apps agotan la batería</item>
      <item quantity="one"><xliff:g id="APP">%1$s</xliff:g> agota la batería</item>
    </plurals>
    <string name="high_power_filter_on" msgid="447849271630431531">"Sin optimizar"</string>
    <string name="high_power_on" msgid="8778058701270819268">"Sin optimizar"</string>
    <string name="high_power_off" msgid="317000444619279018">"Optimizando el uso de la batería"</string>
    <string name="high_power_system" msgid="3966701453644915787">"Optimización de la batería no disponible"</string>
    <string name="high_power_desc" msgid="2753076899835765338">"No se aplica la optimización de la batería, por lo que se puede agotar más rápido."</string>
    <string name="high_power_prompt_title" msgid="2574478825228409124">"¿Permitir que la app se ejecute siempre en segundo plano?"</string>
    <string name="high_power_prompt_body" msgid="6460557929559616041">"Si permites que <xliff:g id="APP_NAME">%1$s</xliff:g> se ejecute siempre en segundo plano, es posible que se reduzca la duración de la batería. \n\nPuedes cambiar esta opción más tarde en Configuración &gt; Apps y notificaciones."</string>
    <string name="battery_summary" msgid="2491764359695671207">"Se usó el <xliff:g id="PERCENTAGE">%1$s</xliff:g> desde la última carga completa"</string>
    <string name="battery_power_management" msgid="7507188088567087384">"Administración de energía"</string>
    <string name="no_battery_summary" msgid="5769159953384122003">"No se usó la batería desde la última carga completa"</string>
    <string name="app_notification_preferences" msgid="2004680717999108725">"Configuración de la aplicación"</string>
    <string name="system_ui_settings" msgid="936169564323330967">"Mostrar sintonizador de IU del sistema"</string>
    <string name="additional_permissions" msgid="4656871347558988462">"Permisos adicionales"</string>
    <string name="additional_permissions_more" msgid="8188145515437525307">"<xliff:g id="COUNT">%1$d</xliff:g> más"</string>
    <string name="share_remote_bugreport_dialog_title" msgid="1575283098565582433">"¿Deseas compartir el informe de errores?"</string>
    <string name="share_remote_bugreport_dialog_message_finished" msgid="4869053468609007680">"El administrador de TI solicitó un informe de errores para solucionar los problemas de este dispositivo. Es posible que se compartan apps y datos."</string>
    <string name="share_remote_bugreport_dialog_message" msgid="8714439220818865391">"El administrador de TI solicitó un informe de errores para solucionar los problemas de este dispositivo. Es posible que se compartan apps y datos, y que el dispositivo se ralentice temporalmente."</string>
    <string name="sharing_remote_bugreport_dialog_message" msgid="3523877008096439251">"Este informe de errores se compartirá con tu administrador de TI. Para obtener más información, comunícate con él."</string>
    <string name="share_remote_bugreport_action" msgid="7173093464692893276">"Compartir"</string>
    <string name="decline_remote_bugreport_action" msgid="1276509879613158895">"Rechazar"</string>
    <string name="usb_use_charging_only" msgid="1743303747327057947">"Sin transferencia de datos"</string>
    <string name="usb_use_charging_only_desc" msgid="1234421230461847336">"Solo cargar el dispositivo"</string>
    <string name="usb_use_power_only" msgid="3408055485802114621">"Cargar dispositivo conectado"</string>
    <string name="usb_use_file_transfers" msgid="483915710802018503">"Transferencia de archivos"</string>
    <string name="usb_use_file_transfers_desc" msgid="1020257823387107336">"Transferir archivos a otro dispositivo"</string>
    <string name="usb_use_photo_transfers" msgid="4641181628966036093">"PTP"</string>
    <string name="usb_use_photo_transfers_desc" msgid="7490250033610745765">"Transferir fotos o archivos si no se admite MTP (PTP)"</string>
    <string name="usb_use_tethering" msgid="2897063414491670531">"Conexión a red por USB"</string>
    <string name="usb_use_MIDI" msgid="8621338227628859789">"MIDI"</string>
    <string name="usb_use_MIDI_desc" msgid="6464135515868405143">"Usar este dispositivo como MIDI"</string>
    <string name="usb_use" msgid="6783183432648438528">"Utilizar USB para lo siguiente:"</string>
    <string name="usb_default_label" msgid="3372838450371060750">"Configuración predeterminada de USB"</string>
    <string name="usb_default_info" msgid="167172599497085266">"Si conectas otro dispositivo cuando tu teléfono está desbloqueado, se aplicará esta configuración. Solo debes conectar dispositivos de confianza."</string>
    <!-- no translation found for usb_power_title (5602112548385798646) -->
    <skip />
    <string name="usb_pref" msgid="8521832005703261700">"USB"</string>
    <string name="usb_preference" msgid="5084550082591493765">"Preferencias de USB"</string>
    <string name="usb_control_title" msgid="1946791559052157693">"USB controlado por"</string>
    <string name="usb_control_host" msgid="7404215921555021871">"Dispositivo conectado"</string>
    <string name="usb_control_device" msgid="527916783743021577">"Este dispositivo"</string>
    <string name="usb_switching" msgid="3654709188596609354">"Cambiando…"</string>
    <string name="usb_switching_failed" msgid="5721262697715454137">"No se pudo cambiar"</string>
    <string name="usb_summary_charging_only" msgid="678095599403565146">"Cargando este dispositivo"</string>
    <string name="usb_summary_power_only" msgid="4901734938857822887">"Cargando dispositivo conectado"</string>
    <string name="usb_summary_file_transfers" msgid="5498487271972556431">"Transferencia de archivos"</string>
    <string name="usb_summary_tether" msgid="2554569836525075702">"Conexión a red por USB"</string>
    <string name="usb_summary_photo_transfers" msgid="7331503733435780492">"PTP"</string>
    <string name="usb_summary_MIDI" msgid="2372443732675899571">"MIDI"</string>
    <string name="usb_summary_file_transfers_power" msgid="2788374660532868630">"Transferencia de archivos y carga"</string>
    <string name="usb_summary_tether_power" msgid="4853034392919904792">"Conexión USB y de carga"</string>
    <string name="usb_summary_photo_transfers_power" msgid="9077173567697482239">"PTP y carga"</string>
    <string name="usb_summary_MIDI_power" msgid="1184681982025435815">"Modo MIDI y carga"</string>
    <string name="background_check_pref" msgid="5304564658578987535">"Verificación en segundo plano"</string>
    <string name="background_check_title" msgid="225170874283229686">"Acceso en segundo plano completo"</string>
    <string name="assist_access_context_title" msgid="5201495523514096201">"Utilizar el texto de la pantalla"</string>
    <string name="assist_access_context_summary" msgid="6951814413185646275">"Permitir que la aplicación de asistencia acceda a los contenidos de la pantalla como texto"</string>
    <string name="assist_access_screenshot_title" msgid="4395902231753643633">"Utilizar la captura de pantalla"</string>
    <string name="assist_access_screenshot_summary" msgid="5276593070956201863">"Permitir que la aplicación de asistencia acceda a una imagen de la pantalla"</string>
    <string name="assist_flash_title" msgid="5449512572885550108">"Iluminar pantalla"</string>
    <string name="assist_flash_summary" msgid="3032289860177784594">"Iluminar los bordes de la pantalla cuando la app de asistencia acceda al texto desde la pantalla o una captura de pantalla"</string>
    <string name="assist_footer" msgid="8248015363806299068">"Las aplicaciones de asistencia pueden brindarte ayuda en función de la pantalla que estás viendo. Para ofrecerte asistencia integrada, algunas aplicaciones son compatibles con los servicios de selector y entrada de voz."</string>
    <string name="average_memory_use" msgid="717313706368825388">"Uso promedio de la memoria"</string>
    <string name="maximum_memory_use" msgid="2171779724001152933">"Uso máximo de la memoria"</string>
    <string name="memory_usage" msgid="5594133403819880617">"Uso de la memoria"</string>
    <string name="app_list_memory_use" msgid="3178720339027577869">"Uso de aplicaciones"</string>
    <string name="memory_details" msgid="6133226869214421347">"Detalles"</string>
    <string name="memory_use_summary" msgid="3915964794146424142">"Se utilizó un promedio de <xliff:g id="SIZE">%1$s</xliff:g> de memoria en las últimas tres horas"</string>
    <string name="no_memory_use_summary" msgid="6708111974923274436">"No se utilizó la memoria en las últimas tres horas"</string>
    <string name="sort_avg_use" msgid="4416841047669186903">"Ordenar según el uso promedio"</string>
    <string name="sort_max_use" msgid="3370552820889448484">"Ordenar según el uso máximo"</string>
    <string name="memory_performance" msgid="5448274293336927570">"Rendimiento"</string>
    <string name="total_memory" msgid="5244174393008910567">"Memoria total"</string>
    <string name="average_used" msgid="690235917394070169">"Uso promedio (%)"</string>
    <string name="free_memory" msgid="439783742246854785">"Libre(s)"</string>
    <string name="memory_usage_apps" msgid="5776108502569850579">"Memoria que utilizan las aplicaciones"</string>
    <plurals name="memory_usage_apps_summary" formatted="false" msgid="1355637088533572208">
      <item quantity="other"><xliff:g id="COUNT">%1$d</xliff:g> aplicaciones usaron la memoria en las últimas <xliff:g id="DURATION_1">%2$s</xliff:g>.</item>
      <item quantity="one">1 aplicación usó la memoria en las últimas <xliff:g id="DURATION_0">%2$s</xliff:g>.</item>
    </plurals>
    <string name="running_frequency" msgid="7260225121706316639">"Frecuencia"</string>
    <string name="memory_maximum_usage" msgid="2047013391595835607">"Uso máximo"</string>
    <string name="no_data_usage" msgid="4665617440434654132">"No se usaron datos"</string>
    <string name="zen_access_warning_dialog_title" msgid="6323325813123130154">"¿Quieres que la app <xliff:g id="APP">%1$s</xliff:g> tenga acceso a No interrumpir?"</string>
    <string name="zen_access_warning_dialog_summary" msgid="8468714854067428987">"La aplicación podrá activar y desactivar la función No interrumpir y realizar cambios de configuración relacionados."</string>
    <string name="zen_access_disabled_package_warning" msgid="6565908224294537889">"Debe seguir activado porque el acceso a las notificaciones está activado"</string>
    <string name="zen_access_revoke_warning_dialog_title" msgid="7377261509261811449">"¿Quieres revocar el acceso de la app <xliff:g id="APP">%1$s</xliff:g> en No interrumpir?"</string>
    <string name="zen_access_revoke_warning_dialog_summary" msgid="8689801842914183595">"Se quitarán todas las normas del modo No interrumpir que creó esta app."</string>
    <string name="ignore_optimizations_on" msgid="6865583039303804932">"No optimizar"</string>
    <string name="ignore_optimizations_off" msgid="9186557038453586295">"Optimizar"</string>
    <string name="ignore_optimizations_on_desc" msgid="1280043916460939932">"Es posible que la batería se agote más rápido. La app ya no tendrá restricciones para usar batería en segundo plano."</string>
    <string name="ignore_optimizations_off_desc" msgid="3324571675983286177">"Es recomendable para una mayor duración de la batería"</string>
    <string name="ignore_optimizations_title" msgid="3464172726254542889">"¿Deseas permitir que la aplicación <xliff:g id="APP">%s</xliff:g> ignore las optimizaciones de la batería?"</string>
    <string name="app_list_preference_none" msgid="1635406344616653756">"Ninguno"</string>
    <string name="work_profile_usage_access_warning" msgid="3477719910927319122">"Desactivar el acceso al uso de datos para esta app no evitará que el administrador realice el seguimiento del uso de datos de las apps de tu perfil de trabajo"</string>
    <string name="accessibility_lock_screen_progress" msgid="4597298121698665401">"Caracteres utilizados: <xliff:g id="COUNT_0">%1$d</xliff:g> de <xliff:g id="COUNT_1">%2$d</xliff:g>"</string>
    <string name="draw_overlay" msgid="7902083260500573027">"Mostrar sobre otras apps"</string>
    <string name="system_alert_window_settings" msgid="6458633954424862521">"Mostrar sobre otras apps"</string>
    <string name="system_alert_window_apps_title" msgid="1537949185175079866">"Aplicaciones"</string>
    <string name="system_alert_window_access_title" msgid="3074573819155116817">"Mostrar sobre otras apps"</string>
    <string name="permit_draw_overlay" msgid="4468994037192804075">"Permitir mostrar sobre otras apps"</string>
    <string name="allow_overlay_description" msgid="1607235723669496298">"Permite que esta app se muestre sobre otras en uso. La app podrá ver si tocas o cambias lo que aparece en la pantalla."</string>
    <string name="manage_external_storage_title" msgid="8024521099838816100">"Acceso a todos los archivos"</string>
    <string name="permit_manage_external_storage" msgid="6928847280689401761">"Permitir administrar todos los archivos"</string>
    <string name="allow_manage_external_storage_description" msgid="5707948153603253225">"Permite que esta app lea, modifique y borre todos los archivos en el dispositivo o cualquier volumen de almacenamiento conectado. Si habilitas el permiso, es posible que la app acceda a archivos sin tu conocimiento explícito."</string>
    <string name="filter_manage_external_storage" msgid="6751640571715343804">"Pueden acceder a todos los archivos"</string>
    <string name="keywords_vr_listener" msgid="902737490270081131">"rv, procesador de realidad virtual, estéreo, servicio de ayuda"</string>
    <string name="overlay_settings" msgid="2030836934139139469">"Mostrar sobre otras apps"</string>
    <string name="system_alert_window_summary" msgid="1435856750594492891">"<xliff:g id="COUNT_0">%1$d</xliff:g> de <xliff:g id="COUNT_1">%2$d</xliff:g> apps que pueden mostrarse sobre otras apps"</string>
    <string name="filter_overlay_apps" msgid="2483998217116789206">"Aplicaciones con permiso"</string>
    <string name="app_permission_summary_allowed" msgid="1155115629167757278">"Permitido"</string>
    <string name="app_permission_summary_not_allowed" msgid="2673793662439097900">"No permitido"</string>
    <string name="keywords_install_other_apps" msgid="563895867658775580">"instalar, apps, fuentes desconocidas"</string>
    <string name="write_settings" msgid="6864794401614425894">"Modificar conf. sistema"</string>
    <string name="keywords_write_settings" msgid="6908708078855507813">"editar, modificar, sistema, configuración"</string>
    <string name="write_settings_summary" msgid="2085800775513476479">"<xliff:g id="COUNT_0">%1$d</xliff:g> de <xliff:g id="COUNT_1">%2$d</xliff:g> aplicaciones pueden modificar la config. del sistema"</string>
    <string name="filter_install_sources_apps" msgid="6930762738519588431">"Puede instalar otras apps"</string>
    <string name="filter_write_settings_apps" msgid="4754994984909024093">"Puede modificar la configuración del sistema"</string>
    <string name="write_settings_title" msgid="3011034187823288557">"Puede modificar la configuración del sistema"</string>
    <string name="write_system_settings" msgid="5555707701419757421">"Modificar conf. sistema"</string>
    <string name="permit_write_settings" msgid="3113056800709924871">"Permitir cambios en configuración del sistema"</string>
    <string name="write_settings_description" msgid="1474881759793261146">"Este permiso admite que una aplicación modifique la configuración del sistema."</string>
    <string name="write_settings_on" msgid="8533286548451191112">"Sí"</string>
    <string name="write_settings_off" msgid="1781103034490679144">"No"</string>
    <string name="external_source_switch_title" msgid="101571983954849473">"Confiar en esta fuente"</string>
    <string name="camera_gesture_title" msgid="5559439253128696180">"Gira la muñeca dos veces para la cámara"</string>
    <string name="camera_gesture_desc" msgid="7557645057320805328">"Gira la muñeca dos veces para abrir la aplicación de la cámara"</string>
    <string name="camera_double_tap_power_gesture_title" msgid="8264757967127716261">"Botón de encendido dos veces para cámara"</string>
    <string name="camera_double_tap_power_gesture_desc" msgid="1539147023700755155">"Abre la cámara de forma rápida sin desbloquear la pantalla"</string>
    <string name="screen_zoom_title" msgid="6928045302654960559">"Tamaño en pantalla"</string>
    <string name="screen_zoom_short_summary" msgid="2458636490408833800">"Aumenta o reduce el tamaño de los elementos en pantalla"</string>
    <string name="screen_zoom_keywords" msgid="5964023524422386592">"densidad de la pantalla, zoom de la pantalla, escala"</string>
    <string name="screen_zoom_summary" msgid="1362984939045594989">"Aumenta o reduce el tamaño de los elementos en pantalla. Algunas apps pueden cambiar de posición."</string>
    <string name="screen_zoom_preview_title" msgid="5288355628444562735">"Vista previa"</string>
    <string name="screen_zoom_make_smaller_desc" msgid="2628662648068995971">"Reducir el tamaño"</string>
    <string name="screen_zoom_make_larger_desc" msgid="7268794713428853139">"Aumentar el tamaño"</string>
    <string name="screen_zoom_conversation_icon_alex" msgid="2896036059049355968">"A"</string>
    <string name="screen_zoom_conversation_icon_pete" msgid="4873109337506890558">"P"</string>
    <string name="screen_zoom_conversation_message_1" msgid="2641317981482545659">"¡Hola!"</string>
    <string name="screen_zoom_conversation_message_2" msgid="6528272610590915790">"¿Quieres que tomemos un café y nos pongamos al día?"</string>
    <string name="screen_zoom_conversation_message_3" msgid="6930848361702066106">"Me encanta la idea. Conozco un buen lugar cerca de aquí."</string>
    <string name="screen_zoom_conversation_message_4" msgid="2501043894465807210">"¡Perfecto!"</string>
    <string name="screen_zoom_conversation_timestamp_1" msgid="512353741016062507">"Mar 6:00 p.m."</string>
    <string name="screen_zoom_conversation_timestamp_2" msgid="472183807915497199">"Mar 6:01 p.m."</string>
    <string name="screen_zoom_conversation_timestamp_3" msgid="1659313906250856104">"Mar 6:02 p.m."</string>
    <string name="screen_zoom_conversation_timestamp_4" msgid="2046797647382623313">"Mar 6:03 p.m."</string>
    <string name="disconnected" msgid="3469373726996129247">"Sin conexión"</string>
    <string name="keyboard_disconnected" msgid="796053864561894531">"No conectado"</string>
    <string name="data_usage_summary_format" msgid="6844301859713164522">"<xliff:g id="AMOUNT">%1$s</xliff:g> de datos usados"</string>
    <string name="data_usage_wifi_format" msgid="7644390582649568117">"Uso de datos con Wi‑Fi: <xliff:g id="AMOUNT">^1</xliff:g>"</string>
    <plurals name="notification_summary" formatted="false" msgid="7638388920823212470">
      <item quantity="other">Desactivadas para <xliff:g id="COUNT">%d</xliff:g> apps</item>
      <item quantity="one">Desactivadas para 1 app</item>
    </plurals>
    <string name="notification_summary_none" msgid="9179312319023988089">"Activadas para todas las apps"</string>
    <string name="apps_summary" msgid="4007416751775414252">"<xliff:g id="COUNT">%1$d</xliff:g> apps instaladas"</string>
    <string name="apps_summary_example" msgid="6034002063446955592">"Apps instaladas: 24"</string>
    <string name="storage_summary" msgid="5903562203143572768">"En uso: <xliff:g id="PERCENTAGE">%1$s</xliff:g> - Libre: <xliff:g id="FREE_SPACE">%2$s</xliff:g>"</string>
    <string name="storage_summary_with_sdcard" msgid="2063780050580228868">"Almacenamiento interno: <xliff:g id="PERCENTAGE">%1$s</xliff:g> en uso (<xliff:g id="FREE_SPACE">%2$s</xliff:g> libre)"</string>
    <string name="display_summary" msgid="5526061030874717172">"Suspender después de <xliff:g id="TIMEOUT_DESCRIPTION">%1$s</xliff:g> de inactividad"</string>
    <string name="display_dashboard_summary" msgid="5102247404958535634">"Fondo de pantalla, suspender, tamaño de fuente"</string>
    <string name="display_dashboard_summary_with_style" msgid="2792175367835485163">"Estilos, fondos de pantalla, tiempo de espera de la pantalla, tamaño de fuente"</string>
    <string name="display_dashboard_nowallpaper_summary" msgid="6198590533661927162">"Suspender, tamaño de fuente"</string>
    <string name="display_summary_example" msgid="4275121979039344438">"Suspender después de 10 minutos de inactividad"</string>
    <string name="memory_summary" msgid="8221954450951651735">"Se usó un promedio de <xliff:g id="USED_MEMORY">%1$s</xliff:g> de <xliff:g id="TOTAL_MEMORY">%2$s</xliff:g> memoria"</string>
    <string name="users_summary" msgid="8473589474976307510">"Accediste como <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="payment_summary" msgid="5513009140568552693">"App predeterminada: <xliff:g id="APP_NAME">%1$s</xliff:g>"</string>
    <string name="backup_disabled" msgid="4503062265560959320">"Copia de seguridad inhabilitada"</string>
    <string name="android_version_summary" msgid="7818952662015042768">"Se actualizó a Android <xliff:g id="VERSION">%1$s</xliff:g>"</string>
    <string name="android_version_pending_update_summary" msgid="5404532347171027730">"Actualización disponible"</string>
    <string name="disabled_by_policy_title" msgid="8296938784202750494">"Acción no permitida"</string>
    <string name="disabled_by_policy_title_adjust_volume" msgid="1669689058213728099">"No se puede cambiar el volumen"</string>
    <string name="disabled_by_policy_title_outgoing_calls" msgid="2776004460663768982">"No está permitido hacer llamadas"</string>
    <string name="disabled_by_policy_title_sms" msgid="6309460145439706922">"No está permitido enviar SMS"</string>
    <string name="disabled_by_policy_title_camera" msgid="8567781468959299078">"No está permitido usar la cámara"</string>
    <string name="disabled_by_policy_title_screen_capture" msgid="6137746705692573992">"No está permitido tomar capturas de pantalla"</string>
    <string name="disabled_by_policy_title_suspend_packages" msgid="4223983156635729793">"No se puede abrir esta app"</string>
    <string name="default_admin_support_msg" msgid="8338570262037182531">"Si tienes alguna pregunta, comunícate con tu administrador de TI"</string>
    <string name="admin_support_more_info" msgid="8407433155725898290">"Más detalles"</string>
    <string name="admin_profile_owner_message" msgid="8860709969532649195">"El administrador puede controlar y administrar las apps y los datos asociados con tu perfil de trabajo, incluida la configuración, los permisos, el acceso corporativo, la actividad de la red y la información de la ubicación del dispositivo."</string>
    <string name="admin_profile_owner_user_message" msgid="4929926887231544950">"El administrador puede controlar y administrar las apps y los datos asociados con este usuario, incluida la configuración, los permisos, el acceso corporativo, la actividad de la red y la información de la ubicación del dispositivo."</string>
    <string name="admin_device_owner_message" msgid="5503131744126520590">"El administrador puede controlar y administrar las apps y los datos asociados con este dispositivo, incluida la configuración, los permisos, el acceso corporativo, la actividad de red y la información de la ubicación del dispositivo."</string>
    <string name="condition_turn_off" msgid="402707350778441939">"Desactivar"</string>
    <string name="condition_turn_on" msgid="3911077299444314791">"Activar"</string>
    <string name="condition_expand_show" msgid="1501084007540953213">"Mostrar"</string>
    <string name="condition_expand_hide" msgid="8347564076209121058">"Ocultar"</string>
    <string name="condition_hotspot_title" msgid="7903918338790641071">"El hotspot está activo"</string>
    <string name="condition_airplane_title" msgid="5847967403687381705">"El modo de avión está activado"</string>
    <string name="condition_airplane_summary" msgid="1964500689287879888">"Redes no disponibles"</string>
    <string name="condition_zen_title" msgid="7674761111934567490">"\"No interrumpir\" activado"</string>
    <string name="condition_zen_summary_phone_muted" msgid="6516753722927681820">"Se silenció el teléfono"</string>
    <string name="condition_zen_summary_with_exceptions" msgid="9019937492602199663">"Con excepciones"</string>
    <string name="condition_battery_title" msgid="6395113995454385248">"Ahorro de batería activado"</string>
    <string name="condition_battery_summary" msgid="8436806157833107886">"Funciones restringidas"</string>
    <string name="condition_cellular_title" msgid="155474690792125747">"Datos móviles desactivados"</string>
    <string name="condition_cellular_summary" msgid="1678098728303268851">"Solo se puede acceder a Internet mediante Wi‑Fi"</string>
    <string name="condition_bg_data_title" msgid="2719263664589753094">"Ahorro de datos"</string>
    <string name="condition_bg_data_summary" msgid="1736255283216193834">"Funciones restringidas"</string>
    <string name="condition_work_title" msgid="174326145616998813">"Perfil de trabajo desactivado"</string>
    <string name="condition_work_summary" msgid="7113473121312772398">"Para apps y notificaciones"</string>
    <string name="condition_device_muted_action_turn_on_sound" msgid="4078406807327674934">"Activar sonido"</string>
    <string name="condition_device_muted_title" msgid="2446306263428466378">"Se silenció el timbre"</string>
    <string name="condition_device_muted_summary" msgid="3772178424510397327">"Para llamadas y notificaciones"</string>
    <string name="condition_device_vibrate_title" msgid="9058943409545158583">"Solo vibración"</string>
    <string name="condition_device_vibrate_summary" msgid="7537724181691903202">"Para llamadas y notificaciones"</string>
    <string name="night_display_suggestion_title" msgid="5418911386429667704">"Programar Luz nocturna"</string>
    <string name="night_display_suggestion_summary" msgid="4218017907425509769">"Cambiar automáticamente el tono de la pantalla por la noche"</string>
    <string name="condition_night_display_title" msgid="1072880897812554421">"\"Luz nocturna\" activada"</string>
    <string name="condition_night_display_summary" msgid="3278349775875166984">"La pantalla adopta un tono ámbar"</string>
    <string name="condition_grayscale_title" msgid="9029271080007984542">"Escala de grises"</string>
    <string name="condition_grayscale_summary" msgid="1306034149271251292">"Mostrar únicamente en color gris"</string>
    <string name="homepage_condition_footer_content_description" msgid="1568313430995646108">"Contraer"</string>
    <string name="suggestions_title_v2" msgid="421003737901460147">"Sugerencias para ti"</string>
    <string name="suggestions_title" msgid="61841299295602686">"Sugerencias"</string>
    <string name="suggestions_summary" msgid="1709710458908440469">"+<xliff:g id="ID_1">%1$d</xliff:g>"</string>
    <string name="suggestions_more_title" msgid="240124526378997009">"y <xliff:g id="ID_1">%1$d</xliff:g> más"</string>
    <plurals name="suggestions_collapsed_title" formatted="false" msgid="5023679825210836444">
      <item quantity="other"><xliff:g id="COUNT">%1$d</xliff:g> sugerencias</item>
      <item quantity="one">1 sugerencia</item>
    </plurals>
    <plurals name="suggestions_collapsed_summary" formatted="false" msgid="3789011332018516832">
      <item quantity="other"><xliff:g id="COUNT">%1$d</xliff:g> sugerencias más</item>
      <item quantity="one">1 sugerencia más</item>
    </plurals>
    <string name="suggestion_remove" msgid="6753986344585367776">"Quitar"</string>
    <string name="color_temperature" msgid="8256912135746305176">"Temperatura de colores fríos"</string>
    <string name="color_temperature_desc" msgid="6713259535885669622">"Usar colores de pantalla más fríos"</string>
    <string name="color_temperature_toast" msgid="7611532183532407342">"Para aplicar el cambio de color, apaga la pantalla"</string>
    <string name="camera_laser_sensor_switch" msgid="7097842750947187671">"Sensor láser de la cámara"</string>
    <string name="ota_disable_automatic_update" msgid="1953894421412420231">"Actualizaciones automáticas del sistema"</string>
    <string name="ota_disable_automatic_update_summary" msgid="7803279951533276841">"Aplicar actualizaciones al reiniciar el dispositivo"</string>
    <string name="usage" msgid="287782903846013936">"Uso"</string>
    <string name="cellular_data_usage" msgid="5874156338825285334">"Uso de datos móviles"</string>
    <string name="app_cellular_data_usage" msgid="7603292978956033926">"Uso de datos de la app"</string>
    <string name="wifi_data_usage" msgid="6868503699134605707">"Uso de datos Wi‑Fi"</string>
    <string name="non_carrier_data_usage" msgid="6494603202578414755">"Uso de datos que no corresponde al proveedor"</string>
    <string name="ethernet_data_usage" msgid="4552227880905679761">"Uso de datos de Ethernet"</string>
    <string name="wifi" msgid="2932584495223243842">"Wi-Fi"</string>
    <string name="ethernet" msgid="4665162609974492983">"Ethernet"</string>
    <string name="cell_data_template" msgid="6077963976103260821">"Datos móviles: <xliff:g id="AMOUNT">^1</xliff:g>"</string>
    <string name="wifi_data_template" msgid="935934798340307438">"Datos de Wi-Fi: <xliff:g id="AMOUNT">^1</xliff:g>"</string>
    <string name="ethernet_data_template" msgid="1429173767445201145">"Datos de Ethernet: <xliff:g id="AMOUNT">^1</xliff:g>"</string>
    <string name="billing_cycle" msgid="6618424022653876279">"Límite y advertencia de datos"</string>
    <string name="app_usage_cycle" msgid="341009528778520583">"Ciclo de uso de datos móviles"</string>
    <string name="cell_data_warning" msgid="5664921950473359634">"Advertencia de datos: <xliff:g id="ID_1">^1</xliff:g>"</string>
    <string name="cell_data_limit" msgid="256855024790622112">"Límite de datos: <xliff:g id="ID_1">^1</xliff:g>"</string>
    <string name="cell_data_warning_and_limit" msgid="8393200831986035724">"Advertencia de datos: <xliff:g id="ID_1">^1</xliff:g>/Límite de datos: <xliff:g id="ID_2">^2</xliff:g>"</string>
    <string name="billing_cycle_fragment_summary" msgid="6346655500491631357">"El <xliff:g id="ID_1">%1$s</xliff:g> de cada mes"</string>
    <string name="network_restrictions" msgid="8385824604048229846">"Restricciones de red"</string>
    <plurals name="network_restrictions_summary" formatted="false" msgid="3875128958788008975">
      <item quantity="other"><xliff:g id="COUNT">%1$d</xliff:g> restricciones</item>
      <item quantity="one">1 restricción</item>
    </plurals>
    <string name="operator_warning" msgid="5672761970087591211">"El cálculo de datos del proveedor puede diferir del que hace el dispositivo."</string>
    <string name="non_carrier_data_usage_warning" msgid="7361998122602474430">"Excluye los datos que usan las redes del proveedor"</string>
    <string name="data_used_template" msgid="8229342096562327646">"Datos usados: <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="set_data_warning" msgid="1685771882794205462">"Configurar advertencia"</string>
    <string name="data_warning" msgid="2925054658166062884">"Advertencia de datos"</string>
    <string name="data_warning_footnote" msgid="5991901765915710592">"El dispositivo mide la advertencia y el límite de datos, que pueden diferir de los que registra tu proveedor."</string>
    <string name="set_data_limit" msgid="9010326815874642680">"Establecer límite de datos"</string>
    <string name="data_limit" msgid="8731731657513652363">"Límite de datos"</string>
    <string name="data_usage_template" msgid="3822452362629968010">"Se usaron <xliff:g id="ID_1">%1$s</xliff:g> en el período: <xliff:g id="ID_2">%2$s</xliff:g>"</string>
    <string name="configure" msgid="1499586749829665889">"Configurar"</string>
    <string name="data_usage_other_apps" msgid="5649047093607329537">"Otras apps incluidas en el uso de datos"</string>
    <plurals name="data_saver_unrestricted_summary" formatted="false" msgid="3316296488378947221">
      <item quantity="other"><xliff:g id="COUNT">%1$d</xliff:g> apps tienen permiso para usar datos sin restricción cuando se activa el Ahorro de datos</item>
      <item quantity="one">1 app tiene permiso para usar datos sin restricción cuando se activa el Ahorro de datos</item>
    </plurals>
    <string name="data_usage_title" msgid="4039024073687469094">"Datos principales"</string>
    <string name="data_usage_wifi_title" msgid="1060495519280456926">"Datos de Wi-Fi"</string>
    <string name="data_used" msgid="7770571947591789895">"Datos usados: <xliff:g id="ID_1">^1</xliff:g>"</string>
    <string name="data_used_formatted" msgid="7913920278059077938">"Se usaron <xliff:g id="ID_1">^1</xliff:g> <xliff:g id="ID_2">^2</xliff:g>"</string>
    <string name="data_overusage" msgid="3680477320458707259">"Exceso: <xliff:g id="ID_1">^1</xliff:g>"</string>
    <string name="data_remaining" msgid="6316251496381922837">"Datos restantes: <xliff:g id="ID_1">^1</xliff:g>"</string>
    <string name="data_usage_chart_brief_content_description" msgid="5548074070258881530">"Un gráfico que muestra el uso de datos entre el <xliff:g id="START_DATE">%1$s</xliff:g> y el <xliff:g id="END_DATE">%2$s</xliff:g>"</string>
    <string name="data_usage_chart_no_data_content_description" msgid="5481968839079467231">"No hay datos en este período"</string>
    <plurals name="billing_cycle_days_left" formatted="false" msgid="661792524671718753">
      <item quantity="other">Quedan %d días</item>
      <item quantity="one">Queda %d día</item>
    </plurals>
    <string name="billing_cycle_none_left" msgid="1694844019159277504">"No queda tiempo"</string>
    <string name="billing_cycle_less_than_one_day_left" msgid="1210202399053992163">"Queda menos de 1 día"</string>
    <string name="carrier_and_update_text" msgid="5363656651921656280">"Actualizado hace <xliff:g id="ID_2">^2</xliff:g> por <xliff:g id="ID_1">^1</xliff:g>"</string>
    <string name="no_carrier_update_text" msgid="5432798085593055966">"Actualizado hace <xliff:g id="ID_1">^2</xliff:g>"</string>
    <string name="carrier_and_update_now_text" msgid="5075861262344398849">"Actualizado recién por <xliff:g id="ID_1">^1</xliff:g>"</string>
    <string name="no_carrier_update_now_text" msgid="7898004907837200752">"Actualizado recién"</string>
    <string name="launch_mdp_app_text" msgid="8791816789749304897">"Ver plan"</string>
    <string name="launch_wifi_text" msgid="976421974332512894">"Ver detalles"</string>
    <string name="data_saver_title" msgid="2593804270788863815">"Ahorro de datos"</string>
    <string name="unrestricted_data_saver" msgid="7922563266857367495">"Datos sin restricciones"</string>
    <string name="restrict_background_blocklisted" msgid="2308345280442438232">"Se desactivaron los datos en segundo plano"</string>
    <string name="data_saver_on" msgid="7848893946018448793">"Activado"</string>
    <string name="data_saver_off" msgid="5891210864117269045">"Desactivado"</string>
    <string name="data_saver_switch_title" msgid="7111538580123722959">"Usar Ahorro de datos"</string>
    <string name="unrestricted_app_title" msgid="7117585996574329284">"Uso de datos sin restricción"</string>
    <string name="unrestricted_app_summary" msgid="282698963532000403">"Acceso a datos sin restricción"</string>
    <string name="home_app" msgid="6056850504746902747">"Página principal"</string>
    <string name="no_default_home" msgid="3588073707316139318">"No hay ninguna página principal predeterminada"</string>
    <string name="lockpattern_settings_require_cred_before_startup" msgid="4098653943835666086">"Inicio seguro"</string>
    <string name="lockpattern_settings_require_pattern_before_startup_summary" msgid="311325321794497404">"Solicitar patrón para iniciar tu dispositivo. Mientras esté apagado, no podrá recibir llamadas, mensajes, notificaciones ni alarmas."</string>
    <string name="lockpattern_settings_require_pin_before_startup_summary" msgid="1881271630312222251">"Solicitar PIN para iniciar el dispositivo. Mientras está apagado, no podrá recibir llamadas, mensajes, notificaciones ni alarmas."</string>
    <string name="lockpattern_settings_require_password_before_startup_summary" msgid="8651761245246411947">"Solicitar contraseña para iniciar tu dispositivo. Mientras esté apagado, no podrá recibir llamadas, mensajes, notificaciones ni alarmas."</string>
    <string name="suggestion_additional_fingerprints" msgid="4726777300101156208">"Agregar otra huella digital"</string>
    <string name="suggestion_additional_fingerprints_summary" msgid="2825364645039666674">"Desbloquea con otro dedo"</string>
    <string name="battery_saver_on_summary" msgid="4605146593966255848">"Activado"</string>
    <string name="battery_saver_off_scheduled_summary" msgid="2193875981740829819">"Se activará cuando quede <xliff:g id="BATTERY_PERCENTAGE">%1$s</xliff:g>"</string>
    <string name="battery_saver_off_summary" msgid="4411561435493109261">"Desactivado"</string>
    <string name="battery_saver_button_turn_on" msgid="2206239048232352476">"Activar ahora"</string>
    <string name="battery_saver_button_turn_off" msgid="6371072408072481484">"Desactivar ahora"</string>
    <string name="not_battery_optimizing" msgid="8361294470943376258">"La optimización de la batería no está en uso"</string>
    <string name="lockscreen_remote_input" msgid="6030274311185811503">"Si el dispositivo está bloqueado, evita la escritura de respuestas y otros textos en las notificaciones"</string>
    <string name="default_spell_checker" msgid="7108373288347014351">"Corrector predeterminado"</string>
    <string name="choose_spell_checker" msgid="7402513404783243675">"Elegir corrector ortográfico"</string>
    <string name="spell_checker_primary_switch_title" msgid="529240542284039243">"Usar el corrector ortográfico"</string>
    <string name="spell_checker_not_selected" msgid="8818618543474481451">"Sin seleccionar"</string>
    <string name="notification_log_no_title" msgid="2343315128609978203">"(ninguno)"</string>
    <string name="notification_log_details_delimiter" msgid="2475986465985309821">": "</string>
    <string name="notification_log_details_package" msgid="3205243985502010202">"paquete"</string>
    <string name="notification_log_details_key" msgid="2690467272328709046">"clave"</string>
    <string name="notification_log_details_group" msgid="1765952974599794393">"grupo"</string>
    <string name="notification_log_details_group_summary" msgid="4364622087007803822">"(resumen)"</string>
    <string name="notification_log_details_visibility" msgid="6811292866832243357">"visibilidad"</string>
    <string name="notification_log_details_public_version" msgid="3057653571018432759">"versión pública"</string>
    <string name="notification_log_details_priority" msgid="4772047133062255513">"prioridad"</string>
    <string name="notification_log_details_importance" msgid="8516198274667183446">"importancia"</string>
    <string name="notification_log_details_explanation" msgid="6966274549873070059">"explicación"</string>
    <string name="notification_log_details_badge" msgid="648647240928645446">"puede mostrar insignias"</string>
    <string name="notification_log_details_content_intent" msgid="2768423554375629089">"intent"</string>
    <string name="notification_log_details_delete_intent" msgid="8296434571041573503">"borrar intent"</string>
    <string name="notification_log_details_full_screen_intent" msgid="4151243693072002296">"intent en pantalla completa"</string>
    <string name="notification_log_details_actions" msgid="2269605330470905236">"acciones"</string>
    <string name="notification_log_details_title" msgid="8365761340979164197">"título"</string>
    <string name="notification_log_details_remoteinput" msgid="264204203044885921">"entradas remotas"</string>
    <string name="notification_log_details_content_view" msgid="7193602999512479112">"vista personalizada"</string>
    <string name="notification_log_details_extras" msgid="8602887256103970989">"adicionales"</string>
    <string name="notification_log_details_icon" msgid="6728710746466389675">"ícono"</string>
    <string name="notification_log_details_parcel" msgid="2098454650154230531">"tamaño del paquete"</string>
    <string name="notification_log_details_ashmem" msgid="6163312898302809015">"ashmem"</string>
    <string name="notification_log_details_alerted" msgid="5285078967825048406">"notificación enviada"</string>
    <string name="notification_log_channel" msgid="3406738695621767204">"canal"</string>
    <string name="notification_log_details_none" msgid="1090852853755089991">"ninguno"</string>
    <string name="notification_log_details_ranking_null" msgid="6607596177723101524">"Falta el objeto de la clasificación."</string>
    <string name="notification_log_details_ranking_none" msgid="2484105338466675261">"El objeto de la clasificación no incluye esta tecla."</string>
    <string name="theme_customization_device_default" msgid="7641813022590999286">"Opción predeterminada del dispositivo"</string>
    <string name="display_cutout_emulation" msgid="1421648375408281244">"Corte de pantalla"</string>
    <string name="display_cutout_emulation_keywords" msgid="4506580703807358127">"recorte de la pantalla, corte"</string>
    <string name="overlay_option_device_default" msgid="7986355499809313848">"Opción predeterminada del dispositivo"</string>
    <string name="overlay_toast_failed_to_apply" msgid="4839587811338164960">"Error al aplicar superposición"</string>
    <string name="special_access" msgid="1767980727423395147">"Acceso especial de apps"</string>
    <plurals name="special_access_summary" formatted="false" msgid="4995506406763570815">
      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> apps pueden usar datos sin restricciones</item>
      <item quantity="one">1 app puede usar datos sin restricciones</item>
    </plurals>
    <string name="special_access_more" msgid="132919514147475846">"Ver más"</string>
    <string name="confirm_convert_to_fbe_warning" msgid="3783325656948378111">"¿Estás seguro de que quieres borrar los datos del usuario y convertirlos a encriptación de archivo?"</string>
    <string name="button_confirm_convert_fbe" msgid="339648921918438106">"Borrar y convertir"</string>
    <string name="reset_shortcut_manager_throttling" msgid="2183940254903144298">"Restablecer la limitación de frecuencia de ShortcutManager"</string>
    <string name="reset_shortcut_manager_throttling_complete" msgid="8949943009096885470">"Se restableció la limitación de frecuencia de ShortcutManager"</string>
    <string name="notification_suggestion_title" msgid="6309263655965785411">"Controlar los datos que aparecen en la pantalla bloqueada"</string>
    <string name="notification_suggestion_summary" msgid="7615611244249276113">"Ocultar o mostrar el contenido de las notificaciones"</string>
    <string name="page_tab_title_summary" msgid="7188875610123234454">"Todas"</string>
    <string name="page_tab_title_support" msgid="3235725053332345773">"Sugerencias y asistencia"</string>
    <string name="developer_smallest_width" msgid="632354817870920911">"Ancho más pequeño"</string>
    <string name="premium_sms_none" msgid="8737045049886416739">"Ninguna app que instalaste solicitó acceso a SMS premium"</string>
    <string name="premium_sms_warning" msgid="2192300872411073324">"SMS Premium podría implicar cargos en la factura de tu proveedor. Si otorgaste permiso a alguna app, podrás enviar SMS premium con esa app."</string>
    <string name="premium_sms_access" msgid="5605970342699013212">"Acceso a SMS premium"</string>
    <string name="bluetooth_disabled" msgid="835838280837359514">"Desactivado"</string>
    <string name="bluetooth_connected_summary" msgid="8043167194934315712">"Conectado a <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="bluetooth_connected_multiple_devices_summary" msgid="2294954614327771844">"Conectado a varios dispositivos"</string>
    <string name="demo_mode" msgid="6566167465451386728">"Modo demostración de la IU del sistema"</string>
    <string name="dark_ui_mode" msgid="898146394425795281">"Tema oscuro"</string>
    <string name="dark_ui_mode_disabled_summary_dark_theme_on" msgid="4554134480159161533">"Se inhabilitó temporalmente debido al Ahorro de batería"</string>
    <string name="dark_ui_mode_disabled_summary_dark_theme_off" msgid="4154227921313505702">"Activado temporalmente por el Ahorro de batería"</string>
    <string name="dark_ui_settings_dark_summary" msgid="1214821092462388494">"Las apps compatibles también se cambiarán a tema oscuro"</string>
    <string name="dark_ui_settings_dialog_acknowledge" msgid="250437497729953965">"Entendido"</string>
    <string name="dark_theme_slice_title" msgid="4684222119481114062">"Prueba el Tema oscuro"</string>
    <string name="dark_theme_slice_subtitle" msgid="5555724345330434268">"Extiende la duración de la batería"</string>
    <string name="quick_settings_developer_tiles" msgid="7336007844525766623">"Mosaicos de configuración rápida para programadores"</string>
    <string name="adb_authorization_timeout_title" msgid="6996844506783749754">"Inhabilitar tiempo de espera de autorización ADB"</string>
    <string name="adb_authorization_timeout_summary" msgid="409931540424019778">"Inhabilita la revocación automática de autorizaciones ADB para sistemas que no se volvieron a conectar dentro de un período predeterminado (siete días) o uno configurado por el usuario (mínimo de un día)."</string>
    <string name="winscope_trace_quick_settings_title" msgid="4104768565053226689">"Seguimiento de Winscope"</string>
    <string name="sensors_off_quick_settings_title" msgid="8472151847125917167">"Sensores desactivados"</string>
    <string name="managed_profile_settings_title" msgid="3400923723423564217">"Configuración del perfil de trabajo"</string>
    <string name="managed_profile_contact_search_title" msgid="7685402733942182110">"Búsqueda de contactos"</string>
    <string name="managed_profile_contact_search_summary" msgid="2771343453017731940">"Permitir que tu organización busque contactos para identificar a emisores y contactos"</string>
    <string name="cross_profile_calendar_title" msgid="7570277841490216947">"Sincronizar perfiles en el calendario"</string>
    <string name="cross_profile_calendar_summary" msgid="8856185206722860069">"Mostrar eventos de trabajo en el calendario personal"</string>
    <plurals name="hours" formatted="false" msgid="1853396353451635458">
      <item quantity="other"><xliff:g id="NUMBER">%s</xliff:g> horas</item>
      <item quantity="one">1 hora</item>
    </plurals>
    <plurals name="minutes" formatted="false" msgid="6244503272924425418">
      <item quantity="other"><xliff:g id="NUMBER">%s</xliff:g> minutos</item>
      <item quantity="one">1 minuto</item>
    </plurals>
    <plurals name="seconds" formatted="false" msgid="4237020272336995370">
      <item quantity="other"><xliff:g id="NUMBER">%s</xliff:g> segundos</item>
      <item quantity="one">1 segundo</item>
    </plurals>
    <string name="automatic_storage_manager_settings" msgid="519158151463974656">"Administrar el almacenamiento"</string>
    <string name="automatic_storage_manager_text" msgid="6900593059927987273">"El administrador de almacenamiento quita de tu dispositivo las fotos y los videos con copia de seguridad para liberar espacio de almacenamiento."</string>
    <string name="automatic_storage_manager_days_title" msgid="5077286114860539367">"Quitar fotos y videos"</string>
    <string name="automatic_storage_manager_preference_title" msgid="3483357910142595444">"Administrador de almacenamiento"</string>
    <string name="automatic_storage_manager_primary_switch_title" msgid="9131959126462101994">"Usar el Administrador de almacenamiento"</string>
    <string name="deletion_helper_automatic_title" msgid="597196990024769472">"Automático"</string>
    <string name="deletion_helper_manual_title" msgid="1068812971600327101">"Manual"</string>
    <string name="deletion_helper_preference_title" msgid="6364023246849161274">"Liberar espacio ahora"</string>
    <string name="gesture_preference_title" msgid="8291899281322647187">"Gestos"</string>
    <string name="gesture_preference_summary" product="default" msgid="7941981260703379398">"Gestos rápidos para controlar tu teléfono"</string>
    <string name="gesture_preference_summary" product="tablet" msgid="4031666250963488007">"Gestos rápidos para controlar tu tablet"</string>
    <string name="gesture_preference_summary" product="device" msgid="3520072325356373349">"Gestos rápidos para controlar tu dispositivo"</string>
    <string name="double_tap_power_for_camera_title" msgid="7982364144330923683">"Abrir cámara rápidamente"</string>
    <string name="double_tap_power_for_camera_summary" msgid="1100926048598415509">"Para abrir la cámara rápidamente, presiona dos veces el botón de encendido. Funciona desde cualquier pantalla."</string>
    <string name="double_tap_power_for_camera_suggestion_title" msgid="4299496243418753571">"Abre la cámara rápidamente"</string>
    <string name="double_twist_for_camera_mode_title" msgid="472455236910935684">"Girar cámara para selfie"</string>
    <string name="double_twist_for_camera_mode_summary" msgid="592503740044744951"></string>
    <string name="double_twist_for_camera_suggestion_title" msgid="8178844037382604158">"Toma selfies más rápido"</string>
    <string name="system_navigation_title" msgid="1698862900901417194">"Navegación del sistema"</string>
    <string name="swipe_up_to_switch_apps_title" msgid="6677266952021118342">"Navegación con 2 botones"</string>
    <string name="swipe_up_to_switch_apps_summary" msgid="1415457307836359560">"Para cambiar de app, desliza el dedo hacia arriba sobre el botón de inicio. Para ver todas las apps, vuelve a deslizar el dedo hacia arriba. Para volver, presiona el botón \"Atrás\"."</string>
    <string name="swipe_up_to_switch_apps_suggestion_title" msgid="5754081720589900007">"Prueba el nuevo botón de inicio"</string>
    <string name="swipe_up_to_switch_apps_suggestion_summary" msgid="8885866570559435110">"Activa el nuevo gesto para cambiar de app"</string>
    <string name="emergency_settings_preference_title" msgid="6183455153241187148">"Seguridad y emergencia"</string>
    <string name="edge_to_edge_navigation_title" msgid="714427081306043819">"Navegación por gestos"</string>
    <string name="edge_to_edge_navigation_summary" msgid="8497033810637690561">"Para ir a la pantalla principal, desliza el dedo hacia arriba desde la parte inferior de la pantalla. Para cambiar de app, desliza el dedo hacia arriba desde la parte inferior, sostenlo y, luego, suéltalo. Para ir atrás, desliza el dedo desde el borde izquierdo o el derecho."</string>
    <string name="legacy_navigation_title" msgid="7877402855994423727">"Navegación con 3 botones"</string>
    <string name="legacy_navigation_summary" msgid="5905301067778326433">"Ve atrás o a la pantalla principal y cambia de app con los botones de la parte inferior de la pantalla."</string>
    <string name="keywords_system_navigation" msgid="3131782378486554934">"navegación del sistema, navegación con 2 botones, navegación con 3 botones, navegación por gestos, deslizar"</string>
    <string name="gesture_not_supported_dialog_message" msgid="5316512246119347889">"La app de inicio predeterminada <xliff:g id="DEFAULT_HOME_APP">%s</xliff:g> no admite la navegación por gestos"</string>
    <string name="gesture_not_supported_positive_button" msgid="7909969459977021893">"Cambiar de app de inicio predeterminada"</string>
    <string name="information_label" msgid="6939310810756569298">"Información"</string>
    <string name="low_label" msgid="6525629096999711220">"Baja"</string>
    <string name="high_label" msgid="357503396626018487">"Alta"</string>
    <string name="left_edge" msgid="1513576842959071849">"Borde izquierdo"</string>
    <string name="right_edge" msgid="1505309103265829121">"Borde derecho"</string>
    <string name="back_sensitivity_dialog_message" msgid="6638367716784103306">"La sensibilidad alta puede entrar en conflicto con los gestos de la app que se hagan en los bordes de la pantalla."</string>
    <string name="back_sensitivity_dialog_title" msgid="6153608904168908264">"Sensibilidad posterior"</string>
    <string name="gesture_settings_activity_title" msgid="6047431928567911330">"Configuración de gestos"</string>
    <string name="keywords_gesture_navigation_settings" msgid="667561222717238931">"navegación por gestos, sensibilidad posterior, gesto de retroceso"</string>
    <string name="ambient_display_title" product="default" msgid="5885136049497127396">"Presionar la pantalla dos veces para revisar el teléfono"</string>
    <string name="ambient_display_title" product="tablet" msgid="205744440641466921">"Presionar dos veces la tablet para revisarla"</string>
    <string name="ambient_display_title" product="device" msgid="4164103424628824786">"Presionar dos veces el dispositivo para revisarlo"</string>
    <string name="swipe_bottom_to_notifications_title" msgid="7631744948948666524">"Desliza para ver notific."</string>
    <string name="swipe_bottom_to_notifications_summary" msgid="8073261995155440308">"Desliza el dedo hacia abajo desde el borde inferior para ver las notificaciones"</string>
    <string name="one_handed_title" msgid="1741600445540072513">"Modo de una mano"</string>
    <string name="one_handed_mode_enabled" msgid="3396864848786359651">"Usar el modo de una mano"</string>
    <string name="one_handed_app_taps_to_exit" msgid="1496702498286387879">"Salir del modo cuando se cambia de app"</string>
    <string name="one_handed_timeout_title" msgid="8851767822595789976">"Tiempo de espera"</string>
    <string name="one_handed_timeout_short" msgid="304069319841702995">"4 segundos"</string>
    <string name="one_handed_timeout_medium" msgid="6723411319911799018">"8 segundos"</string>
    <string name="one_handed_timeout_long" msgid="6537332654662635890">"12 segundos"</string>
    <string name="keywords_one_handed" msgid="969440592493034101">"accesibilidad"</string>
    <string name="ambient_display_summary" msgid="2650326740502690434">"Para consultar la hora, las notificaciones y otra información, presiona dos veces la pantalla."</string>
    <string name="ambient_display_pickup_title" product="default" msgid="4418310591912877548">"Levantar el teléfono para revisarlo"</string>
    <string name="ambient_display_pickup_title" product="tablet" msgid="8055486872070888377">"Levanta la tablet para revisarla"</string>
    <string name="ambient_display_pickup_title" product="device" msgid="8980156994848721455">"Levanta el dispositivo para revisarlo"</string>
    <string name="ambient_display_wake_screen_title" msgid="7637678749035378085">"Activar pantalla"</string>
    <string name="ambient_display_pickup_summary" product="default" msgid="1087355013674109242">"Para consultar la hora, las notificaciones y otra información, levanta el teléfono."</string>
    <string name="ambient_display_pickup_summary" product="tablet" msgid="2589556997034530529">"Para consultar la hora, las notificaciones y otra información, levanta la tablet."</string>
    <string name="ambient_display_pickup_summary" product="device" msgid="1916011370011115627">"Para consultar la hora, las notificaciones y otra información, levanta el dispositivo."</string>
    <string name="ambient_display_tap_screen_title" product="default" msgid="2811332293938467179">"Presionar para revisar el teléfono"</string>
    <string name="ambient_display_tap_screen_title" product="tablet" msgid="6461531447715370632">"Presiona para revisar la tablet"</string>
    <string name="ambient_display_tap_screen_title" product="device" msgid="4423803387551153840">"Presiona para revisar el dispositivo"</string>
    <string name="ambient_display_tap_screen_summary" msgid="4480489179996521405">"Para consultar la hora, las notificaciones y otra información, presiona la pantalla."</string>
    <string name="emergency_gesture_screen_title" msgid="3280543310204360902">"Ayuda en emergencias"</string>
    <string name="emergency_gesture_switchbar_title" msgid="7494629420708117232">"Usar SOS de emergencia"</string>
    <string name="emergency_gesture_entrypoint_summary" msgid="4730874229911208834">"Administrador: <xliff:g id="APP_NAME">%1$s</xliff:g>"</string>
    <string name="emergency_gesture_screen_summary" msgid="458991229689082120">"Inicia las acciones que se indican más abajo presionando rápidamente el botón de encendido 5 veces o más."</string>
    <string name="emergency_gesture_sound_setting_title" msgid="7153948164862156536">"Reproducir alarma de cuenta regresiva"</string>
    <string name="emergency_gesture_sound_setting_summary" msgid="9215504009890604179">"Reproducir un sonido fuerte antes de solicitar ayuda"</string>
    <string name="emergency_gesture_call_for_help_title" msgid="4969340870836239982">"Llamar para obtener ayuda"</string>
    <string name="emergency_gesture_call_for_help_dialog_title" msgid="8901271205171421201">"Número al que llamar para pedir ayuda"</string>
    <string name="emergency_gesture_call_for_help_summary" msgid="6552830427932669221">"<xliff:g id="PHONE_NUMBER">%1$s</xliff:g>; presiona para cambiar"</string>
    <string name="emergency_gesture_number_override_notes" msgid="7270300987756837957">"Si ingresas un número que no es de emergencia:\n • Tu dispositivo debe estar desbloqueado para usar SOS de emergencia.\n • Es posible que no se responda tu llamada."</string>
    <string name="fingerprint_swipe_for_notifications_title" msgid="2271217256447175017">"Deslizar tu huella para ver notificaciones"</string>
    <string name="fingerprint_gesture_screen_title" msgid="9086261338232806522">"Deslizar huella digital"</string>
    <string name="fingerprint_swipe_for_notifications_summary" product="default" msgid="286662791588779673">"Para ver las notificaciones, desliza el dedo hacia abajo en el sensor de huellas digitales ubicado en la parte posterior del teléfono."</string>
    <string name="fingerprint_swipe_for_notifications_summary" product="tablet" msgid="8642092907817554454">"Para ver las notificaciones, desliza el dedo hacia abajo en el sensor de huellas digitales ubicado en la parte posterior de la tablet."</string>
    <string name="fingerprint_swipe_for_notifications_summary" product="device" msgid="3888927017311372398">"Para ver las notificaciones, desliza el dedo hacia abajo en el sensor de huellas digitales ubicado en la parte posterior del dispositivo."</string>
    <string name="fingerprint_swipe_for_notifications_suggestion_title" msgid="2956636269742745449">"Consulta tus notificaciones rápidamente"</string>
    <string name="gesture_setting_on" msgid="3223448394997988591">"Activado"</string>
    <string name="gesture_setting_off" msgid="3444029475726294919">"Desactivado"</string>
    <string name="oem_unlock_enable_disabled_summary_bootloader_unlocked" msgid="65713754674288193">"El bootloader está desbloqueado"</string>
    <string name="oem_unlock_enable_disabled_summary_connectivity" msgid="8045017109714463041">"Primero debes conectarte a Internet"</string>
    <string name="oem_unlock_enable_disabled_summary_connectivity_or_locked" msgid="7425519481227423860">"Conéctate a Internet o comunícate con tu proveedor"</string>
    <string name="oem_unlock_enable_disabled_summary_sim_locked_device" msgid="168124660162907358">"No disponible en dispositivos bloqueados por el proveedor"</string>
    <string name="oem_lock_info_message" msgid="8843145669619429197">"Reinicia el dispositivo para habilitar la función de protección correspondiente."</string>
    <string name="automatic_storage_manager_freed_bytes" msgid="706230592123831676">"Espacio que se liberó: <xliff:g id="SIZE">%1$s</xliff:g>\n\nÚltima vez que se ejecutó: <xliff:g id="DATE">%2$s</xliff:g>"</string>
    <string name="web_action_enable_title" msgid="6654581786741216382">"Apps instantáneas"</string>
    <string name="web_action_enable_summary" msgid="2658930257777545990">"Abre vínculos en apps, incluso aunque no estén instaladas"</string>
    <string name="web_action_section_title" msgid="994717569424234098">"Apps instantáneas"</string>
    <string name="instant_apps_settings" msgid="4280942494969957858">"Preferencias de las Apps instantáneas"</string>
    <string name="domain_url_section_title" msgid="9028890472923474958">"Apps instaladas"</string>
    <string name="automatic_storage_manager_activation_warning" msgid="170508173207142665">"Tu almacenamiento ahora está a cargo del administrador de almacenamiento"</string>
    <string name="account_for_section_header" msgid="7466759342105251096">"Cuentas de <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="configure_section_header" msgid="3126887329521705210">"Configuración"</string>
    <string name="auto_sync_account_title" msgid="1070908045600374254">"Sincronizar datos de apps automáticamente"</string>
    <string name="auto_sync_personal_account_title" msgid="3544275021920818595">"Sincronizar datos personales automáticamente"</string>
    <string name="auto_sync_work_account_title" msgid="6060310415978781885">"Sincronizar los datos de trabajo automáticamente"</string>
    <string name="auto_sync_account_summary" msgid="7580352130028957346">"Permitir que las apps actualicen datos automáticamente"</string>
    <string name="account_sync_title" msgid="7036067017433297574">"Sincronización de la cuenta"</string>
    <string name="account_sync_summary_some_on" msgid="911460286297968724">"Sincronización activada para <xliff:g id="ID_1">%1$d</xliff:g> de <xliff:g id="ID_2">%2$d</xliff:g> elementos"</string>
    <string name="account_sync_summary_all_on" msgid="2953682111836599841">"Sincronización activada para todos los elementos"</string>
    <string name="account_sync_summary_all_off" msgid="6378301874540507884">"Sincronización desactivada para todos los elementos"</string>
    <string name="enterprise_privacy_settings" msgid="786350385374794180">"Información del dispositivo administrado"</string>
    <string name="enterprise_privacy_settings_summary_generic" msgid="5471858290610344646">"Cambios y opciones de configuración que administra tu organización"</string>
    <string name="enterprise_privacy_settings_summary_with_name" msgid="1315413275836515937">"Cambios y opciones de configuración que administra <xliff:g id="ORGANIZATION_NAME">%s</xliff:g>"</string>
    <string name="enterprise_privacy_header" msgid="4626225398848641603">"Para brindar acceso a los datos de trabajo, es posible que tu organización instale programas y cambie la configuración en tu dispositivo.\n\nPara obtener más información, comunícate con el administrador de tu organización."</string>
    <string name="enterprise_privacy_exposure_category" msgid="2507761423540037308">"Tipos de información que tu organización puede ver"</string>
    <string name="enterprise_privacy_exposure_changes_category" msgid="5459989751333816587">"Cambios que realizó el administrador de tu organización"</string>
    <string name="enterprise_privacy_device_access_category" msgid="140157499478630004">"Tu acceso a este dispositivo"</string>
    <string name="enterprise_privacy_enterprise_data" msgid="3963070078195245028">"Datos asociados a tu cuenta de trabajo, como el correo electrónico y el calendario"</string>
    <string name="enterprise_privacy_installed_packages" msgid="6707006112254572820">"Lista de apps en tu dispositivo"</string>
    <string name="enterprise_privacy_usage_stats" msgid="6328506963853465534">"Consumo de tiempo y datos de cada app"</string>
    <string name="enterprise_privacy_network_logs" msgid="3081744541193695887">"Registro de tráfico de red más reciente"</string>
    <string name="enterprise_privacy_bug_reports" msgid="2635897583413134123">"Informe de errores más reciente"</string>
    <string name="enterprise_privacy_security_logs" msgid="8494681624247959075">"Registro de seguridad más reciente"</string>
    <string name="enterprise_privacy_none" msgid="6026527690979756431">"Ninguno"</string>
    <string name="enterprise_privacy_enterprise_installed_packages" msgid="9114143640515900082">"Apps instaladas"</string>
    <string name="enterprise_privacy_apps_count_estimation_info" msgid="7959907857710107792">"La cantidad de apps es aproximada. Es posible que no se cuenten las apps que no hayas instalado desde Play Store."</string>
    <plurals name="enterprise_privacy_number_packages_lower_bound" formatted="false" msgid="5403847001419529018">
      <item quantity="other">Al menos <xliff:g id="COUNT_1">%d</xliff:g> apps</item>
      <item quantity="one">Al menos <xliff:g id="COUNT_0">%d</xliff:g> app</item>
    </plurals>
    <string name="enterprise_privacy_location_access" msgid="8023838718108456971">"Permisos de ubicación"</string>
    <string name="enterprise_privacy_microphone_access" msgid="7242958026470143653">"Permisos de micrófono"</string>
    <string name="enterprise_privacy_camera_access" msgid="7685460535880069016">"Permisos de cámara"</string>
    <string name="enterprise_privacy_enterprise_set_default_apps" msgid="7498546659083996300">"Apps predeterminadas"</string>
    <plurals name="enterprise_privacy_number_packages" formatted="false" msgid="8568544906431825430">
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g> apps</item>
      <item quantity="one"><xliff:g id="COUNT_0">%d</xliff:g> app</item>
    </plurals>
    <string name="enterprise_privacy_input_method" msgid="3278314982700662246">"Teclado predeterminado"</string>
    <string name="enterprise_privacy_input_method_name" msgid="2974859490559054584">"Se configuró en <xliff:g id="APP_LABEL">%s</xliff:g>"</string>
    <string name="enterprise_privacy_always_on_vpn_device" msgid="1735829327405126695">"Se activó la función \"VPN siempre activada\""</string>
    <string name="enterprise_privacy_always_on_vpn_personal" msgid="8395903360175064841">"Se activó la función \"VPN siempre activada\" en tu perfil personal"</string>
    <string name="enterprise_privacy_always_on_vpn_work" msgid="2496961514592522377">"Se activó la función \"VPN siempre activada\" en tu perfil de trabajo"</string>
    <string name="enterprise_privacy_global_http_proxy" msgid="4350347418068037051">"Se estableció el proxy HTTP global"</string>
    <string name="enterprise_privacy_ca_certs_device" msgid="1816495877258727663">"Credenciales de confianza"</string>
    <string name="enterprise_privacy_ca_certs_personal" msgid="1516422660828485795">"Credenciales de confianza en tu perfil personal"</string>
    <string name="enterprise_privacy_ca_certs_work" msgid="4318941788592655561">"Credenciales de confianza en tu perfil de trabajo"</string>
    <plurals name="enterprise_privacy_number_ca_certs" formatted="false" msgid="6459725295322004179">
      <item quantity="other">Al menos <xliff:g id="COUNT_1">%d</xliff:g> certificados de CA</item>
      <item quantity="one">Al menos <xliff:g id="COUNT_0">%d</xliff:g> certificado de CA</item>
    </plurals>
    <string name="enterprise_privacy_lock_device" msgid="464054894363899866">"El administrador puede bloquear el dispositivo y reestablecer la contraseña"</string>
    <string name="enterprise_privacy_wipe_device" msgid="869589182352244591">"El administrador puede borrar todos los datos del dispositivo"</string>
    <string name="enterprise_privacy_failed_password_wipe_device" msgid="7045164901334821226">"Intentos fallidos para ingresar la contraseña antes de borrar los datos del dispositivo"</string>
    <string name="enterprise_privacy_failed_password_wipe_work" msgid="2537582942554484170">"Intentos fallidos para ingresar la contraseña antes de borrar los datos del perfil de trabajo"</string>
    <plurals name="enterprise_privacy_number_failed_password_wipe" formatted="false" msgid="8811973918944217791">
      <item quantity="other"><xliff:g id="COUNT_1">%d</xliff:g> intentos</item>
      <item quantity="one"><xliff:g id="COUNT_0">%d</xliff:g> intento</item>
    </plurals>
    <string name="do_disclosure_generic" msgid="3067459392402324538">"Tu organización administra este dispositivo."</string>
    <string name="do_disclosure_with_name" msgid="867544298924410766">"<xliff:g id="ORGANIZATION_NAME">%s</xliff:g> administra este dispositivo."</string>
    <string name="do_disclosure_learn_more_separator" msgid="5714364437437041671">" "</string>
    <string name="learn_more" msgid="3534519107947510952">"Más información"</string>
    <plurals name="default_camera_app_title" formatted="false" msgid="8112432929729136399">
      <item quantity="other">Apps de cámara</item>
      <item quantity="one">App de cámara</item>
    </plurals>
    <string name="default_calendar_app_title" msgid="1870095225089706093">"App de calendario"</string>
    <string name="default_contacts_app_title" msgid="7740028900741944569">"App de contactos"</string>
    <plurals name="default_email_app_title" formatted="false" msgid="8338194872609410234">
      <item quantity="other">Apps de correo electrónico</item>
      <item quantity="one">App de correo electrónico</item>
    </plurals>
    <string name="default_map_app_title" msgid="7569231732944853320">"App de mapas"</string>
    <plurals name="default_phone_app_title" formatted="false" msgid="4222188821845826493">
      <item quantity="other">Apps de teléfono</item>
      <item quantity="one">App de teléfono</item>
    </plurals>
    <string name="app_names_concatenation_template_2" msgid="8320181646458855457">"<xliff:g id="FIRST_APP_NAME">%1$s</xliff:g>, <xliff:g id="SECOND_APP_NAME">%2$s</xliff:g>"</string>
    <string name="app_names_concatenation_template_3" msgid="7019703249717854148">"<xliff:g id="FIRST_APP_NAME">%1$s</xliff:g>, <xliff:g id="SECOND_APP_NAME">%2$s</xliff:g>, <xliff:g id="THIRD_APP_NAME">%3$s</xliff:g>"</string>
    <string name="storage_photos_videos" msgid="6926197783745481869">"Fotos y videos"</string>
    <string name="storage_music_audio" msgid="1185624135490182822">"Música y audio"</string>
    <string name="storage_games" msgid="1176568610086802469">"Juegos"</string>
    <string name="storage_other_apps" msgid="5902520888043081176">"Otras apps"</string>
    <string name="storage_files" msgid="7968460921272772299">"Archivos"</string>
    <string name="storage_size_large_alternate" msgid="7555149858858591495">"<xliff:g id="NUMBER">^1</xliff:g>"<small>" "<font size="20">"<xliff:g id="UNIT">^2</xliff:g>"</font></small>""</string>
    <string name="storage_volume_total" msgid="7102720999351050601">"En uso de <xliff:g id="TOTAL">%1$s</xliff:g>"</string>
    <string name="storage_percent_full" msgid="7211888326013020857">"usado"</string>
    <string name="clear_instant_app_data" msgid="5951258323364386357">"Borrar app"</string>
    <string name="clear_instant_app_confirmation" msgid="3964731334459209482">"¿Quieres quitar esta app instantánea?"</string>
    <string name="launch_instant_app" msgid="8503927414339606561">"Abrir"</string>
    <string name="game_storage_settings" msgid="2521393115726178837">"Juegos"</string>
    <string name="audio_files_title" msgid="5981409295669041303">"Archivos de audio"</string>
    <string name="app_info_storage_title" msgid="4076977173803093808">"Espacio en uso"</string>
    <string name="webview_uninstalled_for_user" msgid="627352948986275488">"(se desinstaló para <xliff:g id="USER">%s</xliff:g>)"</string>
    <string name="webview_disabled_for_user" msgid="5809886172032644498">"(se inhabilitó para <xliff:g id="USER">%s</xliff:g>)"</string>
    <string name="autofill_app" msgid="7595308061826307921">"Servicio autocompletar"</string>
    <string name="autofill_keywords" msgid="6260653325195017912">"auto, completar, autocompletar"</string>
    <string name="autofill_confirmation_message" msgid="4888767934273494272">"&lt;b&gt;Asegúrate de que esta app sea confiable.&lt;/b&gt; &lt;br/&gt; &lt;br/&gt; &lt;xliff:g id=app_name example=Google Autofill&gt;%1$s&lt;/xliff:g&gt; usa el contenido de tu pantalla para determinar qué se puede autocompletar."</string>
    <string name="debug_autofill_category" msgid="5998163555428196185">"Autocompletar"</string>
    <string name="autofill_logging_level_title" msgid="3733958845861098307">"Nivel de registro"</string>
    <string name="autofill_max_partitions" msgid="7342195529574406366">"Número máximo de solicitudes por sesión"</string>
    <string name="autofill_max_visible_datasets" msgid="4970201981694392229">"Máximo de conjuntos de datos visibles"</string>
    <string name="autofill_reset_developer_options" msgid="6425613608979498608">"Restablecer valores predeterminados"</string>
    <string name="autofill_reset_developer_options_complete" msgid="1276741935956594965">"Se restablecieron las opciones de autocompletar para desarrolladores"</string>
    <string name="location_category" msgid="3496759112306219062">"Ubicación"</string>
    <string name="location_indicator_settings_title" msgid="6655916258720093451">"Indicador de ubicación de la barra de estado"</string>
    <string name="location_indicator_settings_description" msgid="2888022085372804021">"Mostrar para todas las ubicaciones, incluidas la red y la conectividad"</string>
    <string name="enable_gnss_raw_meas_full_tracking" msgid="1206679951510243341">"Forzar dimensiones GNSS completas"</string>
    <string name="enable_gnss_raw_meas_full_tracking_summary" msgid="3841463141138247167">"Seguir todas las frecuencias y constelaciones de GNSS sin ciclo de funciones"</string>
    <string name="device_theme" msgid="5027604586494772471">"Tema del dispositivo"</string>
    <string name="default_theme" msgid="4815428567082263639">"Predeterminado"</string>
    <string name="show_operator_name_title" msgid="3355910331531144028">"Nombre de la red"</string>
    <string name="show_operator_name_summary" msgid="5352696579216501773">"Mostrar el nombre de la red en la barra de estado"</string>
    <string name="storage_manager_indicator" msgid="6187509172735927297">"Administrador de almacenamiento: <xliff:g id="STATUS">^1</xliff:g>"</string>
    <string name="storage_manager_indicator_off" msgid="2705959642617709265">"Desactivado"</string>
    <string name="storage_manager_indicator_on" msgid="8380330763647785309">"Activado"</string>
    <string name="install_type_instant" msgid="7685381859060486009">"App instantánea"</string>
    <string name="automatic_storage_manager_deactivation_warning" msgid="4905106133215702099">"¿Deseas desactivar el administrador de almacenamiento?"</string>
    <string name="storage_movies_tv" msgid="7897612625450668593">"Apps de TV y películas"</string>
    <string name="carrier_provisioning" msgid="7217868336140325816">"Información del aprovisionamiento del proveedor"</string>
    <string name="trigger_carrier_provisioning" msgid="3288805742683538597">"Activar aprovisionamiento del proveedor"</string>
    <string name="zen_suggestion_title" msgid="4555260320474465668">"Actualizar el modo No interrumpir"</string>
    <string name="zen_suggestion_summary" msgid="1984990920503217">"Pausa las notificaciones para concentrarte"</string>
    <string name="disabled_feature" msgid="7151433782819744211">"Función no disponible"</string>
    <string name="disabled_feature_reason_slow_down_phone" msgid="5743569256308510404">"Se desactivó esta función porque ralentiza el teléfono"</string>
    <string name="show_first_crash_dialog" msgid="1696584857732637389">"Mostrar siempre el cuadro de diálogo de bloqueos"</string>
    <string name="show_first_crash_dialog_summary" msgid="4692334286984681111">"Mostrar el cuadro de diálogo cada vez que falle una app"</string>
    <string name="angle_enabled_app" msgid="6044941043384239076">"Seleccionar app compatible con ANGLE"</string>
    <string name="angle_enabled_app_not_set" msgid="4472572224881726067">"No se estableció ninguna app compatible con ANGLE"</string>
    <string name="angle_enabled_app_set" msgid="7811829383833353021">"App compatible con ANGLE: <xliff:g id="APP_NAME">%1$s</xliff:g>"</string>
    <string name="graphics_driver_dashboard_title" msgid="5661084817492587796">"Preferencias del controlador gráfico"</string>
    <string name="graphics_driver_dashboard_summary" msgid="6348759885315793654">"Modificar configuración del controlador gráfico"</string>
    <string name="graphics_driver_footer_text" msgid="5123754522284046790">"Cuando hay varios controladores gráficos, puedes elegir usar el que esté actualizado para las apps instaladas en el dispositivo."</string>
    <string name="graphics_driver_all_apps_preference_title" msgid="1343065382898127360">"Habilitar para todas las apps"</string>
    <string name="graphics_driver_app_preference_title" msgid="3133255818657706857">"Seleccionar controlador gráfico"</string>
    <string name="graphics_driver_app_preference_default" msgid="764432460281859855">"Predeterminado"</string>
    <string name="graphics_driver_app_preference_production_driver" msgid="1515874802568434915">"Controlador de juegos"</string>
    <string name="graphics_driver_app_preference_prerelease_driver" msgid="7355929161805829480">"Controlador para desarrolladores"</string>
    <string name="graphics_driver_app_preference_system" msgid="3754748149113184126">"Controlador gráfico del sistema"</string>
    <!-- no translation found for graphics_driver_all_apps_preference_values:0 (8039644515855740879) -->
    <!-- no translation found for graphics_driver_all_apps_preference_values:1 (157748136905839375) -->
    <!-- no translation found for graphics_driver_all_apps_preference_values:2 (8104576549429294026) -->
    <!-- no translation found for graphics_driver_app_preference_values:0 (6403705826179314116) -->
    <!-- no translation found for graphics_driver_app_preference_values:1 (485288770206606512) -->
    <!-- no translation found for graphics_driver_app_preference_values:2 (5391218026495225599) -->
    <!-- no translation found for graphics_driver_app_preference_values:3 (2586045835780389650) -->
    <string name="platform_compat_dashboard_title" msgid="1323980546791790236">"Cambios en la compatibilidad de la app"</string>
    <string name="platform_compat_dashboard_summary" msgid="4036546607938791337">"Activar o desactivar los cambios de compatibilidad de la app"</string>
    <string name="platform_compat_default_enabled_title" msgid="8973137337738388024">"Cambios habilitados de manera predeterminada"</string>
    <string name="platform_compat_default_disabled_title" msgid="3975847180953793602">"Cambios inhabilitados de manera predeterminada"</string>
    <string name="platform_compat_dialog_title_no_apps" msgid="4387656000745989506">"No hay apps disponibles"</string>
    <string name="platform_compat_dialog_text_no_apps" msgid="5715226015751055812">"Solo se pueden implementar cambios de compatibilidad para las apps depurables. Instala una app depurable y vuelve a intentarlo."</string>
    <string name="unsupported_setting_summary" product="default" msgid="1085229417771470172">"Este teléfono no admite esa opción de configuración"</string>
    <string name="unsupported_setting_summary" product="tablet" msgid="7402414129786489664">"Esta tablet no admite esa opción de configuración"</string>
    <string name="unsupported_setting_summary" product="device" msgid="3422953459122926833">"Este dispositivo no admite esa opción de configuración"</string>
    <string name="disabled_for_user_setting_summary" msgid="9096036019081828639">"El usuario actual no puede cambiar la configuración"</string>
    <string name="disabled_dependent_setting_summary" msgid="4508635725315852504">"Depende de otra opción de configuración"</string>
    <string name="unknown_unavailability_setting_summary" msgid="9060213910510360231">"Configuración no disponible"</string>
    <string name="my_device_info_account_preference_title" msgid="9197139254007133175">"Cuenta"</string>
    <string name="my_device_info_device_name_preference_title" msgid="8053298498727237971">"Nombre del dispositivo"</string>
    <string name="change_wifi_state_title" msgid="5629648102837821525">"Control de Wi-Fi"</string>
    <string name="change_wifi_state_app_detail_switch" msgid="1385358508267180745">"Permitir que la app controle Wi-Fi"</string>
    <string name="change_wifi_state_app_detail_summary" msgid="8230854855584217111">"Permite que esta app active o desactive la conexión Wi-Fi, busque y se conecte a redes Wi-Fi, agregue o quite redes, o inicie un hotspot de acceso local exclusivo."</string>
    <string name="media_output_title" msgid="8283629315159510680">"Reproducir contenido multimedia en"</string>
    <string name="media_output_label_title" msgid="4139048973886819148">"Reproduce <xliff:g id="LABEL">%s</xliff:g> en"</string>
    <string name="media_output_default_summary" msgid="4200343059396412376">"este dispositivo"</string>
    <string name="media_output_summary" product="default" msgid="4760338801715262899">"Teléfono"</string>
    <string name="media_output_summary" product="tablet" msgid="5138101426462250247">"Tablet"</string>
    <string name="media_output_summary" product="device" msgid="3598300438694764381">"Dispositivo"</string>
    <string name="media_out_summary_ongoing_call_state" msgid="475188726850090363">"No disponible durante llamadas"</string>
    <string name="media_output_summary_unavailable" msgid="2695058965888813093">"No disponible"</string>
    <string name="media_output_group_panel_title" msgid="3086245179062913037">"Agregar salida de contenido multimedia"</string>
    <string name="media_output_group" msgid="7918231774595274396">"Grupo"</string>
    <string name="media_output_group_panel_single_device_summary" msgid="5027884071572180516">"Se seleccionó 1 dispositivo"</string>
    <string name="media_output_group_panel_multiple_devices_summary" msgid="4838305763151455248">"Se seleccionaron <xliff:g id="COUNT">%1$d</xliff:g> dispositivos"</string>
    <string name="media_output_switching" msgid="7488216595474868546">"Cambiando…"</string>
    <string name="take_call_on_title" msgid="1159417893879946757">"Atender llamada en"</string>
    <string name="cannot_change_apn_toast" msgid="296540724089240405">"No se puede cambiar este APN."</string>
    <string name="battery_suggestion_title" product="tablet" msgid="1525940496459255289">"Mejorar duración de la batería de la tablet"</string>
    <string name="battery_suggestion_title" product="device" msgid="2280773774080720377">"Mejorar duración de la batería del dispositivo"</string>
    <string name="battery_suggestion_title" product="default" msgid="4811554469047272537">"Mejorar duración de la batería del teléfono"</string>
    <string name="battery_suggestion_summary" msgid="8186720080540016197"></string>
    <string name="gesture_prevent_ringing_screen_title" msgid="8293094715267769349">"Silenciar sonidos"</string>
    <string name="gesture_prevent_ringing_title" msgid="5978577898997523581">"Presiona el botón de encendido y el botón para subir el volumen al mismo tiempo para"</string>
    <string name="gesture_prevent_ringing_sound_title" msgid="4529077822282099235">"Acceso directo para silenciar"</string>
    <string name="prevent_ringing_option_vibrate" msgid="5456962289649581737">"Vibrar"</string>
    <string name="prevent_ringing_option_mute" msgid="7446121133560945051">"Silenciar"</string>
    <string name="prevent_ringing_option_none" msgid="7776676007180834163">"No hacer nada"</string>
    <string name="prevent_ringing_option_vibrate_summary" msgid="3435299885425754304">"Vibrar"</string>
    <string name="prevent_ringing_option_mute_summary" msgid="3939350522269337013">"Silenciar"</string>
    <string name="pref_title_network_details" msgid="7329759534269363308">"Detalles de la red"</string>
    <string name="about_phone_device_name_warning" msgid="1938930553285875166">"El nombre de tu dispositivo es visible para las apps del teléfono. Es posible que también lo vean otras personas cuando te conectes a dispositivos Bluetooth o a una red Wi-Fi, o cuando configures un hotspot de Wi-Fi."</string>
    <string name="devices_title" msgid="649715719278562515">"Dispositivos"</string>
    <string name="homepage_all_settings" msgid="1877827279189801035">"Toda la configuración"</string>
    <string name="homepage_personal_settings" msgid="8312279476519359656">"Sugerencias"</string>
    <string name="choose_network_title" msgid="5355609223363859430">"Elegir una red"</string>
    <string name="network_disconnected" msgid="8281188173486212661">"Desconectado"</string>
    <string name="network_connected" msgid="7637745547242487795">"Conectado"</string>
    <string name="network_connecting" msgid="6856124847029124041">"Conectando…"</string>
    <string name="network_could_not_connect" msgid="676574629319069922">"No se pudo establecer conexión"</string>
    <string name="empty_networks_list" msgid="6519489879480673428">"No se encontraron redes."</string>
    <string name="network_query_error" msgid="6406348372070035274">"No se encontraron redes. Vuelve a intentarlo."</string>
    <string name="forbidden_network" msgid="7404863971282262991">"(prohibida)"</string>
    <string name="no_sim_card" msgid="1497407489810953863">"Sin tarjeta SIM"</string>
    <string name="sim_card" msgid="6381158752066377709">"SIM"</string>
    <string name="wifi_no_sim_card" msgid="7144290066491585672">"No hay ninguna tarjeta SIM"</string>
    <string name="wifi_no_related_sim_card" msgid="3568255415415630510">"No hay información"</string>
    <string name="wifi_require_sim_card_to_connect" msgid="1524984445750423666">"Se requiere una tarjeta SIM para conectarse"</string>
    <string name="wifi_require_specific_sim_card_to_connect" msgid="8136020469861668506">"Se requiere una tarjeta SIM <xliff:g id="WIRELESS_CARRIER">%s</xliff:g> para conectarse"</string>
    <string name="preferred_network_mode_wcdma_perf_summary" msgid="230527592752934655">"Modo de red preferido: WCDMA preferido"</string>
    <string name="preferred_network_mode_gsm_only_summary" msgid="2936969642076535162">"Modo de red preferido: solo GSM"</string>
    <string name="preferred_network_mode_wcdma_only_summary" msgid="632816273979433076">"Modo de red preferido: solo WCDMA"</string>
    <string name="preferred_network_mode_gsm_wcdma_summary" msgid="6419309630040697488">"Modo de red preferido: GSM/WCDMA"</string>
    <string name="preferred_network_mode_cdma_summary" msgid="5735467143380764681">"Modo de red preferido: CDMA"</string>
    <string name="preferred_network_mode_cdma_evdo_summary" msgid="1667358006735235626">"Modo de red preferido: CDMA/EvDo"</string>
    <string name="preferred_network_mode_cdma_only_summary" msgid="6305930965673800101">"Modo de red preferido: solo CDMA"</string>
    <string name="preferred_network_mode_evdo_only_summary" msgid="613903666107299289">"Modo de red preferido: solo EvDo"</string>
    <string name="preferred_network_mode_cdma_evdo_gsm_wcdma_summary" msgid="5643603478619124717">"Modo de red preferido: CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_lte_summary" msgid="4236015557975544307">"Modo de red preferido: LTE"</string>
    <string name="preferred_network_mode_lte_gsm_wcdma_summary" msgid="1377100995001285751">"Modo de red preferido: GSM/WCDMA/LTE"</string>
    <string name="preferred_network_mode_lte_cdma_evdo_summary" msgid="1221806410911793222">"Modo de red preferido: CDMA+LTE/EVDO"</string>
    <string name="preferred_network_mode_lte_cdma_evdo_gsm_wcdma_summary" msgid="8974263692041299883">"Modo de red preferido: LTE/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_global_summary" msgid="817118763629102239">"Modo de red preferido: Global"</string>
    <string name="preferred_network_mode_lte_wcdma_summary" msgid="7326137039981934928">"Modo de red preferido: LTE/WCDMA"</string>
    <string name="preferred_network_mode_lte_gsm_umts_summary" msgid="5105989927899481131">"Modo de red preferido: LTE/GSM/UMTS"</string>
    <string name="preferred_network_mode_lte_cdma_summary" msgid="2364210682008525703">"Modo de red preferido: LTE/CDMA"</string>
    <string name="preferred_network_mode_tdscdma_summary" msgid="796303916110624922">"Modo de red preferido: TDSCDMA"</string>
    <string name="preferred_network_mode_tdscdma_wcdma_summary" msgid="1465990745594594173">"Modo de red preferido: TDSCDMA/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_summary" msgid="3771917510642642724">"Modo de red preferido: LTE/TDSCDMA"</string>
    <string name="preferred_network_mode_tdscdma_gsm_summary" msgid="8906951876805688851">"Modo de red preferido: TDSCDMA/GSM"</string>
    <string name="preferred_network_mode_lte_tdscdma_gsm_summary" msgid="2264537129425897267">"Modo de red preferido: LTE/GSM/TDSCDMA"</string>
    <string name="preferred_network_mode_tdscdma_gsm_wcdma_summary" msgid="2469046704847661521">"Modo de red preferido: TDSCDMA/GSM/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_wcdma_summary" msgid="2276439307637315057">"Modo de red preferido: LTE/TDSCDMA/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_gsm_wcdma_summary" msgid="1640309016390119366">"Modo de red preferido: LTE/TDSCDMA/GSM/WCDMA"</string>
    <string name="preferred_network_mode_tdscdma_cdma_evdo_gsm_wcdma_summary" msgid="8918066490624875671">"Modo de red preferido: TDSCDMA/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_cdma_evdo_gsm_wcdma_summary" msgid="1059705864131001171">"Modo de red preferido: LTE/TDSCDMA/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_nr_only_summary" msgid="9153575102136218656">"Modo de red preferido: solo NR"</string>
    <string name="preferred_network_mode_nr_lte_summary" msgid="4326679533556458480">"Modo de red preferido: NR/LTE"</string>
    <string name="preferred_network_mode_nr_lte_cdma_evdo_summary" msgid="4030662583832600005">"Modo de red preferido: NR/LTE/CDMA/EvDo"</string>
    <string name="preferred_network_mode_nr_lte_gsm_wcdma_summary" msgid="8327982533965785835">"Modo de red preferido: NR/LTE/GSM/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_cdma_evdo_gsm_wcdma_summary" msgid="7892233480076496041">"Modo de red preferido: NR/LTE/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_wcdma_summary" msgid="5762334298562095421">"Modo de red preferido: NR/LTE/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_summary" msgid="2356681171665091175">"Modo de red preferido: NR/LTE/TDSCDMA"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_gsm_summary" msgid="8889597344872814893">"Modo de red preferido: NR/LTE/TDSCDMA/GSM"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_wcdma_summary" msgid="506057560516483258">"Modo de red preferido: NR/LTE/TDSCDMA/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_gsm_wcdma_summary" msgid="4337061745216872524">"Modo de red preferido: NR/LTE/TDSCDMA/GSM/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_cdma_evdo_gsm_wcdma_summary" msgid="3396717432149544381">"Modo de red preferido: NR/LTE/TDSCDMA/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="network_recommended" msgid="4665525658003183348">" (recomendado)"</string>
    <string name="network_lte" msgid="2449425437381668780">"LTE (recomendado)"</string>
    <string name="network_4G" msgid="9018841362928321047">"4G (recomendado)"</string>
    <string name="label_available" msgid="5305726869955838606">"Redes disponibles"</string>
    <string name="load_networks_progress" msgid="4717874401621250401">"Buscando…"</string>
    <string name="register_on_network" msgid="2169662800750709709">"Registrando en <xliff:g id="NETWORK">%s</xliff:g>…"</string>
    <string name="not_allowed" msgid="5756935665192962915">"Tu tarjeta SIM no permite una conexión con esta red."</string>
    <string name="connect_later" msgid="2330538069949281352">"No se puede establecer una conexión con la red en este momento. Vuelve a intentarlo más adelante."</string>
    <string name="registration_done" msgid="1750434215698850123">"Se registró en la red."</string>
    <string name="select_automatically" msgid="2419752566747259155">"Seleccionar red de forma automática"</string>
    <string name="carrier_settings_title" msgid="6959295328730560529">"Config. del proveedor"</string>
    <string name="cdma_lte_data_service" msgid="6937443423651347345">"Configurar servicio de datos"</string>
    <string name="mobile_data_settings_title" msgid="3927524078598009792">"Datos móviles"</string>
    <string name="mobile_data_settings_summary" msgid="7323978798199919063">"Acceder a los datos usando la red móvil"</string>
    <string name="mobile_data_settings_summary_auto_switch" msgid="7851549787645698945">"El teléfono cambiará a este proveedor automáticamente en cuanto esté dentro del rango"</string>
    <string name="mobile_data_settings_summary_unavailable" msgid="3309106501029928951">"No hay ninguna tarjeta SIM disponible"</string>
    <string name="calls_preference" msgid="2166481296066890129">"Preferencia de llamadas"</string>
    <string name="sms_preference" msgid="7742964962568219351">"Preferencia de SMS"</string>
    <string name="calls_and_sms_ask_every_time" msgid="3178743088737726677">"Preguntar siempre"</string>
    <string name="mobile_network_summary_add_a_network" msgid="9079866102827526779">"Agregar una red"</string>
    <plurals name="mobile_network_summary_count" formatted="false" msgid="5173633860800230925">
      <item quantity="other"><xliff:g id="COUNT_1">%1$d</xliff:g> SIM</item>
      <item quantity="one"><xliff:g id="COUNT_0">%1$d</xliff:g> SIM</item>
    </plurals>
    <string name="default_for_calls" msgid="2788950217176988034">"Predeterminada para llamadas"</string>
    <string name="default_for_sms" msgid="1316988329407434771">"Predeterminada para SMS"</string>
    <string name="default_for_calls_and_sms" msgid="8223971369339958151">"Predeterminada para llamadas y SMS"</string>
    <string name="default_for_mobile_data" msgid="3725773640392315626">"Predeterminada para datos móviles"</string>
    <string name="mobile_data_active" msgid="8683694456401350210">"Datos móviles activados"</string>
    <string name="mobile_data_off" msgid="2702029611959308269">"Datos móviles desactivados"</string>
    <string name="subscription_available" msgid="2659722770210403365">"Disponible"</string>
    <string name="mobile_network_in_range" msgid="3528320750936028369">"En el rango"</string>
    <string name="mobile_network_not_in_range" msgid="5680896182395366584">"Fuera de alcance"</string>
    <string name="mobile_network_list_add_more" msgid="4478586073355236604">"Agregar más"</string>
    <string name="mobile_network_active_sim" msgid="6397581267971410039">"Activa / SIM"</string>
    <string name="mobile_network_inactive_sim" msgid="5829757490580409899">"Inactiva / SIM"</string>
    <string name="mobile_network_active_esim" msgid="4673190244386572318">"Activa / SIM descargada"</string>
    <string name="mobile_network_inactive_esim" msgid="2901035056727849007">"Inactiva / SIM descargada"</string>
    <string name="mobile_network_sim_name" msgid="3187192894150386537">"Nombre y color de la SIM"</string>
    <string name="mobile_network_sim_name_label" msgid="1452440641628369625">"Nombre"</string>
    <string name="mobile_network_sim_color_label" msgid="5293944087609632340">"Color (utilizado por apps compatibles)"</string>
    <string name="mobile_network_sim_name_rename" msgid="5967588549571582924">"Guardar"</string>
    <string name="mobile_network_use_sim_on" msgid="7298332437547707908">"Usar SIM"</string>
    <string name="mobile_network_use_sim_off" msgid="6303281166199670639">"Desactivado"</string>
    <string name="mobile_network_disable_sim_explanation" msgid="2851862257846773796">"Para inhabilitar esta tarjeta SIM, quítala"</string>
    <string name="mobile_network_tap_to_activate" msgid="4139979375717958102">"Presiona para activar <xliff:g id="CARRIER">%1$s</xliff:g>"</string>
    <string name="mobile_network_esim_swap_confirm_title" msgid="2762744961192218789">"¿Quieres cambiar a <xliff:g id="CARRIER">%1$s</xliff:g>?"</string>
    <string name="mobile_network_esim_swap_confirm_body" msgid="8168680839542031781">"Solo puede activarse una sola tarjeta SIM descargada a la vez.\n\nSi cambias a <xliff:g id="CARRIER1">%1$s</xliff:g> no se cancelará el servicio de <xliff:g id="CARRIER2">%2$s</xliff:g>."</string>
    <string name="mobile_network_esim_swap_confirm_ok" msgid="8695772737522378095">"Cambiar a <xliff:g id="CARRIER">%1$s</xliff:g>"</string>
    <string name="mobile_network_erase_sim" msgid="4629071168032714930">"Borrar tarjeta SIM"</string>
    <string name="mobile_network_erase_sim_error_dialog_title" msgid="6680959559589234726">"No se puede borrar la tarjeta SIM"</string>
    <string name="mobile_network_erase_sim_error_dialog_body" msgid="6401922869095572710">"No es posible borrar esta tarjeta SIM debido a un error.\n\nReinicia el dispositivo y vuelve a intentarlo."</string>
    <string name="preferred_network_mode_title" msgid="3083431168988535628">"Tipo de red preferido"</string>
    <string name="preferred_network_mode_summary" msgid="537577807865497546">"Cambiar el modo operativo de la red"</string>
    <string name="preferred_network_mode_dialogtitle" msgid="4179420486180351631">"Tipo de red preferido"</string>
    <string name="carrier_settings_euicc" msgid="1541279297111378907">"Proveedor"</string>
    <string name="carrier_settings_version" msgid="4738147451583140935">"Versión de la configuración"</string>
    <string name="call_category" msgid="641461844504128789">"Llamadas"</string>
    <string name="video_calling_settings_title" msgid="5490466306783552190">"Videollamada con el proveedor"</string>
    <string name="cdma_system_select_title" msgid="8261408056382123386">"Sistema seleccionado"</string>
    <string name="cdma_system_select_summary" msgid="384128007068464145">"Cambiar el modo de roaming de CDMA"</string>
    <string name="cdma_system_select_dialogtitle" msgid="6143586810486936984">"Sistema seleccionado"</string>
    <string name="network_operator_category" msgid="5309383730335681395">"Red"</string>
    <string name="network_select_title" msgid="4532395144000206685">"Red"</string>
    <string name="cdma_subscription_title" msgid="3107207913315872336">"Suscripción CDMA"</string>
    <string name="cdma_subscription_summary" msgid="7134032708555561334">"Cambiar entre RUIM/SIM y NV"</string>
    <string name="cdma_subscription_dialogtitle" msgid="555971296756231647">"suscripción"</string>
    <string name="register_automatically" msgid="5208258089316657167">"Registro automático…"</string>
    <string name="roaming_alert_title" msgid="9052791521868787985">"¿Permitir el roaming de datos?"</string>
    <string name="roaming_check_price_warning" msgid="5876977438036791361">"Para saber los precios, consulta con tu proveedor de red."</string>
    <string name="mobile_data_usage_title" msgid="2047864499317759728">"Uso de datos de las apps"</string>
    <string name="mobile_network_mode_error" msgid="9222056129897416074">"El modo de red no es válido: <xliff:g id="NETWORKMODEID">%1$d</xliff:g>. Ignorar."</string>
    <string name="mobile_network_apn_title" msgid="5582995550142073054">"Nombres de puntos de acceso"</string>
    <string name="manual_mode_disallowed_summary" msgid="4243142645520152175">"No está disponible cuando estás conectado a <xliff:g id="CARRIER">%1$s</xliff:g>"</string>
    <string name="see_more" msgid="7499355691042812723">"Ver más"</string>
    <string name="see_less" msgid="2642392725363552793">"Ver menos"</string>
    <string name="sim_action_enable_sub_dialog_title" msgid="4003377033815971802">"¿Quieres activar <xliff:g id="CARRIER_NAME">%1$s</xliff:g>?"</string>
    <string name="sim_action_enable_sub_dialog_title_without_carrier_name" msgid="4842051610633654278">"¿Quieres activar la SIM?"</string>
    <string name="sim_action_switch_sub_dialog_title" msgid="9180969453358718635">"¿Quieres cambiar a <xliff:g id="CARRIER_NAME">%1$s</xliff:g>?"</string>
    <string name="sim_action_switch_psim_dialog_title" msgid="5613177333235213024">"¿Cambiar a uso de tarjeta SIM?"</string>
    <string name="sim_action_switch_sub_dialog_text" msgid="2091834911153293004">"Solo se puede activar una tarjeta SIM a la vez.\n\nSi cambias a <xliff:g id="TO_CARRIER_NAME">%1$s</xliff:g>, no se cancelará el servicio de <xliff:g id="FROM_CARRIER_NAME">%2$s</xliff:g>."</string>
    <string name="sim_action_switch_sub_dialog_text_downloaded" msgid="1396320209544698027">"Solo puede activarse una tarjeta SIM descargada a la vez.\n\nSi cambias a <xliff:g id="TO_CARRIER_NAME">%1$s</xliff:g>, no se cancelará el servicio de <xliff:g id="FROM_CARRIER_NAME">%2$s</xliff:g>."</string>
    <string name="sim_action_switch_sub_dialog_text_single_sim" msgid="6188750682431170845">"Solo se puede activar una tarjeta SIM a la vez.\n\nSi cambias, no se cancelará el servicio de <xliff:g id="TO_CARRIER_NAME">%1$s</xliff:g>."</string>
    <string name="sim_action_switch_sub_dialog_confirm" msgid="1901181581944638961">"Cambiar a <xliff:g id="CARRIER_NAME">%1$s</xliff:g>"</string>
    <string name="sim_action_enabling_sim_without_carrier_name" msgid="2706862823501979981">"Estableciendo conexión con la red…"</string>
    <string name="sim_action_switch_sub_dialog_progress" msgid="8341013572582875574">"Cambiando a <xliff:g id="CARRIER_NAME">%1$s</xliff:g>"</string>
    <string name="sim_action_enable_sim_fail_title" msgid="1765646238941015899">"No se puede cambiar de proveedor"</string>
    <string name="sim_action_enable_sim_fail_text" msgid="4781863235721417544">"No se puede cambiar de proveedor debido a un error."</string>
    <string name="privileged_action_disable_sub_dialog_title" msgid="3298942357601334418">"¿Quieres desactivar <xliff:g id="CARRIER_NAME">%1$s</xliff:g>?"</string>
    <string name="privileged_action_disable_sub_dialog_title_without_carrier" msgid="6518373229436331608">"¿Quieres desactivar la tarjeta SIM?"</string>
    <string name="privileged_action_disable_sub_dialog_progress" msgid="5900243067681478102">"Desactivando SIM<xliff:g id="ELLIPSIS">…</xliff:g>"</string>
    <string name="privileged_action_disable_fail_title" msgid="6689494935697043555">"No se puede inhabilitar el proveedor"</string>
    <string name="privileged_action_disable_fail_text" msgid="8404023523406091819">"Se produjo un error y no se pudo inhabilitar tu proveedor."</string>
    <string name="sim_action_enable_dsds_title" msgid="226508711751577169">"¿Quieres usar 2 tarjetas SIM?"</string>
    <string name="sim_action_enable_dsds_text" msgid="970986559326263949">"Este dispositivo puede tener 2 tarjetas SIM activas al mismo tiempo. Para seguir usando una sola, presiona \"No, gracias\"."</string>
    <string name="sim_action_restart_title" msgid="7054617569121993825">"¿Quieres reiniciar el dispositivo?"</string>
    <string name="sim_action_restart_text" msgid="8019300474703571013">"Para comenzar, reinicia el dispositivo. Luego, podrás agregar otra tarjeta SIM."</string>
    <string name="sim_action_continue" msgid="1688813133152389943">"Continuar"</string>
    <string name="sim_action_reboot" msgid="3508948833333441538">"Reiniciar"</string>
    <string name="sim_action_no_thanks" msgid="435717748384544195">"No, gracias"</string>
    <string name="sim_switch_button" msgid="1405772571706095387">"Cambiar"</string>
    <string name="dsds_activation_failure_title" msgid="4467364110584914794">"No se puede activar la SIM"</string>
    <string name="dsds_activation_failure_body_msg1" msgid="6303921196869256391">"Quita la SIM y vuelve a insertarla. Si el problema persiste, reinicia el dispositivo."</string>
    <string name="dsds_activation_failure_body_msg2" msgid="73044349546544410">"Vuelve a activar la SIM. Si el problema persiste, reinicia el dispositivo."</string>
    <string name="sim_setup_channel_id" msgid="8797972565087458515">"Activación de red"</string>
    <string name="post_dsds_reboot_notification_title_with_carrier" msgid="3308827462185135307">"<xliff:g id="CARRIER_NAME">%1$s</xliff:g> está activo"</string>
    <string name="post_dsds_reboot_notification_text" msgid="7533428378211541410">"Presiona para actualizar la configuración de la tarjeta SIM"</string>
    <string name="sim_card_label" msgid="5632157635124050923">"Tarjeta SIM"</string>
    <string name="erase_sim_dialog_title" msgid="881253002169177016">"¿Quieres borrar esta tarjeta SIM descargada?"</string>
    <string name="erase_sim_dialog_text" msgid="753031064269699885">"Si borras esta tarjeta SIM, se quitará el servicio de <xliff:g id="CARRIER_NAME_A">%1$s</xliff:g> de este dispositivo.\n\nSin embargo, no se cancelará el servicio de <xliff:g id="CARRIER_NAME_B">%1$s</xliff:g>."</string>
    <string name="erase_sim_confirm_button" msgid="8309115684335320541">"Borrar"</string>
    <string name="erasing_sim" msgid="7877703231075699139">"Borrando tarjeta SIM…"</string>
    <string name="erase_sim_fail_title" msgid="2024446702985862427">"No se puede borrar la tarjeta SIM"</string>
    <string name="erase_sim_fail_text" msgid="7870804401227483131">"No es posible borrar esta tarjeta SIM porque se produjo un error.\n\nReinicia el dispositivo y vuelve a intentarlo."</string>
    <string name="network_connection_request_dialog_title" msgid="1896186380874289434">"Conectar al dispositivo"</string>
    <string name="network_connection_request_dialog_summary" msgid="7693038309792726170">"La app de <xliff:g id="APPNAME">%1$s</xliff:g> quiere usar una red Wi-Fi temporal para conectarse a tu dispositivo"</string>
    <string name="network_connection_timeout_dialog_message" msgid="598509083077743772">"No se encontraron dispositivos. Asegúrate de que los dispositivos estén encendidos y puedan conectarse."</string>
    <string name="network_connection_timeout_dialog_ok" msgid="6022675321823723755">"Volver a intentarlo"</string>
    <string name="network_connection_errorstate_dialog_message" msgid="3360714322047603239">"Se produjo un error. La aplicación canceló la solicitud para elegir un dispositivo."</string>
    <string name="network_connection_connect_successful" msgid="2587314077675642476">"Conexión exitosa"</string>
    <string name="network_connection_connect_failure" msgid="6803313816657494319">"Error de conexión"</string>
    <string name="network_connection_request_dialog_showall" msgid="6392059758456994944">"Mostrar todo"</string>
    <string name="network_connection_searching_message" msgid="8521819623516926482">"Buscando dispositivo…"</string>
    <string name="network_connection_connecting_message" msgid="433189540877274889">"Estableciendo conexión con dispositivo…"</string>
    <string name="bluetooth_left_name" msgid="7440064067910080502">"Izquierdo"</string>
    <string name="bluetooth_right_name" msgid="7588088072444124949">"Derecho"</string>
    <string name="bluetooth_middle_name" msgid="3909371955137442319">"Funda"</string>
    <string name="settings_panel_title" msgid="346363079938069215">"Panel de Configuración"</string>
    <string name="internet_connectivity_panel_title" msgid="2044237561024730108">"Conexión a Internet"</string>
    <string name="volume_connectivity_panel_title" msgid="8772438444782726321">"Volumen"</string>
    <string name="mobile_data_ap_mode_disabled" msgid="6067959496888990983">"No disponible en modo de avión"</string>
    <string name="force_desktop_mode" msgid="1336913605091334238">"Forzar modo de escritorio"</string>
    <string name="force_desktop_mode_summary" msgid="4587416867846930479">"Forzar el modo de escritorio experimental en pantallas secundarias"</string>
    <!-- no translation found for enable_non_resizable_multi_window (6832903754625404477) -->
    <skip />
    <!-- no translation found for enable_non_resizable_multi_window_summary (3275763753261901999) -->
    <skip />
    <string name="hwui_force_dark_title" msgid="4256904905631994219">"Anular forzar el modo oscuro"</string>
    <string name="hwui_force_dark_summary" msgid="6515748781487952769">"Anula la función forzar el modo oscuro para que esté siempre activo"</string>
    <string name="enable_blurs_on_windows_title" msgid="4218144213800778872">"Habilitar difuminado"</string>
    <string name="enable_blurs_on_windows_summary" msgid="8962906921531490386">"Habilita el difuminado de ventanas en el nivel del compositor. Debes reiniciar el dispositivo."</string>
    <string name="privacy_dashboard_title" msgid="6845403825611829558">"Privacidad"</string>
    <string name="privacy_dashboard_summary" msgid="5775090172422786808">"Permisos, actividad de la cuenta, datos personales"</string>
    <string name="contextual_card_dismiss_remove" msgid="8636557343011606722">"Quitar"</string>
    <string name="contextual_card_dismiss_keep" msgid="440516181066490747">"Guardar"</string>
    <string name="contextual_card_dismiss_confirm_message" msgid="6434344989238055188">"¿Quieres quitar esta sugerencia?"</string>
    <string name="contextual_card_removed_message" msgid="5755438207494260867">"Se quitó la sugerencia"</string>
    <string name="contextual_card_undo_dismissal_text" msgid="5200381837316691406">"Deshacer"</string>
    <string name="low_storage_summary" msgid="1979492757417779718">"Queda poco espacio de almacenamiento (en uso: <xliff:g id="PERCENTAGE">%1$s</xliff:g>; libre: <xliff:g id="FREE_SPACE">%2$s</xliff:g>)"</string>
    <string name="contextual_card_feedback_send" msgid="7409408664417908922">"Enviar comentarios"</string>
    <string name="contextual_card_feedback_confirm_message" msgid="3186334562157665381">"¿Te gustaría compartir tus comentarios sobre esta sugerencia?"</string>
    <string name="copyable_slice_toast" msgid="1008251852798990606">"Se copió <xliff:g id="COPY_CONTENT">%1$s</xliff:g> en el portapapeles."</string>
    <string name="search_bar_account_avatar_content_description" msgid="880523277036898350"></string>
    <string name="permission_bar_chart_empty_text" msgid="4856719891991325077">"Ninguna aplicación usó permisos"</string>
    <string name="permission_bar_chart_title" msgid="2493212904955611441">"Uso de permisos en las últimas 24 horas"</string>
    <string name="permission_bar_chart_details" msgid="5816698018592357088">"Ver todo en el panel"</string>
    <plurals name="permission_bar_chart_label" formatted="false" msgid="4853396794340896078">
      <item quantity="other"><xliff:g id="NUMBER">%s</xliff:g> apps</item>
      <item quantity="one">1 app</item>
    </plurals>
    <string name="accessibility_usage_title" msgid="9190967143518779145">"Uso de accesibilidad"</string>
    <plurals name="accessibility_usage_summary" formatted="false" msgid="6910643986958263005">
      <item quantity="other"><xliff:g id="SERVICE_COUNT">%1$d</xliff:g> apps tienen acceso completo a tu dispositivo</item>
      <item quantity="one">1 app tiene acceso completo a tu dispositivo</item>
    </plurals>
    <string name="media_output_panel_title" msgid="5920946795078065159">"Cambiar de salida"</string>
    <string name="media_output_panel_summary_of_playing_device" msgid="6998758947764222915">"Reproduciendo en <xliff:g id="DEVICE_NAME">%1$s</xliff:g>"</string>
    <string name="media_output_disconnected_status" msgid="5567111639832431865">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g> (desconectado)"</string>
    <string name="media_output_switch_error_text" msgid="603563475910236831">"Error: Presiona, y vuelve a intentarlo."</string>
    <string name="wfc_disclaimer_title_text" msgid="4617195934203523503">"Información importante"</string>
    <string name="wfc_disclaimer_agree_button_text" msgid="4082872292910770344">"CONTINUAR"</string>
    <string name="wfc_disclaimer_disagree_text" msgid="8424457394700137703">"NO, GRACIAS"</string>
    <string name="wfc_disclaimer_location_title_text" msgid="7913919887475418423">"Ubicación"</string>
    <string name="wfc_disclaimer_location_desc_text" msgid="2799241640320172899">"Es posible que tu proveedor de servicios recopile información sobre tu ubicación para brindar este servicio.\n\nRevisa su política de privacidad."</string>
    <string name="forget_passpoint_dialog_message" msgid="2433875063907365760">"Es posible que pierdas acceso a los datos o al tiempo restantes. Consúltalo con tu proveedor antes de quitarlo."</string>
    <string name="keywords_content_capture" msgid="7802155522681936956">"captura de contenido, contenido de app"</string>
    <string name="content_capture" msgid="868372905432812238">"Contenido de la app"</string>
    <string name="content_capture_summary" msgid="49720773699715531">"Permite que las apps envíen contenido al sistema Android"</string>
    <string name="capture_system_heap_dump_title" msgid="9210974110606886455">"Capturar volcado de pila del sistema"</string>
    <string name="capturing_system_heap_dump_message" msgid="8410503247477360622">"Capturando volcado del montón del sistema"</string>
    <string name="error_capturing_system_heap_dump_message" msgid="2352983250048200052">"No se pudo capturar el volcado de pila del sistema"</string>
    <string name="automatic_system_heap_dump_title" msgid="4093306504711109479">"Capturar automáticamente volcados de pila del sistema"</string>
    <string name="automatic_system_heap_dump_summary" msgid="4060846186592886986">"Capturar automáticamente un volcado de pila para el sistema Android cuando usa demasiada memoria"</string>
    <string name="wifi_disconnect_button_text" msgid="5698154296678571998">"Desconectar"</string>
    <string name="wfc_disclaimer_emergency_limitation_title_text" msgid="8276287227589397162">"Llamadas de emergencia"</string>
    <string name="wfc_disclaimer_emergency_limitation_desc_text" msgid="5503902001191552196">"Tu proveedor no admite llamadas de emergencia mediante la función Llamada por Wi-Fi.\nEl dispositivo cambia automáticamente a una red móvil para hacer una llamada de emergencia.\nEste tipo de llamadas solo se pueden realizar en áreas con cobertura móvil."</string>
    <string name="wifi_calling_summary" msgid="8566648389959032967">"Usar Wi‑Fi para mejorar la calidad de las llamadas"</string>
    <string name="backup_calling_settings_title" msgid="519714752900364326">"Llamada de copia de seguridad"</string>
    <string name="backup_calling_setting_summary" msgid="451295393447465830">"Si <xliff:g id="BACKUP_CALLING_OPERATOR_TEXT">%1$s</xliff:g> no está disponible, usa tu SIM de datos móviles para realizar y recibir llamadas de <xliff:g id="BACKUP_CALLING_CARRIER_TEXT">%1$s</xliff:g>."</string>
    <string name="keywords_backup_calling" msgid="8592800915478816800">"llamada de copia de seguridad"</string>
    <string name="enable_receiving_mms_notification_title" msgid="6465218559386990248">"Mensaje MMS entrante"</string>
    <string name="enable_sending_mms_notification_title" msgid="7120641300854953375">"No se puede enviar el mensaje MMS"</string>
    <string name="enable_mms_notification_summary" msgid="6432752438276672500">"Presiona para permitir los mensajes MMS en <xliff:g id="OPERATOR_NAME">%1$s</xliff:g> cuando los datos móviles estén desactivados"</string>
    <string name="enable_mms_notification_channel_title" msgid="1798206332620642108">"Mensaje MMS"</string>
    <string name="sim_combination_warning_notification_title" msgid="1365401631492986487">"Problema con la combinación de SIM"</string>
    <string name="dual_cdma_sim_warning_notification_summary" msgid="2826474790710586487">"Si usas <xliff:g id="OPERATOR_NAMES">%1$s</xliff:g>, podría limitarse la funcionalidad. Presiona para obtener más información."</string>
    <string name="dual_cdma_sim_warning_notification_channel_title" msgid="1049161096896074364">"Combinación de SIM"</string>
    <string name="work_policy_privacy_settings" msgid="2702644843505242596">"Información sobre la política de tu trabajo"</string>
    <string name="work_policy_privacy_settings_summary" msgid="690118670737638405">"Configuración gestionada por tu administrador de TI"</string>
    <string name="track_frame_time_keywords" msgid="7885340257945922239">"GPU"</string>
    <string name="bug_report_handler_title" msgid="713439959113250125">"Controlador de informes de errores"</string>
    <string name="bug_report_handler_picker_footer_text" msgid="4935758328366585673">"Determina qué app controla el acceso directo a los informes de errores en el dispositivo."</string>
    <string name="personal_profile_app_subtext" msgid="5586060806997067676">"Personal"</string>
    <string name="work_profile_app_subtext" msgid="5043419461440127879">"Trabajo"</string>
    <string name="system_default_app_subtext" msgid="5212055189703164839">"Predeterminada del sistema"</string>
    <string name="select_invalid_bug_report_handler_toast_text" msgid="8857326334015386692">"Esta opción ya no es válida. Vuelve a intentarlo."</string>
    <string name="device_controls_sentence" msgid="4887752349920801907">"Controles de dispositivos"</string>
    <string name="quick_controls_lower" msgid="6675573610027367819">"controles de dispositivos"</string>
    <string name="cards_passes_sentence" msgid="1866311782387946944">"Tarjetas y pases"</string>
    <string name="cards_passes_lower" msgid="2429722007109957877">"tarjetas y pases"</string>
    <string name="power_menu_setting_name" msgid="7843519296976254765">"Menú de encendido"</string>
    <string name="power_menu_setting_title" msgid="7716546106215378956">"Menú del botón de encendido"</string>
    <string name="power_menu_cards_passes" msgid="1707852019651773645">"Mostrar tarjetas y pases"</string>
    <string name="power_menu_device_controls" msgid="5114816270328063924">"Mostrar controles de dispositivos"</string>
    <string name="power_menu_cards_passes_device_controls" msgid="8645794247280620106">"Mostrar tarjetas, pases y controles de dispositivos"</string>
    <string name="power_menu_lock_screen_category" msgid="1478249026305417128">"Pantalla de bloqueo"</string>
    <string name="power_menu_none" msgid="4620640577918731270">"No mostrar contenido"</string>
    <string name="power_menu_privacy" msgid="7900052501075197854">"Contenido sensible"</string>
    <string name="power_menu_privacy_show" msgid="2112741022037054383">"Mostrar tarjetas y controles cuando está bloqueado"</string>
    <string name="power_menu_privacy_show_controls" msgid="8294874046577167797">"Mostrar controles en pantalla bloqueada"</string>
    <string name="power_menu_privacy_show_cards" msgid="8937303188629541026">"Mostrar tarjetas en la pantalla bloqueada"</string>
    <string name="power_menu_privacy_hide" msgid="1617102911157977095">"Ocultar tarjetas y controles cuando está bloqueado"</string>
    <string name="power_menu_privacy_not_secure" msgid="6247119934128206924">"Para usarlo, debes establecer un bloqueo de pantalla"</string>
    <string name="device_controls_setting_toggle" msgid="8972005569207737469">"Mostrar controles de dispositivos"</string>
    <string name="cards_passes_setting_toggle" msgid="3380984848045396695">"Mostrar tarjetas y pases"</string>
    <string name="device_controls_setting_subtitle" msgid="4388544861427973600">"Para acceder a los controles de dispositivos conectados, mantén presionado el botón de encendido."</string>
    <string name="cards_passes_setting_subtitle" msgid="4427459738229697469">"Para acceder a tus formas de pago, tarjetas de embarque, etc., mantén pulsado el botón de encendido."</string>
    <string name="rtt_settings_title" msgid="7049259598645966354"></string>
    <string name="rtt_settings_no_visible" msgid="7440356831140948382"></string>
    <string name="rtt_settings_visible_during_call" msgid="7866181103286073700"></string>
    <string name="rtt_settings_always_visible" msgid="2364173070088756238"></string>
    <string name="media_output_panel_stop_casting_button" msgid="6094875883164119035">"Detener transmisión"</string>
    <string name="volte_5G_limited_title" msgid="5908052268836750629">"¿Deseas desactivar VoLTE?"</string>
    <string name="volte_5G_limited_text" msgid="7150583768725182345">"También se desactivará tu conexión 5G.\nDurante una llamada de voz, no puedes usar Internet y es posible que algunas apps no funcionen."</string>
    <string name="no_5g_in_dsds_text" product="default" msgid="772747677303920132">"Este teléfono se limitará a 4G cuando se usen 2 tarjetas SIM. "<annotation id="url">"Más información"</annotation></string>
    <string name="no_5g_in_dsds_text" product="tablet" msgid="4757328474425714624">"Esta tablet se limitará a 4G cuando se usen 2 tarjetas SIM. "<annotation id="url">"Más información"</annotation></string>
    <string name="no_5g_in_dsds_text" product="device" msgid="6983783505032683314">"Este dispositivo se limitará a 4G cuando se usen 2 tarjetas SIM. "<annotation id="url">"Más información"</annotation></string>
    <string name="cached_apps_freezer" msgid="1057519579761550350">"Suspende la ejecución de apps almacenadas en caché"</string>
    <string name="overlay_settings_title" msgid="1032863083496396365">"Permitir pantallas superpuestas en Configuración"</string>
    <string name="overlay_settings_summary" msgid="2745336273786148166">"Permite que las apps que pueden mostrar contenido sobre otras se superpongan a las pantallas de Configuración"</string>
    <string name="media_controls_title" msgid="403271085636252597">"Contenido multimedia"</string>
    <string name="media_controls_summary" msgid="3573121049460596520">"Reproductor multimedia en la Configuración rápida"</string>
    <string name="media_controls_resume_description" msgid="7702723104730495227">"Muestra el reproductor multimedia durante un período extendido para reanudar la reproducción de manera sencilla"</string>
    <string name="media_controls_hide_player" msgid="2751439192580884015">"Ocultar reproductor"</string>
    <string name="media_controls_show_player" msgid="8504571042365814021">"Mostrar reproductor"</string>
    <string name="media_controls_no_players" msgid="3493023121892175946">"No hay jugadores disponibles"</string>
    <string name="media_controls_apps_title" msgid="9129092193224838008">"Apps permitidas"</string>
    <string name="keywords_media_controls" msgid="8345490568291778638">"contenido multimedia"</string>
    <string name="connected_device_see_all_summary" msgid="2056010318537268108">"Se activará el Bluetooth"</string>
    <string name="bluetooth_setting_on" msgid="4808458394436224124">"Activado"</string>
    <string name="bluetooth_setting_off" msgid="4965493913199554789">"Desactivado"</string>
    <string name="provider_internet_settings" msgid="3831259474776313323">"Internet"</string>
    <string name="provider_network_settings_title" msgid="2624756136016346774">"SIM"</string>
    <string name="airplane_safe_networks" msgid="6057114281183247124">"Ver redes para el modo de avión"</string>
    <string name="airplane_safe_networks_summary" msgid="4879620804022818385">"Encuentra redes para el modo de avión y conéctate a ellas."</string>
    <string name="keywords_airplane_safe_networks" msgid="5902708537892978245">"avión, segura para aviones"</string>
    <string name="calls_and_sms" msgid="1931855083959003306">"Llamadas y SMS"</string>
    <string name="calls_and_sms_category" msgid="2021321997884906046">"Llamada por Wi‑Fi"</string>
    <!-- no translation found for calls_sms_wfc_summary (3940529919408667336) -->
    <skip />
    <!-- no translation found for calls_sms_footnote (8051604228144899434) -->
    <skip />
    <string name="calls_preference_title" msgid="7536882032182563800">"Llamadas"</string>
    <string name="sms_preference_title" msgid="8392745501754864395">"SMS"</string>
    <string name="calls_sms_preferred" msgid="6016477652522583496">"preferencia"</string>
    <string name="calls_sms_calls_preferred" msgid="252913858812799809">"preferencia para llamadas"</string>
    <string name="calls_sms_sms_preferred" msgid="5826706870873784062">"preferencia para SMS"</string>
    <string name="calls_sms_unavailable" msgid="4055729705246556529">"no disponible"</string>
    <string name="calls_sms_no_sim" msgid="2336377399761819718">"No hay ninguna tarjeta SIM"</string>
    <string name="network_and_internet_preferences_title" msgid="8038469368705591439">"Preferencias"</string>
    <string name="network_and_internet_preferences_summary" msgid="613207494152304537">"Conectarse a redes públicas"</string>
    <string name="keywords_internet" msgid="7674082764898690310">"conexión de red, internet, inalámbrico, datos, wifi, wi-fi, wi fi, datos móviles, móvil, proveedor de telefonía, 4g, 3g, 2g, lte"</string>
    <string name="view_airplane_safe_networks" msgid="9170023210981508906">"Ver redes para modo de avión"</string>
    <string name="viewing_airplane_mode_networks" msgid="4548508852659577531">"Viendo redes en modo de avión"</string>
    <string name="turn_off_airplane_mode" msgid="7141986366534514443">"Desactivar el modo de avión"</string>
    <string name="reset_your_internet_title" msgid="4856899004343241310">"¿Deseas restablecer la conexión a Internet?"</string>
    <string name="reset_internet_text" product="default" msgid="8797910368942544453">"Esta acción finalizará la llamada telefónica"</string>
    <string name="reset_internet_text" product="tablet" msgid="8797910368942544453">"Esta acción finalizará la llamada telefónica"</string>
    <string name="resetting_internet_text" msgid="6696779371800051806">"Restableciendo conexión a Internet…"</string>
    <string name="fix_connectivity" msgid="2781433603228089501">"Corregir conectividad"</string>
    <string name="airplane_mode_network_available" msgid="1059499681300395240">"Hay redes disponibles para el modo de avión"</string>
    <string name="to_switch_networks_disconnect_ethernet" msgid="6615374552827587197">"Para cambiar de red, desconéctate de Ethernet"</string>
    <!-- no translation found for cannot_switch_networks_while_connected (3867944849171754777) -->
    <skip />
    <string name="preference_summary_default_combination" msgid="4643585915107796253">"<xliff:g id="STATE">%1$s</xliff:g>/<xliff:g id="NETWORKMODE">%2$s</xliff:g>"</string>
    <string name="mobile_data_connection_active" msgid="2422223108911581552">"Conexión establecida"</string>
    <string name="mobile_data_off_summary" msgid="3841411571485837651">"No se conectará automáticamente a Internet"</string>
    <string name="non_carrier_network_unavailable" msgid="9031567407964127997">"No hay otras redes disponibles"</string>
    <string name="all_network_unavailable" msgid="1163897808282057496">"No hay redes disponibles"</string>
    <string name="aware_summary_when_bedtime_on" msgid="2063856008597376344">"No disponible cuando el modo hora de dormir está activado"</string>
    <string name="reset_importance_completed" msgid="3595536767426097205">"Se restableció la prioridad de notificaciones."</string>
    <string name="apps_dashboard_title" msgid="3269953499954393706">"Apps"</string>
    <string name="bluetooth_message_access_notification_content" msgid="2986108412562309009">"Un dispositivo que no es de confianza quiere acceder a tus mensajes. Presiona para ver más detalles"</string>
    <string name="bluetooth_message_access_dialog_title" msgid="9009836130395061579">"¿Quieres permitir el acceso a los mensajes?"</string>
    <string name="bluetooth_message_access_dialog_content" msgid="2304761898608701739">"Un dispositivo Bluetooth que no es de confianza, <xliff:g id="DEVICE_NAME_0">%1$s</xliff:g>, quiere acceder a tus mensajes.\n\nNunca antes te habías conectado a <xliff:g id="DEVICE_NAME_1">%2$s</xliff:g>."</string>
    <string name="bluetooth_phonebook_access_notification_content" msgid="4280361621526852063">"Un dispositivo que no es de confianza quiere acceder a tus contactos y al registro de llamadas. Presiona para ver más detalles"</string>
    <string name="bluetooth_phonebook_access_dialog_title" msgid="7624607995928968721">"¿Quieres permitir el acceso a los contactos y al registro de llamadas?"</string>
    <string name="bluetooth_phonebook_access_dialog_content" msgid="4766700015848574532">"Un dispositivo Bluetooth que no es de confianza, <xliff:g id="DEVICE_NAME_0">%1$s</xliff:g>, quiere acceder a tus contactos y al registro de llamadas. Esto incluye datos sobre llamadas entrantes y salientes.\n\nNunca antes te habías conectado a <xliff:g id="DEVICE_NAME_1">%2$s</xliff:g>."</string>
    <string name="category_name_brightness" msgid="8520372392029305084">"Brillo"</string>
    <string name="category_name_lock_display" msgid="7478785189102882266">"Pantalla de bloqueo"</string>
    <string name="category_name_visibility" msgid="4485030512199246405">"Visibilidad"</string>
    <string name="category_name_color" msgid="937514550918977151">"Color"</string>
    <string name="category_name_others" msgid="2366006298768550310">"Otras opciones"</string>
    <string name="category_name_general" msgid="7737273712848115886">"General"</string>
    <string name="default_see_all_apps_title" msgid="7481113230662612178">"Ver todas las apps"</string>
    <!-- no translation found for smart_forwarding_title (8368634861971949799) -->
    <skip />
    <!-- no translation found for smart_forwarding_summary_enabled (3341062878373185604) -->
    <skip />
    <!-- no translation found for smart_forwarding_summary_disabled (5033880700091914809) -->
    <skip />
    <!-- no translation found for smart_forwarding_ongoing_title (962226849074401228) -->
    <skip />
    <!-- no translation found for smart_forwarding_ongoing_text (2189209372407117114) -->
    <skip />
    <!-- no translation found for smart_forwarding_failed_title (1859891191023516080) -->
    <skip />
    <!-- no translation found for smart_forwarding_failed_text (5370431503707373653) -->
    <skip />
    <!-- no translation found for smart_forwarding_failed_not_activated_text (997396203001257904) -->
    <skip />
    <!-- no translation found for smart_forwarding_input_mdn_title (5105463748849841763) -->
    <skip />
    <!-- no translation found for smart_forwarding_input_mdn_dialog_title (7542216086697868415) -->
    <skip />
    <!-- no translation found for smart_forwarding_missing_mdn_text (2907314684242542226) -->
    <skip />
    <!-- no translation found for smart_forwarding_missing_alert_dialog_text (7870419247987316112) -->
    <skip />
</resources>
