<?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="4676390750360727396">"Sí"</string>
    <string name="no" msgid="6731231425810196216">"No"</string>
    <string name="create" msgid="3578857613172647409">"Crear"</string>
    <string name="allow" msgid="3349662621170855910">"Permitir"</string>
    <string name="deny" msgid="6947806159746484865">"Rechazar"</string>
    <string name="device_info_default" msgid="7847265875578739287">"Desconocido"</string>
    <plurals name="show_dev_countdown" formatted="false" msgid="7201398282729229649">
      <item quantity="other">Estás a <xliff:g id="STEP_COUNT_1">%1$d</xliff:g> pasos de ser programador.</item>
      <item quantity="one">Estás a <xliff:g id="STEP_COUNT_0">%1$d</xliff:g> paso de ser programador.</item>
    </plurals>
    <string name="show_dev_on" msgid="1110711554982716293">"¡Ya eres programador!"</string>
    <string name="show_dev_already" msgid="2151632240145446227">"No es necesario, ya eres programador."</string>
    <string name="dev_settings_disabled_warning" msgid="4909448907673974370">"Primero habilita las opciones para programador."</string>
    <string name="header_category_wireless_networks" msgid="5110914332313954940">"Conexiones inalámbricas y redes"</string>
    <string name="header_category_system" msgid="2816866961183068977">"Sistema"</string>
    <string name="radio_info_data_connection_enable" msgid="8656750679353982712">"Habilitar la conexión de datos"</string>
    <string name="radio_info_data_connection_disable" msgid="8541302390883231216">"Inhabilitar la conexión de datos"</string>
    <string name="volte_provisioned_switch_string" msgid="7979882929810283786">"VoLTE suministrada"</string>
    <string name="vt_provisioned_switch_string" msgid="7876998291744854759">"Videollamadas suministradas"</string>
    <string name="wfc_provisioned_switch_string" msgid="3985406545172898078">"Llamadas por Wi-Fi suministradas"</string>
    <string name="eab_provisioned_switch_string" msgid="3482272907448592975">"EAB/Presence suministrados"</string>
    <string name="cbrs_data_switch_string" msgid="2811485394350106691">"Datos de CBRS"</string>
    <string name="dsds_switch_string" msgid="4832797810509029243">"Habilitar DSDS"</string>
    <string name="dsds_dialog_title" msgid="4031918551366689574">"¿Reiniciar dispositivo?"</string>
    <string name="dsds_dialog_message" msgid="8593083316067158412">"Para cambiar esta configuración, debes reiniciar el dispositivo."</string>
    <string name="dsds_dialog_confirm" msgid="2853118984344309612">"Reiniciar"</string>
    <string name="dsds_dialog_cancel" msgid="654653450305828711">"Cancelar"</string>
    <string name="radio_info_radio_power" msgid="7187666084867419643">"Potencia de la señal móvil"</string>
    <string name="radioInfo_menu_viewADN" msgid="7069468158519465139">"Ver libreta de direcciones de SIM"</string>
    <string name="radioInfo_menu_viewFDN" msgid="7934301566925610318">"Ver números fijos"</string>
    <string name="radioInfo_menu_viewSDN" msgid="7130280686244955669">"Ver números del servicio técnico"</string>
    <string name="radioInfo_menu_getIMS" msgid="185171476413967831">"Estado del servicio de IMS"</string>
    <string name="radio_info_ims_reg_status_title" msgid="16971785902696970">"Estado de IMS"</string>
    <string name="radio_info_ims_reg_status_registered" msgid="5614116179751126247">"Registrado"</string>
    <string name="radio_info_ims_reg_status_not_registered" msgid="4438054067642750717">"No registrado"</string>
    <string name="radio_info_ims_feature_status_available" msgid="3687807290327566879">"Disponible"</string>
    <string name="radio_info_ims_feature_status_unavailable" msgid="4606182208970114368">"No disponible"</string>
    <string name="radio_info_ims_reg_status" msgid="7534612158445529715">"Registro de IMS: <xliff:g id="STATUS">%1$s</xliff:g>\nVoz mediante LTE: <xliff:g id="AVAILABILITY_0">%2$s</xliff:g>\nVoz por Wi-Fi: <xliff:g id="AVAILABILITY_1">%3$s</xliff:g>\nVideollamada: <xliff:g id="AVAILABILITY_2">%4$s</xliff:g>\nInterfaz de UT: <xliff:g id="AVAILABILITY_3">%5$s</xliff:g>"</string>
    <string name="radioInfo_service_in" msgid="1697703164394784618">"En servicio"</string>
    <string name="radioInfo_service_out" msgid="7999094221728929681">"Fuera de servicio"</string>
    <string name="radioInfo_service_emergency" msgid="6274434235469661525">"Solo emergencia"</string>
    <string name="radioInfo_service_off" msgid="7536423790014501173">"Radio desactivada"</string>
    <string name="radioInfo_roaming_in" msgid="9045363884600341051">"Roaming"</string>
    <string name="radioInfo_roaming_not" msgid="4849214885629672819">"Sin roaming"</string>
    <string name="radioInfo_phone_idle" msgid="7489244938838742820">"Inactivo"</string>
    <string name="radioInfo_phone_ringing" msgid="4883724645684297895">"Timbrando"</string>
    <string name="radioInfo_phone_offhook" msgid="5873835692449118954">"Llamada en curso"</string>
    <string name="radioInfo_data_disconnected" msgid="1959735267890719418">"Desconectado"</string>
    <string name="radioInfo_data_connecting" msgid="8404571440697917823">"Conectando"</string>
    <string name="radioInfo_data_connected" msgid="7074301157399238697">"Conectado"</string>
    <string name="radioInfo_data_suspended" msgid="5315325487890334196">"Suspendido"</string>
    <string name="radioInfo_unknown" msgid="1476509178755955088">"Desconocida"</string>
    <string name="radioInfo_display_packets" msgid="8654359809877290639">"paquetes"</string>
    <string name="radioInfo_display_bytes" msgid="4018206969492931883">"bytes"</string>
    <string name="radioInfo_display_dbm" msgid="3621221793699882781">"dBm"</string>
    <string name="radioInfo_display_asu" msgid="1422248392727818082">"asu"</string>
    <string name="radioInfo_lac" msgid="8415219164758307156">"LAC"</string>
    <string name="radioInfo_cid" msgid="4362599198392643138">"CID"</string>
    <string name="sdcard_unmount" product="nosdcard" msgid="6325292633327972272">"Desmontar almacenamiento USB"</string>
    <string name="sdcard_unmount" product="default" msgid="3364184561355611897">"Desmontar la tarjeta SD"</string>
    <string name="sdcard_format" product="nosdcard" msgid="6285310523155166716">"Eliminar almacenamiento USB"</string>
    <string name="sdcard_format" product="default" msgid="6713185532039187532">"Borrar tarjeta SD"</string>
    <string name="preview_pager_content_description" msgid="8926235999291761243">"Vista previa"</string>
    <string name="preview_page_indicator_content_description" msgid="4821343428913401264">"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="1690992332887488183">"Aumenta o reduce el tamaño del texto en pantalla."</string>
    <string name="font_size_make_smaller_desc" msgid="7919995133365371569">"Reducir el tamaño"</string>
    <string name="font_size_make_larger_desc" msgid="4316986572233686061">"Aumentar el tamaño"</string>
    <!-- no translation found for font_size_preview_text (4818424565068376732) -->
    <skip />
    <string name="font_size_preview_text_headline" msgid="7955317408475392247">"Texto de muestra"</string>
    <string name="font_size_preview_text_title" msgid="1310536233106975546">"El maravilloso mago de Oz"</string>
    <string name="font_size_preview_text_subtitle" msgid="4231671528173110093">"Capítulo 11: La maravillosa Ciudad Esmeralda de Oz"</string>
    <string name="font_size_preview_text_body" msgid="2846183528684496723">"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="3450855718056759095">"Aceptar"</string>
    <string name="sdcard_setting" product="nosdcard" msgid="8281011784066476192">"Almacenamiento USB"</string>
    <string name="sdcard_setting" product="default" msgid="5922637503871474866">"Tarjeta SD"</string>
    <string name="bluetooth" msgid="5549625000628014477">"Bluetooth"</string>
    <string name="bluetooth_is_discoverable" msgid="8373421452106840526">"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="2849387702249327748">"Visible para todos los dispositivos Bluetooth cercanos"</string>
    <string name="bluetooth_not_visible_to_other_devices" msgid="9120274591523391910">"No visible para otros dispositivos Bluetooth"</string>
    <string name="bluetooth_only_visible_to_paired_devices" msgid="2049983392373296028">"Solo visible para los dispositivos sincronizados"</string>
    <string name="bluetooth_visibility_timeout" msgid="8002247464357005429">"Definir visibilidad"</string>
    <string name="bluetooth_lock_voice_dialing" msgid="3139322992062086225">"Bloquear marcación por voz"</string>
    <string name="bluetooth_lock_voice_dialing_summary" msgid="4741338867496787042">"Impedir el uso de Bluetooth del dispositivo cuando la pantalla esté bloqueada."</string>
    <string name="bluetooth_devices" msgid="1886018064039454227">"Dispositivos Bluetooth"</string>
    <string name="bluetooth_device_name" msgid="8415828355207423800">"Nombre del dispositivo"</string>
    <string name="bluetooth_device_details" msgid="4594773497930028085">"Configuración del dispositivo"</string>
    <string name="bluetooth_profile_details" msgid="6823621790324933337">"Configuración del perfil"</string>
    <string name="bluetooth_name_not_set" msgid="2653752006416027426">"No se ha establecido ningún nombre; se utiliza el nombre de cuenta"</string>
    <string name="bluetooth_scan_for_devices" msgid="9214184305566815727">"Buscar dispositivos"</string>
    <string name="bluetooth_rename_device" msgid="4352483834491958740">"Cambiar nombre del dispositivo"</string>
    <string name="bluetooth_rename_button" msgid="1648028693822994566">"Cambiar nombre"</string>
    <string name="bluetooth_disconnect_title" msgid="7830252930348734303">"¿Desconectar dispositivo?"</string>
    <string name="bluetooth_disconnect_all_profiles" product="default" msgid="8208712728668714199">"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="6611038575213485336">"Tu tablet se desconectará de <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="bluetooth_disconnect_all_profiles" product="device" msgid="3995834526315103965">"Tu dispositivo se desconectará de <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="bluetooth_disconnect_dialog_ok" msgid="3308586619539119106">"Desconectar"</string>
    <string name="bluetooth_empty_list_user_restricted" msgid="603521233563983689">"No tienes permiso para cambiar la configuración de Bluetooth."</string>
    <string name="bluetooth_pairing_pref_title" msgid="7429413067477968637">"Sincronizar dispositivo nuevo"</string>
    <string name="bluetooth_is_visible_message" msgid="6222396240776971862">"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="1109366350000220283">"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="6807634484499166486">"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="8413944740341742061">"Dirección Bluetooth del dispositivo: <xliff:g id="BLUETOOTH_MAC_ADDRESS">%1$s</xliff:g>"</string>
    <string name="bluetooth_is_disconnect_question" msgid="5334933802445256306">"¿Desconectar <xliff:g id="DEVICE_NAME">%1$s</xliff:g>?"</string>
    <string name="bluetooth_broadcasting" msgid="16583128958125247">"Transmisión"</string>
    <string name="bluetooth_device" msgid="5291950341750186887">"Dispositivo Bluetooth sin nombre"</string>
    <string name="progress_scanning" msgid="192587958424295789">"Buscando"</string>
    <string name="bluetooth_no_devices_found" msgid="1085232930277181436">"No se encontraron dispositivos Bluetooth cercanos."</string>
    <string name="bluetooth_notif_ticker" msgid="4726721390078512173">"Solicitud de vinculación de Bluetooth"</string>
    <string name="bluetooth_notif_title" msgid="2485175521845371514">"Vinculando solicitud"</string>
    <string name="bluetooth_notif_message" msgid="5057417127600942904">"Presiona para realizar una sincronización con <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="bluetooth_show_received_files" msgid="3144149432555230410">"Archivos recibidos"</string>
    <string name="bluetooth_show_files_received_via_bluetooth" msgid="5445105773989432594">"Archivos recibidos (Bluetooth)"</string>
    <string name="device_picker" msgid="4978696506172252813">"Elegir dispositivo"</string>
    <string name="bluetooth_ask_enablement" msgid="3387222809404177525">"<xliff:g id="APP_NAME">%1$s</xliff:g> quiere activar la conexión Bluetooth"</string>
    <string name="bluetooth_ask_disablement" msgid="5890386255790160573">"<xliff:g id="APP_NAME">%1$s</xliff:g> quiere desactivar la conexión Bluetooth"</string>
    <string name="bluetooth_ask_enablement_no_name" msgid="1644353686104482763">"Una app quiere activar la conexión Bluetooth"</string>
    <string name="bluetooth_ask_disablement_no_name" msgid="9218830122674868548">"Una app quiere desactivar la conexión Bluetooth"</string>
    <string name="bluetooth_ask_discovery" product="tablet" msgid="4791779658660357386">"<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="1308225382575535366">"<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="225715443477752935">"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="4949152735544109994">"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="8528329166577187961">"<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="4398738575307583138">"<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="1702590641426207062">"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="8549952177383992238">"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="1141843490422565755">"<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="5195836980079191473">"<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="7009338445281693765">"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="8386904242279878734">"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="2279471426575892686">"<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="6961969825475461450">"<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="692477613671555006">"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="6374480121751597648">"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="4850574877288036646">"Activando Bluetooth..."</string>
    <string name="bluetooth_turning_off" msgid="2337747302892025192">"¿Desactivar Bluetooth?"</string>
    <string name="bluetooth_connection_permission_request" msgid="4747918249032890077">"Solicitud para establecer conexión de Bluetooth"</string>
    <string name="bluetooth_connection_notif_message" msgid="3603316575471431846">"Presiona para conectarte a \"<xliff:g id="DEVICE_NAME">%1$s</xliff:g>\"."</string>
    <string name="bluetooth_connection_dialog_text" msgid="8455427559949998023">"¿Deseas conectarte a “<xliff:g id="DEVICE_NAME">%1$s</xliff:g>”?"</string>
    <string name="bluetooth_phonebook_request" msgid="3951420080540915279">"Solicitud de acceso a agenda telefónica"</string>
    <string name="bluetooth_pb_acceptance_dialog_text" msgid="8930347091018455505">"<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="6919682671787049800">"No volver a preguntar"</string>
    <string name="bluetooth_pb_remember_choice" msgid="3622898084442402071">"No volver a preguntar"</string>
    <string name="bluetooth_map_request" msgid="4595727689513143902">"Solicitud de acceso a mensajes"</string>
    <string name="bluetooth_map_acceptance_dialog_text" msgid="8712508202081143737">"%1$s quiere acceder a tus mensajes. ¿Quieres permitir el acceso a %2$s?"</string>
    <string name="bluetooth_sap_request" msgid="2669762224045354417">"Solicitud de acceso a SIM"</string>
    <string name="bluetooth_sap_acceptance_dialog_text" msgid="4414253873553608690">"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="522235742194965734">"Visible como \"<xliff:g id="DEVICE_NAME">^1</xliff:g>\" para otros dispositivos"</string>
    <string name="bluetooth_off_footer" msgid="8406865700572772936">"Activa el Bluetooth para establecer conexión con otros dispositivos."</string>
    <string name="bluetooth_paired_device_title" msgid="8638994696317952019">"Tus dispositivos"</string>
    <string name="bluetooth_pairing_page_title" msgid="7712127387361962608">"Sincronizar dispositivo nuevo"</string>
    <string name="bluetooth_pref_summary" product="tablet" msgid="3520035819421024105">"Permite que la tablet se comunique con dispositivos Bluetooth cercanos"</string>
    <string name="bluetooth_pref_summary" product="device" msgid="2205100629387332862">"Permite que el dispositivo se comunique con dispositivos Bluetooth cercanos"</string>
    <string name="bluetooth_pref_summary" product="default" msgid="782032074675157079">"Permite que el teléfono se comunique con dispositivos Bluetooth cercanos"</string>
    <string name="bluetooth_disable_a2dp_hw_offload" msgid="4936610906348223810">"No aligeramiento hardware Bluetooth A2DP"</string>
    <string name="bluetooth_disable_a2dp_hw_offload_dialog_title" msgid="4340101417209145308">"¿Reiniciar?"</string>
    <string name="bluetooth_disable_a2dp_hw_offload_dialog_message" msgid="8827019472003234568">"Debes reiniciar el dispositivo para cambiar esta opción."</string>
    <string name="bluetooth_disable_a2dp_hw_offload_dialog_confirm" msgid="2053793518537051975">"Reiniciar"</string>
    <string name="bluetooth_disable_a2dp_hw_offload_dialog_cancel" msgid="2382443064737856652">"Cancelar"</string>
    <string name="connected_device_available_media_title" msgid="2560067541413280645">"Dispositivos de medios disponibles"</string>
    <string name="connected_device_available_call_title" msgid="697154660967595684">"Dispositivos de llamada disponibles"</string>
    <string name="connected_device_connected_title" msgid="5871712271201945606">"Conectados actualmente"</string>
    <string name="connected_device_saved_title" msgid="688364359746674536">"Dispositivos guardados"</string>
    <string name="connected_device_add_device_summary" msgid="4041865900298680338">"Se activará el Bluetooth para sincronizar"</string>
    <string name="connected_device_connections_title" msgid="5988939345181466770">"Preferencias de conexión"</string>
    <string name="connected_device_previously_connected_title" msgid="491765792822244604">"Dispositivos conectados previamente"</string>
    <string name="connected_device_previously_connected_screen_title" msgid="6196066429488377795">"Conectados anteriormente"</string>
    <string name="connected_device_bluetooth_turned_on_toast" msgid="5683648191381637533">"Se activó el Bluetooth"</string>
    <string name="previous_connected_see_all" msgid="3626779872898778415">"Ver todo"</string>
    <string name="date_and_time" msgid="9062980487860757694">"Fecha y hora"</string>
    <string name="choose_timezone" msgid="1362834506479536274">"Elige la zona horaria"</string>
    <!-- no translation found for intent_sender_data_label (6332324780477289261) -->
    <skip />
    <string name="intent_sender_sendbroadcast_text" msgid="1415735148895872715">"Enviar <xliff:g id="BROADCAST">broadcast</xliff:g>"</string>
    <string name="intent_sender_action_label" msgid="616458370005452389">"<xliff:g id="ACTION">Action</xliff:g>:"</string>
    <string name="intent_sender_startactivity_text" msgid="5080516029580421895">"Inicio <xliff:g id="ACTIVITY">activity</xliff:g>"</string>
    <string name="intent_sender_resource_label" msgid="6963659726895482829">"<xliff:g id="RESOURCE">Resource</xliff:g>:"</string>
    <string name="intent_sender_account_label" msgid="465210404475603404">"Cuenta:"</string>
    <string name="proxy_settings_title" msgid="9049437837600320881">"Proxy"</string>
    <string name="proxy_clear_text" msgid="5555400754952012657">"Eliminar"</string>
    <string name="proxy_port_label" msgid="5655276502233453400">"Puerto proxy"</string>
    <string name="proxy_exclusionlist_label" msgid="7700491504623418701">"Omitir proxy para"</string>
    <string name="proxy_defaultView_text" msgid="6387985519141433291">"Restaurar configuraciones predeterminadas"</string>
    <string name="proxy_action_text" msgid="2957063145357903951">"Finalizar"</string>
    <string name="proxy_hostname_label" msgid="8490171412999373362">"Nombre de host proxy"</string>
    <string name="proxy_error" msgid="8926675299638611451">"Atención"</string>
    <string name="proxy_error_dismiss" msgid="4993171795485460060">"Aceptar"</string>
    <string name="proxy_error_invalid_host" msgid="6865850167802455230">"El nombre del host que has escrito no es válido."</string>
    <string name="proxy_error_invalid_exclusion_list" msgid="678527645450894773">"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="5539106187558215246">"Debes completar el campo de puerto."</string>
    <string name="proxy_error_empty_host_set_port" msgid="2451694104858226781">"El campo del puerto debe estar vacío si el campo de servidor está vacío."</string>
    <string name="proxy_error_invalid_port" msgid="5988270202074492710">"El puerto que has escrito no es válido."</string>
    <string name="proxy_warning_limited_support" msgid="7229337138062837422">"El navegador usa el proxy HTTP, pero tal vez las demás aplicaciones no lo usen."</string>
    <string name="proxy_url_title" msgid="7185282894936042359">"URL config. autom. proxy: "</string>
    <string name="radio_info_subid" msgid="204582608052503412">"ID secundario actual:"</string>
    <string name="radio_info_dds" msgid="5471937791273237508">"ID secundario de la SIM de datos predeterminada:"</string>
    <string name="radio_info_dl_kbps" msgid="6894556071523815984">"Ancho de banda de DL (kbps):"</string>
    <string name="radio_info_ul_kbps" msgid="946464073571185678">"Ancho de banda de UL (kbps):"</string>
    <string name="radio_info_signal_location_label" msgid="3242990404410530456">"Información sobre la ubicación del teléfono (no disponible):"</string>
    <string name="radio_info_phy_chan_config" msgid="7133247058801474028">"Configuración del canal físico de LTE:"</string>
    <string name="radio_info_cell_info_refresh_rate" msgid="7062777594049622128">"Frecuencia de actualización de la información del teléfono:"</string>
    <string name="radio_info_cellinfo_label" msgid="6213223844927623098">"Información sobre las dimensiones de los teléfonos:"</string>
    <string name="radio_info_gprs_service_label" msgid="4209624131644060517">"Servicio de datos:"</string>
    <string name="radio_info_roaming_label" msgid="6141505430275138647">"Roaming:"</string>
    <string name="radio_info_imei_label" msgid="1220524224732944192">"IMEI:"</string>
    <string name="radio_info_call_redirect_label" msgid="2743797189722106231">"Redireccionamiento de llamada:"</string>
    <string name="radio_info_ppp_resets_label" msgid="3587319503902576102">"Cantidad de PPP restablecidos desde el inicio:"</string>
    <string name="radio_info_current_network_label" msgid="9151285540639134945">"Red actual:"</string>
    <string name="radio_info_ppp_received_label" msgid="363579470428151850">"Datos recibidos:"</string>
    <string name="radio_info_gsm_service_label" msgid="1370863866816125489">"Servicio de voz:"</string>
    <string name="radio_info_signal_strength_label" msgid="5155734002519307416">"Potencia de la señal:"</string>
    <string name="radio_info_call_status_label" msgid="2611065018172747413">"Estado de la llamada de voz:"</string>
    <string name="radio_info_ppp_sent_label" msgid="7748668735880404586">"Datos enviados:"</string>
    <string name="radio_info_message_waiting_label" msgid="1037302619943328273">"Mensaje en espera:"</string>
    <string name="radio_info_phone_number_label" msgid="7942153178953255231">"Número de teléfono:"</string>
    <string name="radio_info_band_mode_label" msgid="8730871744887454509">"Seleccionar banda de radio"</string>
    <string name="radio_info_voice_network_type_label" msgid="1443496502370667071">"Tipo de red de voz:"</string>
    <string name="radio_info_data_network_type_label" msgid="7094323145105149312">"Tipo de red de datos:"</string>
    <string name="phone_index_label" msgid="1934407597576454430">"Seleccionar guía telefónica"</string>
    <string name="radio_info_set_perferred_label" msgid="3511830813500105512">"Establecer el tipo de red preferida:"</string>
    <string name="radio_info_ping_hostname_v4" msgid="7045103377818314709">"Hacer ping a IPv4 de nombre de host (www.google.com):"</string>
    <string name="radio_info_ping_hostname_v6" msgid="1130906124160553954">"Hacer ping a IPv6 de nombre de host (www.google.com):"</string>
    <string name="radio_info_http_client_test" msgid="2382286093023138339">"Prueba de cliente HTTP:"</string>
    <string name="ping_test_label" msgid="579228584343892613">"Ejecutar prueba de ping"</string>
    <string name="radio_info_smsc_label" msgid="6399460520126501354">"SMSC:"</string>
    <string name="radio_info_smsc_update_label" msgid="7258686760358791539">"Actualizar"</string>
    <string name="radio_info_smsc_refresh_label" msgid="6902302130315125102">"Actualizar"</string>
    <string name="radio_info_toggle_dns_check_label" msgid="6625185764803245075">"Activar o desactivar la comprobación de DNS"</string>
    <string name="oem_radio_info_label" msgid="6163141792477958941">"Configuración/Información específica a OEM"</string>
    <string name="band_mode_title" msgid="4071411679019296568">"Establecer modo de banda de radio"</string>
    <string name="band_mode_loading" msgid="3555063585133586152">"Cargando lista de banda…"</string>
    <string name="band_mode_set" msgid="5730560180249458484">"Establecer"</string>
    <string name="band_mode_failed" msgid="1495968863884716379">"Incorrecto"</string>
    <string name="band_mode_succeeded" msgid="2701016190055887575">"Correcto"</string>
    <string name="sdcard_changes_instructions" msgid="4482324130377280131">"Los cambios entran en vigencia cuando se vuelve a conectar el cable USB."</string>
    <string name="sdcard_settings_screen_mass_storage_text" msgid="3741220147296482474">"Activar el espacio de almacenamiento masivo USB"</string>
    <string name="sdcard_settings_total_bytes_label" msgid="9184160745785062144">"Total de bytes:"</string>
    <string name="sdcard_settings_not_present_status" product="nosdcard" msgid="1636218515775929394">"Almacenamiento USB desactivado"</string>
    <string name="sdcard_settings_not_present_status" product="default" msgid="2048419626134861599">"Sin tarjeta SD"</string>
    <string name="sdcard_settings_available_bytes_label" msgid="763232429899373001">"Bytes disponibles:"</string>
    <string name="sdcard_settings_mass_storage_status" product="nosdcard" msgid="7993410985895217054">"USB como almacenamiento masivo"</string>
    <string name="sdcard_settings_mass_storage_status" product="default" msgid="2742075324087038036">"La tarjeta SD se usa como dispositivo de almacenamiento masivo."</string>
    <string name="sdcard_settings_unmounted_status" product="nosdcard" msgid="5128923500235719226">"Puedes extraer el almac. USB."</string>
    <string name="sdcard_settings_unmounted_status" product="default" msgid="666233604712540408">"Ya puedes extraer la tarjeta SD."</string>
    <string name="sdcard_settings_bad_removal_status" product="nosdcard" msgid="7761390725880773697">"¡El almacenamiento USB se extrajo mientras se encontraba en uso!"</string>
    <string name="sdcard_settings_bad_removal_status" product="default" msgid="5145797653495907970">"¡Se ha extraído la tarjeta SD mientras se encontraba en uso!"</string>
    <string name="sdcard_settings_used_bytes_label" msgid="8820289486001170836">"Bytes utilizados:"</string>
    <string name="sdcard_settings_scanning_status" product="nosdcard" msgid="7503429447676219564">"Explorando almacenamiento USB para obtener medios..."</string>
    <string name="sdcard_settings_scanning_status" product="default" msgid="2763464949274455656">"Explorando medios en la tarjeta SD..."</string>
    <string name="sdcard_settings_read_only_status" product="nosdcard" msgid="3624143937437417788">"USB en modo de solo lectura"</string>
    <string name="sdcard_settings_read_only_status" product="default" msgid="4518291824764698112">"La tarjeta SD se activó como un dispositivo de solo lectura."</string>
    <string name="skip_label" msgid="47510779345218297">"Omitir"</string>
    <string name="next_label" msgid="4693520878012668114">"Siguiente"</string>
    <string name="language_picker_title" msgid="3596315202551687690">"Idiomas"</string>
    <string name="locale_remove_menu" msgid="7651301406723638854">"Quitar"</string>
    <string name="add_a_language" msgid="2330538812283783022">"Agregar un idioma"</string>
    <plurals name="dlg_remove_locales_title" formatted="false" msgid="4276642359346122396">
      <item quantity="other">¿Quitar los idiomas seleccionados?</item>
      <item quantity="one">¿Quitar el idioma seleccionado?</item>
    </plurals>
    <string name="dlg_remove_locales_message" msgid="1361354927342876114">"Se mostrará el texto en otro idioma."</string>
    <string name="dlg_remove_locales_error_title" msgid="2653242337224911425">"No se pueden quitar todos los idiomas"</string>
    <string name="dlg_remove_locales_error_message" msgid="6697381512654262821">"Debes tener al menos un idioma preferido"</string>
    <string name="locale_not_translated" msgid="516862628177166755">"Es posible que no esté disponible en algunas apps"</string>
    <string name="action_drag_label_move_up" msgid="9052210023727612540">"Mover hacia arriba"</string>
    <string name="action_drag_label_move_down" msgid="7448713844582912157">"Mover hacia abajo"</string>
    <string name="action_drag_label_move_top" msgid="557081389352288310">"Mover al principio"</string>
    <string name="action_drag_label_move_bottom" msgid="2468642142414126482">"Mover al final"</string>
    <string name="action_drag_label_remove" msgid="2861038147166966206">"Quitar el idioma"</string>
    <string name="activity_picker_label" msgid="6295660302548177109">"Elige actividad"</string>
    <string name="device_info_label" msgid="6551553813651711205">"Información de dispositivo"</string>
    <string name="display_label" msgid="8074070940506840792">"Pantalla"</string>
    <string name="phone_info_label" product="tablet" msgid="7820855350955963628">"Información del tablet"</string>
    <string name="phone_info_label" product="default" msgid="2127552523124277664">"Información del dispositivo"</string>
    <string name="sd_card_settings_label" product="nosdcard" msgid="8101475181301178428">"Almacenamiento USB"</string>
    <string name="sd_card_settings_label" product="default" msgid="5743100901106177102">"Tarjeta SD"</string>
    <string name="proxy_settings_label" msgid="3271174136184391743">"Configuración de proxy"</string>
    <string name="cancel" msgid="6859253417269739139">"Cancelar"</string>
    <string name="okay" msgid="1997666393121016642">"Aceptar"</string>
    <string name="forget" msgid="1400428660472591263">"Olvidar"</string>
    <string name="save" msgid="879993180139353333">"Guardar"</string>
    <string name="done" msgid="6942539184162713160">"Listo"</string>
    <string name="apply" msgid="1577045208487259229">"Aplicar"</string>
    <string name="share" msgid="6791534619806355910">"Compartir"</string>
    <string name="add" msgid="3709942705501136412">"Agregar"</string>
    <string name="settings_label" msgid="1626402585530130914">"Configuración"</string>
    <string name="settings_label_launcher" msgid="8344735489639482340">"Configuración"</string>
    <string name="settings_shortcut" msgid="3936651951364030415">"Configuración"</string>
    <string name="airplane_mode" msgid="8837269988154128601">"Modo avión"</string>
    <string name="wireless_networks_settings_title" msgid="3643009077742794212">"Conexiones inalámbricas y redes"</string>
    <string name="radio_controls_summary" msgid="1838624369870907268">"Administrar Wi-Fi, Bluetooth, modo avión, redes móviles y VPN"</string>
    <string name="cellular_data_title" msgid="6835451574385496662">"Datos móviles"</string>
    <string name="calls_title" msgid="1262096900483238572">"Permitir llamadas"</string>
    <string name="sms_messages_title" msgid="1778636286080572535">"Mensajes SMS"</string>
    <string name="cellular_data_summary" msgid="4660351864416939504">"Permitir el uso de datos en redes móviles"</string>
    <string name="allow_data_usage_title" msgid="2238205944729213062">"Permitir usar datos en roaming"</string>
    <string name="roaming" msgid="2619521775007402005">"Roaming"</string>
    <string name="roaming_enable" msgid="3737380951525303961">"Conectar a servicios de datos en roaming"</string>
    <string name="roaming_disable" msgid="1295279574370898378">"Conectar a servicios de datos en roaming"</string>
    <string name="roaming_reenable_message" msgid="9141007271031717369">"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="4387601818162120589">"Enciéndelo"</string>
    <string name="roaming_warning" msgid="4275443317524544705">"Es posible que incurras en gastos importantes."</string>
    <string name="roaming_warning_multiuser" product="tablet" msgid="6458990250829214777">"Al permitir el roaming de datos, los costos de roaming que deberás asumir pueden ser altos.\n\nEsta configuración afecta a todos los usuarios de esta tablet."</string>
    <string name="roaming_warning_multiuser" product="default" msgid="6368421100292355440">"Al permitir el roaming de datos, los costos de roaming que deberás asumir pueden ser altos.\n\nEsta configuración afecta a todos los usuarios de este dispositivo."</string>
    <string name="roaming_reenable_title" msgid="6068100976707316772">"¿Permitir el roaming de datos?"</string>
    <string name="networks" msgid="6333316876545927039">"Selección de operador"</string>
    <string name="sum_carrier_select" msgid="3616956422251879163">"Elegir un operador de red"</string>
    <string name="date_and_time_settings_title" msgid="3350640463596716780">"Fecha y hora"</string>
    <string name="date_and_time_settings_title_setup_wizard" msgid="2391530758339384324">"Configurar fecha y hora"</string>
    <string name="date_and_time_settings_summary" msgid="7095318986757583584">"Establecer fecha, hora, zona horaria y formatos"</string>
    <string name="date_time_auto" msgid="4290527098376721491">"Usar la hora de la red"</string>
    <string name="zone_auto_title" msgid="3217703906014135437">"Usar la zona horaria proporcionada por la red"</string>
    <string name="date_time_24hour_auto" msgid="6276269188890332084">"Usar configuración regional predeterminada"</string>
    <string name="date_time_24hour_title" msgid="3203537578602803850">"Formato de 24 horas"</string>
    <string name="date_time_24hour" msgid="1193032284921000063">"Formato de 24 horas"</string>
    <string name="date_time_set_time_title" msgid="6296795651349047016">"Hora"</string>
    <string name="time_format_category_title" msgid="736190761036057769">"Formato de hora"</string>
    <string name="date_time_set_timezone_title" msgid="3047322337368233197">"Zona horaria"</string>
    <string name="date_time_set_timezone" msgid="5045627174274377814">"Zona horaria"</string>
    <string name="date_time_set_date_title" msgid="6928286765325608604">"Fecha"</string>
    <string name="date_time_search_region" msgid="2478334699004021972">"Búsqueda por región"</string>
    <string name="date_time_select_region" msgid="5434001881313168586">"Región"</string>
    <string name="date_time_select_fixed_offset_time_zones" msgid="6084375085203448645">"Seleccionar desplazamiento UTC"</string>
    <string name="zone_change_to_from_dst" msgid="118656001224045590">"<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="1359698475641349336">"<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="164876167707284017">"<xliff:g id="TIME_TYPE">%2$s</xliff:g> (<xliff:g id="OFFSET">%1$s</xliff:g>)"</string>
    <string name="zone_info_footer" msgid="4192803402331390389">"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="8652423870143056964">"Zona horaria: <xliff:g id="OFFSET_AND_NAME">%1$s</xliff:g>. Sin horario de verano."</string>
    <string name="zone_time_type_dst" msgid="8850494578766845276">"Horario de verano"</string>
    <string name="zone_time_type_standard" msgid="3462424485380376522">"Hora estándar"</string>
    <string name="zone_menu_by_region" msgid="8370437123807764346">"Seleccionar por región"</string>
    <string name="zone_menu_by_offset" msgid="7161573994228041794">"Seleccionar por desplazamiento de UTC"</string>
    <string name="date_picker_title" msgid="1338210036394128512">"Fecha"</string>
    <string name="time_picker_title" msgid="483460752287255019">"Hora"</string>
    <string name="lock_after_timeout" msgid="3041497579354520533">"Bloquear al finalizar el tiempo de espera de pantalla"</string>
    <string name="lock_after_timeout_summary" msgid="6446294520193562658">"<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="4887058374400817711">"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="5693037914721259546">"<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="5074906168357568434">"Mostrar datos de propietario en pantalla bloqueada"</string>
    <string name="owner_info_settings_title" msgid="5530285568897386122">"Mensaje en pantalla de bloqueo"</string>
    <string name="security_enable_widgets_title" msgid="2754833397070967846">"Habilitar widgets"</string>
    <string name="security_enable_widgets_disabled_summary" msgid="6392489775303464905">"El administrador inhabilitó la opción"</string>
    <string name="lockdown_settings_title" msgid="7393790212603280213">"Mostrar opción de bloqueo"</string>
    <string name="lockdown_settings_summary" msgid="4359438673563318171">"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="2992742466966021682">"Bloquear pantalla al perder confianza"</string>
    <string name="trust_lost_locks_screen_summary" msgid="693784434582021206">"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="7472393443779227052">"Ninguno"</string>
    <string name="owner_info_settings_status" msgid="120407527726476378">"<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="7591869574491036360">"Por ejemplo, Android de Juan"</string>
    <string name="user_info_settings_title" msgid="1195015434996724736">"Datos de usuario"</string>
    <string name="show_profile_info_on_lockscreen_label" msgid="2741208907263877990">"Mostrar datos del perfil en pantalla bloqueada"</string>
    <string name="profile_info_settings_title" msgid="3518603215935346604">"Datos del perfil"</string>
    <string name="Accounts_settings_title" msgid="1643879107901699406">"Cuentas"</string>
    <string name="location_settings_title" msgid="1369675479310751735">"Ubicación"</string>
    <string name="location_settings_master_switch_title" msgid="3560242980335542411">"Usar ubicación"</string>
    <string name="location_settings_summary_location_off" msgid="794370259612167176">"Desactivado"</string>
    <plurals name="location_settings_summary_location_on" formatted="false" msgid="5513447650619485188">
      <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="8523775367089431611">"Cargando…"</string>
    <string name="account_settings_title" msgid="626177544686329806">"Cuentas"</string>
    <string name="security_settings_title" msgid="7945465324818485460">"Seguridad"</string>
    <string name="encryption_and_credential_settings_title" msgid="6514904533438791561">"Encriptación y credenciales"</string>
    <string name="encryption_and_credential_settings_summary" product="default" msgid="8721883002237981248">"Teléfono encriptado"</string>
    <string name="decryption_settings_summary" product="default" msgid="5671817824042639849">"Teléfono no encriptado"</string>
    <string name="encryption_and_credential_settings_summary" product="tablet" msgid="7200428573872395685">"Dispositivo encriptado"</string>
    <string name="decryption_settings_summary" product="tablet" msgid="5794135636155570977">"Dispositivo no encriptado"</string>
    <string name="lockscreen_settings_title" msgid="1099738951060387656">"Pantalla de bloqueo"</string>
    <string name="lockscreen_settings_what_to_show_category" msgid="278055252361575926">"Qué mostrar"</string>
    <string name="security_settings_summary" msgid="967393342537986570">"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="6068799952798901542">"Establecer Mi ubicación, desbloqueo de pantalla, bloqueo de almacenamiento de credencial"</string>
    <string name="security_passwords_title" msgid="2881269890053568809">"Privacidad"</string>
    <string name="disabled_by_administrator_summary" msgid="1601828700318996341">"El administrador inhabilitó esta opción"</string>
    <string name="security_status_title" msgid="5848766673665944640">"Estado de seguridad"</string>
    <string name="security_dashboard_summary_face" msgid="268234254306703218">"Bloqueo de pantalla, desbloqueo facial"</string>
    <string name="security_dashboard_summary" msgid="6757421634477554939">"Bloqueo de pantalla, huella digital"</string>
    <string name="security_dashboard_summary_no_fingerprint" msgid="8129641548372335540">"Bloqueo de pantalla"</string>
    <string name="security_settings_face_preference_summary" msgid="1290187225482642821">"Se agregó el rostro"</string>
    <string name="security_settings_face_preference_summary_none" msgid="5596571291522936724">"Configurar Desbloqueo facial"</string>
    <string name="security_settings_face_preference_title" msgid="5277300443693527785">"Desbloqueo facial"</string>
    <string name="security_settings_face_profile_preference_title" msgid="3906383224724942953">"Desbloqueo facial para el trabajo"</string>
    <string name="security_settings_face_enroll_education_title" msgid="6027417312490791135">"Cómo configurar el Desbloqueo facial"</string>
    <string name="security_settings_face_enroll_education_title_accessibility" msgid="4233918594329755623">"Configurar Desbloqueo facial"</string>
    <string name="security_settings_face_enroll_education_title_unlock_disabled" msgid="4697363240703556987">"Usa tu rostro para autenticarte"</string>
    <string name="security_settings_face_enroll_education_message" msgid="4401918487764636333"></string>
    <string name="security_settings_face_enroll_education_start" msgid="6186306855277346454">"Iniciar"</string>
    <string name="security_settings_face_enroll_introduction_accessibility" msgid="7784083491315229721">"Usar config. de accesibilidad"</string>
    <string name="security_settings_face_enroll_introduction_accessibility_expanded" msgid="5924018301323255439"></string>
    <string name="security_settings_face_enroll_introduction_accessibility_diversity" msgid="4455532390587307262"></string>
    <string name="security_settings_face_enroll_introduction_accessibility_vision" msgid="7075186169796301461"></string>
    <string name="security_settings_face_enroll_introduction_cancel" msgid="4277182322482408514">"Cancelar"</string>
    <string name="security_settings_face_enroll_introduction_title" msgid="2694505011712885439">"Usa tu rostro para desbloquear"</string>
    <string name="security_settings_face_enroll_introduction_title_unlock_disabled" msgid="8180330567034286589">"Usa tu rostro para autenticarte"</string>
    <string name="security_settings_face_enroll_introduction_message" msgid="6150611993438981458">"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="6393270235632444857">"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="5704661081718707858">"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="3316520154949466889"></string>
    <string name="security_settings_face_enroll_introduction_footer_part_1" msgid="5594630288374571903"></string>
    <string name="security_settings_face_enroll_introduction_footer_part_2" msgid="7576241712527601978"></string>
    <string name="security_settings_face_enroll_introduction_footer_part_3" msgid="7355240941877607603"></string>
    <string name="security_settings_face_enroll_repeat_title" msgid="4019853239039918762">"Centra el rostro en el círculo"</string>
    <string name="security_settings_face_enroll_enrolling_skip" msgid="5808832403353263368">"Omitir"</string>
    <string name="face_add_max" msgid="4408683751143942949">"Puedes agregar hasta <xliff:g id="COUNT">%d</xliff:g> rostros"</string>
    <string name="face_intro_error_max" msgid="160022811747660581">"Agregaste la cantidad máxima permitida de rostros"</string>
    <string name="face_intro_error_unknown" msgid="6367721696446677261">"No se pueden agregar más rostros"</string>
    <string name="security_settings_face_enroll_error_dialog_title" msgid="2869110702072655323">"No se completó el registro"</string>
    <string name="security_settings_face_enroll_dialog_ok" msgid="2980238861223265089">"Aceptar"</string>
    <string name="security_settings_face_enroll_error_timeout_dialog_message" msgid="1701191960569185087">"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="3825066262969499407">"No funcionó el registro de rostros."</string>
    <string name="security_settings_face_enroll_finish_title" msgid="8268014305067971249">"Ya terminaste. Está todo listo."</string>
    <string name="security_settings_face_enroll_done" msgid="6670735678797960484">"Listo"</string>
    <string name="security_settings_face_settings_use_face_category" msgid="4087133372842623883">"Desbloq. facial para"</string>
    <string name="security_settings_face_settings_use_face_unlock_phone" msgid="8780794239930621913">"Desbloquear teléfono"</string>
    <string name="security_settings_face_settings_use_face_for_apps" msgid="5751549943998662469">"Acceso a apps y pagos"</string>
    <string name="security_settings_face_settings_require_category" msgid="2523822050054597822">"Requisitos del Desbloqueo facial"</string>
    <string name="security_settings_face_settings_require_attention" msgid="8523824066748480516">"Los ojos deben estar abiertos"</string>
    <string name="security_settings_face_settings_require_attention_details" msgid="6595676992796133643">"Para desbloquear el teléfono, debes abrir los ojos"</string>
    <string name="security_settings_face_settings_require_confirmation" msgid="2559602923985027572">"Requerir siempre confirmación"</string>
    <string name="security_settings_face_settings_require_confirmation_details" msgid="6466094680756211420">"Solicitar confirmación al usar el desbloqueo facial en apps"</string>
    <string name="security_settings_face_settings_remove_face_data" msgid="304401377141467791">"Borrar datos faciales"</string>
    <string name="security_settings_face_settings_enroll" msgid="495403103503629382">"Configurar Desbloqueo facial"</string>
    <string name="security_settings_face_settings_footer" msgid="1233594882557106034">"Usa el desbloqueo facial para desbloquear tu dispositivo, acceder a apps y confirmar pagos.\n\nTen en cuenta lo siguiente:\nMirar el teléfono puede desbloquearlo aunque no lo desees.\n\nUn tercero puede desbloquear el teléfono si lo sostiene frente a tu rostro, incluso aunque tengas los ojos cerrados.\n\nPor otro lado, también puede desbloquearlo cualquier persona que se parezca mucho a ti, como un hermano gemelo."</string>
    <string name="security_settings_face_settings_remove_dialog_title" msgid="4829278778459836075">"¿Quieres borrar los datos faciales?"</string>
    <string name="security_settings_face_settings_remove_dialog_details" msgid="1959642447512807205">"Se borrarán de forma permanente y segura las imágenes y los datos biométricos que utilice el Desbloqueo facial. Luego de la eliminación, 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_context_subtitle" msgid="4381276009777294566">"Usa tu rostro para desbloquear el teléfono"</string>
    <string name="security_settings_fingerprint_preference_title" msgid="2488725232406204350">"Huella digital"</string>
    <string name="fingerprint_manage_category_title" msgid="8293801041700001681">"Adm. huellas digitales"</string>
    <string name="fingerprint_usage_category_title" msgid="8438526918999536619">"Usar huella dig. para"</string>
    <string name="fingerprint_add_title" msgid="1926752654454033904">"Agregar una huella digital"</string>
    <string name="fingerprint_enable_keyguard_toggle_title" msgid="5078060939636911795">"bloqueo de pantalla"</string>
    <plurals name="security_settings_fingerprint_preference_summary" formatted="false" msgid="624961700033979880">
      <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="1507739327565151923"></string>
    <string name="security_settings_fingerprint_enroll_introduction_title" msgid="3201556857492526098">"Desbloquea con tu huella digital"</string>
    <string name="security_settings_fingerprint_enroll_introduction_title_unlock_disabled" msgid="7066417934622827305">"Usa tus huellas digitales"</string>
    <string name="security_settings_fingerprint_enroll_introduction_message" msgid="3508870672887336095">"Solo toca el sensor de huellas digitales para desbloquear tu teléfono, autorizar compras o acceder a las apps. Ten cuidado con las personas que agregas, ya que todas las huellas digitales que agregues podrán realizar estas acciones.\n\nNota: Tu huella digital puede ser menos segura que un PIN o un patrón eficaz."</string>
    <string name="security_settings_fingerprint_enroll_introduction_message_unlock_disabled" msgid="1550756694054944874">"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="6817326798834882531">"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="3199351118385606526">"Cancelar"</string>
    <string name="security_settings_fingerprint_enroll_introduction_continue" msgid="7472492858148162530">"Continuar"</string>
    <string name="security_settings_fingerprint_enroll_introduction_cancel_setup" msgid="5021369420474432665">"Omitir"</string>
    <string name="security_settings_fingerprint_enroll_introduction_continue_setup" msgid="1961957425135180242">"Siguiente"</string>
    <string name="setup_fingerprint_enroll_skip_title" msgid="362050541117362034">"¿Omitir huella digital?"</string>
    <string name="setup_fingerprint_enroll_skip_after_adding_lock_text" msgid="958990414356204763">"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="4988210105913705679">"¿Omitir bloqueo de la pantalla?"</string>
    <string name="lock_screen_intro_skip_dialog_text_frp" product="tablet" msgid="1581834104051243425">"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="4629503416877189572">"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="2423428240245737909">"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="5219287483885558525">"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="1466238255429527112">"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="3008526710555416125">"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="2323522873558834513">"Omitir"</string>
    <string name="go_back_button_label" msgid="4745265266186209467">"Atrás"</string>
    <string name="skip_lock_screen_dialog_button_label" msgid="7478349557867790778">"Omitir"</string>
    <string name="cancel_lock_screen_dialog_button_label" msgid="4525833484240246349">"Cancelar"</string>
    <string name="security_settings_fingerprint_enroll_find_sensor_title" msgid="3051496861358227199">"Toca el sensor"</string>
    <string name="security_settings_fingerprint_enroll_find_sensor_message" msgid="8793966374365960368">"Se encuentra en la parte posterior del teléfono. Usa el dedo índice."</string>
    <string name="security_settings_fingerprint_enroll_find_sensor_content_description" msgid="2058830032070449160">"Ilustración del dispositivo y la ubicación del sensor de huellas digitales"</string>
    <string name="security_settings_fingerprint_enroll_dialog_name_label" msgid="7086763077909041106">"Nombre"</string>
    <string name="security_settings_fingerprint_enroll_dialog_ok" msgid="4150384963879569750">"Aceptar"</string>
    <string name="security_settings_fingerprint_enroll_dialog_delete" msgid="4114615413240707936">"Borrar"</string>
    <string name="security_settings_fingerprint_enroll_start_title" msgid="2068961812439460133">"Toca el sensor"</string>
    <string name="security_settings_fingerprint_enroll_start_message" msgid="3909929328942564524">"Coloca el dedo en el sensor y levántalo cuando sientas una vibración."</string>
    <string name="security_settings_fingerprint_enroll_repeat_title" msgid="2819679722403209778">"Levanta el dedo y vuelve a tocar"</string>
    <string name="security_settings_fingerprint_enroll_repeat_message" msgid="6158989350522518586">"Sigue levantando el dedo para agregar diferentes partes de la huella digital."</string>
    <string name="security_settings_fingerprint_enroll_finish_title" msgid="7567276170287972230">"Se agregó la huella digital"</string>
    <string name="security_settings_fingerprint_enroll_finish_message" msgid="8970048776120548976">"Cuando veas este ícono, usa tu huella digital para identificarte o aprobar compras."</string>
    <string name="security_settings_fingerprint_enroll_enrolling_skip" msgid="3710211704052369752">"Hacerlo más tarde"</string>
    <string name="setup_fingerprint_enroll_enrolling_skip_title" msgid="6808422329107426923">"¿Omitir configuración de huella digital?"</string>
    <string name="setup_fingerprint_enroll_enrolling_skip_message" msgid="274849306857859783">"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="7914950545902198894">"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="2300047476104528001">"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="5823994499768751994">"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="2053646029913482047">"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="8884769457436280503">"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="1752907123591111728">"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 para configurar el Desbloqueo facial. Si necesitas ir hacia atrás, presiona Cancelar."</string>
    <string name="lock_screen_pin_skip_title" msgid="8064328201816780457">"¿Omitir configuración del PIN?"</string>
    <string name="lock_screen_password_skip_title" msgid="4155009417576409182">"¿Omitir configuración de la contraseña?"</string>
    <string name="lock_screen_pattern_skip_title" msgid="6467327818577283960">"¿Omitir configuración del patrón?"</string>
    <string name="security_settings_fingerprint_enroll_setup_screen_lock" msgid="1195743489835505376">"Configurar bloqueo de pantalla"</string>
    <string name="security_settings_fingerprint_enroll_done" msgid="4014607378328187567">"Listo"</string>
    <string name="security_settings_fingerprint_enroll_touch_dialog_title" msgid="1863561601428695160">"Ese no es el sensor"</string>
    <string name="security_settings_fingerprint_enroll_touch_dialog_message" msgid="2989019978041986175">"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="3618021988442639280">"No se completó el registro"</string>
    <string name="security_settings_fingerprint_enroll_error_timeout_dialog_message" msgid="2942551158278899627">"Se alcanzó el límite de tiempo para el registro de huellas digitales. Vuelve a intentarlo."</string>
    <string name="security_settings_fingerprint_enroll_error_generic_dialog_message" msgid="3624760637222239293">"El registro de huellas digitales no funcionó. Vuelve a intentarlo o usa otro dedo."</string>
    <string name="fingerprint_enroll_button_add" msgid="6317978977419045463">"Agregar otra huella digital"</string>
    <string name="fingerprint_enroll_button_next" msgid="6247009337616342759">"Siguiente"</string>
    <string name="security_settings_fingerprint_enroll_disclaimer" msgid="2624905914239271751">"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="7846871823167357942">" 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="1888772560642539718">"Levanta el dedo y vuelve a tocar el sensor"</string>
    <string name="fingerprint_add_max" msgid="1020927549936895822">"Puedes agregar hasta <xliff:g id="COUNT">%d</xliff:g> huellas digitales"</string>
    <string name="fingerprint_intro_error_max" msgid="6864066984678078441">"Agregaste la cantidad máxima permitida de huellas digitales"</string>
    <string name="fingerprint_intro_error_unknown" msgid="1905692132326523040">"No se pueden agregar más huellas digitales"</string>
    <string name="fingerprint_last_delete_title" msgid="6410310101247028988">"¿Quitar las huellas digitales?"</string>
    <string name="fingerprint_delete_title" msgid="1368196182612202898">"Quitar \"<xliff:g id="FINGERPRINT_ID">%1$s</xliff:g>\""</string>
    <string name="fingerprint_delete_message" msgid="8597787803567398131">"¿Quieres borrar esta huella digital?"</string>
    <string name="fingerprint_last_delete_message" msgid="7852321001254275878">"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="6521520787746771912">"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="2634726361059274289">"Sí, deseo quitarlas"</string>
    <string name="crypt_keeper_settings_title" msgid="4219233835490520414">"Encriptación"</string>
    <string name="crypt_keeper_encrypt_title" product="tablet" msgid="1060273569887301457">"Encriptar Tablet"</string>
    <string name="crypt_keeper_encrypt_title" product="default" msgid="1878996487755806122">"Encriptar dispositivo"</string>
    <string name="crypt_keeper_encrypted_summary" msgid="1868233637888132906">"Encriptado"</string>
    <string name="crypt_keeper_desc" product="tablet" msgid="503014594435731275">"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="2579929266645543631">"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="1189623490604750854">"Encriptar tablet"</string>
    <string name="crypt_keeper_button_text" product="default" msgid="2008346408473255519">"Encriptar dispositivo"</string>
    <string name="crypt_keeper_low_charge_text" msgid="2029407131227814893">"Carga tu batería e inténtalo nuevamente."</string>
    <string name="crypt_keeper_unplugged_text" msgid="4785376766063053901">"Enchufa tu cargador e inténtalo nuevamente."</string>
    <string name="crypt_keeper_dialog_need_password_title" msgid="4058971800557767">"Sin contraseña o PIN de pantalla de bloqueo"</string>
    <string name="crypt_keeper_dialog_need_password_message" msgid="4071395977297369642">"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="5100339496381875522">"¿Encriptar?"</string>
    <string name="crypt_keeper_final_desc" product="tablet" msgid="517662068757620756">"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="287503113671320916">"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="1783951453124244969">"Encriptando"</string>
    <string name="crypt_keeper_setup_description" product="tablet" msgid="6689952371032099350">"Espera mientras se encripta tu tablet. <xliff:g id="PERCENT">^1</xliff:g>% completado."</string>
    <string name="crypt_keeper_setup_description" product="default" msgid="951918761585534875">"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="1655047311546745695">"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="1862964662304683072">"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="556504311511212648">"Para desbloquear la tablet, apágala y vuelve a encenderla."</string>
    <string name="crypt_keeper_force_power_cycle" product="default" msgid="1794353635603020327">"Para desbloquear el teléfono, apágalo y vuelve a encenderlo."</string>
    <string name="crypt_keeper_warn_wipe" msgid="2738374897337991667">"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="2223340178473871064">"Escribe la contraseña"</string>
    <string name="crypt_keeper_failed_title" msgid="7133499413023075961">"Encriptación incorrecta"</string>
    <string name="crypt_keeper_failed_summary" product="tablet" msgid="8219375738445017266">"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="3270131542549577953">"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="8759119849089795751">"Desencriptación incorrecta"</string>
    <string name="crypt_keeper_data_corrupt_summary" product="tablet" msgid="840107296925798402">"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="8843311420059663824">"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="4168332125223483198">"Cambiar método de introducción"</string>
    <string name="suggested_lock_settings_title" msgid="8498743819223200961">"Protege tu teléfono"</string>
    <string name="suggested_lock_settings_summary" product="tablet" msgid="2296800316150748710">"Agrega un bloqueo de pantalla para proteger la tablet"</string>
    <string name="suggested_lock_settings_summary" product="device" msgid="7562847814806365373">"Agrega bloqueo de pantalla para proteger el dispositivo"</string>
    <string name="suggested_lock_settings_summary" product="default" msgid="1526355348444658181">"Agrega un bloqueo de pantalla para proteger el teléfono"</string>
    <string name="suggested_fingerprint_lock_settings_title" msgid="2174553391551398081">"Agrega una huella digital como desbloqueo"</string>
    <string name="suggested_fingerprint_lock_settings_summary" product="tablet" msgid="5738274583658668124"></string>
    <string name="suggested_fingerprint_lock_settings_summary" product="device" msgid="5738274583658668124"></string>
    <string name="suggested_fingerprint_lock_settings_summary" product="default" msgid="5738274583658668124"></string>
    <string name="lock_settings_picker_title" msgid="1095755849152582712">"Bloqueo de pantalla"</string>
    <string name="lock_settings_picker_title_profile" msgid="8822511284992306796">"Elegir bloqueo"</string>
    <string name="setup_lock_settings_picker_title" product="tablet" msgid="90329443364067215">"Protege tu tablet"</string>
    <string name="setup_lock_settings_picker_title" product="device" msgid="2399952075134938929">"Protege tu dispositivo"</string>
    <string name="setup_lock_settings_picker_title" product="default" msgid="1572244299605153324">"Protege el teléfono"</string>
    <string name="lock_settings_picker_biometrics_added_security_message" msgid="1507307757032207572">"Para mayor seguridad, establece un bloqueo de pantalla secundario"</string>
    <string name="setup_lock_settings_picker_message" product="tablet" msgid="8919671129189936210">"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="3787276514406353777">"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="3692856437543730446">"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_fingerprint_message" msgid="4755230324778371292">"Elegir el método secundario de bloqueo de pantalla"</string>
    <string name="lock_settings_picker_face_message" msgid="197106534637556054">"Elige el método secundario de bloqueo de pantalla"</string>
    <string name="setup_lock_settings_options_button_label" msgid="8511153243629402929">"Opciones de bloqueo de la pantalla"</string>
    <string name="setup_lock_settings_options_dialog_title" msgid="5058207955455973917">"Opciones de bloqueo de la pantalla"</string>
    <string name="unlock_set_unlock_launch_picker_title" msgid="2084576942666016993">"Bloqueo de pantalla"</string>
    <string name="unlock_set_unlock_launch_picker_summary_lock_immediately" msgid="5967714169972542586">"<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="4696710373399258413">"<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="124176557311393483">"Bloqueo del perfil"</string>
    <string name="unlock_set_unlock_launch_picker_change_title" msgid="5045866882028324941">"Cambiar pant. bloqueada"</string>
    <string name="unlock_set_unlock_launch_picker_change_summary" msgid="2790960639554590668">"Cambiar/inhab. patrón/PIN/contraseña"</string>
    <string name="unlock_set_unlock_launch_picker_enable_summary" msgid="4791110798817242301">"Elige un método para bloquear la pantalla."</string>
    <string name="unlock_set_unlock_off_title" msgid="7117155352183088342">"Ninguno"</string>
    <string name="unlock_set_unlock_off_summary" msgid="94361581669110415"></string>
    <string name="unlock_set_unlock_none_title" msgid="5679243878975864640">"Deslizar"</string>
    <string name="unlock_set_unlock_none_summary" msgid="8914673583104628191">"Sin seguridad"</string>
    <string name="unlock_set_unlock_pattern_title" msgid="2912067603917311700">"Patrón"</string>
    <string name="unlock_set_unlock_pattern_summary" msgid="7062696666227725593">"Seguridad media"</string>
    <string name="unlock_set_unlock_pin_title" msgid="5846029709462329515">"PIN"</string>
    <string name="unlock_set_unlock_pin_summary" msgid="907878650556383388">"Nivel de seguridad medio a alto"</string>
    <string name="unlock_set_unlock_password_title" msgid="8775603825675090937">"Contraseña"</string>
    <string name="unlock_set_unlock_password_summary" msgid="8856220848940929546">"Nivel de seguridad alto"</string>
    <string name="unlock_set_do_later_title" msgid="4894767558414979243">"Ahora no"</string>
    <string name="current_screen_lock" msgid="4104091715420072219">"Bloqueo de pantalla actual"</string>
    <string name="fingerprint_unlock_set_unlock_pattern" msgid="4939057588092120368">"Huella digital y patrón"</string>
    <string name="fingerprint_unlock_set_unlock_pin" msgid="8010746824051056986">"Huella digital y PIN"</string>
    <string name="fingerprint_unlock_set_unlock_password" msgid="7351131075806338634">"Huella digital y contraseña"</string>
    <string name="fingerprint_unlock_skip_fingerprint" msgid="1441077909803666681">"Continuar sin huellas digitales"</string>
    <string name="fingerprint_unlock_title" msgid="2826226740306003991">"Puedes desbloquear tu teléfono con tus huellas digitales. Para mayor seguridad, esta opción requiere un método secundario de bloqueo de pantalla."</string>
    <string name="face_unlock_set_unlock_pattern" msgid="4077659104229192018">"Desbloqueo facial y patrón"</string>
    <string name="face_unlock_set_unlock_pin" msgid="1359249613033276716">"Desbloqueo facial y PIN"</string>
    <string name="face_unlock_set_unlock_password" msgid="7135335310498158870">"Desbloqueo facial y contraseña"</string>
    <string name="face_unlock_skip_face" msgid="3481956557015165094">"Continuar sin el Desbloqueo facial"</string>
    <string name="face_unlock_title" msgid="9042382084472444316">"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="unlock_set_unlock_disabled_summary" msgid="2051593894736282302">"Inhabilitada: admin, encriptación o credenciales"</string>
    <string name="unlock_set_unlock_mode_off" msgid="5881952274566013651">"Ninguno"</string>
    <string name="unlock_set_unlock_mode_none" msgid="8467360084676871617">"Deslizar"</string>
    <string name="unlock_set_unlock_mode_pattern" msgid="7837270780919299289">"Patrón"</string>
    <string name="unlock_set_unlock_mode_pin" msgid="3541326261341386690">"PIN"</string>
    <string name="unlock_set_unlock_mode_password" msgid="1203938057264146610">"Contraseña"</string>
    <string name="unlock_setup_wizard_fingerprint_details" msgid="7893457665921363009">"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="1427036227416979120">"Desactivar el bloqueo de pantalla"</string>
    <string name="unlock_disable_frp_warning_title" msgid="264008934468492550">"¿Deseas quitar la protección del dispositivo?"</string>
    <string name="unlock_disable_frp_warning_title_profile" msgid="5507136301904313583">"¿Quieres quitar la protección del perfil?"</string>
    <string name="unlock_disable_frp_warning_content_pattern" msgid="8869767290771023461">"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="2986105377420905314">"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="586996206210265131">"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="3370462835533123695">"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="5420612686852555537">"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="3595476296430536798">"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="1550718040483548220">"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="3679351662094349506">"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="8682200103576359918">"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="6718155854303231675">"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="7790688070593867767">"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="4209564603132870532">"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="7569285520567674461">"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="2994300676764706047">"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="6984215718701688202">"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="4994062501123299418">"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="7075138677177748705">"Sí, deseo quitarla"</string>
    <string name="unlock_change_lock_pattern_title" msgid="2044092014872741130">"Cambiar patrón de desbloqueo"</string>
    <string name="unlock_change_lock_pin_title" msgid="806629901095938484">"Cambiar PIN de desbloqueo"</string>
    <string name="unlock_change_lock_password_title" msgid="5606298470358768865">"Cambiar la contraseña de desbloqueo"</string>
    <string name="unlock_footer_high_complexity_requested" msgid="7529087063617325912">"<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="4195620619469851350">"<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="428655972363263817">"<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="6275441987228550440">"<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="2219711062197089783">"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="4277765862798876826">"Se borrarán tus datos"</string>
    <string name="lock_last_pattern_attempt_before_wipe_device" msgid="1688030823464420974">"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="5350785938296254352">"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="6208035114731421034">"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="7851504071368235547">"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="4049024921333961715">"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="4660886542496781672">"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="2437716252059050291">"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="5799931839127476913">"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="6786586046975042158">"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="5047439819181833824">"Hubo demasiados intentos incorrectos. Se borrarán los datos de este dispositivo."</string>
    <string name="lock_failed_attempts_now_wiping_user" msgid="6188180643494518001">"Hubo demasiados intentos incorrectos. Se borrará este usuario."</string>
    <string name="lock_failed_attempts_now_wiping_profile" msgid="1745475043685915442">"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="8246716090548717312">"Descartar"</string>
    <plurals name="lockpassword_password_too_short" formatted="false" msgid="1957883871187697796">
      <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="5019935246875659237">
      <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="4602203784934526940">"Continuar"</string>
    <plurals name="lockpassword_password_too_long" formatted="false" msgid="4581209996591221075">
      <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="185568652740755131">
      <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_contains_non_digits" msgid="7284664023164191198">"Solo puede contener dígitos entre el 0 y el 9"</string>
    <string name="lockpassword_pin_recently_used" msgid="1401569207976460727">"El administrador del dispositivo no permite el uso de un PIN reciente"</string>
    <string name="lockpassword_pin_blacklisted_by_admin" msgid="8563366383328811472">"Tu administrador de TI bloquea los PIN comunes. Prueba uno diferente."</string>
    <string name="lockpassword_illegal_character" msgid="8049611046639943217">"No puede incluir un carácter no válido"</string>
    <string name="lockpassword_password_requires_alpha" msgid="3036589522150097731">"Debe tener al menos una letra"</string>
    <string name="lockpassword_password_requires_digit" msgid="5140062925787058765">"Debe tener al menos un dígito"</string>
    <string name="lockpassword_password_requires_symbol" msgid="5944350865681510893">"Debe tener al menos un símbolo"</string>
    <plurals name="lockpassword_password_requires_letters" formatted="false" msgid="9013132344745898400">
      <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="2626327674921055486">
      <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="7860796359913920356">
      <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="1967587658356336828">
      <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="6751305770863640574">
      <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="4440596998172043055">
      <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>
    <string name="lockpassword_password_recently_used" msgid="942665351220525547">"El administrador del dispositivo no permite el uso de contraseñas recientes"</string>
    <string name="lockpassword_password_blacklisted_by_admin" msgid="9105101266246197027">"Tu administrador de TI bloquea las contraseñas comunes. Prueba una diferente."</string>
    <string name="lockpassword_pin_no_sequential_digits" msgid="680765285206990584">"No se permiten secuencias de dígitos ascendentes, descendentes ni repetidas"</string>
    <string name="lockpassword_confirm_label" msgid="8176726201389902380">"Confirmar"</string>
    <string name="lockpassword_cancel_label" msgid="8818529276331121899">"Cancelar"</string>
    <string name="lockpassword_clear_label" msgid="5724429464960458155">"Borrar"</string>
    <string name="lockpassword_credential_changed" msgid="581649578639853343">"Ya se cambió el bloqueo de pantalla. Vuelve a intentarlo con el nuevo bloqueo de pantalla."</string>
    <string name="lockpattern_tutorial_cancel_label" msgid="6431583477570493261">"Cancelar"</string>
    <string name="lockpattern_tutorial_continue_label" msgid="3559793618653400434">"Siguiente"</string>
    <string name="lock_setup" msgid="3355847066343753943">"Se completó la configuración."</string>
    <string name="manage_device_admin" msgid="537804979483211453">"Apps de administración"</string>
    <string name="number_of_device_admins_none" msgid="7185056721919496069">"No hay apps activas"</string>
    <plurals name="number_of_device_admins" formatted="false" msgid="3361891840111523393">
      <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="4629279457536987768">"Agentes de confianza"</string>
    <string name="disabled_because_no_backup_security" msgid="6877660253409580377">"Para usarlo, debes establecer un bloqueo de pantalla."</string>
    <string name="manage_trust_agents_summary" msgid="1475819820389620546">"Ninguno"</string>
    <plurals name="manage_trust_agents_summary_on" formatted="false" msgid="3935182396726101824">
      <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="1037056952714061893">"Bluetooth"</string>
    <string name="bluetooth_quick_toggle_summary" msgid="5293641680139873341">"Activar Bluetooth"</string>
    <string name="bluetooth_settings" msgid="1810521656168174329">"Bluetooth"</string>
    <string name="bluetooth_settings_title" msgid="1908745291161353016">"Bluetooth"</string>
    <string name="bluetooth_settings_summary" msgid="2091062709530570462">"Administrar conexiones, establecer nombre y detección del dispositivo"</string>
    <string name="bluetooth_pairing_request" msgid="2605098826364694673">"¿Vincular con <xliff:g id="DEVICE_NAME">%1$s</xliff:g>?"</string>
    <string name="bluetooth_pairing_key_msg" msgid="418124944140102021">"Código de vinculación Bluetooth"</string>
    <string name="bluetooth_enter_passkey_msg" msgid="6813273136442138444">"Ingresa el código de sincronización y luego presiona Intro."</string>
    <string name="bluetooth_enable_alphanumeric_pin" msgid="7222713483058171357">"El PIN contiene letras o símbolos."</string>
    <string name="bluetooth_pin_values_hint" msgid="3815897557875873646">"Por lo general, 0000 o 1234"</string>
    <string name="bluetooth_pin_values_hint_16_digits" msgid="7849359451584101077">"Debe contener 16 dígitos"</string>
    <string name="bluetooth_enter_pin_other_device" msgid="4637977124526813470">"Puede que también tengas que escribir este PIN en el otro dispositivo."</string>
    <string name="bluetooth_enter_passkey_other_device" msgid="2798719004030279602">"Puede que también tengas que escribir esta clave de acceso en otro dispositivo."</string>
    <string name="bluetooth_confirm_passkey_msg" msgid="3708312912841950052">"Para sincronizar 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="1615930853859551491">"¿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="2796550001376088433">"Para sincronizar 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="9082518313285787097">"Permitir el acceso a tus contactos y al historial de llamadas"</string>
    <string name="bluetooth_error_title" msgid="6850384073923533096"></string>
    <string name="bluetooth_connecting_error_message" msgid="1397388344342081090">"No se pudo establecer conexión con <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="bluetooth_preference_scan_title" msgid="2277464653118896016">"Buscar dispositivos"</string>
    <string name="bluetooth_search_for_devices" msgid="2754007356491461674">"Actualizar"</string>
    <string name="bluetooth_searching_for_devices" msgid="9203739709307871727">"Buscando..."</string>
    <string name="bluetooth_preference_device_settings" msgid="907776049862799122">"Configuración de dispositivos"</string>
    <string name="bluetooth_preference_paired_dialog_title" msgid="8875124878198774180">"Dispositivo sincronizado"</string>
    <string name="bluetooth_preference_paired_dialog_internet_option" msgid="7112953286863428412">"Conexión a Internet"</string>
    <string name="bluetooth_preference_paired_dialog_keyboard_option" msgid="2271954176947879628">"Teclado"</string>
    <string name="bluetooth_preference_paired_dialog_contacts_option" msgid="7747163316331917594">"Contactos e historial de llamadas"</string>
    <string name="bluetooth_pairing_dialog_title" msgid="1417255032435317301">"¿Sincronizar con este dispositivo?"</string>
    <string name="bluetooth_pairing_dialog_sharing_phonebook_title" msgid="7664141669886358618">"¿Compartir libreta telefónica?"</string>
    <string name="bluetooth_pairing_dialog_contants_request" msgid="5531109163573611348">"<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="8451248193517851958">"<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="1617401232446299411">"Dispositivos disponibles"</string>
    <string name="bluetooth_preference_no_found_devices" msgid="7594339669961811591">"No hay dispositivos disponibles."</string>
    <string name="bluetooth_device_context_connect" msgid="3997659895003244941">"Conectar"</string>
    <string name="bluetooth_device_context_disconnect" msgid="8220072022970148683">"Desconectar"</string>
    <string name="bluetooth_device_context_pair_connect" msgid="7611522504813927727">"Vincular y conectar"</string>
    <string name="bluetooth_device_context_unpair" msgid="662992425948536144">"Desvincular"</string>
    <string name="bluetooth_device_context_disconnect_unpair" msgid="7644014238070043798">"Desconectar y desvincular"</string>
    <string name="bluetooth_device_context_connect_advanced" msgid="2643129703569788771">"Opciones…"</string>
    <string name="bluetooth_menu_advanced" msgid="8572178316357220524">"Config. avanzada"</string>
    <string name="bluetooth_advanced_titlebar" msgid="2142159726881547669">"Bluetooth avanzado"</string>
    <string name="bluetooth_empty_list_bluetooth_off" msgid="6351930724051893423">"Cuando Bluetooth está activado, permite conectarse con dispositivos cercanos"</string>
    <string name="bluetooth_scanning_on_info_message" msgid="824285504325592644">"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="1295915006005700650">"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="4500234659813241053">"No se pudo establecer la conexión. Vuelve a intentarlo."</string>
    <string name="device_details_title" msgid="6576953269221085300">"Detalles del dispositivo"</string>
    <string name="bluetooth_device_mac_address" msgid="2513724313558236181">"Dirección Bluetooth del dispositivo: <xliff:g id="ADDRESS">%1$s</xliff:g>"</string>
    <string name="bluetooth_unpair_dialog_title" msgid="38467834196432400">"¿Olvidar este dispositivo?"</string>
    <string name="bluetooth_unpair_dialog_body" product="default" msgid="9087609557757135712">"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="7785695793007576501">"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="251257782642157557">"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="5932168717642676140">"<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="3829370108973879006">"Olvidar este dispositivo"</string>
    <string name="bluetooth_connect_specific_profiles_title" msgid="6952214406025825164">"Conectar a..."</string>
    <string name="bluetooth_disconnect_a2dp_profile" msgid="3524648279150937177">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g> se desconectará del audio multimedia."</string>
    <string name="bluetooth_disconnect_headset_profile" msgid="8635908811168780720">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g> se desconectará del audio de manos libres."</string>
    <string name="bluetooth_disconnect_hid_profile" msgid="3282295189719352075">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g> se desconectará del dispositivo de entrada."</string>
    <string name="bluetooth_disconnect_pan_user_profile" msgid="8037627994382458698">"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="8355910926439312604">"<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="6251611115860359886">"<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="6066342531927499308">"Dispositivo Bluetooth sincronizado"</string>
    <string name="bluetooth_device_advanced_online_mode_title" msgid="3689050071425683114">"Conectar"</string>
    <string name="bluetooth_device_advanced_online_mode_summary" msgid="1204424107263248336">"Conectar al dispositivo Bluetooth"</string>
    <string name="bluetooth_device_advanced_profile_header_title" msgid="102745381968579605">"Utilizar para"</string>
    <string name="bluetooth_device_advanced_rename_device" msgid="5148578059584955791">"Cambiar el nombre"</string>
    <string name="bluetooth_device_advanced_enable_opp_title" msgid="8222550640371627365">"Permitir transferencias de archivos entrantes"</string>
    <string name="bluetooth_pan_user_profile_summary_connected" msgid="6436258151814414028">"Conectado para Internet"</string>
    <string name="bluetooth_pan_nap_profile_summary_connected" msgid="1322694224800769308">"Compartiendo conexión"</string>
    <string name="bluetooth_dock_settings" msgid="3218335822716052885">"Configuración de la base"</string>
    <string name="bluetooth_dock_settings_title" msgid="5543069893044375188">"Utilizar la base para el audio"</string>
    <string name="bluetooth_dock_settings_headset" msgid="1001821426078644650">"Como altavoz"</string>
    <string name="bluetooth_dock_settings_a2dp" msgid="8791004998846630574">"Para música y medios"</string>
    <string name="bluetooth_dock_settings_remember" msgid="5551459057010609115">"Recordar la configuración"</string>
    <string name="bluetooth_max_connected_audio_devices_string" msgid="6752690395207847881">"Máximo de dispositivos de audio Bluetooth conectados"</string>
    <string name="bluetooth_max_connected_audio_devices_dialog_title" msgid="5936561749790095473">"Selecciona una cantidad máxima de dispositivos de audio Bluetooth conectados"</string>
    <string name="wifi_display_settings_title" msgid="8740852850033480136">"Transmitir"</string>
    <string name="wifi_display_enable_menu_item" msgid="4883036464138167674">"Habilitar pantalla inalámbrica"</string>
    <string name="wifi_display_no_devices_found" msgid="1382012407154143453">"No se encontraron dispositivos cercanos."</string>
    <string name="wifi_display_status_connecting" msgid="5688608834000748607">"Conectando"</string>
    <string name="wifi_display_status_connected" msgid="8364125226376985558">"Conectado"</string>
    <string name="wifi_display_status_in_use" msgid="8556830875615434792">"En uso"</string>
    <string name="wifi_display_status_not_available" msgid="5714978725794210102">"No disponible"</string>
    <string name="wifi_display_details" msgid="7791118209992162698">"Configuración de visualización"</string>
    <string name="wifi_display_options_title" msgid="5740656401635054838">"Opciones de pantalla inalámbrica"</string>
    <string name="wifi_display_options_forget" msgid="9119048225398894580">"Borrar"</string>
    <string name="wifi_display_options_done" msgid="5703116500357822557">"Listo"</string>
    <string name="wifi_display_options_name" msgid="4756080222307467898">"Nombre"</string>
    <string name="wifi_band_24ghz" msgid="852929254171856911">"2.4 GHz"</string>
    <string name="wifi_band_5ghz" msgid="6433822023268515117">"5 GHz"</string>
    <string name="wifi_sign_in_button_text" msgid="8404345621836792112">"Acceder"</string>
    <string name="wifi_tap_to_sign_in" msgid="6990161842394669054">"Presiona aquí para acceder a la red"</string>
    <string name="tx_link_speed" msgid="6139577455916971837">"<xliff:g id="TRANSMIT_LINK_SPEED">%1$d</xliff:g> Mbps"</string>
    <string name="rx_link_speed" msgid="5729003360923133988">"<xliff:g id="RECEIVE_LINK_SPEED">%1$d</xliff:g> Mbps"</string>
    <string name="wifi_ask_enable" msgid="2795469717302060104">"<xliff:g id="REQUESTER">%s</xliff:g> quiere activar la conexión Wi-Fi"</string>
    <string name="wifi_ask_disable" msgid="728366570145493573">"<xliff:g id="REQUESTER">%s</xliff:g> quiere desactivar la conexión Wi-Fi"</string>
    <string name="art_verifier_for_debuggable_title" msgid="6029838014407791341">"Verificar bytecode de apps depurables"</string>
    <string name="art_verifier_for_debuggable_summary" msgid="2250352478065428399">"Permitir que ART verifique el bytecode de apps depurables"</string>
    <string name="nfc_quick_toggle_title" msgid="6769159366307299004">"NFC"</string>
    <string name="nfc_quick_toggle_summary" product="tablet" msgid="8302974395787498915">"Permitir el intercambio de datos cuando la tablet entre en contacto con otro dispositivo"</string>
    <string name="nfc_quick_toggle_summary" product="default" msgid="5237208142892767592">"Permitir el intercambio de datos cuando el dispositivo toque otro dispositivo"</string>
    <string name="nfc_disclaimer_title" msgid="4364003873202264039">"Activa NFC"</string>
    <string name="nfc_disclaimer_content" msgid="5566907911915158075">"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="150400737244061585">"Proteger NFC"</string>
    <string name="nfc_secure_toggle_summary" product="default" msgid="2135032222065627938">"Permitir uso de pagos NFC y Transit solo cuando la pantalla está desbloqueada"</string>
    <string name="android_beam_settings_title" msgid="7832812974600338649">"Android Beam"</string>
    <string name="android_beam_on_summary" msgid="3618057099355636830">"Listo para transmitir contenido de aplicaciones por NFC"</string>
    <string name="android_beam_off_summary" msgid="4663095428454779138">"Desactivada"</string>
    <string name="nfc_disabled_summary" msgid="3507017304297395467">"No disponible porque NFC está desactivada"</string>
    <string name="android_beam_label" msgid="6257036050366775040">"Android Beam"</string>
    <string name="android_beam_explained" msgid="1810540319385192758">"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="8850161330437693895">"Wi-Fi"</string>
    <string name="wifi_quick_toggle_summary" msgid="2696547080481267642">"Activar Wi-Fi"</string>
    <string name="wifi_settings" msgid="29722149822540994">"Wi-Fi"</string>
    <string name="wifi_settings_master_switch_title" msgid="4746267967669683259">"Usar Wi-Fi"</string>
    <string name="wifi_settings_category" msgid="8719175790520448014">"Configuración de Wi-Fi"</string>
    <string name="wifi_settings_title" msgid="3103415012485692233">"Wi-Fi"</string>
    <string name="wifi_settings_summary" msgid="668767638556052820">"Configurar y administrar los puntos de acceso de teléfonos inalámbricos"</string>
    <string name="wifi_select_network" msgid="4210954938345463209">"Seleccionar red Wi-Fi"</string>
    <string name="wifi_starting" msgid="6732377932749942954">"Activando Wi-Fi..."</string>
    <string name="wifi_stopping" msgid="8952524572499500804">"Desactivando Wi-Fi..."</string>
    <string name="wifi_error" msgid="3207971103917128179">"Error"</string>
    <string name="wifi_sap_no_channel_error" msgid="3108445199311817111">"Banda de 5 GHZ no disponible en este país"</string>
    <string name="wifi_in_airplane_mode" msgid="8652520421778203796">"En modo avión"</string>
    <string name="wifi_notify_open_networks" msgid="76298880708051981">"Notificaciones de red abierta"</string>
    <string name="wifi_notify_open_networks_summary" msgid="2761326999921366960">"Notificarme cuando haya una red pública de alta calidad"</string>
    <string name="wifi_wakeup" msgid="8815640989361538036">"Activar Wi-Fi automáticamente"</string>
    <string name="wifi_wakeup_summary" msgid="2530814331062997163">"La conexión Wi-Fi se volverá a activar automáticamente cerca de las redes guardadas de alta calidad, como tu red doméstica"</string>
    <string name="wifi_wakeup_summary_no_location" msgid="7494539594649967699">"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="7247227922074840445">"La opción no está disponible porque la búsqueda de Wi-Fi está desactivada"</string>
    <string name="wifi_wakeup_summary_scoring_disabled" msgid="108339002136866897">"Para usar la función, selecciona un proveedor de calificación de red"</string>
    <string name="wifi_poor_network_detection" msgid="4925789238170207169">"Evitar malas conexiones"</string>
    <string name="wifi_poor_network_detection_summary" msgid="7016103106105907127">"Solo usar una red Wi-Fi si ofrece una conexión a Internet estable"</string>
    <string name="wifi_avoid_poor_network_detection_summary" msgid="1644292503152790501">"Solo usar redes que tengan una conexión a Internet estable"</string>
    <string name="use_open_wifi_automatically_title" msgid="6851951242903078588">"Conectar a redes abiertas"</string>
    <string name="use_open_wifi_automatically_summary" msgid="2982091714252931713">"Conectar automáticamente a redes públicas de alta calidad"</string>
    <string name="use_open_wifi_automatically_summary_scoring_disabled" msgid="593964217679325831">"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="8472122600853650258">"Para usar la función, selecciona un proveedor de calificación de red compatible"</string>
    <string name="wifi_install_credentials" msgid="3551143317298272860">"Instalar certificados"</string>
    <string name="wifi_scan_notify_text" msgid="5544778734762998889">"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="3426075479272242098">"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="7104867814641144485">"No volver a mostrar"</string>
    <string name="wifi_setting_sleep_policy_title" msgid="5149574280392680092">"Mantener Wi-Fi durante suspensión"</string>
    <string name="wifi_setting_on_during_sleep_title" msgid="8308975500029751565">"Wi‑Fi activada en suspensión"</string>
    <string name="wifi_setting_sleep_policy_error" msgid="8174902072673071961">"Hubo un problema mientras se cambiaba la configuración"</string>
    <string name="wifi_suspend_efficiency_title" msgid="2338325886934703895">"Mejorar el rendimiento"</string>
    <string name="wifi_suspend_optimizations" msgid="1220174276403689487">"Optimización de Wi-Fi"</string>
    <string name="wifi_suspend_optimizations_summary" msgid="4151428966089116856">"Minimizar el consumo de la batería con Wi-Fi activado"</string>
    <string name="wifi_limit_optimizations_summary" msgid="9000801068363468950">"Limitar batería que usa Wi-Fi"</string>
    <string name="wifi_switch_away_when_unvalidated" msgid="8593144541347373394">"Cambiar a datos móviles si la red Wi-Fi pierde acceso a Internet"</string>
    <string name="wifi_cellular_data_fallback_title" msgid="8753386877755616476">"Cambiar a datos móviles automáticamente"</string>
    <string name="wifi_cellular_data_fallback_summary" msgid="1403505355490119307">"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="6234851776910938957">"Agregar red"</string>
    <string name="wifi_configure_settings_preference_title" msgid="2913345003906899146">"Preferencias de Wi-Fi"</string>
    <string name="wifi_configure_settings_preference_summary_wakeup_on" msgid="646393113104367290">"La conexión Wi-Fi vuelve a activarse automáticamente"</string>
    <string name="wifi_configure_settings_preference_summary_wakeup_off" msgid="2782566279864356713">"La conexión Wi-Fi no vuelve a activarse automáticamente"</string>
    <string name="wifi_access_points" msgid="7053990007031968609">"Redes Wi-Fi"</string>
    <string name="wifi_menu_more_options" msgid="2448097861752719396">"Más opciones"</string>
    <string name="wifi_menu_p2p" msgid="7619851399250896797">"Wi-Fi directo"</string>
    <string name="wifi_menu_scan" msgid="1470911530412095868">"Buscar"</string>
    <string name="wifi_menu_advanced" msgid="7522252991919573664">"Config. avanzada"</string>
    <string name="wifi_menu_configure" msgid="6150926852602171938">"Configurar"</string>
    <string name="wifi_menu_connect" msgid="4996220309848349408">"Conectar a la red"</string>
    <string name="wifi_menu_remember" msgid="8814185749388713796">"Recordar red"</string>
    <string name="wifi_menu_forget" msgid="8736964302477327114">"Olvidar red"</string>
    <string name="wifi_menu_modify" msgid="2068554918652440105">"Modificar red"</string>
    <string name="wifi_empty_list_wifi_off" msgid="8056223875951079463">"Para ver las redes disponibles, activa Wi-Fi."</string>
    <string name="wifi_empty_list_wifi_on" msgid="8746108031587976356">"Buscando redes Wi-Fi…"</string>
    <string name="wifi_empty_list_user_restricted" msgid="7322372065475939129">"No tienes permiso para cambiar la red Wi‑Fi."</string>
    <string name="wifi_more" msgid="3195296805089107950">"Más"</string>
    <string name="wifi_setup_wps" msgid="8128702488486283957">"Configuración automática (WPS)"</string>
    <string name="wifi_settings_scanning_required_title" msgid="3815269816331500375">"¿Quieres activar la búsqueda de Wi‑Fi?"</string>
    <string name="wifi_settings_scanning_required_summary" msgid="6352918945128328916">"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="3155631874578023647">"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="1364287182804820646">"Activar"</string>
    <string name="wifi_settings_scanning_required_enabled" msgid="5527653791584018157">"Se activó la búsqueda de Wi‑Fi"</string>
    <string name="wifi_show_advanced" msgid="3409422789616520979">"Opciones avanzadas"</string>
    <string name="wifi_advanced_toggle_description_expanded" msgid="2380600578544493084">"Lista desplegable Opciones avanzadas. Presiona dos veces para contraerla."</string>
    <string name="wifi_advanced_toggle_description_collapsed" msgid="1463812308429197263">"Lista desplegable Opciones avanzadas. Presiona dos veces para expandirla."</string>
    <string name="wifi_ssid" msgid="5519636102673067319">"Nombre de la red"</string>
    <string name="wifi_ssid_hint" msgid="897593601067321355">"Ingresa el SSID"</string>
    <string name="wifi_security" msgid="6603611185592956936">"Seguridad"</string>
    <string name="wifi_hidden_network" msgid="973162091800925000">"Red oculta"</string>
    <string name="wifi_hidden_network_warning" msgid="6674068093531603452">"Si tu 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 suponga un riesgo de seguridad, ya que tu teléfono emitirá su señal de forma regular 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="5514120261628065287">"Potencia de la señal"</string>
    <string name="wifi_status" msgid="4824568012414605414">"Estado"</string>
    <string name="tx_wifi_speed" msgid="2994278184097786511">"Transmitir velocidad de vínculo"</string>
    <string name="rx_wifi_speed" msgid="7206089638282839236">"Recibir velocidad de vínculo"</string>
    <string name="wifi_frequency" msgid="7791090119577812214">"Frecuencia"</string>
    <string name="wifi_ip_address" msgid="1440054061044402918">"Dirección IP"</string>
    <string name="passpoint_label" msgid="6381371313076009926">"Se guardó mediante"</string>
    <string name="passpoint_content" msgid="8447207162397870483">"Credenciales de <xliff:g id="NAME">%1$s</xliff:g>"</string>
    <string name="wifi_eap_method" msgid="8529436133640730382">"Método EAP"</string>
    <string name="please_select_phase2" msgid="5231074529772044898">"Autenticación de fase 2"</string>
    <string name="wifi_eap_ca_cert" msgid="3521574865488892851">"Certificado de CA"</string>
    <string name="wifi_eap_domain" msgid="8471124344218082064">"Dominio"</string>
    <string name="wifi_eap_user_cert" msgid="1291089413368160789">"Certificado del usuario"</string>
    <string name="wifi_eap_identity" msgid="4359453783379679103">"Identidad"</string>
    <string name="wifi_eap_anonymous" msgid="2989469344116577955">"Identidad anónima"</string>
    <string name="wifi_password" msgid="5948219759936151048">"Contraseña"</string>
    <string name="wifi_sae_password_id" msgid="1697832722221765763">"Identificador de contraseña SAE"</string>
    <string name="wifi_show_password" msgid="6461249871236968884">"Mostrar contraseña"</string>
    <string name="wifi_ap_band_config" msgid="1611826705989117930">"Seleccionar banda AP"</string>
    <string name="wifi_ap_choose_auto" msgid="2677800651271769965">"Automático"</string>
    <string name="wifi_ap_choose_2G" msgid="8724267386885036210">"Banda de 2.4 GHz"</string>
    <string name="wifi_ap_choose_5G" msgid="8813128641914385634">"Banda de 5.0 GHz"</string>
    <string name="wifi_ap_prefer_5G" msgid="2501070491623803139">"Banda preferida: 5.0 GHz"</string>
    <string name="wifi_ap_2G" msgid="8378132945192979364">"2.4 GHz"</string>
    <string name="wifi_ap_5G" msgid="4020713496716329468">"5.0 GHz"</string>
    <string name="wifi_ap_band_select_one" msgid="3476254666116431650">"Elige al menos una banda para el hotspot de Wi-Fi:"</string>
    <string name="wifi_ip_settings" msgid="3359331401377059481">"Configuración de IP"</string>
    <string name="wifi_privacy_settings" msgid="5500777170960315928">"Privacidad"</string>
    <string name="wifi_privacy_settings_ephemeral_summary" msgid="1539659414108891004">"Dirección MAC aleatoria"</string>
    <string name="wifi_dpp_add_device_to_network" msgid="8674936581557695411">"Agregar un dispositivo"</string>
    <string name="wifi_dpp_center_qr_code" msgid="6244508369721032655">"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="4794621158747044107">"Escanear código QR"</string>
    <string name="wifi_dpp_scan_qr_code_join_network" msgid="4371771604088014396">"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="8096370383700478819">"Escanea un código QR para unirte a la red Wi-Fi"</string>
    <string name="wifi_dpp_share_wifi" msgid="9065890131734833809">"Compartir Wi‑Fi"</string>
    <string name="wifi_dpp_scan_qr_code_with_another_device" msgid="5854392840857123065">"Escanea este código QR para conectarte a \"<xliff:g id="SSID">%1$s</xliff:g>\" y compartir la contraseña"</string>
    <string name="wifi_dpp_scan_open_network_qr_code_with_another_device" msgid="4436318319178361543">"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="3372757783382381044">"Vuelve a intentarlo. Si el problema persiste, comunícate con el fabricante del dispositivo"</string>
    <string name="wifi_dpp_failure_not_compatible" msgid="2829930473520603740">"Se produjo un error"</string>
    <string name="wifi_dpp_failure_timeout" msgid="5228320772245820458">"Asegúrate de que el dispositivo se haya enchufado, cargado y encendido"</string>
    <string name="wifi_dpp_failure_generic" msgid="8030831192606098356">"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="2643768115109632725">"No se puede agregar \"<xliff:g id="SSID">%1$s</xliff:g>\" a este dispositivo"</string>
    <string name="wifi_dpp_check_connection_try_again" msgid="2632966336733361805">"Comprueba la conexión y vuelve a intentarlo"</string>
    <string name="wifi_dpp_choose_network" msgid="7139308800110200281">"Elegir una red"</string>
    <string name="wifi_dpp_choose_network_to_connect_device" msgid="4025269026652486605">"Selecciona una red para conectar tu dispositivo"</string>
    <string name="wifi_dpp_add_device_to_wifi" msgid="5459084866460319042">"¿Agregar este dispositivo a \"<xliff:g id="SSID">%1$s</xliff:g>\"?"</string>
    <string name="wifi_dpp_wifi_shared_with_device" msgid="7669684043486750097">"Se compartió la red Wi-Fi con el dispositivo"</string>
    <string name="wifi_dpp_add_another_device" msgid="8415243205104666929">"Agregar otro dispositivo"</string>
    <string name="wifi_dpp_choose_different_network" msgid="4081965219206680361">"Seleccionar otra red"</string>
    <string name="wifi_dpp_could_not_add_device" msgid="1598945041477461501">"No se pudo agregar el dispositivo"</string>
    <string name="wifi_dpp_device_found" msgid="8618134150169810107">"Se encontró el dispositivo"</string>
    <string name="wifi_dpp_sharing_wifi_with_this_device" msgid="5579154298588011712">"Compartiendo Wi-Fi con este dispositivo…"</string>
    <string name="wifi_dpp_connecting" msgid="7111851118215580428">"Conectando…"</string>
    <string name="wifi_dpp_share_hotspot" msgid="762408459341741405">"Compartir hotspot"</string>
    <string name="wifi_dpp_lockscreen_title" msgid="8401802203867904622">"Verifica tu identidad"</string>
    <string name="wifi_dpp_wifi_password" msgid="4938294574591503213">"Contraseña de Wi-Fi: <xliff:g id="PASSWORD">%1$s</xliff:g>"</string>
    <string name="wifi_dpp_hotspot_password" msgid="4120419278831581613">"Contraseña del hotspot: <xliff:g id="PASSWORD">%1$s</xliff:g>"</string>
    <string name="wifi_dpp_add_device" msgid="4072206063308645677">"Agregar dispositivo"</string>
    <string name="wifi_dpp_connect_network_using_qr_code" msgid="3887335309163999665">"Usar un código QR para agregar un dispositivo a esta red"</string>
    <string name="wifi_dpp_qr_code_is_not_valid_format" msgid="3700087439867692944">"El código QR no es un formato válido"</string>
    <string name="retry" msgid="6472609612090877557">"Reintentar"</string>
    <string name="wifi_shared" msgid="844142443226926070">"Compartir con otros usuarios del dispositivo"</string>
    <string name="wifi_unchanged" msgid="3410422020930397102">"(sin cambios)"</string>
    <string name="wifi_unspecified" msgid="4917316464723064807">"Selecciona"</string>
    <string name="wifi_multiple_cert_added" msgid="3240743501460165224">"(Se agregaron varios certificados)"</string>
    <string name="wifi_use_system_certs" msgid="5270879895056893783">"Usar certificados de sistema"</string>
    <string name="wifi_do_not_provide_eap_user_cert" msgid="5160499244977160665">"No proporcionar"</string>
    <string name="wifi_do_not_validate_eap_server" msgid="4266754430576348471">"No validar"</string>
    <string name="wifi_do_not_validate_eap_server_warning" msgid="1787190245542586660">"No especificaste ningún certificado. Tu conexión no será privada."</string>
    <string name="wifi_ssid_too_long" msgid="3474753269579895244">"El nombre de la red es demasiado largo."</string>
    <string name="wifi_no_domain_warning" msgid="5223011964091727376">"Se debe especificar un dominio."</string>
    <string name="wifi_wps_available_first_item" msgid="4422547079984583502">"WSP disponible"</string>
    <string name="wifi_wps_available_second_item" msgid="8427520131718215301">" (WSP disponible)"</string>
    <string name="wifi_carrier_connect" msgid="8174696557882299911">"Red Wi‑Fi del proveedor"</string>
    <string name="wifi_carrier_content" msgid="4634077285415851933">"Conectarse mediante <xliff:g id="NAME">%1$s</xliff:g>"</string>
    <string name="wifi_scan_always_turnon_message" msgid="203123538572122989">"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="6162424298483845679">"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="5538901671131941043">"Para desactivar la opción, accede a la sección Avanzada del menú ampliado."</string>
    <string name="wifi_scan_always_confirm_allow" msgid="5355973075896817232">"Permitir"</string>
    <string name="wifi_scan_always_confirm_deny" msgid="4463982053823520710">"Denegar"</string>
    <string name="wifi_hotspot_title" msgid="7726205804813286950">"¿Acceder para conectarse?"</string>
    <string name="wifi_hotspot_message" msgid="3673833421453455747">"<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="5065506390164939225">"CONECTAR"</string>
    <string name="no_internet_access_text" msgid="5926979351959279577">"Esta red no tiene acceso a Internet. ¿Deseas mantener la conexión?"</string>
    <string name="partial_connectivity_text" msgid="1287030663891772340">"Puede que algunas apps y servicios no funcionen debido a la conectividad limitada. ¿Usar igualmente?"</string>
    <string name="no_internet_access_remember" msgid="4697314331614625075">"No volver a preguntar para esta red"</string>
    <string name="lost_internet_access_title" msgid="5779478650636392426">"La red Wi-Fi no está conectada a Internet"</string>
    <string name="lost_internet_access_text" msgid="9029649339816197345">"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="2262459569601190039">"Cambiar a datos móviles"</string>
    <string name="lost_internet_access_cancel" msgid="338273139419871110">"Seguir usando Wi-Fi"</string>
    <string name="lost_internet_access_persist" msgid="7634876061262676255">"No volver a mostrar"</string>
    <string name="wifi_connect" msgid="1076622875777072845">"Conectar"</string>
    <string name="wifi_turned_on_message" msgid="4432839393213448846">"Wi-Fi activado"</string>
    <!-- no translation found for wifi_connected_to_message (2265022072754345638) -->
    <skip />
    <string name="wifi_connecting" msgid="8760426806460651215">"Conectando…"</string>
    <!-- no translation found for wifi_disconnect (3445234285136039895) -->
    <skip />
    <string name="wifi_failed_connect_message" msgid="8491902558970292871">"No se pudo establecer conexión con la red."</string>
    <string name="wifi_not_in_range_message" msgid="6616864204007424228">"Red fuera de alcance"</string>
    <string name="wifi_forget" msgid="8168174695608386644">"Olvidar"</string>
    <string name="wifi_modify" msgid="6100248070440710782">"Modificar"</string>
    <string name="wifi_failed_forget_message" msgid="1348172929201654986">"No se pudo borrar la red."</string>
    <string name="wifi_save" msgid="3331121567988522826">"Guardar"</string>
    <string name="wifi_failed_save_message" msgid="6650004874143815692">"No se pudo guardar la red."</string>
    <string name="wifi_cancel" msgid="6763568902542968964">"Cancelar"</string>
    <string name="wifi_forget_dialog_title" msgid="6224151903586192426">"¿Quieres olvidar la red?"</string>
    <string name="wifi_forget_dialog_message" msgid="2337060138532166680">"Se borrarán todas las contraseñas de esta red"</string>
    <plurals name="wifi_saved_access_points_summary" formatted="false" msgid="6094679048871529675">
      <item quantity="other">%d redes</item>
      <item quantity="one">1 red</item>
    </plurals>
    <plurals name="wifi_saved_passpoint_access_points_summary" formatted="false" msgid="8256430439661111672">
      <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="2504425359919617586">
      <item quantity="other">%d redes y suscripciones</item>
      <item quantity="one">1 red y suscripción</item>
    </plurals>
    <string name="wifi_advanced_titlebar" msgid="4485841401774142908">"Config. avanzada de Wi-Fi"</string>
    <string name="wifi_advanced_ssid_title" msgid="1552309166043760291">"SSID"</string>
    <string name="wifi_advanced_mac_address_title" msgid="6571335466330978393">"Dirección MAC"</string>
    <string name="wifi_advanced_ip_address_title" msgid="6215297094363164846">"Dirección IP"</string>
    <string name="wifi_details_title" msgid="8954667664081737098">"Detalles de la red"</string>
    <string name="wifi_details_subnet_mask" msgid="6720279144174924410">"Máscara de subred"</string>
    <string name="wifi_details_dns" msgid="8648826607751830768">"DNS"</string>
    <string name="wifi_details_ipv6_address_header" msgid="6734119149106422148">"Direcciones IPv6"</string>
    <string name="wifi_saved_access_points_label" msgid="2013409399392285262">"Redes guardadas"</string>
    <string name="wifi_subscribed_access_points_tab" msgid="6480224551765489055">"Suscripciones"</string>
    <!-- no translation found for wifi_saved_access_points_tab (2659675386657663705) -->
    <skip />
    <string name="wifi_advanced_settings_label" msgid="3654366894867838338">"Configuración de IP"</string>
    <string name="wifi_advanced_not_available" msgid="5823045095444154586">"La configuración avanzada de Wi‑Fi no está disponible para este usuario"</string>
    <string name="wifi_ip_settings_menu_save" msgid="7296724066102908366">"Guardar"</string>
    <string name="wifi_ip_settings_menu_cancel" msgid="6582567330136502340">"Cancelar"</string>
    <string name="wifi_ip_settings_invalid_ip_address" msgid="2513142355364274970">"Escribe una dirección IP válida."</string>
    <string name="wifi_ip_settings_invalid_gateway" msgid="8164264988361096450">"Escribe una dirección de puerta de enlace válida."</string>
    <string name="wifi_ip_settings_invalid_dns" msgid="8744583948328391047">"Escribe una dirección DNS válida."</string>
    <string name="wifi_ip_settings_invalid_network_prefix_length" msgid="40470058023181052">"Escribe una longitud de prefijo de red entre 0 y 32."</string>
    <string name="wifi_dns1" msgid="7344118050720080045">"DNS 1"</string>
    <string name="wifi_dns2" msgid="1368601006824882659">"DNS 2"</string>
    <string name="wifi_gateway" msgid="163914742461092086">"Puerta de enlace"</string>
    <string name="wifi_network_prefix_length" msgid="3028785234245085998">"Longitud de prefijo de red"</string>
    <string name="wifi_p2p_settings_title" msgid="5444461191435291082">"Wi-Fi directo"</string>
    <string name="wifi_p2p_device_info" msgid="3191876744469364173">"Información del dispositivo"</string>
    <string name="wifi_p2p_persist_network" msgid="1646424791818168590">"Recordar esta conexión"</string>
    <string name="wifi_p2p_menu_search" msgid="3436429984738771974">"Buscar dispositivos"</string>
    <string name="wifi_p2p_menu_searching" msgid="2396704492143633876">"Buscando…"</string>
    <string name="wifi_p2p_menu_rename" msgid="8448896306960060415">"Cambiar el nombre del dispositivo"</string>
    <string name="wifi_p2p_peer_devices" msgid="299526878463303432">"Otros dispositivos"</string>
    <string name="wifi_p2p_remembered_groups" msgid="3847022927914068230">"Grupos recordados"</string>
    <string name="wifi_p2p_failed_connect_message" msgid="8491862096448192157">"No se pudo establecer conexión."</string>
    <string name="wifi_p2p_failed_rename_message" msgid="2562182284946936380">"Error al cambiar nombre del dispositivo"</string>
    <string name="wifi_p2p_disconnect_title" msgid="3216846049677448420">"¿Deseas desconectarte?"</string>
    <string name="wifi_p2p_disconnect_message" msgid="8227342771610125771">"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="3283805371034883105">"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="255267538099324413">"¿Quieres cancelar la invitación?"</string>
    <string name="wifi_p2p_cancel_connect_message" msgid="7477756213423749402">"¿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="834559380069647086">"¿Deseas borrar este grupo?"</string>
    <string name="wifi_hotspot_checkbox_text" msgid="7763495093333664887">"Hotspot de Wi-Fi"</string>
    <string name="wifi_hotspot_off_subtext" msgid="2199911382555864644">"No se está compartiendo Internet ni contenido con otros dispositivos"</string>
    <string name="wifi_hotspot_tethering_on_subtext" product="tablet" msgid="5936710887156133458">"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="5556202634866621632">"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="5017191966153008">"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="353306131026431089">"No se configuró una contraseña"</string>
    <string name="wifi_hotspot_name_title" msgid="8237000746618636778">"Nombre del hotspot"</string>
    <string name="wifi_hotspot_name_summary_connecting" msgid="3378299995508671967">"Activando <xliff:g id="WIFI_HOTSPOT_NAME">%1$s</xliff:g>…"</string>
    <string name="wifi_hotspot_name_summary_connected" msgid="3888672084861445362">"Otros dispositivos pueden conectarse a <xliff:g id="WIFI_HOTSPOT_NAME">%1$s</xliff:g>"</string>
    <string name="wifi_hotspot_password_title" msgid="8676859981917573801">"Contraseña del hotspot"</string>
    <string name="wifi_hotspot_ap_band_title" msgid="1165801173359290681">"Banda AP"</string>
    <string name="wifi_hotspot_footer_info_regular" msgid="4789553667374849566">"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="857988412470694109">"Las apps pueden crear un hotspot para compartir contenido con dispositivos cercanos."</string>
    <string name="wifi_hotspot_auto_off_title" msgid="1590313508558948079">"Desactivar el hotspot de manera automática"</string>
    <string name="wifi_hotspot_auto_off_summary" msgid="5858098059725925084">"Si no hay dispositivos conectados, se desactivará el hotspot de Wi‑Fi"</string>
    <string name="wifi_tether_starting" msgid="1322237938998639724">"Activando hotspot…"</string>
    <string name="wifi_tether_stopping" msgid="4835852171686388107">"Desactivando hotspot…"</string>
    <string name="wifi_tether_enabled_subtext" msgid="7842111748046063857">"<xliff:g id="NETWORK_SSID">%1$s</xliff:g> está activa"</string>
    <string name="wifi_tether_failed_subtext" msgid="1484941858530919002">"Error en hotspot de Wi-Fi portátil"</string>
    <string name="wifi_tether_configure_ap_text" msgid="7974681394041609308">"Configurar hotspot Wi-Fi"</string>
    <string name="wifi_hotspot_configure_ap_text" msgid="5478614731464220432">"Configuración de hotspot Wi-Fi"</string>
    <string name="wifi_hotspot_configure_ap_text_summary" msgid="5560680057727007011">"Hotspot WPA2 PSK de AndroidAP"</string>
    <string name="wifi_tether_configure_ssid_default" msgid="8467525402622138547">"Android Hotspot"</string>
    <string name="wifi_calling_settings_title" msgid="4102921303993404577">"Llamadas por Wi-Fi"</string>
    <string name="wifi_calling_suggestion_title" msgid="5702964371483390024">"Recibe más llamadas gracias a la red Wi‑Fi"</string>
    <string name="wifi_calling_suggestion_summary" msgid="1331793267608673739">"Activa Llamada con Wi‑Fi para extender la cobertura"</string>
    <string name="wifi_calling_mode_title" msgid="2164073796253284289">"Preferencia de llamada"</string>
    <string name="wifi_calling_mode_dialog_title" msgid="7105195222267749226">"Preferencia de llamada"</string>
    <string name="wifi_calling_roaming_mode_title" msgid="1565039047187685115">"Preferencia de la itinerancia"</string>
    <!-- no translation found for wifi_calling_roaming_mode_summary (8642014873060687717) -->
    <skip />
    <string name="wifi_calling_roaming_mode_dialog_title" msgid="7800926602662078576">"Preferencia de la itinerancia"</string>
  <string-array name="wifi_calling_mode_choices_v2">
    <item msgid="742988808283756263">"Wi-Fi"</item>
    <item msgid="7715869266611010880">"Móvil"</item>
    <item msgid="2838022395783120596">"Solo Wi-Fi"</item>
  </string-array>
  <string-array name="wifi_calling_mode_choices_v2_without_wifi_only">
    <item msgid="6132150507201243768">"Wi-Fi"</item>
    <item msgid="1118703915148755405">"Móvil"</item>
  </string-array>
    <string name="wifi_calling_mode_wifi_preferred_summary" msgid="9092988115148569860">"Si no hay ninguna red Wi-Fi disponible, usa una red móvil"</string>
    <string name="wifi_calling_mode_cellular_preferred_summary" msgid="240885549023046403">"Si la red móvil no está disponible, usa Wi-Fi"</string>
    <string name="wifi_calling_mode_wifi_only_summary" msgid="3688265826855460036">"Llamar mediante Wi-Fi. La llamada finalizará si se pierde la conexión."</string>
    <string name="wifi_calling_off_explanation" msgid="564780186974911501">"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="2329334487851497223"></string>
    <string name="emergency_address_title" msgid="932729250447887545">"Dirección de emergencia"</string>
    <string name="emergency_address_summary" msgid="7751971156196115129">"Se usa como tu ubicación cuando haces una llamada de emergencia mediante Wi-Fi"</string>
    <string name="private_dns_help_message" msgid="3299567069152568958"><annotation id="url">"Más información"</annotation>" sobre las funciones de DNS privado"</string>
    <string name="private_dns_mode_on" msgid="5882613439541371003">"Activado"</string>
    <string name="wifi_calling_pref_managed_by_carrier" msgid="6845711858866828986">"Configuración que administra el proveedor"</string>
    <string name="wifi_calling_settings_activation_instructions" msgid="7492509632478260955">"Habilitar Llamada por Wi-Fi"</string>
    <string name="wifi_calling_turn_on" msgid="1171403510313983983">"Activar Llamada por Wi-Fi"</string>
    <string name="wifi_calling_not_supported" msgid="7878640438907807754">"La Llamada por Wi‑Fi no es compatible con %1$s"</string>
    <string name="carrier" msgid="5264014738689761132">"Proveedor"</string>
    <string name="display_settings_title" msgid="1708697328627382561">"Pantalla"</string>
    <string name="sound_settings" msgid="5534671337768745343">"Sonido"</string>
    <string name="all_volume_title" msgid="4296957391257836961">"Volumen"</string>
    <string name="musicfx_title" msgid="3415566786340790345">"Efectos de la música"</string>
    <string name="ring_volume_title" msgid="5592466070832128777">"Volumen de tono"</string>
    <string name="vibrate_in_silent_title" msgid="3897968069156767036">"Vibrar en modo silencioso"</string>
    <string name="notification_sound_title" msgid="5137483249425507572">"Sonido de notificación predeterminado"</string>
    <string name="incoming_call_volume_title" msgid="8073714801365904099">"Tono de llamada"</string>
    <string name="notification_volume_title" msgid="2012640760341080408">"Notificación"</string>
    <string name="checkbox_notification_same_as_incoming_call" msgid="1073644356290338921">"Utilizar el volumen de las llamadas entrantes para las notificaciones"</string>
    <string name="home_work_profile_not_supported" msgid="1357721012342357037">"No admite perfiles de trabajo."</string>
    <string name="notification_sound_dialog_title" msgid="3805140135741385667">"Sonido de notificación predeterminado"</string>
    <string name="media_volume_title" msgid="3576565767317118106">"Medios"</string>
    <string name="media_volume_summary" msgid="5363248930648849974">"Establecer volumen para la música y los videos"</string>
    <string name="alarm_volume_title" msgid="2285597478377758706">"Alarma"</string>
    <string name="dock_settings_summary" msgid="455802113668982481">"Configuración de audio para la base adjunta"</string>
    <string name="dtmf_tone_enable_title" msgid="8533399267725365088">"Tonos táctiles del teclado de marcado"</string>
    <string name="sound_effects_enable_title" msgid="4429690369187229592">"Sonidos al presionar"</string>
    <string name="lock_sounds_enable_title" msgid="450098505659399520">"Sonido de bloqueo de pantalla"</string>
    <string name="audio_record_proc_title" msgid="4271091199976457534">"Cancelación por ruido"</string>
    <string name="volume_media_description" msgid="7949355934788807863">"Música, video, juegos y otros medios"</string>
    <string name="volume_ring_description" msgid="5936851631698298989">"Tono de llamada y notificaciones"</string>
    <string name="volume_notification_description" msgid="5810902320215328321">"Notificaciones"</string>
    <string name="volume_alarm_description" msgid="8322615148532654841">"Alarmas"</string>
    <string name="volume_ring_mute" msgid="3018992671608737202">"Silenciar tono y notificaciones"</string>
    <string name="volume_media_mute" msgid="3399059928695998166">"Silenciar música y otros archivos multimedia"</string>
    <string name="volume_notification_mute" msgid="7955193480006444159">"Silenciar notificaciones"</string>
    <string name="volume_alarm_mute" msgid="4452239420351035936">"Silenciar alarmas"</string>
    <string name="dock_settings" msgid="1820107306693002541">"Base"</string>
    <string name="dock_settings_title" msgid="9161438664257429372">"Configuración de la base"</string>
    <string name="dock_audio_settings_title" msgid="3324750259959570305">"Audio"</string>
    <string name="dock_audio_summary_desk" msgid="6487784412371139335">"Configuración para la base adjunta del escritorio"</string>
    <string name="dock_audio_summary_car" msgid="6740897586006248450">"Configuración para la base adjunta del automóvil"</string>
    <string name="dock_audio_summary_none" product="tablet" msgid="8215337394914283607">"El tablet no está en la estación"</string>
    <string name="dock_audio_summary_none" product="default" msgid="289909253741048784">"El dispositivo no se encuentra en la base"</string>
    <string name="dock_audio_summary_unknown" msgid="4465059868974255693">"Configuración para la base adjunta"</string>
    <string name="dock_not_found_title" msgid="3290961741828952424">"No se encontró la base"</string>
    <string name="dock_not_found_text" product="tablet" msgid="8405432495282299143">"Debes acoplar la tablet antes de configurar el audio del conector."</string>
    <string name="dock_not_found_text" product="default" msgid="1460497923342627801">"Debes acoplar el dispositivo antes de configurar el audio del conector."</string>
    <string name="dock_sounds_enable_title" msgid="885839627097024110">"Sonido al insertar el conector"</string>
    <string name="dock_sounds_enable_summary_on" product="tablet" msgid="838102386448981339">"Reproducir sonido cuando se inserte o elimine el tablet de la base."</string>
    <string name="dock_sounds_enable_summary_on" product="default" msgid="8491180514199743771">"Reproducir sonido al insertar o retirar el dispositivo de la base."</string>
    <string name="dock_sounds_enable_summary_off" product="tablet" msgid="4308252722466813560">"No reproducir sonido cuando se inserte o elimine un tablet de la base."</string>
    <string name="dock_sounds_enable_summary_off" product="default" msgid="2034927992716667672">"No reproducir sonido al insertar o retirar el dispositivo de la base."</string>
    <string name="account_settings" msgid="6403589284618783461">"Cuentas"</string>
    <string name="accessibility_category_work" msgid="4339262969083355720">"Cuentas de perfil de trabajo (<xliff:g id="MANAGED_BY">%s</xliff:g>)"</string>
    <string name="accessibility_category_personal" msgid="1263518850905945594">"Cuentas de perfil personal"</string>
    <string name="accessibility_work_account_title" msgid="1231830766637939527">"Cuenta de trabajo (<xliff:g id="MANAGED_BY">%s</xliff:g>)"</string>
    <string name="accessibility_personal_account_title" msgid="2169071663029067826">"Cuenta personal (<xliff:g id="MANAGED_BY">%s</xliff:g>)"</string>
    <string name="search_settings" msgid="1910951467596035063">"Buscar"</string>
    <string name="display_settings" msgid="7965901687241669598">"Pantalla"</string>
    <string name="accelerometer_title" msgid="7854608399547349157">"Girar automáticamente la pantalla"</string>
    <string name="color_mode_title" msgid="9186249332902370471">"Colores"</string>
    <string name="color_mode_option_natural" msgid="5013837483986772758">"Naturales"</string>
    <string name="color_mode_option_boosted" msgid="8588223970257287524">"Mejorados"</string>
    <string name="color_mode_option_saturated" msgid="4569683960058798843">"Saturados"</string>
    <string name="color_mode_option_automatic" msgid="7996505473528529568">"Automático"</string>
    <string name="color_mode_summary_natural" msgid="6624188642920403099">"Solo usar colores precisos"</string>
    <string name="color_mode_summary_automatic" msgid="4669516973360709431">"Ajustar entre colores vívidos y reales"</string>
    <string name="accelerometer_summary_on" product="tablet" msgid="429982132339828942">"Cambiar la orientación automáticamente al girar el tablet"</string>
    <string name="accelerometer_summary_on" product="default" msgid="1133737282813048021">"Cambiar la orientación automáticamente al girar el dispositivo"</string>
    <string name="accelerometer_summary_off" product="tablet" msgid="4781734213242521682">"Cambiar la orientación automáticamente al girar el tablet"</string>
    <string name="accelerometer_summary_off" product="default" msgid="5485489363715740761">"Cambiar la orientación automáticamente al girar el dispositivo"</string>
    <string name="brightness" msgid="8480105032417444275">"Nivel de brillo"</string>
    <string name="brightness_title" msgid="5746272622112982836">"Brillo"</string>
    <string name="brightness_summary" msgid="838917350127550703">"Ajustar el brillo de la pantalla"</string>
    <string name="auto_brightness_title" msgid="6341042882350279391">"Brillo automático"</string>
    <string name="auto_brightness_summary" msgid="5652108419977937800">"El brillo de la pantalla se justa al entorno"</string>
    <string name="auto_brightness_summary_on" msgid="3519854265558828744">"Activado"</string>
    <string name="auto_brightness_summary_off" msgid="2802336459335410626">"Inhabilitado"</string>
    <string name="auto_brightness_summary_very_low" msgid="6483976609035853764">"El nivel de brillo preferido es muy bajo"</string>
    <string name="auto_brightness_summary_low" msgid="5609877905833960427">"El nivel de brillo preferido es bajo"</string>
    <string name="auto_brightness_summary_default" msgid="7225666614394726845">"El nivel de brillo preferido es predeterminado"</string>
    <string name="auto_brightness_summary_high" msgid="7172304165631136027">"El nivel de brillo preferido es alto"</string>
    <string name="auto_brightness_summary_very_high" msgid="979277812582279078">"El nivel de brillo preferido es muy alto"</string>
    <string name="auto_brightness_off_title" msgid="2996864829946190795">"Inhabilitado"</string>
    <string name="auto_brightness_very_low_title" msgid="8252988638614126320">"Muy bajo"</string>
    <string name="auto_brightness_low_title" msgid="1632186441514863377">"Bajo"</string>
    <string name="auto_brightness_default_title" msgid="936771997353506620">"Predeterminado"</string>
    <string name="auto_brightness_high_title" msgid="2527853305981497345">"Alto"</string>
    <string name="auto_brightness_very_high_title" msgid="8867164854439331022">"Muy alto"</string>
    <string name="auto_brightness_subtitle" msgid="6454652530864093466">"Tu nivel preferido de brillo"</string>
    <string name="auto_brightness_off_summary" msgid="7629228736838155268">"No ajustar según la luz disponible"</string>
    <string name="auto_brightness_very_high_summary" msgid="4551003097086220709">"Mayor uso de batería"</string>
    <string name="auto_brightness_disclaimer" msgid="871436423746343406">"Optimiza el nivel de brillo según la luz disponible. También puedes ajustarlo temporalmente."</string>
    <string name="auto_brightness_description" msgid="7310335517128283729">"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="4093966473741329340">"Mostrar balance de blancos"</string>
    <string name="display_white_balance_summary" msgid="2432539678792029039"></string>
    <string name="adaptive_sleep_title" msgid="455088457232472047">"Atención a la pantalla"</string>
    <string name="adaptive_sleep_summary_on" msgid="410222811715459549">"Activado: No se apagará la pantalla si estás mirándola"</string>
    <string name="adaptive_sleep_summary_off" msgid="3099674463517017514">"Desactivado"</string>
    <string name="adaptive_sleep_title_no_permission" msgid="7893003608238361004">"Se requiere acceso a la cámara"</string>
    <string name="adaptive_sleep_summary_no_permission" msgid="2875851728693203108">"Presiona para administrar los permisos de los Servicios de personalización del dispositivo"</string>
    <string name="adaptive_sleep_description" msgid="3741651460279997459">"Impide que se apague la pantalla si estás mirándola"</string>
    <string name="adaptive_sleep_privacy" msgid="5335695648960686765">"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_summary" msgid="6922838078388927214">"Mantener la pantalla encendida mientras la miras"</string>
    <string name="night_display_title" msgid="2626451512200357686">"Luz nocturna"</string>
    <string name="night_display_text" msgid="1837277457033025056">"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="6574111412154833409">"Programa"</string>
    <string name="night_display_auto_mode_never" msgid="2483761922928753400">"Ninguno"</string>
    <string name="night_display_auto_mode_custom" msgid="2379394568898721765">"Activar a una hora personalizada"</string>
    <string name="night_display_auto_mode_twilight" msgid="589042813708244059">"Activar de atardecer a amanecer"</string>
    <string name="night_display_start_time_title" msgid="8918016772613689584">"Hora de inicio"</string>
    <string name="night_display_end_time_title" msgid="8286061578083519350">"Hora de finalización"</string>
    <string name="night_display_status_title" msgid="1784041143360286267">"Estado"</string>
    <string name="night_display_temperature_title" msgid="1435292789272017136">"Intensidad"</string>
    <string name="night_display_summary_off" msgid="1792750041697946539">"Desactivado/<xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="night_display_summary_off_auto_mode_never" msgid="3583590137322963513">"Nunca se activará automáticamente"</string>
    <string name="night_display_summary_off_auto_mode_custom" msgid="6365668239253173208">"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="3596291693781757392">"Se activará automáticamente al atardecer"</string>
    <string name="night_display_summary_on" msgid="1355713529996456744">"Activado/<xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="night_display_summary_on_auto_mode_never" msgid="9117830821363119835">"Nunca se desactivará automáticamente"</string>
    <string name="night_display_summary_on_auto_mode_custom" msgid="5510753572245577263">"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="852270120144683507">"Se desactivará automáticamente al amanecer"</string>
    <string name="night_display_activation_on_manual" msgid="277343561277625826">"Activar ahora"</string>
    <string name="night_display_activation_off_manual" msgid="4074557720918572883">"Desactivar ahora"</string>
    <string name="night_display_activation_on_twilight" msgid="6976051971534953845">"Activar hasta el amanecer"</string>
    <string name="night_display_activation_off_twilight" msgid="7196227685059907233">"Desactivar hasta el atardecer"</string>
    <string name="night_display_activation_on_custom" msgid="5472029024427933598">"Activar hasta la(s) <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="night_display_activation_off_custom" msgid="6169984658293744715">"Desactivar hasta la(s) <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="night_display_not_currently_on" msgid="6273540991113206401">"Luz nocturna no activada ahora"</string>
    <string name="screen_timeout" msgid="4882669461447531301">"Tiempo de espera de la pantalla"</string>
    <string name="screen_timeout_title" msgid="5130038655092628247">"Cuando se apaga la pantalla"</string>
    <string name="screen_timeout_summary" msgid="327761329263064327">"Después de <xliff:g id="TIMEOUT_DESCRIPTION">%1$s</xliff:g> de inactividad"</string>
    <string name="wallpaper_settings_title" msgid="5449180116365824625">"Fondo de pantalla"</string>
    <string name="style_and_wallpaper_settings_title" msgid="3608097576881470764">"Estilos y fondos de pantalla"</string>
    <string name="wallpaper_settings_summary_default" msgid="3395741565658711416">"Predeterminado"</string>
    <string name="wallpaper_settings_summary_custom" msgid="515035303981687172">"Personalizado"</string>
    <string name="wallpaper_suggestion_title" msgid="8583988696513822528">"Cambiar fondo de pantalla"</string>
    <string name="wallpaper_suggestion_summary" msgid="1579144009898110491">"Personalizar tu pantalla"</string>
    <string name="wallpaper_settings_fragment_title" msgid="519078346877860129">"Elegir fondo de pantalla"</string>
    <string name="style_suggestion_title" msgid="4710867417147087928">"Personaliza tu Pixel"</string>
    <string name="style_suggestion_summary" msgid="1811974280164432649">"Prueba diferentes estilos, fondos de pantalla y mucho más"</string>
    <string name="screensaver_settings_title" msgid="1770575686476851778">"Protector de pantalla"</string>
    <string name="screensaver_settings_summary_either_long" msgid="7302740999250873332">"Mientras se carga o está conectado"</string>
    <string name="screensaver_settings_summary_either_short" msgid="6140527286137331478">"En ambos casos"</string>
    <string name="screensaver_settings_summary_sleep" msgid="9086186698140423493">"Mientras se carga"</string>
    <string name="screensaver_settings_summary_dock" msgid="2072657401664633283">"Cuando está conectado"</string>
    <string name="screensaver_settings_summary_never" msgid="5165622985174349585">"Nunca"</string>
    <string name="screensaver_settings_summary_off" msgid="2481581696365146473">"Apagado"</string>
    <string name="screensaver_settings_disabled_prompt" msgid="1239088321034437608">"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="7262410541382890146">"Cuándo comenzar"</string>
    <string name="screensaver_settings_current" msgid="4663846038247130023">"Protector de pantalla actual"</string>
    <string name="screensaver_settings_dream_start" msgid="4998187847985120168">"Comenzar ahora"</string>
    <string name="screensaver_settings_button" msgid="7292214707625717013">"Configuración"</string>
    <string name="automatic_brightness" msgid="5014143533884135461">"Brillo automático"</string>
    <string name="lift_to_wake_title" msgid="4555378006856277635">"Levantar el dispositivo para activarlo"</string>
    <string name="ambient_display_screen_title" msgid="4252755516328775766">"Pantalla Ambiente"</string>
    <string name="ambient_display_category_triggers" msgid="4359289754456268573">"Cuándo mostrar"</string>
    <string name="doze_title" msgid="2375510714460456687">"Nuevas notificaciones"</string>
    <string name="doze_summary" msgid="3846219936142814032">"Activar la pantalla cuando haya notificaciones"</string>
    <string name="doze_always_on_title" msgid="1046222370442629646">"Siempre activada"</string>
    <string name="doze_always_on_summary" msgid="6978257596231155345">"Muestra la hora, los íconos de notificaciones y otra información. Aumenta el uso de la batería."</string>
    <string name="title_font_size" msgid="4405544325522105222">"Tamaño de fuente"</string>
    <string name="short_summary_font_size" msgid="6819778801232989076">"Aumenta o reduce el tamaño del texto en pantalla"</string>
    <string name="sim_lock_settings" msgid="3392331196873564292">"Bloqueo de la tarjeta SIM"</string>
    <string name="sim_lock_settings_category" msgid="6242052161214271091">"Bloqueo de la tarjeta SIM"</string>
    <string name="sim_lock_settings_summary_off" msgid="8028944267104896401">"Inhabilitado"</string>
    <string name="sim_lock_settings_summary_on" msgid="39103355956342985">"Bloqueado"</string>
    <string name="sim_lock_settings_title" msgid="9018585580955414596">"Bloqueo de la tarjeta SIM"</string>
    <string name="sim_pin_toggle" msgid="1742123478029451888">"Bloquear la tarjeta SIM"</string>
    <string name="sim_lock_on" product="tablet" msgid="5058355081270397764">"Se requiere PIN para utilizar el tablet"</string>
    <string name="sim_lock_on" product="default" msgid="2503536505568814324">"Se requiere PIN para utilizar el dispositivo"</string>
    <string name="sim_lock_off" product="tablet" msgid="2813800553917012356">"Se requiere PIN para utilizar el tablet"</string>
    <string name="sim_lock_off" product="default" msgid="258981978215428916">"Se requiere PIN para utilizar el dispositivo"</string>
    <string name="sim_pin_change" msgid="6311414184279932368">"Cambiar el PIN de la tarjeta SIM"</string>
    <string name="sim_enter_pin" msgid="6608715137008508432">"PIN de tarjeta SIM"</string>
    <string name="sim_enable_sim_lock" msgid="4517742794997166918">"Bloquear la tarjeta SIM"</string>
    <string name="sim_disable_sim_lock" msgid="7664729528754784824">"Desbloquear tarjeta SIM"</string>
    <string name="sim_enter_old" msgid="6074196344494634348">"PIN de tarjeta SIM anterior"</string>
    <string name="sim_enter_new" msgid="8742727032729243562">"Nuevo PIN de tarjeta SIM"</string>
    <string name="sim_reenter_new" msgid="6523819386793546888">"Volver a ingresar el nuevo PIN"</string>
    <string name="sim_change_pin" msgid="7328607264898359112">"PIN de tarjeta SIM"</string>
    <string name="sim_bad_pin" msgid="2345230873496357977">"PIN incorrecto"</string>
    <string name="sim_pins_dont_match" msgid="1695021563878890574">"Los PIN no coinciden"</string>
    <string name="sim_change_failed" msgid="3602072380172511475">"No se puede cambiar el PIN.\nPIN posiblemente incorrecto."</string>
    <string name="sim_change_succeeded" msgid="8556135413096489627">"El PIN de la tarjeta SIM se ha cambiado correctamente"</string>
    <string name="sim_lock_failed" msgid="2489611099235575984">"No se puede cambiar el estado de bloqueo de la tarjeta SIM.\nPIN posiblemente incorrecto."</string>
    <string name="sim_pin_disable_failed" msgid="7932981135799678220">"No se puede inhabilitar el PIN."</string>
    <string name="sim_pin_enable_failed" msgid="3414621075632931753">"No se puede habilitar el PIN."</string>
    <string name="sim_enter_ok" msgid="6475946836899218919">"Aceptar"</string>
    <string name="sim_enter_cancel" msgid="6240422158517208036">"Cancelar"</string>
    <string name="sim_multi_sims_title" msgid="9159427879911231239">"Se encontraron varias tarjetas SIM"</string>
    <string name="sim_multi_sims_summary" msgid="2698176447067691396">"Selecciona la SIM que prefieras usar para datos móviles."</string>
    <string name="sim_change_data_title" msgid="5045967581557404143">"¿Usar a <xliff:g id="CARRIER">%1$s</xliff:g> para datos móviles?"</string>
    <string name="sim_change_data_message" msgid="4307243848083368600">"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="7929746101841679535">"Usar <xliff:g id="CARRIER">%1$s</xliff:g>"</string>
    <string name="sim_preferred_title" msgid="5567909634636045268">"¿Actualizar tarjeta SIM?"</string>
    <string name="sim_preferred_message" msgid="8466930554330635780">"<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="4003655226832658066">"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="1582398808893048097">
      <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="pin_failed" msgid="1848423634948587645">"Error al desbloquear la tarjeta SIM con el PIN"</string>
    <string name="system_update_settings_list_item_title" msgid="3342887311059985961">"Actualiz. del sistema"</string>
    <string name="system_update_settings_list_item_summary" msgid="3853057315907710747"></string>
    <string name="firmware_version" msgid="4801135784886859972">"Versión de Android"</string>
    <string name="security_patch" msgid="8438384045870296634">"Nivel de parche de seguridad de Android"</string>
    <string name="model_info" msgid="1952009518045740889">"Modelo"</string>
    <string name="model_summary" msgid="8306235877567782987">"Modelo: %1$s"</string>
    <string name="hardware_info" msgid="2605080746512527805">"Modelo y hardware"</string>
    <string name="hardware_revision" msgid="8893547686367095527">"Versión de hardware"</string>
    <string name="fcc_equipment_id" msgid="149114368246356737">"ID del equipo"</string>
    <string name="baseband_version" msgid="1848990160763524801">"Versión de banda base"</string>
    <string name="kernel_version" msgid="9192574954196167602">"Versión de kernel"</string>
    <string name="build_number" msgid="3075795840572241758">"Número de compilación"</string>
    <string name="module_version" msgid="7329118610303805859">"Actualización del sistema de Google Play"</string>
    <string name="device_info_not_available" msgid="8062521887156825182">"No disponible"</string>
    <string name="device_status_activity_title" msgid="1411201799384697904">"Estado"</string>
    <string name="device_status" msgid="607405385799807324">"Estado"</string>
    <string name="device_status_summary" product="tablet" msgid="3292717754497039686">"Estado de la batería, la red y otra información"</string>
    <string name="device_status_summary" product="default" msgid="2599162787451519618">"Número de teléfono, señal, etc."</string>
    <string name="storage_settings" msgid="4211799979832404953">"Almacenamiento"</string>
    <string name="storage_settings_for_app" msgid="1922207623125501014">"Almacenamiento y caché"</string>
    <string name="storage_usb_settings" msgid="7293054033137078060">"Almacenamiento"</string>
    <string name="storage_settings_title" msgid="8746016738388094064">"Configuración de almacenamiento"</string>
    <string name="storage_settings_summary" product="nosdcard" msgid="3543813623294870759">"Desmontar almacenamiento USB, ver almacenamiento disponible"</string>
    <string name="storage_settings_summary" product="default" msgid="9176693537325988610">"Desmontar tarjeta SD, ver espacio de almacenamiento disponible"</string>
    <string name="imei_multi_sim" msgid="6387012961838800539">"IMEI (ranura de SIM %1$d)"</string>
    <string name="status_number" product="tablet" msgid="1138837891091222272">"MDN"</string>
    <string name="status_number" product="default" msgid="5948892105546651296">"Número de teléfono"</string>
    <string name="status_number_sim_slot" product="tablet" msgid="2755592991367858860">"MDN (ranura de SIM %1$d)"</string>
    <string name="status_number_sim_slot" product="default" msgid="1898212200138025729">"Teléfono (ranura de SIM %1$d)"</string>
    <string name="status_number_sim_status" product="tablet" msgid="1367110147304523864">"MDN en SIM"</string>
    <string name="status_number_sim_status" product="default" msgid="9123351360569466330">"Número de teléfono en SIM"</string>
    <string name="status_min_number" msgid="3519504522179420597">"MIN"</string>
    <string name="status_msid_number" msgid="909010114445780530">"MSID"</string>
    <string name="status_prl_version" msgid="1007470446618081441">"Versión de PRL"</string>
    <string name="meid_multi_sim" msgid="748999971744491771">"MEID (ranura de SIM %1$d)"</string>
    <string name="scanning_status_text_wifi_on_ble_on" msgid="5262263689045962681">"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="2115399719199757550">"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="3212656150021004088">"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="6381094990708345188">"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="1751442889111731088">"MEID"</string>
    <string name="status_icc_id" msgid="943368755577172747">"ICCID"</string>
    <string name="status_data_network_type" msgid="7570837037428932780">"Tipo de red de datos móviles"</string>
    <string name="status_voice_network_type" msgid="5663112239742353547">"Tipo de red de voz móvil"</string>
    <string name="status_latest_area_info" msgid="7222470836568238054">"Información del operador"</string>
    <string name="status_data_state" msgid="5503181397066522950">"Estado de red móvil"</string>
    <string name="status_esim_id" msgid="6456255368300906317">"EID"</string>
    <string name="status_service_state" msgid="2323931627519429503">"Estado del servicio"</string>
    <string name="status_signal_strength" msgid="3732655254188304547">"Potencia de la señal"</string>
    <string name="status_roaming" msgid="2638800467430913403">"Roaming"</string>
    <string name="status_operator" msgid="2274875196954742087">"Red"</string>
    <string name="status_wifi_mac_address" msgid="2202206684020765378">"Dirección MAC de Wi-Fi"</string>
    <string name="status_bt_address" msgid="4195174192087439720">"Dirección de Bluetooth"</string>
    <string name="status_serial_number" msgid="2257111183374628137">"Número de serie"</string>
    <string name="status_up_time" msgid="7294859476816760399">"Tiempo de actividad"</string>
    <string name="status_awake_time" msgid="2393949909051183652">"Hora de actividad"</string>
    <string name="internal_memory" msgid="9129595691484260784">"Almacenamiento interno"</string>
    <string name="sd_memory" product="nosdcard" msgid="2510246194083052841">"Almacenamiento USB"</string>
    <string name="sd_memory" product="default" msgid="151871913888051515">"Tarjeta SD"</string>
    <string name="memory_available" msgid="5052397223077021181">"Disponible"</string>
    <string name="memory_available_read_only" msgid="6497534390167920206">"Disponible (solo lectura)"</string>
    <string name="memory_size" msgid="6629067715017232195">"Espacio total"</string>
    <string name="memory_calculating_size" msgid="2188358544203768588">"Calculando…"</string>
    <string name="memory_apps_usage" msgid="5128673488173839077">"Aplicaciones y datos de aplicaciones"</string>
    <string name="memory_media_usage" msgid="3738830697707880405">"Medios"</string>
    <string name="memory_downloads_usage" msgid="3755173051677533027">"Descargas"</string>
    <string name="memory_dcim_usage" msgid="558887013613822577">"Imágenes, videos"</string>
    <string name="memory_music_usage" msgid="1363785144783011606">"Audio (música, tonos de teléfono, podcasts, etc.)"</string>
    <string name="memory_media_misc_usage" msgid="6094866738586451683">"Otros archivos"</string>
    <string name="memory_media_cache_usage" msgid="6704293333141177910">"Datos almacenados en caché"</string>
    <string name="sd_eject" product="nosdcard" msgid="4988563376492400073">"Desactivar alm. comp."</string>
    <string name="sd_eject" product="default" msgid="6915293408836853020">"Desmontar la tarjeta SD"</string>
    <string name="sd_eject_summary" product="nosdcard" msgid="5009296896648072891">"Desmontar el almacenamiento USB interno"</string>
    <string name="sd_eject_summary" product="default" msgid="3300599435073550246">"Desmonta la tarjeta SD para que puedas extraerla de forma segura"</string>
    <string name="sd_insert_summary" product="nosdcard" msgid="5264016886409577313">"Inserta USB"</string>
    <string name="sd_insert_summary" product="default" msgid="2048640010381803841">"Insertar una tarjeta SD para el montaje"</string>
    <string name="sd_mount" product="nosdcard" msgid="8966695015677343116">"Activar el almacenamiento USB"</string>
    <string name="sd_mount" product="default" msgid="5940523765187704135">"Montar tarjeta SD"</string>
    <string name="sd_mount_summary" product="nosdcard" msgid="4673411327373419641"></string>
    <string name="sd_mount_summary" product="default" msgid="4673411327373419641"></string>
    <string name="sd_format" product="nosdcard" msgid="2148179271623099054">"Eliminar almacenamiento USB"</string>
    <string name="sd_format" product="default" msgid="2576054280507119870">"Borrar tarjeta SD"</string>
    <string name="sd_format_summary" product="nosdcard" msgid="6331905044907914603">"Borra todos los datos del almacenamiento USB interno, como la música y las fotos"</string>
    <string name="sd_format_summary" product="default" msgid="212703692181793109">"Borra todos los datos de la tarjeta SD, como la música y las fotos"</string>
    <string name="memory_clear_cache_title" msgid="5423840272171286191">"¿Deseas borrar los datos almacenados en caché?"</string>
    <string name="memory_clear_cache_message" msgid="4550262490807415948">"Se borrarán datos en caché de las aplicaciones."</string>
    <string name="mtp_ptp_mode_summary" msgid="3710436114807789270">"La función MTP o PTP está activa."</string>
    <string name="dlg_confirm_unmount_title" product="nosdcard" msgid="3077285629197874055">"¿Desactivar almac. USB?"</string>
    <string name="dlg_confirm_unmount_title" product="default" msgid="3634502237262534381">"¿Desactivar tarjeta SD?"</string>
    <string name="dlg_confirm_unmount_text" product="nosdcard" msgid="4322636662873269018">"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="6998379994779187692">"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="4642742385125426529"></string>
    <string name="dlg_error_unmount_title" product="default" msgid="4642742385125426529"></string>
    <string name="dlg_error_unmount_text" product="nosdcard" msgid="9191518889746166147">"No se pudo desactivar el almacenamiento USB. Inténtalo de nuevo más tarde."</string>
    <string name="dlg_error_unmount_text" product="default" msgid="3500976899159848422">"No se pudo desactivar la tarjeta SD. Vuelve a intentarlo más tarde."</string>
    <string name="unmount_inform_text" product="nosdcard" msgid="7120241136790744265">"El almacenamiento USB se desmontará."</string>
    <string name="unmount_inform_text" product="default" msgid="1904212716075458402">"Se desactivará la tarjeta SD."</string>
    <string name="sd_ejecting_title" msgid="8824572198034365468">"Desmontando"</string>
    <string name="sd_ejecting_summary" msgid="2028753069184908491">"Desmontaje en progreso"</string>
    <string name="storage_low_title" msgid="1388569749716225155">"Poco espacio de almacenamiento"</string>
    <string name="storage_low_summary" msgid="7737465774892563129">"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="7141058657592615390">"Cambiar nombre"</string>
    <string name="storage_menu_mount" msgid="1014683672493425425">"Activar"</string>
    <string name="storage_menu_unmount" msgid="681485356885955898">"Expulsar"</string>
    <string name="storage_menu_format" msgid="7690626079653152152">"Formato"</string>
    <string name="storage_menu_format_public" msgid="7464714208010125682">"Formatear como almac. portátil"</string>
    <string name="storage_menu_format_private" msgid="546017531835902096">"Formatear como almac. interno"</string>
    <string name="storage_menu_migrate" msgid="3969621494238154294">"Migrar los datos"</string>
    <string name="storage_menu_forget" msgid="6305824238997983426">"Olvidar"</string>
    <string name="storage_menu_set_up" msgid="4263294929451685366">"Configurar"</string>
    <string name="storage_menu_explore" msgid="4637496051816521560">"Explorar"</string>
    <string name="storage_menu_free" msgid="6386070442027135427">"Liberar espacio"</string>
    <string name="storage_menu_manage" msgid="5914482953856430780">"Administrar el almacenamiento"</string>
    <string name="storage_title_usb" msgid="679612779321689418">"Conexión con comput. por USB"</string>
    <string name="usb_connection_category" msgid="7805945595165422882">"Conectarse como"</string>
    <string name="usb_mtp_title" msgid="3399663424394065964">"Dispositivo multimedia (MTP)"</string>
    <string name="usb_mtp_summary" msgid="4617321473211391236">"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="3852760810622389620">"Cámara (PTP)"</string>
    <string name="usb_ptp_summary" msgid="7406889433172511530">"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="3069990264258413994">"MIDI"</string>
    <string name="usb_midi_summary" msgid="539169474810956358">"Permite que las aplicaciones compatibles con MIDI funcionen con software MIDI mediante USB en tu computadora."</string>
    <string name="storage_other_users" msgid="808708845102611856">"Otros usuarios"</string>
    <string name="storage_internal_title" msgid="690771193137801021">"Almacenamiento del dispositivo"</string>
    <string name="storage_external_title" msgid="3433462910096848696">"Almacenamiento portátil"</string>
    <string name="storage_volume_summary" msgid="7023441974367853372">"<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="5691585991420946254">"<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="1303803057698959872">"En uso de <xliff:g id="TOTAL">%1$s</xliff:g> disponibles"</string>
    <string name="storage_volume_used_total" msgid="6113121714019000244">"Uso total de <xliff:g id="TOTAL">%1$s</xliff:g>"</string>
    <string name="storage_mount_success" msgid="687641090137253647">"Se activó <xliff:g id="NAME">%1$s</xliff:g>."</string>
    <string name="storage_mount_failure" msgid="1042621107954547316">"No se pudo activar <xliff:g id="NAME">%1$s</xliff:g>."</string>
    <string name="storage_unmount_success" msgid="5737203344673441677">"<xliff:g id="NAME">%1$s</xliff:g> se expulsó de forma segura."</string>
    <string name="storage_unmount_failure" msgid="5758387106579519489">"<xliff:g id="NAME">%1$s</xliff:g> no se pudo expulsar de forma segura."</string>
    <string name="storage_format_success" msgid="3023144070597190555">"Se formateó <xliff:g id="NAME">%1$s</xliff:g>."</string>
    <string name="storage_format_failure" msgid="6032640952779735766">"No se pudo formatear <xliff:g id="NAME">%1$s</xliff:g>."</string>
    <string name="storage_rename_title" msgid="8242663969839491485">"Renombrar almacenamiento"</string>
    <string name="storage_dialog_unmounted" msgid="6403320870103261477">"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="3732209361668282254">"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="4503128224360482228">"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="4018647158382548820">"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="3582802571684490057"><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="9028875424669047327">"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="1370847944388479245">"¿Deseas borrar <xliff:g id="NAME">^1</xliff:g>?"</string>
    <string name="storage_internal_forget_confirm" msgid="1148446041396902905">"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="6141154016753507490">"Aplicaciones"</string>
    <string name="storage_detail_images" msgid="6950678857740634769">"Imágenes"</string>
    <string name="storage_detail_videos" msgid="2919743464827110953">"Videos"</string>
    <string name="storage_detail_audio" msgid="1197685141676483213">"Audio"</string>
    <string name="storage_detail_cached" msgid="8547136365247818567">"Datos almacenados en caché"</string>
    <string name="storage_detail_other" msgid="8404938385075638238">"Otro"</string>
    <string name="storage_detail_system" msgid="4629506366064709687">"Sistema"</string>
    <string name="storage_detail_explore" msgid="7911344011431568294">"Explorar <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_detail_dialog_other" msgid="8845766044697204852">"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="862835644848361569">"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="3267254783294197804">"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="5085400514028585772">"Configurar el dispositivo <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_init_external_title" msgid="4867326438945303598">"Usar como medio de almacenamiento portátil"</string>
    <string name="storage_wizard_init_external_summary" msgid="7476105886344565074">"Para transferir fotos y otros archivos multimedia entre dispositivos"</string>
    <string name="storage_wizard_init_internal_title" msgid="9100613534261408519">"Usar como medio de almacenamiento interno"</string>
    <string name="storage_wizard_init_internal_summary" msgid="6240417501036216410">"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="2814021794538252546">"Formatear como almacenamiento"</string>
    <string name="storage_wizard_format_confirm_body" msgid="4401758710076806509">"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="4905690038882041566">"Formatear como almacen. portátil"</string>
    <string name="storage_wizard_format_confirm_public_body" msgid="1516932692920060272">"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="2774557300531702572">"Borrar y formatear"</string>
    <string name="storage_wizard_format_progress_title" msgid="6487352396450582292">"Formateando dispositivo (<xliff:g id="NAME">^1</xliff:g>)…"</string>
    <string name="storage_wizard_format_progress_body" msgid="3983764797223576658">"No extraigas <xliff:g id="NAME">^1</xliff:g> durante el proceso de formateo."</string>
    <string name="storage_wizard_migrate_title" msgid="1363078147938160407">"Transferir a almacenam. nuevo"</string>
    <string name="storage_wizard_migrate_body" msgid="890751699549542345">"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="4523444323744239143">"Transferir los datos ahora"</string>
    <string name="storage_wizard_migrate_later" msgid="3173482328116026253">"Transferir los datos más tarde"</string>
    <string name="storage_wizard_migrate_confirm_title" msgid="8564833529613286965">"Transferencia de datos"</string>
    <string name="storage_wizard_migrate_confirm_body" msgid="4212060581792135962"><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="5509475628423823202">"Transferir"</string>
    <string name="storage_wizard_migrate_progress_title" msgid="1665479429044202868">"Transfiriendo los datos…"</string>
    <string name="storage_wizard_migrate_details" msgid="3709728824651136227">"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="6553867088682695655">"Ya puedes usar <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_ready_external_body" msgid="2879508114260597474">"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="122532674037860197">"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="292782012677890250">"Transferir la aplicación <xliff:g id="APP">^1</xliff:g>"</string>
    <string name="storage_wizard_move_confirm_body" msgid="5176432115206478941">"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="1526216561023200694">"Para transferir datos, debes desbloquear al usuario <xliff:g id="APP">^1</xliff:g>."</string>
    <string name="storage_wizard_move_progress_title" msgid="4443920302548035674">"Transfiriendo la aplicación <xliff:g id="APP">^1</xliff:g>…"</string>
    <string name="storage_wizard_move_progress_body" msgid="7802577486578105609">"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="542047237524588792">"Cancelar transferencia"</string>
    <string name="storage_wizard_slow_body" msgid="8010127667184768025">"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="8858395869710288372">"¿Cómo usarás <xliff:g id="NAME">^1</xliff:g>?"</string>
    <string name="storage_wizard_init_v2_internal_title" product="tablet" msgid="4315585580670552654">"Almacenamiento adicional tablet"</string>
    <string name="storage_wizard_init_v2_internal_summary" product="tablet" msgid="570443086512059390">"Solo para apps, archivos y contenido multimedia de esta tablet"</string>
    <string name="storage_wizard_init_v2_internal_action" product="tablet" msgid="7760758592993284143">"Almacenamiento en tablet"</string>
    <string name="storage_wizard_init_v2_internal_title" product="default" msgid="8373070138732653456">"Almacenamiento adicional"</string>
    <string name="storage_wizard_init_v2_internal_summary" product="default" msgid="685194340141573218">"Solo para apps, archivos y contenido multimedia de este teléfono"</string>
    <string name="storage_wizard_init_v2_internal_action" product="default" msgid="904425171564310150">"Almacenamiento del teléfono"</string>
    <string name="storage_wizard_init_v2_or" msgid="1958295749349454436">"O bien"</string>
    <string name="storage_wizard_init_v2_external_title" msgid="3565348221712759463">"Almacenamiento portátil"</string>
    <string name="storage_wizard_init_v2_external_summary" msgid="801198071793584445">"Para transferir archivos y contenido multimedia entre dispositivos"</string>
    <string name="storage_wizard_init_v2_external_action" msgid="8662451480642784031">"Almacenamiento portátil"</string>
    <string name="storage_wizard_init_v2_later" msgid="1080613420170749130">"Configurar más tarde"</string>
    <string name="storage_wizard_format_confirm_v2_title" msgid="5744790239994621663">"¿Quieres formatear <xliff:g id="NAME">^1</xliff:g>?"</string>
    <string name="storage_wizard_format_confirm_v2_body" msgid="4614199613500900975">"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="8258363472135537500">"Formatear <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_migrate_v2_title" msgid="31406330052996898">"¿Transferir el contenido a <xliff:g id="NAME">^1</xliff:g>?"</string>
    <string name="storage_wizard_migrate_v2_body" product="tablet" msgid="4476553430145054781">"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="744760728669284385">"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="1239103359606165360">"Durante la transferencia:"</string>
    <string name="storage_wizard_migrate_v2_checklist_media" msgid="7176991995007075843">"No extraigas <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_migrate_v2_checklist_apps" msgid="3671266712947078734">"Algunas apps no funcionarán"</string>
    <string name="storage_wizard_migrate_v2_checklist_battery" product="tablet" msgid="346012901366624052">"Mantén la tablet cargada"</string>
    <string name="storage_wizard_migrate_v2_checklist_battery" product="default" msgid="3061158350109289521">"Mantén el teléfono cargado"</string>
    <string name="storage_wizard_migrate_v2_now" msgid="1279041707982039591">"Transferir contenido"</string>
    <string name="storage_wizard_migrate_v2_later" msgid="8201360307047198853">"Transferir contenido más tarde"</string>
    <string name="storage_wizard_migrate_progress_v2_title" msgid="1323344099111423785">"Transfiriendo contenido…"</string>
    <string name="storage_wizard_slow_v2_title" msgid="1318285829973607727">"<xliff:g id="NAME">^1</xliff:g> tiene un funcionamiento lento"</string>
    <string name="storage_wizard_slow_v2_body" msgid="6897444467730463117">"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="4126873669723115805">"Volver a empezar"</string>
    <string name="storage_wizard_slow_v2_continue" msgid="49399942893518218">"Continuar"</string>
    <string name="storage_wizard_ready_v2_external_body" msgid="11937346870534608">"Puedes transferir el contenido a <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_ready_v2_internal_body" msgid="4658433206901211269">"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="6239886818487538806">"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="9159414319574976203">"Estado de batería"</string>
    <string name="battery_level_title" msgid="2965679202786873272">"Nivel de la batería"</string>
    <string name="apn_settings" msgid="3743170484827528406">"APN"</string>
    <string name="apn_edit" msgid="1354715499708424718">"Editar pto. de acceso"</string>
    <string name="apn_not_set" msgid="4974192007399968164">"No definido"</string>
    <string name="apn_name" msgid="4115580098369824123">"Nombre"</string>
    <string name="apn_apn" msgid="2479425126733513353">"APN"</string>
    <string name="apn_http_proxy" msgid="1826885957243696354">"Proxy"</string>
    <string name="apn_http_port" msgid="3763259523984976226">"Puerto"</string>
    <string name="apn_user" msgid="455637547356117761">"Nombre de usuario"</string>
    <string name="apn_password" msgid="5412301994998250968">"Contraseña"</string>
    <string name="apn_server" msgid="2436185314756372858">"Servidor"</string>
    <string name="apn_mmsc" msgid="3670124402105585737">"MMSC"</string>
    <string name="apn_mms_proxy" msgid="5374082621073999275">"Proxy de MMS"</string>
    <string name="apn_mms_port" msgid="4074188088199243040">"Puerto MMS"</string>
    <string name="apn_mcc" msgid="4258628382260674636">"MCC"</string>
    <string name="apn_mnc" msgid="8629374076888809874">"MNC"</string>
    <string name="apn_auth_type" msgid="6167205395676037015">"Tipo de autenticación"</string>
    <string name="apn_auth_type_none" msgid="5069592676845549926">"Ninguno"</string>
    <string name="apn_auth_type_pap" msgid="1666934536996033383">"PAP"</string>
    <string name="apn_auth_type_chap" msgid="3369626283789068360">"CHAP"</string>
    <string name="apn_auth_type_pap_chap" msgid="9102343063036134541">"PAP o CHAP"</string>
    <string name="apn_type" msgid="469613123902220544">"Tipo de APN"</string>
    <string name="apn_protocol" msgid="3272222921649348640">"Protocolo APN"</string>
    <string name="apn_roaming_protocol" msgid="3386954381510788422">"Protocolo de APN en itinerancia"</string>
    <string name="carrier_enabled" msgid="407655861175280806">"Activar/Desactivar el APN"</string>
    <string name="carrier_enabled_summaryOn" msgid="6338915271908057531">"APN activado"</string>
    <string name="carrier_enabled_summaryOff" msgid="4300790190221203756">"APN inhabilitado"</string>
    <string name="bearer" msgid="594270280031923558">"Portador"</string>
    <string name="mvno_type" msgid="2543253857818336421">"Tipo de OMV"</string>
    <string name="mvno_match_data" msgid="4560671695220540466">"Valor de OMV"</string>
    <string name="menu_delete" msgid="6981294422841124659">"Eliminar APN"</string>
    <string name="menu_new" msgid="3014205883303921729">"APN nuevo"</string>
    <string name="menu_save" msgid="8109345640668285399">"Guardar"</string>
    <string name="menu_cancel" msgid="2194502410474697474">"Descartar"</string>
    <string name="error_title" msgid="7631322303341024692"></string>
    <string name="error_name_empty" msgid="5508155943840201232">"El campo Nombre no puede estar vacío."</string>
    <string name="error_apn_empty" msgid="4932211013600863642">"El APN no puede estar vacío."</string>
    <string name="error_mcc_not3" msgid="4560171714156251661">"El campo de MCC debe contener 3 dígitos."</string>
    <string name="error_mnc_not23" msgid="8418177072458379439">"El campo MNC debe contener 2 ó 3 dígitos."</string>
    <string name="error_adding_apn_type" msgid="4181334016628549645">"El proveedor no permite que se agreguen APN del tipo %s."</string>
    <string name="restore_default_apn" msgid="8178010218751639581">"Restaurando la configuración APN predeterminada"</string>
    <string name="menu_restore" msgid="8260067415075573273">"Restablecer valores predeterminados"</string>
    <string name="restore_default_apn_completed" msgid="2824775307377604897">"Se restableció la configuración predeterminada de APN."</string>
    <string name="reset_dashboard_title" msgid="6254873816990678620">"Opciones de restablecimiento"</string>
    <string name="reset_dashboard_summary" msgid="4851012632493522755">"Se pueden restablecer las redes, las apps y los dispositivos"</string>
    <string name="reset_network_title" msgid="6166025966016873843">"Restablecer configuración de Wi-Fi, datos móviles y Bluetooth"</string>
    <string name="reset_network_desc" msgid="5547979398298881406">"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="reset_esim_title" msgid="1979762943163078939">"Borrar tarjeta SIM descargada"</string>
    <string name="reset_esim_desc" msgid="5940105242448544634">"Para descargar tarjetas SIM de reemplazo, comunícate con tu proveedor. Esta acción no cancelará ningún plan de servicio móvil."</string>
    <string name="reset_network_button_text" msgid="2035676527471089853">"Restablecer configuración"</string>
    <string name="reset_network_final_desc" msgid="4690205209934596665">"¿Quieres restablecer toda la configuración de red? No podrás deshacer esta acción."</string>
    <string name="reset_network_final_desc_esim" msgid="6641433458865914227">"¿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="1797434793741744635">"Restablecer configuración"</string>
    <string name="reset_network_confirm_title" msgid="1759888886976962773">"¿Restablecer?"</string>
    <string name="network_reset_not_available" msgid="7188610385577164676">"El restablecimiento de la red no está disponible para este usuario."</string>
    <string name="reset_network_complete_toast" msgid="787829973559541880">"Se restableció la configuración de red."</string>
    <string name="reset_esim_error_title" msgid="2679159494023044398">"No se pueden borrar las tarjetas SIM"</string>
    <string name="reset_esim_error_msg" msgid="1356899750645220749">"No es posible borrar las tarjetas SIM descargadas debido a un error.\n\nReinicia el dispositivo y vuelve a intentarlo."</string>
    <string name="master_clear_title" msgid="3531267871084279512">"Borrar todos los datos (restablecer la configuración de fábrica)"</string>
    <string name="master_clear_short_title" msgid="8652450915870274285">"Borrar todos los datos"</string>
    <string name="master_clear_desc" product="tablet" msgid="2314458161059569301">"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="master_clear_desc" product="default" msgid="7647628092266675099">"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="master_clear_accounts" product="default" msgid="6412857499147999073">\n\n"Accediste a las siguientes cuentas:\n"</string>
    <string name="master_clear_other_users_present" product="default" msgid="5161423070702470742">\n\n"Hay otros usuarios presentes en este dispositivo.\n"</string>
    <string name="master_clear_desc_also_erases_external" msgid="1903185203791274237"><li>"Música"</li>\n<li>"Fotos"</li>\n<li>"Otros datos de usuario"</li></string>
    <string name="master_clear_desc_also_erases_esim" msgid="6008213558725767177"><li>"eSIM"</li></string>
    <string name="master_clear_desc_no_cancel_mobile_plan" msgid="5460926449093211144">\n\n"No se cancelará tu plan de servicio móvil."</string>
    <string name="master_clear_desc_erase_external_storage" product="nosdcard" msgid="7744115866662613411">\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="master_clear_desc_erase_external_storage" product="default" msgid="4801026652617377093">\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="969364037450286809">"Eliminar almacenamiento USB"</string>
    <string name="erase_external_storage" product="default" msgid="1397239046334307625">"Borrar tarjeta SD"</string>
    <string name="erase_external_storage_description" product="nosdcard" msgid="4728558173931599429">"Borra todos los datos del almacenamiento USB, como la música o las fotos."</string>
    <string name="erase_external_storage_description" product="default" msgid="1737638779582964966">"Borra todos los datos de la tarjeta SD, como música o fotos."</string>
    <string name="master_clear_button_text" product="tablet" msgid="1893179883931194922">"Borrar todos los datos"</string>
    <string name="master_clear_button_text" product="default" msgid="1893179883931194922">"Borrar todos los datos"</string>
    <string name="master_clear_final_desc" msgid="8219087639717327355">"Se borrarán las apps que hayas descargado y tu información personal. No podrás deshacer esta acción."</string>
    <string name="master_clear_final_desc_esim" msgid="4580223096319568030">"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="master_clear_final_button_text" msgid="5390908019019242910">"Eliminar todo"</string>
    <string name="master_clear_failed" msgid="2503230016394586353">"No se realizó ningún restablecimiento debido a que el servicio \"Eliminar sistema\" no está disponible."</string>
    <string name="master_clear_confirm_title" msgid="1134724452049918413">"¿Borrar todos los datos?"</string>
    <string name="master_clear_not_available" msgid="1000370707967468909">"El restablecimiento de la configuración de fábrica no está disponible para este usuario."</string>
    <string name="master_clear_progress_title" msgid="5194793778701994634">"Borrando"</string>
    <string name="master_clear_progress_text" msgid="6559096229480527510">"Espera un momento…"</string>
    <string name="call_settings_title" msgid="5188713413939232801">"Configuración"</string>
    <string name="call_settings_summary" msgid="7291195704801002886">"Establecer correo de voz, desvío de llamadas, llamada en espera, identificador de llamadas"</string>
    <string name="tether_settings_title_usb" msgid="6688416425801386511">"Conexión a red por USB"</string>
    <string name="tether_settings_title_wifi" msgid="3277144155960302049">"Hotspot portátil"</string>
    <string name="tether_settings_title_bluetooth" msgid="355855408317564420">"Conexión Bluetooth"</string>
    <string name="tether_settings_title_usb_bluetooth" msgid="5355828977109785001">"Compartir conexión"</string>
    <string name="tether_settings_title_all" msgid="3058586928118801157">"Hotspots y dispositivos portátiles"</string>
    <string name="tether_settings_summary_hotspot_on_tether_on" msgid="930464462687425777">"Hotspot activado, conexión mediante dispositivo portátil"</string>
    <string name="tether_settings_summary_hotspot_on_tether_off" msgid="3473671453891735907">"Hotspot activado"</string>
    <string name="tether_settings_summary_hotspot_off_tether_on" msgid="1618256180720077354">"Conexión mediante dispositivo portátil"</string>
    <string name="tether_settings_disabled_on_data_saver" msgid="1576908608463904152">"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="usb_title" msgid="7483344855356312510">"USB"</string>
    <string name="usb_tethering_button_text" msgid="585829947108007917">"Conexión a red por USB"</string>
    <string name="usb_tethering_subtext" product="default" msgid="3711893746716442706">"Compartir la conexión a Internet del teléfono mediante USB"</string>
    <string name="usb_tethering_subtext" product="tablet" msgid="2292916486612255069">"Compartir la conexión a Internet de la tablet mediante USB"</string>
    <string name="bluetooth_tether_checkbox_text" msgid="2379175828878753652">"Conexión Bluetooth"</string>
    <string name="bluetooth_tethering_subtext" product="tablet" msgid="8828883800511737077">"Compartir la conexión a Internet de la tablet mediante Bluetooth"</string>
    <string name="bluetooth_tethering_subtext" product="default" msgid="1904667146601254812">"Compartir la conexión a Internet del teléfono mediante Bluetooth"</string>
    <string name="bluetooth_tethering_off_subtext_config" msgid="376389105752995580">"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="2135590598511178690">"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="2871192409329334813">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g> ya no se anclará a red."</string>
    <string name="tethering_footer_info" msgid="7112228674056306147">"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_help_button_text" msgid="656117495547173630">"Ayuda"</string>
    <string name="network_settings_title" msgid="2876509814832830757">"Red móvil"</string>
    <string name="manage_mobile_plan_title" msgid="7630170375010107744">"Plan móvil"</string>
    <string name="sms_application_title" msgid="4903928270533250448">"SMS"</string>
    <string name="sms_change_default_dialog_title" msgid="1958688831875804286">"¿Quieres cambiar la aplicación de SMS?"</string>
    <string name="sms_change_default_dialog_text" msgid="1522783933230274787">"¿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="602683880284921998">"¿Quieres usar <xliff:g id="NEW_APP">%s</xliff:g> como la aplicación de SMS?"</string>
    <string name="network_scorer_picker_title" msgid="6383879578279046456">"Proveedor de calificación de red"</string>
    <string name="network_scorer_picker_none_preference" msgid="9028375117241790936">"Ninguno"</string>
    <string name="network_scorer_change_active_dialog_title" msgid="3776301550387574975">"¿Cambiar de asistente de Wi-Fi?"</string>
    <string name="network_scorer_change_active_dialog_text" msgid="8035173880322990715">"¿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="7444620909047611601">"¿Deseas usar <xliff:g id="NEW_APP">%s</xliff:g> para administrar tus conexiones de red?"</string>
    <string name="mobile_unknown_sim_operator" msgid="2156912373230276157">"Operador SIM desconocido"</string>
    <string name="mobile_no_provisioning_url" msgid="9053814051811634125">"<xliff:g id="OPERATOR">%1$s</xliff:g> no tiene ningún sitio web de aprovisionamiento"</string>
    <string name="mobile_insert_sim_card" msgid="9052590985784056395">"Inserta la tarjeta SIM y reinicia."</string>
    <string name="mobile_connect_to_internet" msgid="1733894125065249639">"Conéctate a Internet."</string>
    <string name="location_category_recent_location_requests" msgid="1938721350424447421">"Solicitudes de ubicaciones recientes"</string>
    <string name="location_recent_location_requests_see_all" msgid="9063541547120162593">"Ver todo"</string>
    <string name="location_category_location_services" msgid="7437150886946685979">"Servicios de ubicación"</string>
    <string name="location_title" msgid="1029961368397484576">"Mi ubicación"</string>
    <string name="managed_profile_location_switch_title" msgid="6712332547063039683">"Ubicación de perfil de trabajo"</string>
    <string name="location_app_level_permissions" msgid="2777033567595680764">"Permisos de la app"</string>
    <string name="location_app_permission_summary_location_off" msgid="2790918244874943070">"La ubicación está desactivada"</string>
    <plurals name="location_app_permission_summary_location_on" formatted="false" msgid="5336807018727349708">
      <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="4911449278675337490">"Acceso reciente a la ubicación"</string>
    <string name="location_recent_location_access_view_details" msgid="1955078513330927035">"Ver detalles"</string>
    <string name="location_no_recent_apps" msgid="2800907699722178041">"Ninguna aplicación solicitó la ubicación recientemente."</string>
    <string name="location_no_recent_accesses" msgid="7489449862187886009">"Ninguna app accedió recientemente a tu ubicación"</string>
    <string name="location_high_battery_use" msgid="517199943258508020">"Uso de batería alto"</string>
    <string name="location_low_battery_use" msgid="8602232529541903596">"Uso de batería bajo"</string>
    <string name="location_scanning_screen_title" msgid="2297479353298444503">"Búsqueda por Wi‑Fi y Bluetooth"</string>
    <string name="location_scanning_wifi_always_scanning_title" msgid="6216705505621183645">"Búsqueda de Wi‑Fi"</string>
    <string name="location_scanning_wifi_always_scanning_description" msgid="2691110218127379249">"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="5444989508204520019">"Búsqueda de dispositivos Bluetooth"</string>
    <string name="location_scanning_bluetooth_always_scanning_description" msgid="1285526059945206128">"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="4723268446874715222">"Servicios de ubicación para el trabajo"</string>
    <string name="location_network_based" msgid="9134175479520582215">"Ubicación de Wi-Fi y red móvil"</string>
    <string name="location_neighborhood_level" msgid="5141318121229984788">"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="4234820941954812210">"Ubicación determinada por Wi-Fi"</string>
    <string name="location_gps" msgid="8392461023569708478">"Satélites de GPS"</string>
    <string name="location_street_level" product="tablet" msgid="1669562198260860802">"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="4617445745492014203">"Permitir que las aplicaciones usen el sistema GPS de tu dispositivo para determinar tu ubicación"</string>
    <string name="assisted_gps" msgid="4649317129586736885">"Utilizar GPS asistido"</string>
    <string name="assisted_gps_enabled" msgid="8751899609589792803">"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="6982698333968010748">"Utilizar el servidor para asistir el GPS (anula la selección para mejorar el rendimiento del GPS)"</string>
    <string name="use_location_title" msgid="5206937465504979977">"Búsqueda de Google y ubicación"</string>
    <string name="use_location_summary" msgid="3978805802386162520">"Permitir que Google utilice tu ubicación para mejorar los resultados de búsqueda y otros servicios"</string>
    <string name="location_access_title" msgid="7064108942964081243">"Acceso a mi ubicación"</string>
    <string name="location_access_summary" msgid="69031404093194341">"Permitir que las aplicaciones que solicitaron permiso usen la información de tu ubicación"</string>
    <string name="location_sources_heading" msgid="1278732419851088319">"Fuentes de ubicación"</string>
    <string name="about_settings" product="tablet" msgid="593457295516533765">"Acerca de la tablet"</string>
    <string name="about_settings" product="default" msgid="1743378368185371685">"Acerca del dispositivo"</string>
    <string name="about_settings" product="device" msgid="6717640957897546887">"Acerca del dispositivo"</string>
    <string name="about_settings" product="emulator" msgid="221313099578564438">"Acerca del dispositivo emulado"</string>
    <string name="about_settings_summary" msgid="3371517697156165959">"Ver información legal, estado, versión de software del tablet"</string>
    <string name="legal_information" msgid="5769301644270604095">"Información legal"</string>
    <string name="contributors_title" msgid="5917703088825286504">"Colaboradores"</string>
    <string name="manual" msgid="3025943393642974445">"Manual"</string>
    <string name="regulatory_labels" msgid="1293050314122427492">"Etiquetas reglamentarias"</string>
    <string name="safety_and_regulatory_info" msgid="5103161279848427185">"Manual sobre reglamentación y seguridad"</string>
    <string name="copyright_title" msgid="865906688917260647">"Derechos de autor"</string>
    <string name="license_title" msgid="1990487604356037871">"Licencia"</string>
    <string name="module_license_title" msgid="258743239066841860">"Licencias de actualización del sistema de Play"</string>
    <string name="terms_title" msgid="7697580845616764642">"Términos y condiciones"</string>
    <string name="webview_license_title" msgid="2813507464175738967">"Licencia de WebView del sistema"</string>
    <string name="wallpaper_attributions" msgid="3645880512943433928">"Fondos de pantalla"</string>
    <string name="wallpaper_attributions_values" msgid="2996183537914690469">"Proveedores de imágenes satelitales:\n©2014 CNES / Astrium, DigitalGlobe, Bluesky"</string>
    <string name="settings_manual_activity_title" msgid="8133150693616006051">"Manual"</string>
    <string name="settings_manual_activity_unavailable" msgid="4752403782883814898">"Se produjo un error al cargar el manual."</string>
    <string name="settings_license_activity_title" msgid="8525014571806471216">"Licencias de terceros"</string>
    <string name="settings_license_activity_unavailable" msgid="4210539215951487627">"Hay un problema para cargar las licencias."</string>
    <string name="settings_license_activity_loading" msgid="3337535809093591740">"Cargando…"</string>
    <string name="settings_safetylegal_title" msgid="1289483965535937431">"Información de seguridad"</string>
    <string name="settings_safetylegal_activity_title" msgid="6901214628496951727">"Información de seguridad"</string>
    <string name="settings_safetylegal_activity_unreachable" msgid="142307697309858185">"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="8059022597639516348">"Cargando…"</string>
    <string name="confirm_device_credential_pin" msgid="5308435093406166355">"Usar PIN"</string>
    <string name="confirm_device_credential_pattern" msgid="1350321840134412900">"Usar patrón"</string>
    <string name="confirm_device_credential_password" msgid="2195705238498478704">"Usar contraseña"</string>
    <string name="lockpassword_choose_your_screen_lock_header" msgid="2942199737559900752">"Establecer bloqueo de pantalla"</string>
    <string name="lockpassword_choose_your_password_message" msgid="5377842480961577542">"Por motivos de seguridad, establece una contraseña"</string>
    <string name="lockpassword_choose_your_password_header_for_fingerprint" msgid="6624409510609085450">"Configura tu contraseña"</string>
    <string name="lockpassword_choose_your_pattern_header_for_fingerprint" msgid="5901096361617543819">"Configura el patrón"</string>
    <string name="lockpassword_choose_your_pin_message" msgid="6658264750811929338">"Por motivos de seguridad, establece un PIN"</string>
    <string name="lockpassword_choose_your_pin_header_for_fingerprint" msgid="765344692615917183">"Configura el PIN para usar la huella"</string>
    <string name="lockpassword_choose_your_pattern_message" msgid="8631545254345759087">"Por motivos de seguridad, establece un patrón"</string>
    <string name="lockpassword_confirm_your_password_header" msgid="1266027268220850931">"Vuelve a ingresar tu contraseña"</string>
    <string name="lockpassword_confirm_your_pattern_header" msgid="7543433733032330821">"Confirma el patrón"</string>
    <string name="lockpassword_confirm_your_pin_header" msgid="7744513791910572550">"Vuelve a ingresar el PIN"</string>
    <string name="lockpassword_confirm_passwords_dont_match" msgid="5140892109439191415">"Las contraseñas no coinciden"</string>
    <string name="lockpassword_confirm_pins_dont_match" msgid="7226244811505606217">"Los PIN no coinciden"</string>
    <string name="lockpassword_draw_your_pattern_again_header" msgid="2872194349688886781">"Dibuja el patrón una vez más"</string>
    <string name="lockpassword_choose_lock_generic_header" msgid="3811438094903786145">"Desbloquear la selección"</string>
    <string name="lockpassword_password_set_toast" msgid="4875050283108629383">"Se ha configurado la contraseña."</string>
    <string name="lockpassword_pin_set_toast" msgid="6011826444725291475">"Se ha configurado el PIN."</string>
    <string name="lockpassword_pattern_set_toast" msgid="6867259621331406236">"Se ha configurado el patrón."</string>
    <string name="lockpassword_choose_your_password_header_for_face" msgid="6696331060928616331">"Establece contraseña para desb. facial"</string>
    <string name="lockpassword_choose_your_pattern_header_for_face" msgid="3981667199682290816">"Establece patrón para Desbloqueo facial"</string>
    <string name="lockpassword_choose_your_pin_header_for_face" msgid="3692990199320431002">"Establece PIN para Desbloqueo facial"</string>
    <string name="lockpassword_confirm_your_pattern_generic" msgid="2920960858283879113">"Para continuar, usa el patrón del dispositivo"</string>
    <string name="lockpassword_confirm_your_pin_generic" msgid="4062335874438910487">"Para continuar, ingresa el PIN del dispositivo"</string>
    <string name="lockpassword_confirm_your_password_generic" msgid="3976394862548354966">"Para continuar, ingresa la contraseña del dispositivo"</string>
    <string name="lockpassword_confirm_your_pattern_generic_profile" msgid="4435638308193361861">"Para continuar, usa el patrón de tu perfil de trabajo"</string>
    <string name="lockpassword_confirm_your_pin_generic_profile" msgid="3730141667547002246">"Para continuar, ingresa el PIN de tu perfil de trabajo"</string>
    <string name="lockpassword_confirm_your_password_generic_profile" msgid="4250642723467019894">"Para continuar, ingresa la contraseña de tu perfil de trabajo"</string>
    <string name="lockpassword_strong_auth_required_device_pattern" msgid="530802132223800623">"Para mayor seguridad, usa el patrón de tu dispositivo"</string>
    <string name="lockpassword_strong_auth_required_device_pin" msgid="7829294830078036417">"Para mayor seguridad, ingresa el PIN de tu dispositivo"</string>
    <string name="lockpassword_strong_auth_required_device_password" msgid="3552644641574796973">"Para mayor seguridad, ingresa la contraseña de tu dispositivo"</string>
    <string name="lockpassword_strong_auth_required_work_pattern" msgid="3003781907040522053">"Para mayor seguridad, usa el patrón de tu perfil de trabajo"</string>
    <string name="lockpassword_strong_auth_required_work_pin" msgid="3367491332598821552">"Para mayor seguridad, ingresa el PIN de tu perfil de trabajo"</string>
    <string name="lockpassword_strong_auth_required_work_password" msgid="8159775129968582940">"Para mayor seguridad, ingresa la contraseña de tu perfil de trabajo"</string>
    <string name="lockpassword_confirm_your_pattern_details_frp" msgid="6757336656791723193">"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="826520613445990470">"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="8944081074615739040">"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="2898036091609128286">"Verificar patrón"</string>
    <string name="lockpassword_confirm_your_pin_header_frp" msgid="4141601774778898803">"Verificar PIN"</string>
    <string name="lockpassword_confirm_your_password_header_frp" msgid="3762615419295360480">"Verificar contraseña"</string>
    <string name="lockpassword_invalid_pin" msgid="15588049067548470">"PIN incorrecto"</string>
    <string name="lockpassword_invalid_password" msgid="4038507398784975200">"Contraseña incorrecta"</string>
    <string name="lockpattern_need_to_unlock_wrong" msgid="1745247595356012176">"Patrón incorrecto"</string>
    <string name="lock_settings_title" msgid="4213839087748988686">"Seguridad del dispositivo"</string>
    <string name="lockpattern_change_lock_pattern_label" msgid="5679630792003440352">"Cambiar patrón de desbloqueo"</string>
    <string name="lockpattern_change_lock_pin_label" msgid="266707138486731661">"Cambiar PIN de desbloqueo"</string>
    <string name="lockpattern_recording_intro_header" msgid="308287052221942814">"Dibuja un patrón de desbloqueo"</string>
    <string name="lockpattern_recording_intro_footer" msgid="1118579101409152113">"Presiona Menú para obtener ayuda."</string>
    <string name="lockpattern_recording_inprogress" msgid="6667844062721656773">"Levanta el dedo cuando termines."</string>
    <string name="lockpattern_recording_incorrect_too_short" msgid="1348234155120957561">"Une al menos <xliff:g id="NUMBER">%d</xliff:g> puntos. Vuelve a intentarlo."</string>
    <string name="lockpattern_pattern_entered_header" msgid="4316818983675591604">"Patrón registrado"</string>
    <string name="lockpattern_need_to_confirm" msgid="8054853451639221265">"Vuelve a trazar el patrón para confirmar."</string>
    <string name="lockpattern_pattern_confirmed_header" msgid="8455614172231880211">"Patrón de desbloqueo nuevo"</string>
    <string name="lockpattern_confirm_button_text" msgid="1128204343957002841">"Confirmar"</string>
    <string name="lockpattern_restart_button_text" msgid="3337574403350953926">"Revisar"</string>
    <string name="lockpattern_retry_button_text" msgid="3480423193273588166">"Borrar"</string>
    <string name="lockpattern_continue_button_text" msgid="4723771754714471410">"Continuar"</string>
    <string name="lockpattern_settings_title" msgid="3207750489460466680">"Patrón de desbloqueo"</string>
    <string name="lockpattern_settings_enable_title" msgid="6920616873671115281">"Requiere un patrón"</string>
    <string name="lockpattern_settings_enable_summary" msgid="1165707416664252167">"Debes dibujar el patrón para desbloquear la pantalla"</string>
    <string name="lockpattern_settings_enable_visible_pattern_title" msgid="2615606088906120711">"Hacer visible el patrón"</string>
    <string name="lockpattern_settings_enable_visible_pattern_title_profile" msgid="4864525074768391381">"Mostrar el patrón del perfil"</string>
    <string name="lockpattern_settings_enable_tactile_feedback_title" msgid="4389015658335522989">"Vibrar al presionar"</string>
    <string name="lockpattern_settings_enable_power_button_instantly_locks" msgid="5735444062633666327">"Botón de encendido bloquea"</string>
    <string name="lockpattern_settings_power_button_instantly_locks_summary" msgid="8196258755143711694">"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="1652352830005653447">"Conf. patrón de desbloq."</string>
    <string name="lockpattern_settings_change_lock_pattern" msgid="1123908306116495545">"Cambiar patrón de desbloqueo"</string>
    <string name="lockpattern_settings_help_how_to_record" msgid="2614673439060830433">"Cómo dibujar un patrón de desbloqueo"</string>
    <string name="lockpattern_too_many_failed_confirmation_attempts" msgid="6909161623701848863">"Demasiados intentos incorrectos. Vuelve a intentarlo en <xliff:g id="NUMBER">%d</xliff:g> segundos."</string>
    <string name="activity_not_found" msgid="5551664692991605325">"La aplicación no está instalada en tu dispositivo."</string>
    <string name="lock_settings_profile_title" msgid="2121876391814535295">"Seguridad del perfil de trabajo"</string>
    <string name="lock_settings_profile_screen_lock_title" msgid="3334747927367115256">"Bloqueo de pantalla del perfil de trabajo"</string>
    <string name="lock_settings_profile_unification_title" msgid="4973102698492659123">"Usar un mismo bloqueo"</string>
    <string name="lock_settings_profile_unification_summary" msgid="7178299172998641303">"Usa un mismo bloqueo para el perfil de trabajo y la pantalla del dispositivo"</string>
    <string name="lock_settings_profile_unification_dialog_title" msgid="4824620230229285301">"¿Deseas usar el mismo bloqueo?"</string>
    <string name="lock_settings_profile_unification_dialog_body" msgid="7128305504872026659">"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="3221303098797469900">"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="8249970828159656518">"Usar un mismo bloqueo"</string>
    <string name="lock_settings_profile_unification_dialog_uncompliant_confirm" msgid="5943758576756482777">"Usar un mismo bloqueo"</string>
    <string name="lock_settings_profile_unified_summary" msgid="9008819078132993492">"Igual al bloqueo de pantalla del dispositivo"</string>
    <string name="manageapplications_settings_title" msgid="7041951105633616745">"Administrar aplicaciones"</string>
    <string name="manageapplications_settings_summary" msgid="1794401500935451259">"Administrar y eliminar aplicaciones instaladas"</string>
    <string name="applications_settings" msgid="5281808652705396152">"Información de apps"</string>
    <string name="applications_settings_summary" msgid="6683465446264515367">"Administrar aplicaciones, configurar accesos directos de inicio rápido"</string>
    <string name="applications_settings_header" msgid="1014813055054356646">"Configuración de aplicación"</string>
    <string name="install_applications" msgid="4872012136210802181">"Fuentes desconocidas"</string>
    <string name="install_applications_title" msgid="4987712352256508946">"Permitir todas las fuentes"</string>
    <string name="recent_app_category_title" msgid="6673071268966003928">"Apps abiertas recientemente"</string>
    <string name="see_all_apps_title" msgid="1317153498074308438">"Ver las <xliff:g id="COUNT">%1$d</xliff:g> apps"</string>
    <string name="install_all_warning" product="tablet" msgid="8310489909586138165">"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="1952257127370115988">"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="3648003301476423145">"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="1777249286757067969">"Configuración avanzada"</string>
    <string name="advanced_settings_summary" msgid="4016682978071086747">"Activar más opciones de configuración"</string>
    <string name="application_info_label" msgid="5736524913065714880">"Info. de las apps"</string>
    <string name="storage_label" msgid="8700867073480107253">"Almacenamiento"</string>
    <string name="auto_launch_label" msgid="2669236885531442195">"Abrir de forma predet."</string>
    <string name="auto_launch_label_generic" msgid="3230569852551968694">"Valores predeterminados"</string>
    <string name="screen_compatibility_label" msgid="663250687205465394">"Compatibilidad de la pantalla"</string>
    <string name="permissions_label" msgid="2605296874922726203">"Permisos"</string>
    <string name="cache_header_label" msgid="1877197634162461830">"Memoria caché"</string>
    <string name="clear_cache_btn_text" msgid="5756314834291116325">"Borrar caché"</string>
    <string name="cache_size_label" msgid="7505481393108282913">"Memoria caché"</string>
    <plurals name="uri_permissions_text" formatted="false" msgid="3983110543017963732">
      <item quantity="other">%d elementos</item>
      <item quantity="one">1 elemento</item>
    </plurals>
    <string name="clear_uri_btn_text" msgid="8575655132961012158">"Borrar acceso"</string>
    <string name="controls_label" msgid="7611113077086853799">"Controles"</string>
    <string name="force_stop" msgid="7435006169872876756">"Forzar la detención"</string>
    <string name="total_size_label" msgid="1048676419552557254">"Total"</string>
    <string name="application_size_label" msgid="7376689739076506885">"Tamaño de la app"</string>
    <string name="external_code_size_label" msgid="3459343140355961335">"Aplicación en el almacenamiento USB"</string>
    <string name="data_size_label" msgid="6117971066063850416">"Datos del usuario"</string>
    <string name="external_data_size_label" product="nosdcard" msgid="7533821466482000453">"Datos en el almacenamiento USB"</string>
    <string name="external_data_size_label" product="default" msgid="626414192825329708">"Tarjeta SD"</string>
    <string name="uninstall_text" msgid="3644892466144802466">"Desinstalar..."</string>
    <string name="uninstall_all_users_text" msgid="851857393177950340">"Desinstalar en todos los usuarios"</string>
    <string name="install_text" msgid="884360662922471113">"Instalar"</string>
    <string name="disable_text" msgid="6544054052049395202">"Inhabilitar"</string>
    <string name="enable_text" msgid="9217362512327828987">"Habilitar"</string>
    <string name="clear_user_data_text" msgid="355574089263023363">"Liberar espacio de almacenamiento"</string>
    <string name="app_factory_reset" msgid="6635744722502563022">"Desinstalar las actualizaciones"</string>
    <string name="auto_launch_enable_text" msgid="4275746249511874845">"Has elegido lanzar esta aplicación de manera predeterminada para algunas acciones."</string>
    <string name="always_allow_bind_appwidgets_text" msgid="566822577792032925">"Decidiste permitir que esta aplicación pueda crear widgets y acceder a sus datos."</string>
    <string name="auto_launch_disable_text" msgid="7800385822185540166">"No hay configuraciones predeterminadas establecidas."</string>
    <string name="clear_activities" msgid="7408923511535174430">"Borrar valores predeterminados"</string>
    <string name="screen_compatibility_text" msgid="1616155457673106022">"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="7225195569089607846">"Preguntar cuando se lanza"</string>
    <string name="enable_compatibility" msgid="5806819252068617811">"Aplicación en escala"</string>
    <string name="unknown" msgid="1592123443519355854">"Desconocido"</string>
    <string name="sort_order_alpha" msgid="1410278099123670628">"Ordenar por nombre"</string>
    <string name="sort_order_size" msgid="7024513286636502362">"Ordenar por tamaño"</string>
    <string name="sort_order_recent_notification" msgid="6064103501358974282">"Más recientes"</string>
    <string name="sort_order_frequent_notification" msgid="1733204081305830670">"Más frecuentes"</string>
    <string name="show_running_services" msgid="5736278767975544570">"Mostrar los servicios en ejecución"</string>
    <string name="show_background_processes" msgid="2009840211972293429">"Procesos en caché"</string>
    <string name="default_emergency_app" msgid="1951760659640369980">"Aplicación de emergencia"</string>
    <string name="reset_app_preferences" msgid="1321050641018356925">"Restablecer preferencias de apps"</string>
    <string name="reset_app_preferences_title" msgid="6093179367325336662">"¿Restablecer preferencias?"</string>
    <string name="reset_app_preferences_desc" msgid="731757609326016760">"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="2559089511841281242">"Restablecer apps"</string>
    <string name="manage_space_text" msgid="8852711522447794676">"Administrar el espacio"</string>
    <string name="filter" msgid="2018011724373033887">"Filtro"</string>
    <string name="filter_dlg_title" msgid="8693024463731076091">"Elegir opciones de filtro"</string>
    <string name="filter_apps_all" msgid="8899612398848280352">"Todas las apps"</string>
    <string name="filter_apps_disabled" msgid="5862632369555319938">"Apps inhabilitadas"</string>
    <string name="filter_apps_third_party" msgid="7786348047690140979">"Descargado"</string>
    <string name="filter_apps_running" msgid="7767071454371350486">"En ejecución"</string>
    <string name="filter_apps_onsdcard" product="nosdcard" msgid="4843063154701023349">"Almacenamiento USB"</string>
    <string name="filter_apps_onsdcard" product="default" msgid="1477351142334784771">"En tarjeta SD"</string>
    <string name="not_installed" msgid="2797554494953450291">"No instalada para este usuario"</string>
    <string name="installed" msgid="3070865169422600098">"Instalada"</string>
    <string name="no_applications" msgid="7336588977497084921">"No hay aplicaciones."</string>
    <string name="internal_storage" msgid="1584700623164275282">"Almacenamiento interno"</string>
    <string name="recompute_size" msgid="7722567982831691718">"Recalculando el tamaño…"</string>
    <string name="clear_data_dlg_title" msgid="5605258400134511197">"¿Borrar los datos de la app?"</string>
    <string name="clear_data_dlg_text" msgid="3951297329833822490">"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="2402639055725653590">"Aceptar"</string>
    <string name="dlg_cancel" msgid="1674753358972975911">"Cancelar"</string>
    <string name="app_not_found_dlg_title" msgid="3127123411738434964"></string>
    <string name="app_not_found_dlg_text" msgid="4893589904687340011">"La aplicación no está en la lista de aplicaciones instaladas."</string>
    <string name="clear_failed_dlg_text" msgid="8651231637137025815">"No se pudo liberar espacio de almacenamiento de la app."</string>
    <string name="join_two_items" msgid="1336880355987539064">"<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="1873827777191260824">"<xliff:g id="FIRST_ITEM">%1$s</xliff:g>, <xliff:g id="SECOND_ITEM">%2$s</xliff:g>"</string>
    <string name="computing_size" msgid="1599186977475211186">"Calculando..."</string>
    <string name="invalid_size_value" msgid="1582744272718752951">"No se pudo calcular el tamaño del paquete."</string>
    <string name="version_text" msgid="9189073826278676425">"versión <xliff:g id="VERSION_NUM">%1$s</xliff:g>"</string>
    <string name="move_app" msgid="5042838441401731346">"Mover"</string>
    <string name="move_app_to_internal" product="tablet" msgid="2299714147283854957">"Mover al tablet"</string>
    <string name="move_app_to_internal" product="default" msgid="3895430471913858185">"Mover al dispositivo"</string>
    <string name="move_app_to_sdcard" product="nosdcard" msgid="4350451696315265420">"Mover a almacenamiento USB"</string>
    <string name="move_app_to_sdcard" product="default" msgid="1143379049903056407">"Mover a la tarjeta SD"</string>
    <string name="another_migration_already_in_progress" msgid="7817354268848365487">"Hay otra migración en curso."</string>
    <string name="insufficient_storage" msgid="481763122991093080">"No hay suficiente espacio de almacenamiento."</string>
    <string name="does_not_exist" msgid="1501243985586067053">"La aplicación no existe."</string>
    <string name="invalid_location" msgid="4354595459063675191">"La ubicación de la instalación no es válida."</string>
    <string name="system_package" msgid="1352722848400644991">"Las actualizaciones del sistema no se pueden instalar en medios externos."</string>
    <string name="move_error_device_admin" msgid="8673026002690505763">"No se puede instalar la app de administración de dispositivos en medios externos"</string>
    <string name="force_stop_dlg_title" msgid="977530651470711366">"¿Deseas forzar la detención?"</string>
    <string name="force_stop_dlg_text" msgid="7208364204467835578">"Si fuerzas la detención de una aplicación, es posible que funcione incorrectamente."</string>
    <string name="app_install_location_title" msgid="2068975150026852168">"Ubicación de instalación preferida"</string>
    <string name="app_install_location_summary" msgid="5155453752692959098">"Cambiar la ubicación de instalación preferida para nuevas aplicaciones"</string>
    <string name="app_disable_dlg_positive" msgid="7375627244201714263">"Inhabilitar la aplicación"</string>
    <string name="app_disable_dlg_text" msgid="1234624266290478136">"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="7669264654851761857">"¿Desactivar notificaciones?"</string>
    <string name="app_install_details_group_title" msgid="7084623031296083574">"Store"</string>
    <string name="app_install_details_title" msgid="6905279702654975207">"Detalles de la app"</string>
    <string name="app_install_details_summary" msgid="6464796332049327547">"App instalada desde <xliff:g id="APP_STORE">%1$s</xliff:g>"</string>
    <string name="instant_app_details_summary" msgid="4529934403276907045">"Más información en <xliff:g id="APP_STORE">%1$s</xliff:g>"</string>
    <string name="app_ops_running" msgid="7706949900637284122">"En curso"</string>
    <string name="app_ops_never_used" msgid="9114608022906887802">"(Sin utilizar)"</string>
    <string name="no_default_apps" msgid="2915315663141025400">"Sin aplicaciones predet."</string>
    <string name="storageuse_settings_title" msgid="5657014373502630403">"Uso del almacenamiento"</string>
    <string name="storageuse_settings_summary" msgid="3748286507165697834">"Ver el almacenamiento que usan las aplicaciones"</string>
    <string name="service_restarting" msgid="2242747937372354306">"Volver a comenzar"</string>
    <string name="cached" msgid="1059590879740175019">"Proceso de fondo almacenado en memoria caché"</string>
    <string name="no_running_services" msgid="2059536495597645347">"No hay nada en ejecución."</string>
    <string name="service_started_by_app" msgid="818675099014723551">"Iniciado por aplicación"</string>
    <!-- no translation found for service_client_name (4037193625611815517) -->
    <skip />
    <string name="service_background_processes" msgid="6844156253576174488">"<xliff:g id="MEMORY">%1$s</xliff:g> libre"</string>
    <string name="service_foreground_processes" msgid="7583975676795574276">"<xliff:g id="MEMORY">%1$s</xliff:g> en uso"</string>
    <string name="memory" msgid="6609961111091483458">"RAM"</string>
    <!-- no translation found for service_process_name (4098932168654826656) -->
    <skip />
    <string name="running_process_item_user_label" msgid="3129887865552025943">"Usuario: <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="running_process_item_removed_user_label" msgid="8250168004291472959">"Usuario eliminado"</string>
    <string name="running_processes_item_description_s_s" msgid="5790575965282023145">"<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="8019860457123222953">"<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="744424668287252915">"<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="1607384595790852782">"<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="6588371727640789560">"Memoria del dispositivo"</string>
    <string name="running_processes_header_footer" msgid="723908176275428442">"RAM usada por las aplicaciones"</string>
    <string name="running_processes_header_system_prefix" msgid="6104153299581682047">"Sistema"</string>
    <string name="running_processes_header_apps_prefix" msgid="5787594452716832727">"Aplicaciones"</string>
    <string name="running_processes_header_free_prefix" msgid="4620613031737078415">"Libre"</string>
    <string name="running_processes_header_used_prefix" msgid="5924288703085123978">"En uso"</string>
    <string name="running_processes_header_cached_prefix" msgid="7950853188089434987">"En caché"</string>
    <string name="running_processes_header_ram" msgid="996092388884426817">"<xliff:g id="RAM_0">%1$s</xliff:g> de RAM"</string>
    <string name="runningservicedetails_settings_title" msgid="3224004818524731568">"Aplicación en ejecución"</string>
    <string name="no_services" msgid="7133900764462288263">"Inactivo"</string>
    <string name="runningservicedetails_services_title" msgid="391168243725357375">"Servicios"</string>
    <string name="runningservicedetails_processes_title" msgid="928115582044655268">"Procesos"</string>
    <string name="service_stop" msgid="6369807553277527248">"Detener"</string>
    <string name="service_manage" msgid="1876642087421959194">"Configuración"</string>
    <string name="service_stop_description" msgid="9146619928198961643">"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="6050413065144035971">"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="3834163804031287685">"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="479683614471552426">"<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="1130702347066340890">"Proceso principal en uso."</string>
    <string name="process_service_in_use_description" msgid="8993335064403217080">"El servicio <xliff:g id="COMP_NAME">%1$s</xliff:g> está en uso."</string>
    <string name="process_provider_in_use_description" msgid="5586603325677678940">"El proveedor <xliff:g id="COMP_NAME">%1$s</xliff:g> está en uso."</string>
    <string name="runningservicedetails_stop_dlg_title" msgid="4253292537154337233">"¿Deseas detener el servicio?"</string>
    <string name="runningservicedetails_stop_dlg_text" product="tablet" msgid="3371302398335665793">"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="3920243762189484756">"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="8749227808244881255">"Idiomas, entrada y gestos"</string>
    <string name="language_input_gesture_summary_on_with_assist" msgid="7219895055450633449"></string>
    <string name="language_input_gesture_summary_on_non_assist" msgid="756147879200943161"></string>
    <string name="language_input_gesture_summary_off" msgid="4617198819416948217"></string>
    <string name="language_settings" msgid="8758655933029560944">"Idiomas y entradas"</string>
    <string name="language_empty_list_user_restricted" msgid="5984015900102140696">"No tienes permiso para cambiar el idioma del dispositivo."</string>
    <string name="language_keyboard_settings_title" msgid="3709159207482544398">"Idiomas y entradas"</string>
    <string name="input_assistance" msgid="7392740255874966807">"Herramientas"</string>
    <string name="keyboard_settings_category" msgid="8275523930352487827">"Teclado y métodos de entrada"</string>
    <string name="phone_language" msgid="7116581601133118044">"Idiomas"</string>
    <string name="phone_language_summary" msgid="3871309445655554211"></string>
    <string name="auto_replace" msgid="6199184757891937822">"Reemplazar automát."</string>
    <string name="auto_replace_summary" msgid="370288728200084466">"Corregir palabras mal escritas"</string>
    <string name="auto_caps" msgid="6379232078052591265">"Uso de mayúsculas automático"</string>
    <string name="auto_caps_summary" msgid="6358102538315261466">"Escribir con mayúscula la primera letra en las oraciones"</string>
    <string name="auto_punctuate" msgid="4595367243950425833">"Puntuación automática"</string>
    <string name="hardkeyboard_category" msgid="5957168411305769899">"Configuración de teclado físico"</string>
    <string name="auto_punctuate_summary" msgid="4372126865670574837">"Presionar la tecla de espacio dos veces para insertar \".\""</string>
    <string name="show_password" msgid="4837897357002495384">"Mostrar contraseñas"</string>
    <string name="show_password_summary" msgid="3365397574784829969">"Mostrar caracteres brevemente mientras escribes"</string>
    <string name="spellchecker_security_warning" msgid="9060897418527708922">"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="246728645150092058">"Configuración"</string>
    <string name="spellchecker_language" msgid="6041050114690541437">"Idioma"</string>
    <string name="keyboard_and_input_methods_category" msgid="4580907662493721491">"Teclados"</string>
    <string name="virtual_keyboard_category" msgid="1012830752318677119">"Teclado virtual"</string>
    <string name="available_virtual_keyboard_category" msgid="7645766574969139819">"Teclado virtual disponible"</string>
    <string name="add_virtual_keyboard" msgid="3302152381456516928">"Administrar teclados"</string>
    <string name="keyboard_assistance_category" msgid="5843634175231134014">"Ayuda del teclado"</string>
    <string name="physical_keyboard_title" msgid="8285149877925752042">"Teclado físico"</string>
    <string name="show_ime" msgid="2658582193437188227">"Mostrar teclado virtual"</string>
    <string name="show_ime_summary" msgid="8164993045923240698">"Mantener en la pantalla cuando el teclado físico esté activo"</string>
    <string name="keyboard_shortcuts_helper" msgid="4839453720463798145">"Asistente de combinación de teclas"</string>
    <string name="keyboard_shortcuts_helper_summary" msgid="5871299901459743288">"Mostrar accesos directos disponibles"</string>
    <string name="language_and_input_for_work_category_title" msgid="3825906835886710498">"Teclados y herramientas del perfil de trabajo"</string>
    <string name="virtual_keyboards_for_work_title" msgid="2646946676585390499">"Teclado virtual para el trabajo"</string>
    <string name="default_keyboard_layout" msgid="4172606673510531271">"Predeterminadas"</string>
    <string name="pointer_speed" msgid="1221342330217861616">"Velocidad del puntero"</string>
    <string name="game_controller_settings_category" msgid="8794508575329923718">"Controlador de juegos"</string>
    <string name="vibrate_input_devices" msgid="421936611134697943">"Redireccionar vibración"</string>
    <string name="vibrate_input_devices_summary" msgid="82093256723774584">"Enviar la vibración al controlador de juegos cuando esté conectado"</string>
    <string name="keyboard_layout_dialog_title" msgid="8030087214949381372">"Elegir el diseño de teclado"</string>
    <string name="keyboard_layout_dialog_setup_button" msgid="8514583747236476384">"Configurar diseños de teclado"</string>
    <string name="keyboard_layout_dialog_switch_hint" msgid="3889961090676293795">"Para cambiar, presiona Ctrl+espacio."</string>
    <string name="keyboard_layout_default_label" msgid="2952672513543482165">"Predeterminado"</string>
    <string name="keyboard_layout_picker_title" msgid="556081931972771610">"Diseños de teclado"</string>
    <string name="user_dict_settings_title" msgid="3427169369758733521">"Diccionario personal"</string>
    <string name="user_dict_settings_for_work_title" msgid="7634659414713254169">"Diccionario personal para el trabajo"</string>
    <string name="user_dict_settings_summary" msgid="7965571192902870454"></string>
    <string name="user_dict_settings_add_menu_title" msgid="4056762757149923551">"Agregar"</string>
    <string name="user_dict_settings_add_dialog_title" msgid="4702613990174126482">"Agregar al diccionario"</string>
    <string name="user_dict_settings_add_screen_title" msgid="742580720124344291">"Frase"</string>
    <string name="user_dict_settings_add_dialog_more_options" msgid="8848798370746019825">"Más opciones"</string>
    <string name="user_dict_settings_add_dialog_less_options" msgid="2441785268726036101">"Menos opciones"</string>
    <string name="user_dict_settings_add_dialog_confirm" msgid="6225823625332416144">"Aceptar"</string>
    <string name="user_dict_settings_add_word_option_name" msgid="7868879174905963135">"Palabra:"</string>
    <string name="user_dict_settings_add_shortcut_option_name" msgid="660089258866063925">"Acceso directo:"</string>
    <string name="user_dict_settings_add_locale_option_name" msgid="5696358317061318532">"Idioma:"</string>
    <string name="user_dict_settings_add_word_hint" msgid="5725254076556821247">"Escribe una palabra"</string>
    <string name="user_dict_settings_add_shortcut_hint" msgid="7333763456561873445">"Acceso directo opcional"</string>
    <string name="user_dict_settings_edit_dialog_title" msgid="8967476444840548674">"Modificar palabra"</string>
    <string name="user_dict_settings_context_menu_edit_title" msgid="2210564879320004837">"Editar"</string>
    <string name="user_dict_settings_context_menu_delete_title" msgid="9140703913776549054">"Borrar"</string>
    <string name="user_dict_settings_empty_text" msgid="1971969756133074922">"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="6742000040975959247">"Para todos los idiomas"</string>
    <string name="user_dict_settings_more_languages" msgid="7316375944684977910">"Más idiomas..."</string>
    <string name="testing" msgid="6584352735303604146">"Probando"</string>
    <string name="testing_phone_info" product="tablet" msgid="193561832258534798">"Información del tablet"</string>
    <string name="testing_phone_info" product="default" msgid="8656693364332840056">"Información del dispositivo"</string>
    <string name="input_methods_settings_title" msgid="6800066636850553887">"Ingreso de texto"</string>
    <string name="input_method" msgid="5434026103176856164">"Método de entrada"</string>
    <string name="current_input_method" msgid="2636466029213488159">"Teclado actual"</string>
    <string name="input_method_selector" msgid="4311213129681430709">"Selector de método de entrada"</string>
    <string name="input_method_selector_show_automatically_title" msgid="1001612945471546158">"Automático"</string>
    <string name="input_method_selector_always_show_title" msgid="3891824124222371634">"Mostrar siempre"</string>
    <string name="input_method_selector_always_hide_title" msgid="7699647095118680424">"Ocultar siempre"</string>
    <string name="configure_input_method" msgid="1317429869771850228">"Configurar métodos de entrada"</string>
    <string name="input_method_settings" msgid="5801295625486269553">"Configuración"</string>
    <string name="input_method_settings_button" msgid="6778344383871619368">"Configuración"</string>
    <string name="input_methods_settings_label_format" msgid="6002887604815693322">"Configuración de <xliff:g id="IME_NAME">%1$s</xliff:g>"</string>
    <string name="input_methods_and_subtype_enabler_title" msgid="4421813273170250462">"Elegir los métodos de introducción activos"</string>
    <string name="onscreen_keyboard_settings_summary" msgid="5841558383556238653">"Configuración del teclado en pantalla"</string>
    <string name="builtin_keyboard_settings_title" msgid="7688732909551116798">"Teclado físico"</string>
    <string name="builtin_keyboard_settings_summary" msgid="2392531685358035899">"Configuración de teclado físico"</string>
    <string name="gadget_picker_title" msgid="98374951396755811">"Elegir gadget"</string>
    <string name="widget_picker_title" msgid="9130684134213467557">"Elegir control"</string>
    <string name="allow_bind_app_widget_activity_allow_bind_title" msgid="2538303018392590627">"¿Deseas crear el widget y permitir el acceso?"</string>
    <string name="allow_bind_app_widget_activity_allow_bind" msgid="1584388129273282080">"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="7037503685859688034">"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="5890846333487083609">"Estadísticas de uso"</string>
    <string name="testing_usage_stats" msgid="7823048598893937339">"Estadísticas de uso"</string>
    <string name="display_order_text" msgid="8592776965827565271">"Ordenar por:"</string>
    <string name="app_name_label" msgid="5440362857006046193">"Aplicación"</string>
    <string name="last_time_used_label" msgid="8459441968795479307">"Última utilización"</string>
    <string name="usage_time_label" msgid="295954901452833058">"Hora de uso"</string>
    <string name="accessibility_settings" msgid="3975902491934816215">"Accesibilidad"</string>
    <string name="accessibility_settings_title" msgid="2130492524656204459">"Configuración de accesibilidad"</string>
    <string name="accessibility_settings_summary" msgid="981260486011624939">"Lectores de pantalla, pantalla, controles de interacción"</string>
    <string name="vision_settings_title" msgid="4204111425716868288">"Configuración de visión"</string>
    <string name="vision_settings_description" msgid="5679491180156408260">"Puedes personalizar este dispositivo para que se adapte a tus necesidades. Estas funciones de accesibilidad pueden cambiarse más tarde en Configuración."</string>
    <string name="vision_settings_suggestion_title" msgid="8058794060304707004">"Cambiar tamaño de fuente"</string>
    <string name="screen_reader_category_title" msgid="7739154903913400641">"Lectores de pantalla"</string>
    <string name="audio_and_captions_category_title" msgid="3420727114421447524">"Audio y texto en pantalla"</string>
    <string name="display_category_title" msgid="685461049938269166">"Pantalla"</string>
    <string name="interaction_control_category_title" msgid="7836591031872839151">"Controles de interacción"</string>
    <string name="user_installed_services_category_title" msgid="6426376488922158647">"Servicios descargados"</string>
    <string name="experimental_category_title" msgid="5272318666666893547">"Experimental"</string>
    <string name="feature_flags_dashboard_title" msgid="778619522682769966">"Funciones experimentales"</string>
    <string name="talkback_title" msgid="7912059827205988080">"Talkback"</string>
    <string name="talkback_summary" msgid="8331244650729024963">"Lector de pantalla, principalmente, para personas con ceguera o visión reducida"</string>
    <string name="select_to_speak_summary" msgid="4282846695497544515">"Presiona los elementos en tu pantalla para escuchar la lectura en voz alta"</string>
    <string name="accessibility_captioning_title" msgid="8068289534732163115">"Preferencias de subtítulos"</string>
    <string name="accessibility_screen_magnification_title" msgid="6001128808776506021">"Ampliación"</string>
    <string name="accessibility_screen_magnification_gestures_title" msgid="3719929521571489913">"Ampliar presionando tres veces"</string>
    <string name="accessibility_screen_magnification_navbar_title" msgid="4203215572713684224">"Ampliar con combinación de teclas"</string>
    <string name="accessibility_screen_magnification_state_navbar_gesture" msgid="8416035446297644642">"Ampliar con acceso directo y presionar tres veces"</string>
    <string name="accessibility_preference_magnification_summary" msgid="5867883657521404509">"Ampliar la pantalla"</string>
    <string name="accessibility_screen_magnification_short_summary" msgid="3411979839172752057">"Presiona tres veces para ampliar"</string>
    <string name="accessibility_screen_magnification_navbar_short_summary" msgid="3693116360267980492">"Presiona un botón para ampliar"</string>
    <string name="accessibility_screen_magnification_summary" msgid="5258868553337478505"><b>"Para ampliar"</b>", presiona la pantalla 3 veces rápidamente \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>", presiona la pantalla 3 veces rápidamente y mantén presionado la última vez.\n"<ul><li>"Arrastra el dedo para moverte por la pantalla."</li>\n<li>"Levanta el dedo para alejar la imagen."</li></ul>\n\n"No se puede ampliar el teclado ni la barra de navegación."</string>
    <string name="accessibility_screen_magnification_navbar_summary" msgid="6700716275347612310">"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_dialog_title_button" msgid="3682222614034474845">"Usa el botón de accesibilidad para abrir"</string>
    <string name="accessibility_tutorial_dialog_title_gesture" msgid="1342726230497913398">"Usa el gesto para abrir"</string>
    <string name="accessibility_tutorial_dialog_title_gesture_settings" msgid="8539392614235820285">"Usa el nuevo gesto de accesibilidad"</string>
    <string name="accessibility_tutorial_dialog_message_button" msgid="4803108127318033537">"Para activar o desactivar este servicio, presiona el botón de accesibilidad<xliff:g id="ACCESSIBILITY_ICON">%s</xliff:g>en la parte inferior de la pantalla.\n\nSi quieres cambiar de servicio, mantén presionado ese botón."</string>
    <string name="accessibility_tutorial_dialog_message_gesture_without_talkback" msgid="5331865763478710038">"Para activar o desactivar este servicio, desliza dos dedos hacia arriba desde la parte inferior de la pantalla.\n\nPara cambiar de servicio, desliza dos dedos hacia arriba y mantén presionado."</string>
    <string name="accessibility_tutorial_dialog_message_gesture_with_talkback" msgid="7656710338811226339">"Para activar o desactivar este servicio, desliza tres dedos hacia arriba desde la parte inferior de la pantalla.\n\nPara cambiar de servicio, desliza tres dedos hacia arriba y mantén presionado."</string>
    <string name="accessibility_tutorial_dialog_message_gesture_settings_without_talkback" msgid="3582632565941330367">"Para activar o desactivar un servicio de accesibilidad, desliza dos dedos hacia arriba desde la parte inferior de la pantalla.\n\nSi quieres cambiar de servicio, desliza dos dedos hacia arriba y mantén presionado."</string>
    <string name="accessibility_tutorial_dialog_message_gesture_settings_with_talkback" msgid="8539343463529744661">"Para activar o desactivar un servicio de accesibilidad, desliza tres dedos hacia arriba desde la parte inferior de la pantalla.\n\nPara cambiar de servicio, desliza tres dedos hacia arriba y mantén presionado."</string>
    <string name="accessibility_tutorial_dialog_button" msgid="8530755446904847423">"Entendido"</string>
    <string name="accessibility_screen_magnification_navbar_configuration_warning" msgid="70533120652758190">"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="5558685139615434791">"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="2048884356166982714">"Combinación de teclas de volumen"</string>
    <string name="accessibility_shortcut_service_title" msgid="4779360749706905640">"Servicio de combinación de teclas"</string>
    <string name="accessibility_shortcut_service_on_lock_screen_title" msgid="5490636079625489534">"Habilitar en pantalla bloqueada"</string>
    <string name="accessibility_shortcut_description" msgid="1765853731190717372">"Si activas la combinación de teclas, podrás presionar ambas teclas de volumen durante 3 segundos para iniciar una función de accesibilidad."</string>
    <string name="accessibility_toggle_high_text_contrast_preference_title" msgid="2567402942683463779">"Texto de alto contraste"</string>
    <string name="accessibility_toggle_screen_magnification_auto_update_preference_title" msgid="7218498768415430963">"Actualizar automáticamente la ampliación de pantalla"</string>
    <string name="accessibility_toggle_screen_magnification_auto_update_preference_summary" msgid="4392059334816220155">"Actualizar la ampliación de pantalla al cambiar de aplicaciones"</string>
    <string name="accessibility_power_button_ends_call_prerefence_title" msgid="6673851944175874235">"Cortar con el botón de encendido"</string>
    <string name="accessibility_toggle_large_pointer_icon_title" msgid="535173100516295580">"Puntero del mouse grande"</string>
    <string name="accessibility_disable_animations" msgid="5876035711526394795">"Quitar animaciones"</string>
    <string name="accessibility_toggle_master_mono_title" msgid="4363806997971905302">"Audio mono"</string>
    <string name="accessibility_toggle_master_mono_summary" msgid="5634277025251530927">"Combinar canales cuando se reproduce audio"</string>
    <string name="accessibility_toggle_master_balance_title" msgid="551441665399043471">"Balance de audio"</string>
    <string name="accessibility_toggle_master_balance_left_label" msgid="840973259765894310">"Izquierda"</string>
    <string name="accessibility_toggle_master_balance_right_label" msgid="7349959407092157385">"Derecha"</string>
    <string name="accessibility_timeout_default" msgid="8316215621219570607">"Predeterminado"</string>
    <string name="accessibility_timeout_10secs" msgid="1976492627730727871">"10 segundos"</string>
    <string name="accessibility_timeout_30secs" msgid="8055710148052265579">"30 segundos"</string>
    <string name="accessibility_timeout_1min" msgid="6314276027668784112">"1 minuto"</string>
    <string name="accessibility_timeout_2mins" msgid="9062685014853095180">"2 minutos"</string>
    <string name="accessibility_setting_item_control_timeout_title" msgid="870367947690762063">"Tiempo de espera para realizar acción"</string>
    <string name="accessibility_control_timeout_preference_title" msgid="3076566452307147390">"Tiempo de acción"</string>
    <string name="accessibility_control_timeout_preference_summary" msgid="6557680564604287459">"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="6708467774619266508">"Tiempo de respuesta táctil"</string>
    <string name="accessibility_display_inversion_preference_title" msgid="2119647786141420802">"Inversión de color"</string>
    <string name="accessibility_display_inversion_preference_subtitle" msgid="7052959202195368109">"Puede afectar el rendimiento"</string>
    <string name="accessibility_autoclick_preference_title" msgid="2434062071927416098">"Tiempo de permanencia"</string>
    <string name="accessibility_autoclick_description" msgid="4908960598910896933">"Si usas un mouse, puedes configurar el cursor para que haga clic automáticamente cuando se detiene durante un período determinado."</string>
    <string name="accessibility_autoclick_delay_preference_title" msgid="3962261178385106006">"Tiempo de espera antes del clic"</string>
    <string name="accessibility_vibration_settings_title" msgid="3196059463767462026">"Intensidad de la respuesta táctil y vibración"</string>
    <string name="accessibility_notification_vibration_title" msgid="3009997451790678444">"Vibración de las notificaciones"</string>
    <string name="accessibility_ring_vibration_title" msgid="5369395955680650778">"Vibración del tono"</string>
    <string name="accessibility_touch_vibration_title" msgid="3548641513105226156">"Respuesta táctil"</string>
    <string name="accessibility_service_master_switch_title" msgid="6835441300276358239">"Usar el servicio"</string>
    <string name="accessibility_daltonizer_master_switch_title" msgid="8655284637968823154">"Usar la corrección de color"</string>
    <string name="accessibility_caption_master_switch_title" msgid="4010227386676077826">"Usar subtítulos"</string>
    <string name="accessibility_caption_preference_summary" msgid="7898443636143430927">"No todas las apps admiten esta opción de configuración."</string>
    <string name="accessibility_hearingaid_instruction_continue_button" msgid="974461729380409972">"Continuar"</string>
    <string name="accessibility_hearingaid_title" msgid="8312145423610648518">"Audífonos"</string>
    <string name="accessibility_hearingaid_not_connected_summary" msgid="6240237523789614599">"No hay audífonos conectados"</string>
    <string name="accessibility_hearingaid_adding_summary" msgid="2947474468412309778">"Agregar audífonos"</string>
    <string name="accessibility_hearingaid_pair_instructions_message" msgid="3094382949733435414">"Para sincronizar tus audífonos, busca y presiona tu dispositivo en la pantalla siguiente. Asegúrate de que tus audífonos estén en modo de sincronización."</string>
    <string name="accessibility_hearingaid_active_device_summary" msgid="3924362383258688984">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g> activo"</string>
    <plurals name="show_number_hearingaid_count" formatted="false" msgid="3160782397139295486">
      <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_summary_state_enabled" msgid="7914278500885887763">"Activado"</string>
    <string name="accessibility_summary_state_disabled" msgid="2984230257590246745">"Desactivado"</string>
    <string name="accessibility_summary_state_stopped" msgid="1144156815350270876">"No funciona. Presiona para obtener información."</string>
    <string name="accessibility_description_state_stopped" msgid="6953539746047006596">"Este servicio no funciona correctamente."</string>
    <string name="enable_quick_setting" msgid="2366999897816894536">"Mostrar en Configuración rápida"</string>
    <string name="daltonizer_type" msgid="1124178250809091080">"Modo de corrección"</string>
    <plurals name="accessibilty_autoclick_preference_subtitle_extremely_short_delay" formatted="false" msgid="7340347830562315800">
      <item quantity="other">Demora extremadamente breve (<xliff:g id="CLICK_DELAY_LABEL_1">%1$d</xliff:g> ms)</item>
      <item quantity="one">Demora extremadamente breve (<xliff:g id="CLICK_DELAY_LABEL_0">%1$d</xliff:g> ms)</item>
    </plurals>
    <plurals name="accessibilty_autoclick_preference_subtitle_very_short_delay" formatted="false" msgid="5589565607652364932">
      <item quantity="other">Demora muy breve (<xliff:g id="CLICK_DELAY_LABEL_1">%1$d</xliff:g> ms)</item>
      <item quantity="one">Demora muy breve (<xliff:g id="CLICK_DELAY_LABEL_0">%1$d</xliff:g> ms)</item>
    </plurals>
    <plurals name="accessibilty_autoclick_preference_subtitle_short_delay" formatted="false" msgid="5887754135102768400">
      <item quantity="other">Demora breve (<xliff:g id="CLICK_DELAY_LABEL_1">%1$d</xliff:g> ms)</item>
      <item quantity="one">Demora breve (<xliff:g id="CLICK_DELAY_LABEL_0">%1$d</xliff:g> ms)</item>
    </plurals>
    <plurals name="accessibilty_autoclick_preference_subtitle_long_delay" formatted="false" msgid="6340683412750219405">
      <item quantity="other">Demora prolongada (<xliff:g id="CLICK_DELAY_LABEL_1">%1$d</xliff:g> ms)</item>
      <item quantity="one">Demora prolongada (<xliff:g id="CLICK_DELAY_LABEL_0">%1$d</xliff:g> ms)</item>
    </plurals>
    <plurals name="accessibilty_autoclick_preference_subtitle_very_long_delay" formatted="false" msgid="3503199424330634970">
      <item quantity="other">Demora muy prolongada (<xliff:g id="CLICK_DELAY_LABEL_1">%1$d</xliff:g> ms)</item>
      <item quantity="one">Demora muy prologada (<xliff:g id="CLICK_DELAY_LABEL_0">%1$d</xliff:g> ms)</item>
    </plurals>
    <string name="accessibility_vibration_summary" msgid="4272038147476749536">"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="1753566394591809629">"Desactivada para notificaciones y llamadas"</string>
    <string name="accessibility_vibration_summary_low" msgid="7628418309029013867">"Baja para notificaciones y llamadas"</string>
    <string name="accessibility_vibration_summary_medium" msgid="3422136736880414093">"Media para notificaciones y llamadas"</string>
    <string name="accessibility_vibration_summary_high" msgid="3239807793182635729">"Alta para notificaciones y llamadas"</string>
    <string name="accessibility_vibration_intensity_off" msgid="4613890213008630847">"Desactivado"</string>
    <string name="accessibility_vibration_intensity_low" msgid="2017572546489862987">"Baja"</string>
    <string name="accessibility_vibration_intensity_medium" msgid="3782136025830279769">"Media"</string>
    <string name="accessibility_vibration_intensity_high" msgid="2543921139337952491">"Alta"</string>
    <string name="accessibility_menu_item_settings" msgid="3344942964710773365">"Configuración"</string>
    <string name="accessibility_feature_state_on" msgid="2864292320042673806">"Activado"</string>
    <string name="accessibility_feature_state_off" msgid="4172584906487070211">"Desactivado"</string>
    <string name="captioning_preview_title" msgid="1234015253497016890">"Vista previa"</string>
    <string name="captioning_standard_options_title" msgid="3284211791180335844">"Opciones estándar"</string>
    <string name="captioning_locale" msgid="4559155661018823503">"Idioma"</string>
    <string name="captioning_text_size" msgid="6737002449104466028">"Tamaño del texto"</string>
    <string name="captioning_preset" msgid="8939737196538429044">"Estilo de subtítulos"</string>
    <string name="captioning_custom_options_title" msgid="5067500939930322405">"Opciones personalizadas"</string>
    <string name="captioning_background_color" msgid="9053011212948992570">"Color de fondo"</string>
    <string name="captioning_background_opacity" msgid="6029993616419971202">"Opacidad del fondo"</string>
    <string name="captioning_window_color" msgid="6902052743419717394">"Color de ventana de subtítulos"</string>
    <string name="captioning_window_opacity" msgid="5041556024849862376">"Opacidad de ventana de subtítulos"</string>
    <string name="captioning_foreground_color" msgid="85623486537640059">"Color del texto"</string>
    <string name="captioning_foreground_opacity" msgid="4370967856995419788">"Opacidad del texto"</string>
    <string name="captioning_edge_color" msgid="3670094753735263238">"Color del borde"</string>
    <string name="captioning_edge_type" msgid="5997247394951682154">"Tipo de borde"</string>
    <string name="captioning_typeface" msgid="1826169240566563259">"Familia de fuentes"</string>
    <string name="captioning_preview_text" msgid="4067935959797375065">"Así se verán los subtítulos."</string>
    <string name="captioning_preview_characters" msgid="7105909138497851769">"Aa"</string>
    <string name="locale_default" msgid="2593883646136326969">"Predeterminado"</string>
    <string name="color_title" msgid="4258931051732243983">"Color"</string>
    <string name="color_unspecified" msgid="5179683785413568326">"Predeterminado"</string>
    <string name="color_none" msgid="3475640044925814795">"Ninguno"</string>
    <string name="color_white" msgid="8045195170201590239">"Blanco"</string>
    <string name="color_gray" msgid="9192312087142726313">"Gris"</string>
    <string name="color_black" msgid="7517353520909872561">"Negro"</string>
    <string name="color_red" msgid="4949354900304125428">"Rojo"</string>
    <string name="color_green" msgid="5537717328428845841">"Verde"</string>
    <string name="color_blue" msgid="7731984529016953223">"Azul"</string>
    <string name="color_cyan" msgid="7033027180641173211">"Cian"</string>
    <string name="color_yellow" msgid="9112680561610873529">"Amarillo"</string>
    <string name="color_magenta" msgid="5059212823607815549">"Magenta"</string>
    <string name="enable_service_title" msgid="2813477981936919847">"¿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="86713361724771971">"<xliff:g id="SERVICE">%1$s</xliff:g> necesita:"</string>
    <string name="touch_filtered_warning" msgid="8644034725268915030">"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="3064686622453974606">"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="460911459695077779">"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="777577618063306751">"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="7882035264853248228">"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="1224075277603097951">"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="846312597054899472">"<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="5678294638592090340">"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="1262218781398117580">"Ver y controlar la pantalla"</string>
    <string name="accessibility_service_screen_control_description" msgid="5263900135083661468">"Puede leer todo el contenido en la pantalla y mostrarlo sobre otras apps."</string>
    <string name="accessibility_service_action_perform_title" msgid="3591350033271419253">"Ver y realizar acciones"</string>
    <string name="accessibility_service_action_perform_description" msgid="2402904134246069476">"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="8427955451281232788">"Permitir"</string>
    <string name="accessibility_dialog_button_deny" msgid="4307331121783796869">"Rechazar"</string>
    <string name="accessibility_dialog_button_stop" msgid="7861331860214808622">"Detener"</string>
    <string name="accessibility_dialog_button_cancel" msgid="5006357240387387028">"Cancelar"</string>
    <string name="disable_service_title" msgid="3624005212728512896">"¿Quieres detener <xliff:g id="SERVICE">%1$s</xliff:g>?"</string>
    <string name="disable_service_message" msgid="4593387199926310801">"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="7200948194639038807">"No se instaló ningún servicio."</string>
    <string name="accessibility_no_service_selected" msgid="2840969718780083998">"No se seleccionó ningún servicio"</string>
    <string name="accessibility_service_default_description" msgid="1072730037861494125">"No se proporcionó ninguna descripción."</string>
    <string name="settings_button" msgid="3006713718908152930">"Configuración"</string>
    <string name="print_settings" msgid="4742428530112487843">"Impresión"</string>
    <string name="print_settings_summary_no_service" msgid="6354322414246865875">"Desactivado"</string>
    <plurals name="print_settings_summary" formatted="false" msgid="6005468025646083029">
      <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="5810106725778525400">
      <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="3685449667822217816">"Servicios de impresión"</string>
    <string name="print_no_services_installed" msgid="8443039625463872294">"No se instaló ningún servicio."</string>
    <string name="print_no_printers_found" msgid="989018646884973683">"No se encontraron impresoras"</string>
    <string name="print_menu_item_settings" msgid="6591330373682227082">"Configuración"</string>
    <string name="print_menu_item_add_printers" msgid="2890738028215834012">"Agregar impresoras"</string>
    <string name="print_feature_state_on" msgid="8098901852502441048">"Sí"</string>
    <string name="print_feature_state_off" msgid="7294876968403966040">"No"</string>
    <string name="print_menu_item_add_service" msgid="3811645167869797802">"Agregar servicio"</string>
    <string name="print_menu_item_add_printer" msgid="8251218970577291032">"Agregar impresora"</string>
    <string name="print_menu_item_search" msgid="7025589328240514553">"Buscar"</string>
    <string name="print_searching_for_printers" msgid="4680248496457576358">"Buscando impresoras"</string>
    <string name="print_service_disabled" msgid="7739452396114245222">"Servicio desactivado"</string>
    <string name="print_print_jobs" msgid="3582094777756968793">"Trabajos de impresión"</string>
    <string name="print_print_job" msgid="7563741676053287211">"Trabajo de impresión"</string>
    <string name="print_restart" msgid="8373999687329384202">"Reiniciar"</string>
    <string name="print_cancel" msgid="3621199386568672235">"Cancelar"</string>
    <string name="print_job_summary" msgid="8472427347192930694">"<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="1228890182762324249">"Configurando <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_printing_state_title_template" msgid="5736107667714582025">"Imprimiendo <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_cancelling_state_title_template" msgid="7102968925358219875">"Cancelando <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_failed_state_title_template" msgid="1436099128973357969">"Error de impresora <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_blocked_state_title_template" msgid="9065391617425962424">"La impresora bloqueó <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>."</string>
    <string name="print_search_box_shown_utterance" msgid="7730361832020726951">"Cuadro de búsqueda visible"</string>
    <string name="print_search_box_hidden_utterance" msgid="7980832833405818400">"Cuadro de búsqueda oculto"</string>
    <string name="printer_info_desc" msgid="5824995108703060003">"Más información sobre esta impresora"</string>
    <string name="power_usage_summary_title" msgid="7190304207330319919">"Batería"</string>
    <string name="power_usage_summary" msgid="7237084831082848168">"Lo que ha utilizado la batería"</string>
    <string name="power_usage_not_available" msgid="3109326074656512387">"Sin datos de uso de batería"</string>
    <string name="power_usage_level_and_status" msgid="7449847570973811784">"<xliff:g id="LEVEL">%1$s</xliff:g> - <xliff:g id="STATUS">%2$s</xliff:g>"</string>
    <string name="power_discharge_remaining" msgid="4925678997049911808">"Tiempo restante: <xliff:g id="REMAIN">%1$s</xliff:g>"</string>
    <string name="power_charge_remaining" msgid="6132074970943913135">"Carga completa en <xliff:g id="UNTIL_CHARGED">%1$s</xliff:g>"</string>
    <string name="background_activity_title" msgid="8482171736539410135">"Restricción en segundo plano"</string>
    <string name="background_activity_summary" msgid="8140094430510517362">"Permite que la app se ejecute en segundo plano"</string>
    <string name="background_activity_summary_disabled" msgid="3710669050484599847">"La app no puede ejecutarse en segundo plano"</string>
    <string name="background_activity_summary_whitelisted" msgid="1079899502347973947">"No se puede restringir el uso en segundo plano"</string>
    <string name="background_activity_warning_dialog_title" msgid="2216249969149568871">"¿Limitar actividad en segundo plano?"</string>
    <string name="background_activity_warning_dialog_text" msgid="7049624449246121981">"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="6133420589651880824">"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="3386088035570409683">"Uso de la pantalla desde carga completa"</string>
    <string name="power_usage_list_summary" msgid="5584049564906462506">"Uso de la batería desde la última carga completa"</string>
    <string name="screen_usage_summary" msgid="6687403051423153550">"Tiempo que estuvo encendida la pantalla desde la última carga completa"</string>
    <string name="device_usage_list_summary" msgid="5623036661468763251">"Uso del dispositivo desde la última carga completa"</string>
    <string name="battery_since_unplugged" msgid="338073389740738437">"Uso de la batería desde que se desconectó"</string>
    <string name="battery_since_reset" msgid="7464546661121187045">"Uso de la batería desde que se restableció"</string>
    <string name="battery_stats_on_battery" msgid="4970762168505236033">"<xliff:g id="TIME">%1$s</xliff:g> de uso de la batería"</string>
    <string name="battery_stats_duration" msgid="7464501326709469282">"<xliff:g id="TIME">%1$s</xliff:g> desde que se desconectó"</string>
    <string name="battery_stats_charging_label" msgid="4223311142875178785">"Cargando"</string>
    <string name="battery_stats_screen_on_label" msgid="7150221809877509708">"Pantalla encendida"</string>
    <string name="battery_stats_gps_on_label" msgid="1193657533641951256">"GPS activado"</string>
    <string name="battery_stats_camera_on_label" msgid="4935637383628414968">"Cámara activada"</string>
    <string name="battery_stats_flashlight_on_label" msgid="4319637669889411307">"Linterna activada"</string>
    <string name="battery_stats_wifi_running_label" msgid="1845839195549226252">"Wi-Fi"</string>
    <string name="battery_stats_wake_lock_label" msgid="1908942681902324095">"Activa"</string>
    <string name="battery_stats_phone_signal_label" msgid="4137799310329041341">"Señal de la red de celulares"</string>
    <!-- no translation found for battery_stats_last_duration (1535831453827905957) -->
    <skip />
    <string name="awake" msgid="387122265874485088">"Hora de activación del dispositivo"</string>
    <string name="wifi_on_time" msgid="3208518458663637035">"Wi-Fi a tiempo"</string>
    <string name="bluetooth_on_time" msgid="3056108148042308690">"Wi-Fi a tiempo"</string>
    <string name="advanced_battery_title" msgid="6768618303037280828">"Uso de la batería"</string>
    <string name="history_details_title" msgid="3608240585315506067">"Detalles del historial"</string>
    <string name="battery_details_title" msgid="6101394441569858580">"Uso de la batería"</string>
    <string name="details_subtitle" msgid="32593908269911734">"Detalles de uso"</string>
    <string name="controls_subtitle" msgid="390468421138288702">"Ajustar el uso de energía"</string>
    <string name="packages_subtitle" msgid="4736416171658062768">"Paquetes incluidos"</string>
    <string name="battery_tip_summary_title" msgid="368729969313047399">"Las apps se ejecutan con normalidad"</string>
    <string name="battery_tip_summary_summary" product="default" msgid="2198778125778121221">"El consumo de batería en segundo plano del teléfono es normal"</string>
    <string name="battery_tip_summary_summary" product="tablet" msgid="1183976728682325345">"El consumo de batería en segundo plano de la tablet es normal"</string>
    <string name="battery_tip_summary_summary" product="device" msgid="363718204492523920">"El consumo de batería en segundo plano del dispositivo es normal"</string>
    <string name="battery_tip_low_battery_title" msgid="5103420355109677385">"Capacidad de batería baja"</string>
    <string name="battery_tip_low_battery_summary" msgid="4702986182940709150">"La batería no tiene una buena duración"</string>
    <string name="battery_tip_smart_battery_title" product="default" msgid="2542822112725248683">"Mejora la duración de batería del teléfono"</string>
    <string name="battery_tip_smart_battery_title" product="tablet" msgid="6452567046912954866">"Mejora la duración de batería de la tablet"</string>
    <string name="battery_tip_smart_battery_title" product="device" msgid="4445149029390556382">"Mejora la duración de batería del dispositivo"</string>
    <string name="battery_tip_smart_battery_summary" msgid="2326809294592208069">"Activa el administrador de batería"</string>
    <string name="battery_tip_early_heads_up_title" msgid="5788492366387119807">"Activar el Ahorro de batería"</string>
    <string name="battery_tip_early_heads_up_summary" msgid="1639271439914224547">"La batería podría agotarse antes de lo habitual"</string>
    <string name="battery_tip_early_heads_up_done_title" msgid="4294083319255926811">"El Ahorro de batería está activado"</string>
    <string name="battery_tip_early_heads_up_done_summary" msgid="7054036010928794364">"Es posible que algunas funciones estén limitadas"</string>
    <string name="battery_tip_high_usage_title" product="default" msgid="1282187115295901930">"El teléfono se usó más de lo habitual"</string>
    <string name="battery_tip_high_usage_title" product="tablet" msgid="7422137233845959351">"La tablet se usó más de lo habitual"</string>
    <string name="battery_tip_high_usage_title" product="device" msgid="5483320224273724068">"El dispositivo se usó más de lo habitual"</string>
    <string name="battery_tip_high_usage_summary" msgid="5343363604280323738">"La batería podría agotarse antes de lo habitual."</string>
    <string name="battery_tip_dialog_message" product="default" msgid="797225122502556066">"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="49788591262480482">"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="7959652003221931962">"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="2560019187096011163">"Incluye actividad en segundo plano de alta potencia"</string>
    <plurals name="battery_tip_restrict_title" formatted="false" msgid="467228882789275512">
      <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="2996094393897875408">
      <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="5768962491638423979">
      <item quantity="other">%2$d apps tienen un alto consumo de batería en segundo plano</item>
      <item quantity="one">%1$s tiene un alto consumo de batería en segundo plano</item>
    </plurals>
    <plurals name="battery_tip_restrict_handled_summary" formatted="false" msgid="1040488674178753191">
      <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="8130618585820429591">
      <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="7271391929137806299">"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="3175700359860699627">"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="582641081128076191">"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="8291115820018013353">"Restringir"</string>
    <string name="battery_tip_unrestrict_app_dialog_title" msgid="4321334634106715162">"¿Quitar restricción?"</string>
    <string name="battery_tip_unrestrict_app_dialog_message" msgid="6537761705584610231">"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="6022058431218137646">"Quitar"</string>
    <string name="battery_tip_unrestrict_app_dialog_cancel" msgid="3058235875830858902">"Cancelar"</string>
    <string name="battery_tip_dialog_summary_message" product="default" msgid="4628448253185085796">"La cantidad de batería que usan tus apps es normal. 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="8327950887399420971">"La cantidad de batería que usan tus apps es normal. 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="6753742263807939789">"La cantidad de batería que usan tus apps es normal. 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="870632749556793417">"Administrador de batería"</string>
    <string name="smart_battery_title" msgid="6218785691872466076">"Administra apps automáticamente"</string>
    <string name="smart_battery_summary" msgid="1339184602000004058">"Limitar el consumo de batería de las apps que no uses con frecuencia"</string>
    <string name="smart_battery_footer" product="default" msgid="5555604955956219544">"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="smart_battery_footer" product="tablet" msgid="5555604955956219544">"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="smart_battery_footer" product="device" msgid="5555604955956219544">"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="8982477293044330653">"Apps restringidas"</string>
    <plurals name="restricted_app_summary" formatted="false" msgid="7355687633914223530">
      <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="6983512391277778623">"Restringida <xliff:g id="TIME">%1$s</xliff:g>"</string>
    <string name="restricted_app_detail_footer" msgid="6739863162364046859">"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="6553271897488963709">"Usar el administrador de batería"</string>
    <string name="battery_auto_restriction_summary" msgid="8561335400991281062">"Detectar cuando las apps agotan la batería"</string>
    <string name="battery_manager_on" msgid="8643310865054362396">"Activado: detectando cuando las apps agotan la batería"</string>
    <string name="battery_manager_off" msgid="5473135235710343576">"Desactivado"</string>
    <plurals name="battery_manager_app_restricted" formatted="false" msgid="1026141135861471129">
      <item quantity="other">%1$d apps restringidas</item>
      <item quantity="one">%1$d app restringida</item>
    </plurals>
    <string name="battery_header_title_alternate" msgid="1766047545950757380">"<xliff:g id="NUMBER">^1</xliff:g>"<small>" "<font size="20">"<xliff:g id="UNIT">%</xliff:g>"</font></small>""</string>
    <string name="dialog_stop_title" msgid="6395127715596746479">"¿Quieres detener la app?"</string>
    <string name="dialog_stop_message" product="default" msgid="4006631636646776488">"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="2369957934555162428">"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="6195430620406365292">"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="1638726742782558262">"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="8771690983566539742">"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="2854944538238649520">"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="2319777211264004900">"Detener la app"</string>
    <string name="dialog_background_check_title" msgid="6936542136153283692">"¿Desactivar el uso en segundo plano y detener la app?"</string>
    <string name="dialog_background_check_message" product="default" msgid="4045827746349279563">"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="8348214419901788270">"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="5847977433118915863">"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="412876934682899659">"Desactivar"</string>
    <string name="dialog_location_title" msgid="5888917530725874727">"¿Quieres desactivar la ubicación?"</string>
    <string name="dialog_location_message" product="default" msgid="7774807745601479888">"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="118745801732181618">"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="6783678153382298295">"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="4572391197601313986">"Desactivar"</string>
    <string name="power_screen" msgid="3023346080675904613">"Pantalla"</string>
    <string name="power_flashlight" msgid="7794409781003567614">"Linterna"</string>
    <string name="power_camera" msgid="4976286950934622605">"Cámara"</string>
    <string name="power_wifi" msgid="1135085252964054957">"Wi-Fi"</string>
    <string name="power_bluetooth" msgid="4373329044379008289">"Bluetooth"</string>
    <string name="power_cell" msgid="3392999761958982492">"Red móvil en modo de espera"</string>
    <string name="power_phone" msgid="5392641106474567277">"Llamadas de voz"</string>
    <string name="power_idle" product="tablet" msgid="4612478572401640759">"Tablet ausente"</string>
    <string name="power_idle" product="default" msgid="9055659695602194990">"Teléfono inactivo"</string>
    <string name="power_unaccounted" msgid="709925017022660740">"Varios"</string>
    <string name="power_overcounted" msgid="2762354976171358445">"Sobrecalculada"</string>
    <string name="usage_type_cpu" msgid="715162150698338714">"CPU total"</string>
    <string name="usage_type_cpu_foreground" msgid="6500579611933211831">"Primer plano de la CPU"</string>
    <string name="usage_type_wake_lock" msgid="5125438890233677880">"Mantener en funcionamiento"</string>
    <string name="usage_type_gps" msgid="7989688715128160790">"GPS"</string>
    <string name="usage_type_wifi_running" msgid="3134357198266380400">"Wi-Fi en funcionamiento"</string>
    <string name="usage_type_phone" product="tablet" msgid="262638572890253393">"Tablet"</string>
    <string name="usage_type_phone" product="default" msgid="9108247984998041853">"Teléfono"</string>
    <string name="usage_type_data_send" msgid="8971710128438365919">"Paquetes móviles enviados"</string>
    <string name="usage_type_data_recv" msgid="5468564329333954445">"Paquetes móviles recibidos"</string>
    <string name="usage_type_radio_active" msgid="1732647857619420121">"Radio activada"</string>
    <string name="usage_type_data_wifi_send" msgid="1847552143597396162">"Paquetes Wi‑Fi enviados"</string>
    <string name="usage_type_data_wifi_recv" msgid="5678475911549183829">"Paquetes Wi‑Fi recibidos"</string>
    <string name="usage_type_audio" msgid="6957269406840886290">"Audio"</string>
    <string name="usage_type_video" msgid="4295357792078579944">"Video"</string>
    <string name="usage_type_camera" msgid="8299433109956769757">"Cámara"</string>
    <string name="usage_type_flashlight" msgid="1516392356962208230">"Linterna"</string>
    <string name="usage_type_on_time" msgid="3351200096173733159">"Tiempo de activación"</string>
    <string name="usage_type_no_coverage" msgid="3797004252954385053">"Tiempo sin una señal"</string>
    <string name="usage_type_total_battery_capacity" msgid="3798285287848675346">"Capacidad total de la batería"</string>
    <string name="usage_type_computed_power" msgid="5862792259009981479">"Uso de energía computado"</string>
    <string name="usage_type_actual_power" msgid="7047814738685578335">"Uso de energía observado"</string>
    <string name="battery_action_stop" msgid="649958863744041872">"Forzar la detención"</string>
    <string name="battery_action_app_details" msgid="7861051816778419018">"Info. de las apps"</string>
    <string name="battery_action_app_settings" msgid="4570481408106287454">"Configuración de aplicación"</string>
    <string name="battery_action_display" msgid="7338551244519110831">"Configuraciones de pantalla"</string>
    <string name="battery_action_wifi" msgid="8181553479021841207">"Configuración de Wi-Fi"</string>
    <string name="battery_action_bluetooth" msgid="8374789049507723142">"Config. de Bluetooth"</string>
    <string name="battery_desc_voice" msgid="8980322055722959211">"La batería está siendo utilizada por llamadas de voz"</string>
    <string name="battery_desc_standby" product="tablet" msgid="6284747418668280364">"La batería se utiliza cuando el tablet está inactivo"</string>
    <string name="battery_desc_standby" product="default" msgid="3009080001948091424">"La batería se utiliza cuando el dispositivo está inactivo"</string>
    <string name="battery_desc_radio" msgid="5479196477223185367">"La batería está siendo utilizada por la radio celular"</string>
    <string name="battery_sugg_radio" msgid="8211336978326295047">"Cambiar a modo avión para ahorrar batería en áreas sin cobertura celular"</string>
    <string name="battery_desc_flashlight" msgid="2908579430841025494">"Batería utilizada por la linterna"</string>
    <string name="battery_desc_camera" msgid="7375389919760613499">"Batería que usa la cámara"</string>
    <string name="battery_desc_display" msgid="5432795282958076557">"La batería está siendo utilizada por la pantalla y la luz de fondo"</string>
    <string name="battery_sugg_display" msgid="3370202402045141760">"Reduce el brillo y el tiempo de espera de la pantalla"</string>
    <string name="battery_desc_wifi" msgid="2375567464707394131">"Batería utilizada por Wi-Fi"</string>
    <string name="battery_sugg_wifi" msgid="7776093125855397043">"Desactiva Wi-Fi cuando no lo utilices o cuando no esté disponible."</string>
    <string name="battery_desc_bluetooth" msgid="8069070756186680367">"Batería utilizada por Bluetooth"</string>
    <string name="battery_sugg_bluetooth_basic" msgid="4565141162650835009">"Desactiva Bluetooth cuando no lo utilices."</string>
    <string name="battery_sugg_bluetooth_headset" msgid="4071352514714259230">"Intentar conectarse a un dispositivo Bluetooth diferente"</string>
    <string name="battery_desc_apps" msgid="8530418792605735226">"Batería usada por la aplicación"</string>
    <string name="battery_sugg_apps_info" msgid="6907588126789841231">"Detener o desinstalar la aplicación"</string>
    <string name="battery_sugg_apps_gps" msgid="5959067516281866135">"Selecciona el modo de ahorro de batería."</string>
    <string name="battery_sugg_apps_settings" msgid="3974902365643634514">"La aplicación podrá ofrecer una configuración para reducir el uso de la batería."</string>
    <string name="battery_desc_users" msgid="7682989161885027823">"Batería utilizada por el usuario"</string>
    <string name="battery_desc_unaccounted" msgid="7404256448541818019">"Uso de energía variado"</string>
    <string name="battery_msg_unaccounted" msgid="1963583522633067961">"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="5481865509489228603">"Uso de potencia sobrecalculada"</string>
    <string name="mah" msgid="95245196971239711">"<xliff:g id="NUMBER">%d</xliff:g> mAh"</string>
    <string name="battery_used_for" msgid="2690821851327075443">"Se usó durante <xliff:g id="TIME">^1</xliff:g>"</string>
    <string name="battery_active_for" msgid="2964359540508103032">"Activa durante <xliff:g id="TIME">^1</xliff:g>"</string>
    <string name="battery_screen_usage" msgid="6537658662149713585">"Uso de la pantalla: <xliff:g id="TIME">^1</xliff:g>"</string>
    <string name="battery_used_by" msgid="1135316757755282999">"<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="2093409063297375436">"<xliff:g id="PERCENT">%1$s</xliff:g> de la batería total"</string>
    <string name="battery_detail_since_full_charge" msgid="7515347842046955855">"Desglose desde la última carga completa"</string>
    <string name="battery_last_full_charge" msgid="7151251641099019361">"Última carga completa"</string>
    <string name="battery_full_charge_last" msgid="8892335687734288031">"La carga completa dura aproximadamente"</string>
    <string name="battery_footer_summary" msgid="67169726550144016">"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="3350401514602032183">"Durante el uso activo"</string>
    <string name="battery_detail_background" msgid="1929644393553768999">"Mientras se ejecuta en segundo plano"</string>
    <string name="battery_detail_power_usage" msgid="6485766868610469101">"Uso de la batería"</string>
    <string name="battery_detail_info_title" msgid="8227822131405620369">"Desde la última carga completa"</string>
    <string name="battery_detail_manage_title" msgid="9094314252105828014">"Administrar el uso de la batería"</string>
    <string name="advanced_battery_graph_subtext" msgid="5621073891377915877">"El cálculo de batería restante se basa en el uso del dispositivo"</string>
    <string name="estimated_time_left" msgid="7514194472683370877">"Tiempo restante estimado"</string>
    <string name="estimated_charging_time_left" msgid="5614442409326164691">"Para completar la carga"</string>
    <string name="estimated_time_description" msgid="8760210909000037089">"La estimación puede cambiar en función del uso"</string>
    <string name="menu_stats_unplugged" msgid="8296577130840261624">"<xliff:g id="UNPLUGGED">%1$s</xliff:g> desde que se desconectó"</string>
    <string name="menu_stats_last_unplugged" msgid="5922246077592434526">"Durante la última desconexión para <xliff:g id="UNPLUGGED">%1$s</xliff:g>"</string>
    <string name="menu_stats_total" msgid="8973377864854807854">"Total de usos"</string>
    <string name="menu_stats_refresh" msgid="1676215433344981075">"Actualizar"</string>
    <string name="process_mediaserver_label" msgid="6500382062945689285">"Servidor de medios"</string>
    <string name="process_dex2oat_label" msgid="2592408651060518226">"Optimización de las aplicaciones"</string>
    <string name="battery_saver" msgid="8172485772238572153">"Ahorro de batería"</string>
    <string name="battery_saver_auto_title" msgid="8368709389419695611">"Activar automáticamente"</string>
    <string name="battery_saver_auto_no_schedule" msgid="632243833320671052">"Sin programa"</string>
    <string name="battery_saver_auto_routine" msgid="8076053160450346731">"Según tu rutina"</string>
    <string name="battery_saver_auto_percentage" msgid="9000542338151528905">"Según el porcentaje"</string>
    <string name="battery_saver_auto_routine_summary" msgid="3030089882678228374">"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="3653601117764171846">"Se activará cuando quede <xliff:g id="PERCENT">%1$s</xliff:g>"</string>
    <string name="battery_saver_schedule_settings_title" msgid="6000660866895036589">"Establecer un programa"</string>
    <string name="battery_saver_turn_on_summary" msgid="5552800757174173459">"Extender la duración de la batería"</string>
    <string name="battery_saver_sticky_title_new" msgid="613272902035943099">"Desactivar cuando se complete la carga"</string>
    <string name="battery_saver_sticky_description_new" product="default" msgid="6659545534053937371">"El Ahorro de batería se desactiva cuando el teléfono tiene <xliff:g id="PERCENT">%1$s</xliff:g> de carga"</string>
    <string name="battery_saver_sticky_description_new" product="tablet" msgid="6537930800784858686">"El Ahorro de batería se desactiva cuando la tablet tiene <xliff:g id="PERCENT">%1$s</xliff:g> de carga"</string>
    <string name="battery_saver_sticky_description_new" product="device" msgid="8309483774864505603">"El Ahorro de batería se desactiva cuando el dispositivo tiene <xliff:g id="PERCENT">%1$s</xliff:g> de carga"</string>
    <!-- no translation found for battery_saver_seekbar_title (3795833548145424276) -->
    <skip />
    <string name="battery_saver_seekbar_title_placeholder" msgid="1138980155985636295">"Activar"</string>
    <string name="battery_saver_master_switch_title" msgid="622539414546588436">"Usar la función Ahorro de batería"</string>
    <string name="battery_saver_turn_on_automatically_title" msgid="9023847300114669426">"Activar automáticamente"</string>
    <string name="battery_saver_turn_on_automatically_never" msgid="6610846456314373">"Nunca"</string>
    <string name="battery_saver_turn_on_automatically_pct" msgid="8665950426992057191">"con <xliff:g id="PERCENT">%1$s</xliff:g> de batería"</string>
    <string name="battery_percentage" msgid="723291197508049369">"Porcentaje de batería"</string>
    <string name="battery_percentage_description" msgid="8511658577507384014">"Mostrar el porcentaje de la batería en la barra de estado"</string>
    <string name="process_stats_summary_title" msgid="1144688045609771677">"Estadísticas de procesos"</string>
    <string name="process_stats_summary" msgid="109387941605607762">"Estadísticas para geeks sobre procesos activos"</string>
    <string name="app_memory_use" msgid="7849258480392171939">"Uso de memoria"</string>
    <string name="process_stats_total_duration" msgid="7417201400853728029">"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="6522457033380025618">"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="3934992858120683459">"En segundo plano"</string>
    <string name="process_stats_type_foreground" msgid="7713118254089580536">"En primer plano"</string>
    <string name="process_stats_type_cached" msgid="6314925846944806511">"En caché"</string>
    <string name="process_stats_os_label" msgid="4813434110442733392">"Sistema operativo Android"</string>
    <string name="process_stats_os_native" msgid="5322428494231768472">"Nativo"</string>
    <string name="process_stats_os_kernel" msgid="1938523592369780924">"Kernel"</string>
    <string name="process_stats_os_zram" msgid="677138324651671575">"Zram"</string>
    <string name="process_stats_os_cache" msgid="6432533624875078233">"Memorias caché"</string>
    <string name="process_stats_ram_use" msgid="976912589127397307">"Uso de RAM"</string>
    <string name="process_stats_bg_ram_use" msgid="5398191511030462404">"Uso de RAM (en segundo plano)"</string>
    <string name="process_stats_run_time" msgid="6520628955709369115">"Tiempo de ejecución"</string>
    <string name="processes_subtitle" msgid="6827502409379462438">"Procesos"</string>
    <string name="services_subtitle" msgid="4296402367067266425">"Servicios"</string>
    <string name="menu_proc_stats_duration" msgid="2323483592994720196">"Duración"</string>
    <string name="mem_details_title" msgid="6548392825497290498">"Detalles de la memoria"</string>
    <string name="menu_duration_3h" msgid="4714866438374738385">"3 horas"</string>
    <string name="menu_duration_6h" msgid="1940846763432184132">"6 horas"</string>
    <string name="menu_duration_12h" msgid="7890465404584356294">"12 horas"</string>
    <string name="menu_duration_1d" msgid="3393631127622285458">"1 día"</string>
    <string name="menu_show_system" msgid="8864603400415567635">"Mostrar sistema"</string>
    <string name="menu_hide_system" msgid="4106826741703745733">"Ocultar sistema"</string>
    <string name="menu_show_percentage" msgid="4717204046118199806">"Mostrar porcentajes"</string>
    <string name="menu_use_uss" msgid="467765290771543089">"Usar USS"</string>
    <string name="menu_proc_stats_type" msgid="4700209061072120948">"Tipo de estadística"</string>
    <string name="menu_proc_stats_type_background" msgid="2236161340134898852">"En segundo plano"</string>
    <string name="menu_proc_stats_type_foreground" msgid="2286182659954958586">"En primer plano"</string>
    <string name="menu_proc_stats_type_cached" msgid="5084272779786820693">"En caché"</string>
    <string name="voice_input_output_settings" msgid="1336135218350444783">"Entrada y salida de voz"</string>
    <string name="voice_input_output_settings_title" msgid="2442850635048676991">"Configuración entrada y salida de voz"</string>
    <string name="voice_search_settings_title" msgid="2775469246913196536">"Búsqueda por voz"</string>
    <string name="keyboard_settings_title" msgid="5080115226780201234">"Teclado de Android"</string>
    <string name="voice_input_settings" msgid="1099937800539324567">"Configuración de entrada de voz"</string>
    <string name="voice_input_settings_title" msgid="2676028028084981891">"Entrada de voz"</string>
    <string name="voice_service_preference_section_title" msgid="3778706644257601021">"Servicios de entrada de voz"</string>
    <string name="voice_interactor_preference_summary" msgid="1801414022026937190">"Interacción y palabra clave completa"</string>
    <string name="voice_recognizer_preference_summary" msgid="669880813593690527">"Voz a texto simple"</string>
    <string name="voice_interaction_security_warning" msgid="6378608263983737325">"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="1578826947311494239">"Motor preferido"</string>
    <string name="tts_engine_settings_title" msgid="6886964122861384818">"Configuración del motor"</string>
    <string name="tts_sliders_title" msgid="992059150784095263">"Velocidad y tono de la voz"</string>
    <string name="tts_engine_section_title" msgid="6289240207677024034">"Motor"</string>
    <string name="tts_install_voice_title" msgid="6275828614052514320">"Voces"</string>
    <string name="tts_spoken_language" msgid="5542499183472504027">"Idioma de voz"</string>
    <string name="tts_install_voices_title" msgid="8808823756936022641">"Instalar voces"</string>
    <string name="tts_install_voices_text" msgid="5292606786380069134">"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="667467793360277465">"Abrir app"</string>
    <string name="tts_install_voices_cancel" msgid="4711492804851107459">"Cancelar"</string>
    <string name="tts_reset" msgid="2661752909256313270">"Restablecer"</string>
    <string name="tts_play" msgid="2628469503798633884">"Reproducir"</string>
    <string name="vpn_settings_title" msgid="5662579425832406705">"VPN"</string>
    <string name="credentials_title" msgid="4446234003860769883">"Almacenamiento de credenciales"</string>
    <string name="credentials_install" product="nosdcard" msgid="466093273825150847">"Instalar desde almacenamiento"</string>
    <string name="credentials_install" product="default" msgid="953914549998062317">"Instalar desde la tarjeta SD"</string>
    <string name="credentials_install_summary" product="nosdcard" msgid="4220422806818210676">"Instalar certificados desde el almacenamiento"</string>
    <string name="credentials_install_summary" product="default" msgid="5737658257407822713">"Instalar certificados desde la tarjeta SD"</string>
    <string name="credentials_reset" msgid="3239382277144980418">"Borrar credenciales"</string>
    <string name="credentials_reset_summary" msgid="3369361230171260282">"Quitar todos los certificados"</string>
    <string name="trusted_credentials" msgid="4266945289534242402">"Credenciales de confianza"</string>
    <string name="trusted_credentials_summary" msgid="6735221351155686632">"Mostrar certificados de CA de confianza"</string>
    <string name="user_credentials" msgid="3719013347787187083">"Credenciales del usuario"</string>
    <string name="user_credentials_summary" msgid="7271228342106080167">"Ver y modificar las credenciales guardadas"</string>
    <string name="advanced_security_title" msgid="2434776238010578865">"Configuración avanzada"</string>
    <string name="credential_storage_type" msgid="8629968543494001364">"Tipo de almacenamiento"</string>
    <string name="credential_storage_type_hardware" msgid="6077193544333904427">"Copia de seguridad en hardware"</string>
    <string name="credential_storage_type_software" msgid="4403117271207715378">"Solo software"</string>
    <string name="credentials_settings_not_available" msgid="7968275634486624215">"Las credenciales no están disponibles para este usuario."</string>
    <string name="credential_for_vpn_and_apps" msgid="4168197158768443365">"Se instaló para redes VPN y apps"</string>
    <string name="credential_for_wifi" msgid="6228425986551591864">"Se instaló para redes Wi-Fi"</string>
    <string name="credentials_reset_hint" msgid="6297256880896133631">"¿Quieres quitar todas las credenciales?"</string>
    <string name="credentials_erased" msgid="2907836028586342969">"Credenciales borradas"</string>
    <string name="credentials_not_erased" msgid="7685932772284216097">"Imposible borrar almac credenc"</string>
    <string name="usage_access_title" msgid="332333405495457839">"Acceso a datos de uso"</string>
    <string name="emergency_tone_title" msgid="254495218194925271">"Indicador de marcado de emergencia"</string>
    <string name="emergency_tone_summary" msgid="722259232924572153">"Establecer el comportamiento cuando se establece una llamada de emergencia"</string>
    <string name="privacy_settings_title" msgid="2978878794187459190">"Copia de seguridad"</string>
    <string name="backup_summary_state_on" msgid="6407084627816231202">"Activado"</string>
    <string name="backup_summary_state_off" msgid="7388321532624105594">"Desactivado"</string>
    <string name="backup_section_title" msgid="7952232291452882740">"Crear copia de seguridad y Restablecer"</string>
    <string name="personal_data_section_title" msgid="7815209034443782061">"Datos personales"</string>
    <string name="backup_data_title" msgid="1239105919852668016">"Hacer una copia de seguridad de mis datos"</string>
    <string name="backup_data_summary" msgid="708773323451655666">"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="3790872965773196615">"Cuenta de copia de seguridad"</string>
    <string name="backup_data_management_title" msgid="4059093462647090064">"Administrar la cuenta de la copia de seguridad"</string>
    <string name="include_app_data_title" msgid="2829970132260278394">"Incluir datos de aplicación"</string>
    <string name="auto_restore_title" msgid="5397528966329126506">"Restaurar automáticamente"</string>
    <string name="auto_restore_summary" msgid="4235615056371993807">"Al reinstalar se restablece la configuración con copia de seguridad."</string>
    <string name="backup_inactive_title" msgid="685838037986644604">"Servicio de copia de seguridad inactivo"</string>
    <string name="backup_configure_account_default_summary" msgid="2436933224764745553">"Ninguna cuenta está almacenando datos con copia de seguridad."</string>
    <string name="backup_erase_dialog_title" msgid="1027640829482174106"></string>
    <string name="backup_erase_dialog_message" msgid="5221011285568343155">"¿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="694766389396659626">"¿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="960850365007767734">"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="4960761799560705902">"Configuración del administrador del dispositivo"</string>
    <string name="active_device_admin_msg" msgid="578748451637360192">"App de administración del dispositivo"</string>
    <string name="remove_device_admin" msgid="9207368982033308173">"Desactivar esta app de administración del dispositivo"</string>
    <string name="uninstall_device_admin" msgid="271120195128542165">"Desinstalar app"</string>
    <string name="remove_and_uninstall_device_admin" msgid="3837625952436169878">"Desactivar y desinstalar"</string>
    <string name="select_device_admin_msg" msgid="7347389359013278077">"Apps del dispositivo del administrador"</string>
    <string name="no_device_admins" msgid="4846602835339095768">"No hay apps de administración de dispositivo disponibles"</string>
    <string name="personal_device_admin_title" msgid="2849617316347669861">"Personal"</string>
    <string name="managed_device_admin_title" msgid="7853955652864478435">"Trabajo"</string>
    <string name="no_trust_agents" msgid="7450273545568977523">"No hay agentes de confianza disponibles."</string>
    <string name="add_device_admin_msg" msgid="1501847129819382149">"¿Activar la app de administración?"</string>
    <string name="add_device_admin" msgid="4192055385312215731">"Activar la app de administración de este dispositivo"</string>
    <string name="device_admin_add_title" msgid="3140663753671809044">"Administrador del dispositivo"</string>
    <string name="device_admin_warning" msgid="7482834776510188134">"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="8085544856342321981">"<xliff:g id="APP_NAME">%1$s</xliff:g> administrará y supervisará este dispositivo."</string>
    <string name="device_admin_status" msgid="7234814785374977990">"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="6249331160676175009">"¿Activar el Administrador de perfiles?"</string>
    <string name="profile_owner_add_title_simplified" msgid="6856400286736117006">"¿Quieres permitir la supervisión?"</string>
    <string name="adding_profile_owner_warning" msgid="1354474524852805802">"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="7712694507069054530">"El administrador inhabilitó algunas opciones"</string>
    <string name="admin_more_details" msgid="7901420667346456102">"Más información"</string>
    <string name="notification_log_title" msgid="3766148588239398464">"Registro de notificaciones"</string>
    <string name="sound_category_call_ringtone_vibrate_title" msgid="1543777228646645163">"Vibración y tono de llamada"</string>
    <string name="wifi_setup_detail" msgid="2336990478140503605">"Detalles de la red"</string>
    <string name="accessibility_sync_enabled" msgid="558480439730263116">"Sincronización habilitada"</string>
    <string name="accessibility_sync_disabled" msgid="1741194106479011384">"Sincronización inhabilitada"</string>
    <string name="accessibility_sync_in_progress" msgid="4501160520879902723">"Sincronizando ahora"</string>
    <string name="accessibility_sync_error" msgid="8703299118794272041">"Error de sincronización"</string>
    <string name="sync_failed" msgid="1696499856374109647">"Error de sincronización"</string>
    <string name="sync_active" msgid="8476943765960863040">"Sincronización activada"</string>
    <string name="account_sync_settings_title" msgid="5131314922423053588">"Sincronización"</string>
    <string name="sync_is_failing" msgid="1591561768344128377">"En este momento la sincronización experimenta problemas. Volverá en breve."</string>
    <string name="add_account_label" msgid="7811707265834013767">"Agregar cuenta"</string>
    <string name="managed_profile_not_available_label" msgid="852263300911325904">"El perfil de trabajo aún no está disponible."</string>
    <string name="work_mode_label" msgid="7157582467956920750">"Perfil de trabajo"</string>
    <string name="work_mode_on_summary" msgid="3628349169847990263">"Administrado por tu organización"</string>
    <string name="work_mode_off_summary" msgid="2657138190560082508">"Las apps y las notificaciones están desactivadas"</string>
    <string name="remove_managed_profile_label" msgid="3856519337797285325">"Eliminar perfil de trabajo"</string>
    <string name="background_data" msgid="5779592891375473817">"Datos de fondo"</string>
    <string name="background_data_summary" msgid="8328521479872763452">"Las aplicaciones pueden sincronizar, enviar y recibir datos."</string>
    <string name="background_data_dialog_title" msgid="6059217698124786537">"¿Deseas desactivar los datos en segundo plano?"</string>
    <string name="background_data_dialog_message" msgid="6981661606680941633">"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="1682730255435062059">"Autosincronizar datos de aplic."</string>
    <string name="sync_enabled" msgid="4551148952179416813">"Sincronización activada"</string>
    <string name="sync_disabled" msgid="8511659877596511991">"Sincronización desactivada"</string>
    <string name="sync_error" msgid="5060969083117872149">"Error de sincronización"</string>
    <string name="last_synced" msgid="4242919465367022234">"Última sincronización: <xliff:g id="LAST_SYNC_TIME">%1$s</xliff:g>"</string>
    <string name="sync_in_progress" msgid="5151314196536070569">"Sincronizando…"</string>
    <string name="settings_backup" msgid="2274732978260797031">"Hacer una copia de seguridad de configuraciones"</string>
    <string name="settings_backup_summary" msgid="7916877705938054035">"Realizar copia de seguridad de mi configuración"</string>
    <string name="sync_menu_sync_now" msgid="6154608350395805683">"Sincronizar ahora"</string>
    <string name="sync_menu_sync_cancel" msgid="8292379009626966949">"Cancelar sincronización"</string>
    <string name="sync_one_time_sync" msgid="3733796114909082260">"Presiona para sincronizar ahora<xliff:g id="LAST_SYNC_TIME">
%1$s</xliff:g>"</string>
    <string name="sync_gmail" msgid="714886122098006477">"Gmail"</string>
    <string name="sync_calendar" msgid="9056527206714733735">"Calendario"</string>
    <string name="sync_contacts" msgid="9174914394377828043">"Contactos"</string>
    <string name="sync_plug" msgid="3905078969081888738"><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="6205903695598000286">"Conf. de sincronización de aplicación"</string>
    <string name="header_data_and_synchronization" msgid="5165024023936509896">"Sincronización y datos"</string>
    <string name="preference_change_password_title" msgid="8955581790270130056">"Cambiar contraseña"</string>
    <string name="header_account_settings" msgid="5382475087121880626">"Configuración de la cuenta"</string>
    <string name="remove_account_label" msgid="5921986026504804119">"Quitar cuenta"</string>
    <string name="header_add_an_account" msgid="756108499532023798">"Agregar cuenta"</string>
    <string name="really_remove_account_title" msgid="8800653398717172460">"¿Deseas eliminar la cuenta?"</string>
    <string name="really_remove_account_message" product="tablet" msgid="1936147502815641161">"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="3483528757922948356">"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="7507474724882080166">"Si quitas esta cuenta, se borrarán todos sus mensajes, contactos y otros datos del dispositivo."</string>
    <string name="remove_account_failed" msgid="3901397272647112455">"El administrador no permite este cambio"</string>
    <string name="cant_sync_dialog_title" msgid="2777238588398046285">"No se puede sincronizar manualmente"</string>
    <string name="cant_sync_dialog_message" msgid="1938380442159016449">"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="8035706727471334122">"Para iniciar el dispositivo Android, ingresa la contraseña."</string>
    <string name="enter_pin" msgid="5305333588093263790">"Para iniciar el dispositivo Android, ingresa el PIN."</string>
    <string name="enter_pattern" msgid="4187435713036808566">"Para iniciar el dispositivo Android, dibuja el patrón."</string>
    <string name="cryptkeeper_wrong_pattern" msgid="8423835922362956999">"Patrón incorrecto"</string>
    <string name="cryptkeeper_wrong_password" msgid="5200857195368904047">"Contraseña incorrecta"</string>
    <string name="cryptkeeper_wrong_pin" msgid="755720788765259382">"PIN incorrecto"</string>
    <string name="checking_decryption" msgid="8287458611802609493">"Comprobando…"</string>
    <string name="starting_android" msgid="4001324195902252681">"Iniciando Android…"</string>
    <string name="delete" msgid="4219243412325163003">"Borrar"</string>
    <string name="misc_files" msgid="6720680815969643497">"Archivos variados"</string>
    <string name="misc_files_selected_count" msgid="4647048020823912088">"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="2876232009069114352">"<xliff:g id="NUMBER">%1$s</xliff:g> de <xliff:g id="TOTAL">%2$s</xliff:g>"</string>
    <string name="select_all" msgid="1562774643280376715">"Seleccionar todo"</string>
    <string name="data_usage_summary_title" msgid="3804110657238092929">"Uso de datos"</string>
    <string name="data_usage_app_summary_title" msgid="5571051159374290375">"Wi-Fi y datos móviles"</string>
    <string name="data_usage_accounting" msgid="7170028915873577387">"La forma en que el proveedor contabiliza los datos puede variar en tu dispositivo."</string>
    <string name="data_usage_app" msgid="4970478397515423303">"Uso de aplicaciones"</string>
    <string name="data_usage_app_info_label" msgid="3409931235687866706">"INFO. DE LA APLICACIÓN"</string>
    <string name="data_usage_cellular_data" msgid="9168928285122125137">"Datos móviles"</string>
    <string name="data_usage_data_limit" msgid="1193930999713192703">"Establecer límite de datos"</string>
    <string name="data_usage_cycle" msgid="5652529796195787949">"Ciclo de uso de datos"</string>
    <string name="data_usage_app_items_header_text" msgid="5017850810459372828">"Uso de aplicaciones"</string>
    <string name="data_usage_menu_roaming" msgid="8042359966835203296">"Roaming de datos"</string>
    <string name="data_usage_menu_restrict_background" msgid="1989394568592253331">"Restringir datos en 2.º plano"</string>
    <string name="data_usage_menu_allow_background" msgid="2694761978633359223">"Permitir datos 2.º plano"</string>
    <string name="data_usage_menu_split_4g" msgid="5322857680792601899">"Uso aparte de datos móviles 4G"</string>
    <string name="data_usage_menu_show_wifi" msgid="2296217964873872571">"Mostrar Wi-Fi"</string>
    <string name="data_usage_menu_hide_wifi" msgid="7290056718050186769">"Ocultar Wi-Fi"</string>
    <string name="data_usage_menu_show_ethernet" msgid="5181361208532314097">"Mostrar uso de Ethernet"</string>
    <string name="data_usage_menu_hide_ethernet" msgid="3326702187179943681">"Ocultar uso de Ethernet"</string>
    <string name="data_usage_menu_metered" msgid="6235119991372755026">"Restricciones de red"</string>
    <string name="data_usage_menu_auto_sync" msgid="8203999775948778560">"Sincronizar datos automáticamente"</string>
    <string name="data_usage_menu_sim_cards" msgid="6410498422797244073">"Tarjetas SIM"</string>
    <string name="data_usage_cellular_data_summary" msgid="8413357481361268285">"Pausado en el límite"</string>
    <string name="account_settings_menu_auto_sync" msgid="6243013719753700377">"Sincronización automática"</string>
    <string name="account_settings_menu_auto_sync_personal" msgid="785541379617346438">"Sinc. auto. datos personales"</string>
    <string name="account_settings_menu_auto_sync_work" msgid="329565580969147026">"Sinc. auto. datos trabajo"</string>
    <string name="data_usage_change_cycle" msgid="7776556448920114866">"Cambiar el ciclo..."</string>
    <string name="data_usage_pick_cycle_day" msgid="4470796861757050966">"Día del mes para restablecer el ciclo de uso de datos:"</string>
    <string name="data_usage_empty" msgid="8621855507876539282">"Ninguna aplicación usó datos durante este período."</string>
    <string name="data_usage_label_foreground" msgid="4938034231928628164">"Primer plano"</string>
    <string name="data_usage_label_background" msgid="3225844085975764519">"Segundo plano"</string>
    <string name="data_usage_app_restricted" msgid="3568465218866589705">"Restringido"</string>
    <string name="data_usage_disable_mobile" msgid="8656552431969276305">"¿Deseas desactivar los datos móviles?"</string>
    <string name="data_usage_disable_mobile_limit" msgid="4644364396844393848">"Establecer límite datos móviles"</string>
    <string name="data_usage_disable_4g_limit" msgid="6233554774946681175">"Establecer límite de datos en 4G"</string>
    <string name="data_usage_disable_3g_limit" msgid="2558557840444266906">"Establecer límite de datos 2G-3G"</string>
    <string name="data_usage_disable_wifi_limit" msgid="1394901415264660888">"Limitar datos de Wi-Fi"</string>
    <string name="data_usage_tab_wifi" msgid="481146038146585749">"Wi-Fi"</string>
    <string name="data_usage_tab_ethernet" msgid="7298064366282319911">"Ethernet"</string>
    <string name="data_usage_tab_mobile" msgid="454140350007299045">"Móvil"</string>
    <string name="data_usage_tab_4g" msgid="1301978716067512235">"4 GB"</string>
    <string name="data_usage_tab_3g" msgid="6092169523081538718">"2 GB - 3 GB"</string>
    <string name="data_usage_list_mobile" msgid="5588685410495019866">"Celulares"</string>
    <string name="data_usage_list_none" msgid="3933892774251050735">"Ninguna"</string>
    <string name="data_usage_enable_mobile" msgid="986782622560157977">"Datos móviles"</string>
    <string name="data_usage_enable_3g" msgid="6304006671869578254">"Datos de 2 GB - 3 GB"</string>
    <string name="data_usage_enable_4g" msgid="3635854097335036738">"Datos de 4 GB"</string>
    <string name="data_roaming_enable_mobile" msgid="1523331545457578362">"Roaming"</string>
    <string name="data_usage_forground_label" msgid="7654319010655983591">"En primer plano:"</string>
    <string name="data_usage_background_label" msgid="2722008379947694926">"En segundo plano:"</string>
    <string name="data_usage_app_settings" msgid="2279171379771253165">"Configuración de la aplicación"</string>
    <string name="data_usage_app_restrict_background" msgid="7359227831562303223">"Datos en segundo plano"</string>
    <string name="data_usage_app_restrict_background_summary" msgid="5853552187570622572">"Habilitar el uso de datos móviles en segundo plano"</string>
    <string name="data_usage_app_restrict_background_summary_disabled" msgid="7401927377070755054">"Para restringir datos en 2.° plano aquí, limita datos móviles."</string>
    <string name="data_usage_app_restrict_dialog_title" msgid="1613108390242737923">"¿Restringir el uso de datos en segundo plano?"</string>
    <string name="data_usage_app_restrict_dialog" msgid="1466689968707308512">"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="55012417305745608">"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="2438617846762244389">"¿Activar sinc. automática?"</string>
    <string name="data_usage_auto_sync_on_dialog" product="tablet" msgid="8581983093524041669">"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="8651376294887142858">"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="9013139130490125793">"¿Desactivar sinc. automática?"</string>
    <string name="data_usage_auto_sync_off_dialog" msgid="4025938250775413864">"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="1373797281540188533">"Elige el día de inicio de cada ciclo"</string>
    <string name="data_usage_cycle_editor_subtitle" msgid="5512903797979928416">"Día de cada mes:"</string>
    <string name="data_usage_cycle_editor_positive" msgid="8821760330497941117">"Configurar"</string>
    <string name="data_usage_warning_editor_title" msgid="3704136912240060339">"Configurar advertencia de uso de datos"</string>
    <string name="data_usage_limit_editor_title" msgid="9153595142385030015">"Configurar límite de uso de datos"</string>
    <string name="data_usage_limit_dialog_title" msgid="3023111643632996097">"Limitar el uso de datos"</string>
    <string name="data_usage_limit_dialog_mobile" product="tablet" msgid="4983487893343645667">"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="3926320594049434225">"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="2201315502223035062">"¿Restringir el uso de datos en segundo plano?"</string>
    <string name="data_usage_restrict_background" msgid="434093644726734586">"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="7096707497743363380">"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="7910798414964288424">"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="6387081852568846982"><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="860566507375933039"><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="614263770923231598">"Aplicaciones eliminadas"</string>
    <string name="data_usage_uninstalled_apps_users" msgid="7986294489899813194">"Aplicaciones y usuarios eliminados"</string>
    <string name="data_usage_received_sent" msgid="5039699009276621757">"<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="4091294280619255237">"<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="1925687342154538972">"<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="5063981061103812900">"<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="7383175371006596441">"Restricciones de red"</string>
    <string name="data_usage_metered_body" msgid="7655851702771342507">"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="5423305619126978393">"Redes móviles"</string>
    <string name="data_usage_metered_wifi" msgid="1761738002328299714">"Redes Wi‑Fi medidas"</string>
    <string name="data_usage_metered_wifi_disabled" msgid="727808462375941567">"Para seleccionar redes medidas, activa el Wi-Fi."</string>
    <string name="data_usage_metered_auto" msgid="1262028400911918865">"Automático"</string>
    <string name="wifi_metered_title" msgid="5536703738895222444">"Uso de red"</string>
    <string name="data_usage_metered_yes" msgid="9217539611385225894">"Con uso medido"</string>
    <string name="data_usage_metered_no" msgid="4025232961929071789">"Sin uso medido"</string>
    <string name="data_usage_disclaimer" msgid="6887858149980673444">"La forma en que el proveedor calcula los datos puede variar en tu dispositivo."</string>
    <string name="cryptkeeper_emergency_call" msgid="198578731586097145">"Llamada de emergencia"</string>
    <string name="cryptkeeper_return_to_call" msgid="5613717339452772491">"Regresar a llamada"</string>
    <string name="vpn_name" msgid="4689699885361002297">"Nombre"</string>
    <string name="vpn_type" msgid="5435733139514388070">"Tipo"</string>
    <string name="vpn_server" msgid="2123096727287421913">"Dirección del servidor"</string>
    <string name="vpn_mppe" msgid="6639001940500288972">"Encriptación de PPP (MPPE)"</string>
    <string name="vpn_l2tp_secret" msgid="529359749677142076">"L2TP secreto"</string>
    <string name="vpn_ipsec_identifier" msgid="4098175859460006296">"Identificador IPSec"</string>
    <string name="vpn_ipsec_secret" msgid="4526453255704888704">"Clave de IPSec compartida previamente"</string>
    <string name="vpn_ipsec_user_cert" msgid="6880651510020187230">"Certificado de usuario IPSec"</string>
    <string name="vpn_ipsec_ca_cert" msgid="91338213449148229">"Certificado de CA de IPSec"</string>
    <string name="vpn_ipsec_server_cert" msgid="6599276718456935010">"Certificado de servidor IPSec"</string>
    <string name="vpn_show_options" msgid="7182688955890457003">"Mostrar opciones avanzadas"</string>
    <string name="vpn_search_domains" msgid="5391995501541199624">"Dominios de búsqueda de DNS"</string>
    <string name="vpn_dns_servers" msgid="5570715561245741829">"Servidores DNS (por ejemplo, 8.8.8.8)"</string>
    <string name="vpn_routes" msgid="3818655448226312232">"Rutas de reenvío (por ejemplo, 10.0.0.0/8)"</string>
    <string name="vpn_username" msgid="1863901629860867849">"Nombre de usuario"</string>
    <string name="vpn_password" msgid="6756043647233596772">"Contraseña"</string>
    <string name="vpn_save_login" msgid="6350322456427484881">"Guardar información de la cuenta"</string>
    <string name="vpn_not_used" msgid="9094191054524660891">"(no se utiliza)"</string>
    <string name="vpn_no_ca_cert" msgid="8776029412793353361">"(no verificar el servidor)"</string>
    <string name="vpn_no_server_cert" msgid="2167487440231913330">"(recibido desde el servidor)"</string>
    <string name="vpn_always_on_invalid_reason_type" msgid="7574518311224455825">"Este tipo de VPN no puede permanecer conectada todo el tiempo"</string>
    <string name="vpn_always_on_invalid_reason_server" msgid="477304620899799383">"VPN siempre activada solo es compatible con direcciones de servidor numéricas"</string>
    <string name="vpn_always_on_invalid_reason_no_dns" msgid="2226648961940273294">"Debe especificarse un servidor DNS para VPN siempre activada"</string>
    <string name="vpn_always_on_invalid_reason_dns" msgid="3551394495620249972">"Las direcciones de servidor DNS deben ser numéricas para VPN siempre activada"</string>
    <string name="vpn_always_on_invalid_reason_other" msgid="5959352052515258208">"La información ingresada no es compatible con VPN siempre activada"</string>
    <string name="vpn_cancel" msgid="1979937976123659332">"Cancelar"</string>
    <string name="vpn_done" msgid="8678655203910995914">"Ignorar"</string>
    <string name="vpn_save" msgid="4233484051644764510">"Guardar"</string>
    <string name="vpn_connect" msgid="8469608541746132301">"Conectar"</string>
    <string name="vpn_replace" msgid="5442836256121957861">"Reemplazar"</string>
    <string name="vpn_edit" msgid="8647191407179996943">"Editar perfil de VPN"</string>
    <string name="vpn_forget" msgid="3684651372749415446">"Olvidar"</string>
    <string name="vpn_connect_to" msgid="5965299358485793260">"Conectar a <xliff:g id="PROFILE">%s</xliff:g>"</string>
    <string name="vpn_disconnect_confirm" msgid="3743970132487505659">"¿Deseas desconectar esta VPN?"</string>
    <string name="vpn_disconnect" msgid="7426570492642111171">"Desconectar"</string>
    <string name="vpn_version" msgid="1939804054179766249">"Versión <xliff:g id="VERSION">%s</xliff:g>"</string>
    <string name="vpn_forget_long" msgid="2232239391189465752">"Borrar VPN"</string>
    <string name="vpn_replace_vpn_title" msgid="2963898301277610248">"¿Reemplazar VPN existente?"</string>
    <string name="vpn_set_vpn_title" msgid="4009987321156037267">"¿Configurar la VPN siempre activa?"</string>
    <string name="vpn_first_always_on_vpn_message" msgid="7144543717673197102">"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="798121133114824006">"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="3011818750025879902">"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="5611635724578812860">"Ya estás conectado a una VPN. Si te conectas a otra, se reemplazará la VPN actual."</string>
    <string name="vpn_turn_on" msgid="2363136869284273872">"Activar"</string>
    <string name="vpn_cant_connect_title" msgid="4517706987875907511">"No se puede establecer conexión con <xliff:g id="VPN_NAME">%1$s</xliff:g>"</string>
    <string name="vpn_cant_connect_message" msgid="1352832123114214283">"Esta app no es compatible con VPN siempre activada"</string>
    <string name="vpn_title" msgid="6317731879966640551">"VPN"</string>
    <string name="vpn_create" msgid="5628219087569761496">"Agregar perfil VPN"</string>
    <string name="vpn_menu_edit" msgid="408275284159243490">"Modificar perfil"</string>
    <string name="vpn_menu_delete" msgid="8098021690546891414">"Borrar perfil"</string>
    <string name="vpn_menu_lockdown" msgid="7863024538064268139">"VPN siempre activada"</string>
    <string name="vpn_no_vpns_added" msgid="5002741367858707244">"No se agregó ninguna VPN"</string>
    <string name="vpn_always_on_summary" msgid="2821344524094363617">"Mantente siempre conectado a una VPN"</string>
    <string name="vpn_always_on_summary_not_supported" msgid="592304911378771510">"La opción no es compatible con esta app"</string>
    <string name="vpn_always_on_summary_active" msgid="8800736191241875669">"La opción Siempre activa está habilitada"</string>
    <string name="vpn_require_connection" msgid="8388183166574269666">"Bloquear conexiones sin VPN"</string>
    <string name="vpn_require_connection_title" msgid="159053539340576331">"¿Requerir una conexión VPN?"</string>
    <string name="vpn_lockdown_summary" msgid="2200032066376720339">"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="9214462857336483711">"Ninguna"</string>
    <string name="vpn_lockdown_config_error" msgid="3898576754914217248">"La VPN siempre activada requiere una dirección IP tanto para el servidor como para el DNS."</string>
    <string name="vpn_no_network" msgid="3050233675132726155">"No hay conexión de red. Inténtalo de nuevo más tarde."</string>
    <string name="vpn_disconnected" msgid="280531508768927471">"Desconectado de la VPN"</string>
    <string name="vpn_disconnected_summary" msgid="3082851661207900606">"Ninguna"</string>
    <string name="vpn_missing_cert" msgid="5357192202207234745">"Falta un certificado. Edita el perfil."</string>
    <string name="trusted_credentials_system_tab" msgid="3984284264816924534">"Sistema"</string>
    <string name="trusted_credentials_user_tab" msgid="2244732111398939475">"Usuario"</string>
    <string name="trusted_credentials_disable_label" msgid="3864493185845818506">"Inhabilitar"</string>
    <string name="trusted_credentials_enable_label" msgid="2498444573635146913">"Activar"</string>
    <string name="trusted_credentials_remove_label" msgid="3633691709300260836">"Eliminar"</string>
    <string name="trusted_credentials_trust_label" msgid="8003264222650785429">"Confiar"</string>
    <string name="trusted_credentials_enable_confirmation" msgid="83215982842660869">"¿Deseas activar el certificado de CA del sistema?"</string>
    <string name="trusted_credentials_disable_confirmation" msgid="8199697813361646792">"¿Deseas desactivar el certificado de CA del sistema?"</string>
    <string name="trusted_credentials_remove_confirmation" msgid="443561923016852941">"¿Deseas eliminar de forma permanente el certificado de CA del usuario?"</string>
    <string name="credential_contains" msgid="3984922924723974084">"Esta entrada contiene lo siguiente:"</string>
    <string name="one_userkey" msgid="6034020579534914349">"una clave de usuario"</string>
    <string name="one_usercrt" msgid="2150319011101639509">"un certificado de usuario"</string>
    <string name="one_cacrt" msgid="6844397037970164809">"un Certificado de CA"</string>
    <string name="n_cacrts" msgid="5979300323482053820">"%d Certificados de CA"</string>
    <string name="user_credential_title" msgid="1954061209643070652">"Detalles de las credenciales"</string>
    <string name="user_credential_removed" msgid="6514189495799401838">"Credencial quitada: <xliff:g id="CREDENTIAL_NAME">%s</xliff:g>"</string>
    <string name="user_credential_none_installed" msgid="3729607560420971841">"No se instalaron credenciales de usuario"</string>
    <string name="spellcheckers_settings_title" msgid="399981228588011501">"Corrector ortográfico"</string>
    <string name="spellcheckers_settings_for_work_title" msgid="4114555511355171248">"Corrector ortográfico para el trabajo"</string>
    <string name="current_backup_pw_prompt" msgid="7735254412051914576">"Escribe tu contraseña actual de copia de seguridad completa aquí."</string>
    <string name="new_backup_pw_prompt" msgid="8755501377391998428">"Escribe una nueva contraseña para copias de seguridad completas."</string>
    <string name="confirm_new_backup_pw_prompt" msgid="3238728882512787864">"Vuelve a escribir aquí tu nueva contraseña de copia de seguridad completa."</string>
    <string name="backup_pw_set_button_text" msgid="2387480910044648795">"Definir contraseña de copia de seguridad"</string>
    <string name="backup_pw_cancel_button_text" msgid="8845630125391744615">"Cancelar"</string>
    <string name="additional_system_update_settings_list_item_title" msgid="214987609894661992">"Actualizaciones del sistema adicionales"</string>
    <string name="ssl_ca_cert_warning" msgid="2045866713601984673">"Es posible que la red esté supervisada"</string>
    <string name="done_button" msgid="1991471253042622230">"Listo"</string>
    <plurals name="ssl_ca_cert_dialog_title" formatted="false" msgid="7145092748045794650">
      <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="1489335297837656666">
      <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="30645643499556573">
      <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="8216218659139190498">"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="2426799352517325228">
      <item quantity="other">Revisar certificados</item>
      <item quantity="one">Revisar certificado</item>
    </plurals>
    <string name="user_settings_title" msgid="3493908927709169019">"Varios usuarios"</string>
    <string name="user_settings_footer_text" product="device" msgid="5947601460660791129">"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="2153761434649733502">"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="2844602828189838075">"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="7937158411137563543">"Usuarios y perfiles"</string>
    <string name="user_add_user_or_profile_menu" msgid="6923838875175259418">"Agregar usuario o perfil"</string>
    <string name="user_add_user_menu" msgid="1675956975014862382">"Agregar usuario"</string>
    <string name="user_summary_restricted_profile" msgid="6354966213806839107">"Perfil restringido"</string>
    <string name="user_need_lock_message" msgid="5879715064416886811">"Para poder crear un perfil restringido, debes configurar un bloqueo de pantalla que proteja tus aplicaciones y datos personales."</string>
    <string name="user_set_lock_button" msgid="8311219392856626841">"Configurar bloqueo"</string>
    <string name="user_summary_not_set_up" msgid="8778205026866794909">"No configurado"</string>
    <string name="user_summary_restricted_not_set_up" msgid="1628116001964325544">"Sin configurar - Perfil restringido"</string>
    <string name="user_summary_managed_profile_not_set_up" msgid="1659125858619760573">"Sin configurar: perfil de trabajo"</string>
    <string name="user_admin" msgid="993402590002400782">"Administrador"</string>
    <string name="user_you" msgid="1639158809315025986">"Tú (<xliff:g id="NAME">%s</xliff:g>)"</string>
    <string name="user_nickname" msgid="5148818000228994488">"Seudónimo"</string>
    <string name="user_add_user_type_title" msgid="2146438670792322349">"Agregar"</string>
    <string name="user_add_max_count" msgid="5405885348463433157">"Puedes agregar hasta <xliff:g id="USER_COUNT">%1$d</xliff:g> usuarios"</string>
    <string name="user_add_user_item_summary" msgid="4702776187132008661">"Los usuarios tienen sus propias aplicaciones y contenidos."</string>
    <string name="user_add_profile_item_summary" msgid="5931663986889138941">"Desde tu cuenta, puedes restringir el acceso a las aplicaciones y al contenido."</string>
    <string name="user_add_user_item_title" msgid="8212199632466198969">"Usuario"</string>
    <string name="user_add_profile_item_title" msgid="8353515490730363621">"Perfil restringido"</string>
    <string name="user_add_user_title" msgid="2108112641783146007">"¿Agregar usuario nuevo?"</string>
    <string name="user_add_user_message_long" msgid="6768718238082929201">"Para compartir este dispositivo, crea más usuarios. Cada uno tendrá su propio espacio y podrá personalizarlo con apps, un fondo de pantalla y mucho más. Los usuarios también podrán ajustar algunas opciones del dispositivo, como la conexión Wi‑Fi, que afectan a todos los usuarios.\n\nCuando agregues un nuevo usuario, esa persona deberá configurar su espacio.\n\nCualquier usuario podrá actualizar las apps de otras personas. Es posible que no se transfieran los servicios ni las opciones de accesibilidad al nuevo usuario."</string>
    <string name="user_add_user_message_short" msgid="1511354412249044381">"Cuando agregas un nuevo usuario, esa persona debe configurar su espacio.\n\nCualquier usuario puede actualizar las aplicaciones del resto de los usuarios."</string>
    <string name="user_setup_dialog_title" msgid="1765794166801864563">"¿Configurar el usuario ahora?"</string>
    <string name="user_setup_dialog_message" msgid="1004068621380867148">"Asegúrate de que la persona pueda acceder al dispositivo y configurar su espacio."</string>
    <string name="user_setup_profile_dialog_message" msgid="3896568553327558731">"¿Quieres configurar tu perfil ahora?"</string>
    <string name="user_setup_button_setup_now" msgid="3391388430158437629">"Configurar ahora"</string>
    <string name="user_setup_button_setup_later" msgid="3068729597269172401">"Ahora no"</string>
    <string name="user_cannot_manage_message" product="tablet" msgid="7153048188252553320">"Solo los propietarios de la tablet pueden administrar los usuarios."</string>
    <string name="user_cannot_manage_message" product="default" msgid="959315813089950649">"Solo los propietarios del dispositivo pueden administrar los usuarios."</string>
    <string name="user_cannot_add_accounts_message" msgid="5116692653439737050">"Los perfiles restringidos no pueden agregar cuentas."</string>
    <string name="user_remove_user_menu" msgid="6897150520686691355">"Borrar a <xliff:g id="USER_NAME">%1$s</xliff:g> del disp."</string>
    <string name="user_lockscreen_settings" msgid="4965661345247084878">"Configuración de pantalla bloqueada"</string>
    <string name="user_add_on_lockscreen_menu" msgid="9072312646546364619">"Agregar usuarios desde la pantalla de bloqueo"</string>
    <string name="user_new_user_name" msgid="369856859816028856">"Usuario nuevo"</string>
    <string name="user_new_profile_name" msgid="2632088404952119900">"Perfil nuevo"</string>
    <string name="user_confirm_remove_self_title" msgid="8432050170899479556">"¿Deseas borrarte a ti mismo?"</string>
    <string name="user_confirm_remove_title" msgid="8068422695175097315">"¿Borrar este usuario?"</string>
    <string name="user_profile_confirm_remove_title" msgid="5573161550669867342">"¿Eliminar este perfil?"</string>
    <string name="work_profile_confirm_remove_title" msgid="2017323555783522213">"¿Eliminar perfil trabajo?"</string>
    <string name="user_confirm_remove_self_message" product="tablet" msgid="2391372805233812410">"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="7943645442479360048">"Perderás tu espacio y tus datos en este dispositivo. No puedes deshacer esta acción."</string>
    <string name="user_confirm_remove_message" msgid="1020629390993095037">"Se borrarán todas las aplicaciones y todos los datos."</string>
    <string name="work_profile_confirm_remove_message" msgid="323856589749078140">"Si continúas, se borrarán todas las aplicaciones y los datos en este perfil."</string>
    <string name="user_profile_confirm_remove_message" msgid="7373754145959298522">"Se borrarán todas las aplicaciones y todos los datos."</string>
    <string name="user_adding_new_user" msgid="1521674650874241407">"Agregando usuario nuevo..."</string>
    <string name="user_delete_user_description" msgid="3158592592118767056">"Borrar usuario"</string>
    <string name="user_delete_button" msgid="5131259553799403201">"Borrar"</string>
    <string name="user_guest" msgid="8475274842845401871">"Invitado"</string>
    <string name="user_exit_guest_title" msgid="5613997155527410675">"Eliminar invitado"</string>
    <string name="user_exit_guest_confirm_title" msgid="3405527634738147409">"¿Eliminar invitado?"</string>
    <string name="user_exit_guest_confirm_message" msgid="2194459201944413257">"Se eliminarán las aplicaciones y los datos de esta sesión."</string>
    <string name="user_exit_guest_dialog_remove" msgid="6351370829952745350">"Eliminar"</string>
    <string name="user_enable_calling" msgid="5128605672081602348">"Activar llamadas de teléfono"</string>
    <string name="user_enable_calling_sms" msgid="9172507088023097063">"Activar llamadas telefónicas y SMS"</string>
    <string name="user_remove_user" msgid="3612979309028881318">"Borrar usuario"</string>
    <string name="user_enable_calling_confirm_title" msgid="4315789475268695378">"¿Activar llamadas telefónicas?"</string>
    <string name="user_enable_calling_confirm_message" msgid="8061594235219352787">"Se compartirá el historial de llamadas con este usuario."</string>
    <string name="user_enable_calling_and_sms_confirm_title" msgid="7243308401401932681">"¿Activar llamadas telefónicas y SMS?"</string>
    <string name="user_enable_calling_and_sms_confirm_message" msgid="4025082715546544967">"Se compartirá el historial de llamadas y SMS con este usuario."</string>
    <string name="emergency_info_title" msgid="208607506217060337">"Información de emergencia"</string>
    <string name="emergency_info_summary" msgid="5062945162967838521">"Información y contactos de <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="application_restrictions" msgid="8207332020898004394">"Permitir aplicaciones y contenido"</string>
    <string name="apps_with_restrictions_header" msgid="3660449891478534440">"Aplicaciones con restricciones"</string>
    <string name="apps_with_restrictions_settings_button" msgid="3841347287916635821">"Expandir config. a aplicación"</string>
    <string name="nfc_payment_settings_title" msgid="1807298287380821613">"Toca y paga"</string>
    <string name="nfc_payment_how_it_works" msgid="3028822263837896720">"Cómo funciona"</string>
    <string name="nfc_payment_no_apps" msgid="5477904979148086424">"Paga en las tiendas con tu teléfono"</string>
    <string name="nfc_payment_default" msgid="8648420259219150395">"App de pago predeterminada"</string>
    <string name="nfc_payment_default_not_set" msgid="7485060884228447765">"Sin establecer"</string>
    <string name="nfc_payment_app_and_desc" msgid="7942415346564794258">"<xliff:g id="APP">%1$s</xliff:g>: <xliff:g id="DESCRIPTION">%2$s</xliff:g>"</string>
    <string name="nfc_payment_use_default" msgid="3234730182120288495">"Utilizar la aplicación predeterminada"</string>
    <string name="nfc_payment_favor_default" msgid="5743781166099608372">"Siempre"</string>
    <string name="nfc_payment_favor_open" msgid="1923314062109977944">"Excepto cuando otra app de pagos esté abierta"</string>
    <string name="nfc_payment_pay_with" msgid="7524904024378144072">"En una terminal Tocar y pagar, pagar con:"</string>
    <string name="nfc_how_it_works_title" msgid="1984068457698797207">"Cómo pagar en la terminal"</string>
    <string name="nfc_how_it_works_content" msgid="4749007806393224934">"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="259653300203217402">"Entendido"</string>
    <string name="nfc_more_title" msgid="815910943655133280">"Más…"</string>
    <string name="nfc_payment_set_default_label" msgid="7315817259485674542">"¿Establecer como preferencia?"</string>
    <string name="nfc_payment_set_default" msgid="8532426406310833489">"¿Quieres usar <xliff:g id="APP">%1$s</xliff:g> siempre con Tocar y pagar?"</string>
    <string name="nfc_payment_set_default_instead_of" msgid="6993301165940432743">"¿Quieres usar <xliff:g id="APP_0">%1$s</xliff:g> siempre en lugar de <xliff:g id="APP_1">%2$s</xliff:g> con Tocar y pagar?"</string>
    <string name="restriction_settings_title" msgid="4233515503765879736">"Restricciones"</string>
    <string name="restriction_menu_reset" msgid="2067644523489568173">"Eliminar restricciones"</string>
    <string name="restriction_menu_change_pin" msgid="740081584044302775">"Cambiar PIN"</string>
    <string name="app_notifications_switch_label" msgid="9124072219553687583">"Mostrar notificaciones"</string>
    <string name="help_label" msgid="6886837949306318591">"Ayuda y comentarios"</string>
    <string name="support_summary" msgid="2705726826263742491">"Artículos de ayuda, teléfono y chat, comenzar"</string>
    <string name="user_account_title" msgid="1127193807312271167">"Cuenta para contenido"</string>
    <string name="user_picture_title" msgid="7297782792000291692">"ID de foto"</string>
    <string name="extreme_threats_title" msgid="6549541803542968699">"Amenazas extremas"</string>
    <string name="extreme_threats_summary" msgid="8777860706500920667">"Recibir alertas de amenazas extremas contra la vida y propiedad"</string>
    <string name="severe_threats_title" msgid="8362676353803170963">"Amenazas graves"</string>
    <string name="severe_threats_summary" msgid="8848126509420177320">"Recibir alertas de amenazas graves contra la vida y la propiedad"</string>
    <string name="amber_alerts_title" msgid="2772220337031146529">"Alertas AMBER"</string>
    <string name="amber_alerts_summary" msgid="4312984614037904489">"Recibir boletines sobre secuestros de menores"</string>
    <string name="repeat_title" msgid="6473587828597786996">"Repetir"</string>
    <string name="call_manager_enable_title" msgid="7718226115535784017">"Habilitar el Administrador de llamadas"</string>
    <string name="call_manager_enable_summary" msgid="8458447798019519240">"Permitir que este servicio administre la forma de hacer llamadas"</string>
    <string name="call_manager_title" msgid="4479949569744516457">"Administrador de llamadas"</string>
    <!-- no translation found for call_manager_summary (5918261959486952674) -->
    <skip />
    <string name="cell_broadcast_settings" msgid="4124461751977706019">"Alertas de emergencia"</string>
    <string name="network_operators_settings" msgid="2583178259504630435">"Proveedores de red"</string>
    <string name="access_point_names" msgid="1381602020438634481">"Nombres de puntos de acceso"</string>
    <string name="enhanced_4g_lte_mode_title" msgid="2544026384901010606">"VoLTE"</string>
    <string name="enhanced_4g_lte_mode_title_advanced_calling" msgid="480304128966864221">"Llamadas avanzadas"</string>
    <string name="enhanced_4g_lte_mode_title_4g_calling" msgid="6839553611093179243">"Llamadas mediante 4G"</string>
    <string name="enhanced_4g_lte_mode_summary" msgid="4156658595226379286">"Usa servicios de LTE para mejorar comunicaciones de voz y otras (recomendado)"</string>
    <string name="enhanced_4g_lte_mode_summary_4g_calling" msgid="6145184730437907078">"Usar servicios 4G para mejorar comunicaciones de voz y otras (recomendado)"</string>
    <string name="preferred_network_type_title" msgid="3431041717309776341">"Tipo de red preferido"</string>
    <string name="preferred_network_type_summary" msgid="6564884693884755019">"LTE (recomendado)"</string>
    <string name="mms_message_title" msgid="6068098013612041440">"Mensajes MMS"</string>
    <string name="mms_message_summary" msgid="8408985719331988420">"Enviar y recibir con los datos móviles desactivados"</string>
    <string name="data_during_calls_title" msgid="4476240693784306761">"Uso de datos durante llamadas"</string>
    <string name="data_during_calls_summary" msgid="497978580819604521">"Permitir el uso de esta SIM con datos móviles solo durante llamadas"</string>
    <string name="work_sim_title" msgid="4843322164662606891">"SIM de trabajo"</string>
    <string name="user_restrictions_title" msgid="5794473784343434273">"Acceso a aplicaciones y contenido"</string>
    <string name="user_rename" msgid="8523499513614655279">"CAMBIAR NOMBRE"</string>
    <string name="app_restrictions_custom_label" msgid="6160672982086584261">"Definir restricciones de aplicación"</string>
    <string name="user_restrictions_controlled_by" msgid="3164078767438313899">"Controladas por <xliff:g id="APP">%1$s</xliff:g>"</string>
    <string name="app_sees_restricted_accounts" msgid="7503264525057246240">"Esta aplicación puede acceder a tus cuentas."</string>
    <string name="app_sees_restricted_accounts_and_controlled_by" msgid="6968697624437267294">"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="8889556384136994814">"Wi‑Fi y red de celulares"</string>
    <string name="restriction_wifi_config_summary" msgid="70888791513065244">"Permitir modificar la configuración de la red Wi‑Fi y de la red de celulares"</string>
    <string name="restriction_bluetooth_config_title" msgid="8871681580962503671">"Bluetooth"</string>
    <string name="restriction_bluetooth_config_summary" msgid="8372319681287562506">"Permitir modificar la sincronización y configuración de Bluetooth"</string>
    <string name="restriction_nfc_enable_title" msgid="5888100955212267941">"NFC"</string>
    <string name="restriction_nfc_enable_summary_config" msgid="3232480757215851738">"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="3891097373396149915">"Permitir el intercambio de datos cuando la tablet toque otro dispositivo"</string>
    <string name="restriction_nfc_enable_summary" product="default" msgid="825331120501418592">"Permitir el intercambio de datos cuando el teléfono toque otro dispositivo"</string>
    <string name="restriction_location_enable_title" msgid="5020268888245775164">"Ubicación"</string>
    <string name="restriction_location_enable_summary" msgid="3489765572281788755">"Permitir que las aplicaciones usen la información de tu ubicación"</string>
    <string name="wizard_back" msgid="5567007959434765743">"Atrás"</string>
    <string name="wizard_next" msgid="3606212602795100640">"Siguiente"</string>
    <string name="wizard_finish" msgid="3286109692700083252">"Finalizar"</string>
    <string name="user_image_take_photo" msgid="4038201220173969126">"Toma una foto"</string>
    <string name="user_image_choose_photo" msgid="7643300431215339631">"Elige una imagen"</string>
    <string name="user_image_photo_selector" msgid="5492565707299454873">"Seleccionar foto"</string>
    <string name="regulatory_info_text" msgid="5623087902354026557"></string>
    <string name="sim_setup_wizard_title" msgid="1732682852692274928">"Tarjetas SIM"</string>
    <string name="sim_settings_title" msgid="6822745211458959756">"Tarjetas SIM"</string>
    <string name="sim_settings_summary" msgid="4050372057097516088">"<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="7900721153345139783">"Las tarjetas SIM cambiaron."</string>
    <string name="sim_cards_changed_message_summary" msgid="8258058274989383204">"Presiona para establecer actividades"</string>
    <string name="sim_cellular_data_unavailable" msgid="9109302537004566098">"Datos móviles no disponibles"</string>
    <string name="sim_cellular_data_unavailable_summary" msgid="5416535001368135327">"Presiona para seleccionar una SIM de datos"</string>
    <string name="sim_calls_always_use" msgid="7936774751250119715">"Usar siempre para llamadas"</string>
    <string name="select_sim_for_data" msgid="2366081042162853044">"Seleccionar SIM para datos"</string>
    <string name="select_sim_for_sms" msgid="6232060107120265044">"Selecciona una SIM para los SMS"</string>
    <string name="data_switch_started" msgid="2040761479817166311">"Cambiando SIM de datos, esto puede demorar unos minutos…"</string>
    <string name="select_sim_for_calls" msgid="3503094771801109334">"Llamar con"</string>
    <string name="sim_select_card" msgid="211285163525563293">"Seleccionar una tarjeta SIM"</string>
    <string name="sim_card_number_title" msgid="7845379943474336488">"SIM <xliff:g id="CARD_NUMBER">%1$d</xliff:g>"</string>
    <string name="sim_slot_empty" msgid="8964505511911854688">"SIM vacía"</string>
    <string name="sim_editor_name" msgid="1722945976676142029">"Nombre de SIM"</string>
    <string name="sim_name_hint" msgid="7038643345238968930">"Ingresar nombre de tarjeta SIM"</string>
    <string name="sim_editor_title" msgid="4034301817366627870">"Ranura de SIM %1$d"</string>
    <string name="sim_editor_carrier" msgid="5684523444677746573">"Proveedor"</string>
    <string name="sim_editor_number" msgid="6705955651035440667">"Número"</string>
    <string name="sim_editor_color" msgid="2542605938562414355">"Color de SIM"</string>
    <string name="sim_card_select_title" msgid="6668492557519243456">"Seleccionar tarjeta SIM"</string>
    <string name="color_orange" msgid="4417567658855022517">"Naranja"</string>
    <string name="color_purple" msgid="3888532466427762504">"Púrpura"</string>
    <string name="sim_no_inserted_msg" msgid="210316755353227087">"No se insertó ninguna tarjeta SIM."</string>
    <string name="sim_status_title" msgid="6744870675182447160">"Estado de SIM"</string>
    <string name="sim_status_title_sim_slot" msgid="5725659316463979194">"Estado de SIM (ranura de SIM %1$d)"</string>
    <string name="sim_call_back_title" msgid="5181549885999280334">"Devolver la llamada desde la tarjeta SIM predeterminada"</string>
    <string name="sim_outgoing_call_title" msgid="1019763076116874255">"Tarjeta SIM para llamadas salientes"</string>
    <string name="sim_other_call_settings" msgid="8247802316114482477">"Otras configuraciones de llamada"</string>
    <string name="preferred_network_offload_title" msgid="1605829724169550275">"Aliger. de red preferido"</string>
    <string name="preferred_network_offload_header" msgid="2321173571529106767">"Inhab. mostrar nombre red"</string>
    <string name="preferred_network_offload_footer" msgid="5857279426054744020">"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="2252915199889604600">"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="9144010043784767984">"<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="6272913297433198340">"Tarjetas SIM modificadas"</string>
    <string name="sim_notification_summary" msgid="8858043655706669772">"Presiona para configurar"</string>
    <string name="sim_pref_divider" msgid="6778907671867621874">"SIM preferida para"</string>
    <string name="sim_calls_ask_first_prefs_title" msgid="7941299533514115976">"Preguntar siempre"</string>
    <string name="sim_selection_required_pref" msgid="3446721423206414652">"Selección requerida"</string>
    <string name="sim_selection_channel_title" msgid="2760909074892782589">"Selección de SIM"</string>
    <string name="dashboard_title" msgid="5453710313046681820">"Configuración"</string>
    <plurals name="settings_suggestion_header_summary_hidden_items" formatted="false" msgid="5597356221942118048">
      <item quantity="other">Mostrar %d elementos ocultos</item>
      <item quantity="one">Mostrar %d elemento oculto</item>
    </plurals>
    <string name="network_dashboard_title" msgid="3135144174846753758">"Internet y redes"</string>
    <string name="network_dashboard_summary_mobile" msgid="3851083934739500429">"red móvil"</string>
    <string name="network_dashboard_summary_data_usage" msgid="3843261364705042212">"uso de datos"</string>
    <string name="network_dashboard_summary_hotspot" msgid="8494210248613254574">"hotspot"</string>
    <string name="connected_devices_dashboard_title" msgid="2355264951438890709">"Dispositivos conectados"</string>
    <string name="connected_devices_dashboard_summary" msgid="2665221896894251402">"Bluetooth, En automóvil, NFC"</string>
    <string name="connected_devices_dashboard_no_nfc_summary" msgid="3840842725283655533">"Bluetooth, En automóvil"</string>
    <string name="connected_devices_dashboard_no_driving_mode_summary" msgid="5018708106066758867">"Bluetooth, NFC"</string>
    <string name="connected_devices_dashboard_no_driving_mode_no_nfc_summary" msgid="5250078362483148199">"Bluetooth"</string>
    <string name="app_and_notification_dashboard_title" msgid="7838365599185397539">"Apps y notificaciones"</string>
    <string name="app_and_notification_dashboard_summary" msgid="3285151907659820564">"Apps recientes y predeterminadas"</string>
    <string name="notification_settings_work_profile" msgid="3186757479243373003">"Las apps del perfil de trabajo no tienen acceso a las notificaciones."</string>
    <string name="account_dashboard_title" msgid="5895948991491438911">"Cuentas"</string>
    <string name="account_dashboard_default_summary" msgid="3998347400161811075">"No se agregó ninguna cuenta"</string>
    <string name="app_default_dashboard_title" msgid="7342549305933047317">"Apps predeterminadas"</string>
    <string name="system_dashboard_summary" msgid="6839969589170062254">"Idiomas, gestos, hora, copia de seguridad"</string>
    <string name="search_results_title" msgid="1796252422574886932">"Configuración"</string>
    <string name="keywords_wifi" msgid="3646884600964177062">"Wi-Fi, wi-fi, conexión de red, Internet, inalámbrico, datos, wifi"</string>
    <string name="keywords_wifi_notify_open_networks" msgid="8745178424405564885">"notificación de Wi-Fi, notificación de wifi"</string>
    <string name="keywords_vibrate_on_touch" msgid="1494239633254176598">"Detener vibración, presionar, teclado"</string>
    <string name="keywords_time_format" msgid="5581515674151927461">"Usar formato de 24 horas"</string>
    <string name="keywords_storage_files" msgid="7075933058850826819">"Descarga"</string>
    <string name="keywords_app_default" msgid="5822717006354487071">"Abrir con"</string>
    <string name="keywords_applications_settings" msgid="1268353611121497450">"Apps"</string>
    <string name="keywords_time_zone" msgid="998254736898753085">"zona horaria"</string>
    <string name="keywords_draw_overlay" msgid="1001120206241401007">"burbuja de chat, sistema, alerta, ventana, diálogo, mostrar, sobre otras apps, dibujo"</string>
    <string name="keywords_flashlight" msgid="6161632177705233710">"Linterna, luz"</string>
    <string name="keywords_change_wifi_state" msgid="627068244033681010">"Wi-Fi, activar o desactivar, control"</string>
    <string name="keywords_more_mobile_networks" msgid="8995946622054642367">"celular, móvil, operador de telefonía celular, inalámbrico, datos, 4G, 3G, 2G, LTE"</string>
    <string name="keywords_wifi_calling" msgid="1784064367330122679">"wifi, wi-fi, llamar, llamada"</string>
    <string name="keywords_display" msgid="8910345814565493016">"pantalla, pantalla táctil"</string>
    <string name="keywords_display_brightness_level" msgid="3138350812626210404">"atenuar pantalla, pantalla táctil, batería, brillo"</string>
    <string name="keywords_display_night_display" msgid="2534032823231355074">"atenuar pantalla, luz nocturna, tono, modo nocturno, brillo, color de pantalla, color, colores"</string>
    <string name="keywords_display_wallpaper" msgid="7362076351860131776">"fondo, personalizar, personalizar pantalla"</string>
    <string name="keywords_display_font_size" msgid="3404655440064726124">"tamaño del texto"</string>
    <string name="keywords_display_cast_screen" msgid="1209288893924324904">"proyectar, transmitir, duplicar pantalla, compartir pantalla, duplicar pantalla compartida, transmitir pantalla"</string>
    <string name="keywords_storage" msgid="3299217909546089225">"espacio, disco, disco duro, uso de dispositivo"</string>
    <string name="keywords_battery" msgid="1173830745699768388">"uso de energía, carga"</string>
    <string name="keywords_spell_checker" msgid="1399641226370605729">"ortografía, diccionario, corrector ortográfico, corrección automática"</string>
    <string name="keywords_voice_input" msgid="769778245192531102">"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="5150660047085754699">"tarifa, idioma, predeterminado, hablar, texto a voz, accesibilidad, lector de pantalla, ciego"</string>
    <string name="keywords_date_and_time" msgid="758325881602648204">"reloj, horario militar"</string>
    <string name="keywords_network_reset" msgid="6024276007080940820">"restablecer, configuración de fábrica"</string>
    <string name="keywords_factory_data_reset" msgid="2261491208836438871">"borrar, eliminar, restaurar, quitar, restablecer a la configuración de fábrica"</string>
    <string name="keywords_printing" msgid="1701778563617114846">"impresora"</string>
    <string name="keywords_sounds" msgid="5633386070971736608">"sonido de la bocina, bocina, volumen, silenciar, silencio, audio, música"</string>
    <string name="keywords_sounds_and_notifications_interruptions" msgid="5426093074031208917">"no interrumpir, interrumpir, interrupción, descanso"</string>
    <string name="keywords_app" msgid="6334757056536837791">"RAM"</string>
    <string name="keywords_location" msgid="4132655528196729043">"nearby, ubicación, historial, informe, GPS"</string>
    <string name="keywords_accounts" msgid="4479029747403203867">"cuenta, agregar una cuenta, perfil de trabajo"</string>
    <string name="keywords_users" msgid="3434190133131387942">"restricción, restringir, restringido"</string>
    <string name="keywords_keyboard_and_ime" msgid="9143339015329957107">"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="5293291209613191845">"restablecer, preferencias, predeterminadas"</string>
    <string name="keywords_all_apps" msgid="7814015440655563156">"apps, descarga, aplicaciones, sistema"</string>
    <string name="keywords_app_permissions" msgid="4229936435938011023">"apps, permisos, seguridad"</string>
    <string name="keywords_default_apps" msgid="223872637509160136">"apps, predeterminado"</string>
    <string name="keywords_ignore_optimizations" msgid="6102579291119055029">"ignorar optimizaciones, descanso, app standby"</string>
    <string name="keywords_color_mode" msgid="6362744316886077510">"vibrante, RGB, sRGB, color, natural, estándar"</string>
    <string name="keywords_color_temperature" msgid="6239410718075715449">"color, temperatura, D65, D73, blanco, amarillo, azul, cálido, frío"</string>
    <string name="keywords_lockscreen" msgid="5746561909668570047">"desliza para desbloquear, contraseña, patrón, PIN"</string>
    <string name="keywords_profile_challenge" msgid="789611397846512845">"desafíos de trabajo, trabajo, perfil"</string>
    <string name="keywords_unification" msgid="1922900767659821025">"perfil de trabajo, perfil administrado, unificar, unificación, trabajo, perfil"</string>
    <string name="keywords_gesture" msgid="3526905012224714078">"gestos"</string>
    <string name="keywords_payment_settings" msgid="5220104934130446416">"pagar, presionar, pagos"</string>
    <string name="keywords_backup" msgid="470070289135403022">"copia de seguridad, copia"</string>
    <string name="keywords_assist_gesture_launch" msgid="813968759791342591">"gesto"</string>
    <string name="keywords_face_unlock" msgid="254144854349092754">"rostro, desbloqueo, autorización, acceder"</string>
    <string name="keywords_imei_info" msgid="7230982940217544527">"imei, meid, min, versión de prl, imei sv"</string>
    <string name="keywords_sim_status" msgid="6682044233620329507">"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="1459248377212829642">"número de serie, versión de hardware"</string>
    <string name="keywords_android_version" msgid="9069747153590902819">"nivel de parche de seguridad de android, versión de banda base, versión de kernel"</string>
    <string name="keywords_dark_ui_mode" msgid="8999745898782012625">"tema, claro, oscuro, modo"</string>
    <string name="keywords_systemui_theme" msgid="9112852512550404882">"tema oscuro"</string>
    <string name="keywords_device_feedback" msgid="564493721125966719">"error"</string>
    <string name="keywords_ambient_display_screen" msgid="5874969496073249362">"Pantalla Ambiente, pantalla bloqueada"</string>
    <string name="keywords_lock_screen_notif" msgid="6716392855813576197">"notificación en pantalla bloqueada, notificaciones"</string>
    <string name="keywords_face_settings" msgid="7505388678116799329">"rostro"</string>
    <string name="keywords_fingerprint_settings" msgid="4425098764810291897">"huella digital, agregar huella digital"</string>
    <string name="keywords_display_auto_brightness" msgid="4561771351118904241">"atenuar pantalla, pantalla táctil, batería, brillo inteligente, brillo dinámico, brillo automático"</string>
    <string name="keywords_display_adaptive_sleep" msgid="6865504720946121402">"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="5620879898668211494">"rotar, girar, rotación, retrato, paisaje, orientación, vertical, horizontal"</string>
    <string name="keywords_system_update_settings" msgid="7752189778843741773">"actualizar, Android"</string>
    <string name="keywords_zen_mode_settings" msgid="6526742836231604995">"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="8161370660970309476">"pantalla, tiempo de bloqueo, tiempo de espera de la pantalla, bloqueo de pantalla"</string>
    <string name="keywords_storage_settings" msgid="297283751968446577">"memoria, caché, datos, eliminar, borrar, liberar, espacio"</string>
    <string name="keywords_bluetooth_settings" msgid="6804844062789439858">"conectado, dispositivo, audífonos, auriculares, bocina, inalámbrico, sincronizar, auricular, música, multimedia"</string>
    <string name="keywords_wallpaper" msgid="5058364390917429896">"fondo, pantalla, pantalla bloqueada, tema"</string>
    <string name="keywords_styles" msgid="5828725481814049422">"forma del ícono, color destacado, fuente"</string>
    <string name="keywords_assist_input" msgid="5017533309492679287">"predeterminado, asistente"</string>
    <string name="keywords_default_payment_app" msgid="3838565809518896799">"pago, predeterminado"</string>
    <string name="keywords_ambient_display" msgid="3103487805748659132">"notificación entrante"</string>
    <string name="keywords_hotspot_tethering" msgid="1137511742967410918">"conexión USB, conexión Bluetooth, hotspot de Wi-Fi"</string>
    <string name="keywords_touch_vibration" msgid="5983211715076385822">"tecnología háptica, vibrar, pantalla, sensibilidad"</string>
    <string name="keywords_ring_vibration" msgid="4652101158979064884">"háptica, vibrar, teléfono, llamada, sensibilidad, tono"</string>
    <string name="keywords_notification_vibration" msgid="31924624421190547">"háptica, vibrar, sensibilidad"</string>
    <string name="keywords_battery_saver_sticky" msgid="5586215686021650278">"ahorro de batería, fijo, permanente, ahorro de energía, batería"</string>
    <string name="keywords_battery_saver_schedule" msgid="7358789228486231944">"rutina, programa, ahorro de batería, ahorro de energía, batería, automático, porcentaje"</string>
    <string name="keywords_enhance_4g_lte" msgid="2273810564244790859">"volte, llamadas avanzadas, llamadas mediante 4G"</string>
    <string name="default_sound" msgid="8821684447333687810">"Sonido predeterminado"</string>
    <string name="sound_settings_summary" msgid="4100853606668287965">"Volumen de tono: <xliff:g id="PERCENTAGE">%1$s</xliff:g>"</string>
    <string name="sound_dashboard_summary" msgid="3402435125958012986">"Volumen, vibración, No interrumpir"</string>
    <string name="sound_settings_summary_vibrate" msgid="1869282574422220096">"Timbre en vibración"</string>
    <string name="sound_settings_summary_silent" msgid="5074529767435584948">"Timbre en silencio"</string>
    <string name="sound_settings_example_summary" msgid="2404914514266523165">"Volumen de tono: 80%"</string>
    <string name="media_volume_option_title" msgid="2811531786073003825">"Volumen multimedia"</string>
    <string name="remote_media_volume_option_title" msgid="7602586327091007461">"Volumen de transmisión"</string>
    <string name="call_volume_option_title" msgid="1265865226974255384">"Volumen de llamada"</string>
    <string name="alarm_volume_option_title" msgid="8219324421222242421">"Volumen de alarma"</string>
    <string name="ring_volume_option_title" msgid="6767101703671248309">"Volumen de tono"</string>
    <string name="notification_volume_option_title" msgid="6064656124416882130">"Volumen de notificación"</string>
    <string name="ringtone_title" msgid="5379026328015343686">"Tono de llamada"</string>
    <string name="notification_ringtone_title" msgid="4468722874617061231">"Sonido predeterminado"</string>
    <string name="notification_unknown_sound_title" msgid="2535027767851838335">"Sonido que proporcionó la app"</string>
    <string name="notification_sound_default" msgid="565135733949733766">"Sonido de notificaciones predeterminado"</string>
    <string name="alarm_ringtone_title" msgid="6344025478514311386">"Sonido de alarma predeterminado"</string>
    <string name="vibrate_when_ringing_title" msgid="8658910997501323472">"Vibrar para llamadas"</string>
    <string name="other_sound_settings" msgid="3151004537006844718">"Otros sonidos"</string>
    <string name="dial_pad_tones_title" msgid="1999293510400911558">"Tonos del teclado"</string>
    <string name="screen_locking_sounds_title" msgid="1340569241625989837">"Bloqueo de pantalla"</string>
    <string name="charging_sounds_title" msgid="3379885700913955599">"Vibración y sonidos de carga"</string>
    <string name="docking_sounds_title" msgid="155236288949940607">"Sonidos al conectar"</string>
    <string name="touch_sounds_title" msgid="5326587106892390176">"Tonos táctiles"</string>
    <string name="vibrate_on_touch_title" msgid="1510405818894719079">"Vibración táctil"</string>
    <string name="vibrate_on_touch_summary" msgid="8015901758501868229">"Respuesta táctil al presionar, usar el teclado y más"</string>
    <string name="dock_audio_media_title" msgid="1346838179626123900">"Reprod. parlantes conector"</string>
    <string name="dock_audio_media_disabled" msgid="3430953622491538080">"Todo el audio"</string>
    <string name="dock_audio_media_enabled" msgid="667849382924908673">"Solo audio multimedia"</string>
    <string name="emergency_tone_silent" msgid="3750231842974733677">"Silencio"</string>
    <string name="emergency_tone_alert" msgid="8523447641290736852">"Tonos"</string>
    <string name="emergency_tone_vibrate" msgid="2278872257053690683">"Vibraciones"</string>
    <string name="boot_sounds_title" msgid="567029107382343709">"Activar los sonidos"</string>
    <string name="live_caption_title" msgid="2241633148129286971">"Subtitulado instantáneo"</string>
    <string name="live_caption_summary" msgid="3365960379606535783">"Subtitular automáticamente"</string>
    <string name="zen_mode_settings_summary_off" msgid="6119891445378113334">"Nunca"</string>
    <plurals name="zen_mode_settings_summary_on" formatted="false" msgid="2249085722517252521">
      <item quantity="other"><xliff:g id="ON_COUNT">%d</xliff:g> habilitadas</item>
      <item quantity="one">1 habilitada</item>
    </plurals>
    <string name="zen_mode_settings_title" msgid="1066226840983908121">"No interrumpir"</string>
    <string name="zen_mode_slice_subtitle" msgid="1495506059205752083">"Limitar las interrupciones"</string>
    <string name="zen_mode_settings_turn_on_dialog_title" msgid="2297134204747331078">"Activar No interrumpir"</string>
    <string name="zen_mode_behavior_settings_title" msgid="5453115212674008032">"Excepciones"</string>
    <string name="zen_mode_duration_settings_title" msgid="8471983919324532829">"Duración predeterminada"</string>
    <string name="zen_mode_behavior_allow_title" msgid="3845615648136218141">"Permite sonidos/vibraciones de"</string>
    <string name="zen_mode_behavior_no_sound" msgid="1219626004723208056">"Sin sonido"</string>
    <string name="zen_mode_behavior_total_silence" msgid="2229976744274214528">"Silencio total"</string>
    <string name="zen_mode_behavior_no_sound_except" msgid="4968477585788243114">"Sin sonido excepto <xliff:g id="CATEGORIES">%1$s</xliff:g>"</string>
    <string name="zen_mode_behavior_alarms_only" msgid="6455884547877702466">"Sin sonido excepto alarmas y contenido multimedia"</string>
    <string name="zen_mode_automation_settings_title" msgid="6155298704165984370">"Programaciones"</string>
    <string name="zen_mode_delete_automatic_rules" msgid="5975522152123354381">"Borrar programas"</string>
    <string name="zen_mode_schedule_delete" msgid="5717258786128155695">"Borrar"</string>
    <string name="zen_mode_rule_name_edit" msgid="812185626159430507">"Editar"</string>
    <string name="zen_mode_automation_settings_page_title" msgid="8995524726286378583">"Programas"</string>
    <string name="zen_mode_automatic_rule_settings_page_title" msgid="4773111805919088437">"Programar"</string>
    <string name="zen_mode_schedule_category_title" msgid="5482757877262584975">"Programación"</string>
    <string name="zen_mode_automation_suggestion_title" msgid="4321254843908888574">"Silenciar en ciertos momentos"</string>
    <string name="zen_mode_automation_suggestion_summary" msgid="6223252025075862701">"Definir reglas de No interrumpir"</string>
    <string name="zen_mode_schedule_title" msgid="8616187805239590649">"Programación"</string>
    <string name="zen_mode_use_automatic_rule" msgid="489102635414919052">"Usar programa"</string>
    <string name="zen_mode_option_important_interruptions" msgid="3903928008177972500">"Solo prioridad"</string>
    <string name="zen_mode_option_alarms" msgid="5785372117288803600">"Solo alarmas"</string>
    <string name="zen_mode_option_no_interruptions" msgid="8107126344850276878">"Silencio total"</string>
    <string name="zen_mode_summary_combination" msgid="8715563402849273459">"<xliff:g id="MODE">%1$s</xliff:g>: <xliff:g id="EXIT_CONDITION">%2$s</xliff:g>"</string>
    <string name="zen_mode_visual_interruptions_settings_title" msgid="6751708745442997940">"Bloquear alteraciones visuales"</string>
    <string name="zen_mode_visual_signals_settings_subtitle" msgid="6308824824208120508">"Permitir señales visuales"</string>
    <string name="zen_mode_settings_category" msgid="8404473163624911791">"Cuando se activa No interrumpir"</string>
    <string name="zen_mode_restrict_notifications_title" msgid="8138441771855063771">"Restringir notificaciones"</string>
    <string name="zen_mode_restrict_notifications_mute" msgid="3690261619682396872">"Notificaciones sin sonido"</string>
    <string name="zen_mode_restrict_notifications_mute_summary" msgid="5810076116489877312">"Verás las notificaciones en la pantalla"</string>
    <string name="zen_mode_restrict_notifications_mute_footer" msgid="3465600930732602159">"El teléfono no sonará ni vibrará cuando recibas notificaciones."</string>
    <string name="zen_mode_restrict_notifications_hide" msgid="5305121630186687339">"Notificaciones sin sonido ni efectos visuales"</string>
    <string name="zen_mode_restrict_notifications_hide_summary" msgid="7555448406901864904">"No verás ni oirás notificaciones"</string>
    <string name="zen_mode_restrict_notifications_hide_footer" msgid="1069960859746788356">"Tu teléfono no vibrará ni sonará por notificaciones nuevas ni existentes, ni las mostrará. 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 encontrar las notificaciones que te perdiste."</string>
    <string name="zen_mode_restrict_notifications_custom" msgid="7498689167767941034">"Personalizada"</string>
    <string name="zen_mode_restrict_notifications_enable_custom" msgid="4250962169561739747">"Habilitar configuración personalizada"</string>
    <string name="zen_mode_restrict_notifications_disable_custom" msgid="6676997522330453597">"Quitar configuración personalizada"</string>
    <string name="zen_mode_restrict_notifications_summary_muted" msgid="5450158135853888485">"Notificaciones sin sonido"</string>
    <string name="zen_mode_restrict_notifications_summary_custom" msgid="7416121534987213074">"Parcialmente ocultas"</string>
    <string name="zen_mode_restrict_notifications_summary_hidden" msgid="3618285192806732504">"Notificaciones sin sonido ni efectos visuales"</string>
    <string name="zen_mode_what_to_block_title" msgid="5480903548365697159">"Restricciones personalizadas"</string>
    <string name="zen_mode_block_effects_screen_on" msgid="4659484530849212827">"Cuando la pantalla esté encendida"</string>
    <string name="zen_mode_block_effects_screen_off" msgid="4276414460889400625">"Cuando la pantalla esté apagada"</string>
    <string name="zen_mode_block_effect_sound" msgid="7383953383758025895">"Silenciar el sonido y la vibración"</string>
    <string name="zen_mode_block_effect_intent" msgid="350764335391428447">"No activar la pantalla"</string>
    <string name="zen_mode_block_effect_light" msgid="8106976110224107316">"No encender luz intermitente"</string>
    <string name="zen_mode_block_effect_peek" msgid="6836997464098657115">"No mostrar notificaciones en pantalla"</string>
    <string name="zen_mode_block_effect_status" msgid="1651527249762752921">"Ocultar íconos de la barra de estado en la parte superior de la pantalla"</string>
    <string name="zen_mode_block_effect_badge" msgid="214553506070597320">"Ocultar puntos de notificación en íconos de apps"</string>
    <string name="zen_mode_block_effect_ambient" msgid="4704755879961212658">"No activar la pantalla con las notificaciones"</string>
    <string name="zen_mode_block_effect_list" msgid="4722887783222298295">"Ocultar del banner desplegable"</string>
    <string name="zen_mode_block_effect_summary_none" msgid="2617875282623486256">"Nunca"</string>
    <string name="zen_mode_block_effect_summary_screen_off" msgid="1230265589026355094">"Cuando la pantalla está apagada"</string>
    <string name="zen_mode_block_effect_summary_screen_on" msgid="6017536991063513394">"Cuando la pantalla está encendida"</string>
    <string name="zen_mode_block_effect_summary_sound" msgid="1065107568053759972">"Sonido y vibración"</string>
    <string name="zen_mode_block_effect_summary_some" msgid="3635646031575107456">"Sonido, vibración y algunos signos visuales de notificaciones"</string>
    <string name="zen_mode_block_effect_summary_all" msgid="1213328945418248026">"Sonido, vibración y signos visuales de notificaciones"</string>
    <string name="zen_mode_blocked_effects_footer" msgid="5710896246703497760">"Nunca se ocultarán las notificaciones necesarias para el estado y las actividades básicas del teléfono"</string>
    <string name="zen_mode_no_exceptions" msgid="7653433997399582247">"Nada"</string>
    <string name="zen_mode_other_options" msgid="520015080445012355">"otras opciones"</string>
    <string name="zen_mode_add" msgid="90014394953272517">"Agregar"</string>
    <string name="zen_mode_enable_dialog_turn_on" msgid="8287824809739581837">"Activar"</string>
    <string name="zen_mode_button_turn_on" msgid="2824380626482175552">"Activar ahora"</string>
    <string name="zen_mode_button_turn_off" msgid="6181953727880503094">"Desactivar ahora"</string>
    <string name="zen_mode_settings_dnd_manual_end_time" msgid="8860646554263965569">"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="7186615007561990908">"El modo \"No interrumpir\" permanecerá activado hasta que lo desactives"</string>
    <string name="zen_mode_settings_dnd_automatic_rule" msgid="6195725842906270996">"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="1721179577382915270">"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="1965922539531521052">"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="7555742240858292255"><annotation id="link">"Ver configuración personalizada"</annotation></string>
    <string name="zen_interruption_level_priority" msgid="2078370238113347720">"Solo prioridad"</string>
    <string name="zen_mode_and_condition" msgid="4927230238450354412">"<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="1202632669798211342">"Activado/<xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="zen_mode_sound_summary_off_with_info" msgid="2348629457144123849">"Desactivado/<xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="zen_mode_sound_summary_off" msgid="4375814717589425561">"Desactivado"</string>
    <string name="zen_mode_sound_summary_on" msgid="7718273231309882914">"Activado"</string>
    <string name="zen_mode_duration_summary_always_prompt" msgid="3483258992533158479">"Preguntar siempre"</string>
    <string name="zen_mode_duration_summary_forever" msgid="8597777321810802309">"Hasta que lo desactives"</string>
    <plurals name="zen_mode_duration_summary_time_hours" formatted="false" msgid="3224363976852136871">
      <item quantity="other"><xliff:g id="NUM_HOURS">%d</xliff:g> horas</item>
      <item quantity="one">1 hora</item>
    </plurals>
    <string name="zen_mode_duration_summary_time_minutes" msgid="6238305783533884764">"<xliff:g id="NUM_MINUTES">%d</xliff:g> minutos"</string>
    <plurals name="zen_mode_sound_summary_summary_off_info" formatted="false" msgid="6751226506661227581">
      <item quantity="other"><xliff:g id="ON_COUNT">%d</xliff:g> programas se pueden actualizar automáticamente</item>
      <item quantity="one">1 programa se puede actualizar automáticamente</item>
    </plurals>
    <string name="zen_category_behavior" msgid="554277240833452070">"Silenciar dispositivo, pero permitir excepciones"</string>
    <string name="zen_category_exceptions" msgid="7601136604273265629">"Excepciones"</string>
    <string name="zen_category_schedule" msgid="9000447592251450453">"Horarios"</string>
    <string name="zen_sound_title" msgid="4461494611692749446">"Ver todas las excepciones"</string>
    <string name="zen_sound_footer" msgid="7621745273287208979">"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_sound_category_title" msgid="4336596939661729188">"Silenciar todo excepto"</string>
    <string name="zen_sound_all_muted" msgid="4850363350480968114">"Silenciar"</string>
    <string name="zen_sound_none_muted" msgid="3938508512103612527">"No silenciar"</string>
    <string name="zen_sound_one_allowed" msgid="8447313454438932276">"Silenciar, pero permitir <xliff:g id="SOUND_TYPE">%1$s</xliff:g>"</string>
    <string name="zen_sound_two_allowed" msgid="980491120444358550">"Silenciar, pero permitir <xliff:g id="SOUND_TYPE_0">%1$s</xliff:g> y <xliff:g id="SOUND_TYPE_1">%2$s</xliff:g>"</string>
    <string name="zen_sound_three_allowed" msgid="3455767205934547985">"Silenciar, pero permitir <xliff:g id="SOUND_TYPE_0">%1$s</xliff:g>, <xliff:g id="SOUND_TYPE_1">%2$s</xliff:g> y <xliff:g id="SOUND_TYPE_2">%3$s</xliff:g>"</string>
    <string name="zen_custom_settings_dialog_title" msgid="3999383687283620283">"Configuración personalizada"</string>
    <string name="zen_custom_settings_dialog_review_schedule" msgid="7056997717364939238">"Revisar programa"</string>
    <string name="zen_custom_settings_dialog_ok" msgid="5302885851078421866">"Entendido"</string>
    <string name="zen_custom_settings_notifications_header" msgid="6931035609369698584">"Notificaciones"</string>
    <string name="zen_custom_settings_duration_header" msgid="1190989278065507035">"Duración"</string>
    <string name="zen_msg_event_reminder_title" msgid="5137894077488924820">"Mensajes, eventos y recordatorios"</string>
    <string name="zen_msg_event_reminder_footer" msgid="4376930591019535192">"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="6131211000824433013">"Listo"</string>
    <string name="zen_onboarding_settings" msgid="9046451821239946868">"Configuración"</string>
    <string name="zen_onboarding_new_setting_title" msgid="1893095176110470711">"Notificaciones sin sonido ni efectos visuales"</string>
    <string name="zen_onboarding_current_setting_title" msgid="776426065129609376">"Notificaciones sin sonido"</string>
    <string name="zen_onboarding_new_setting_summary" msgid="6293026064871880706">"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="1280614488924843713">"(Configuración actual)"</string>
    <string name="zen_onboarding_dnd_visual_disturbances_header" msgid="1352808651270918932">"¿Quieres cambiar la configuración de notificaciones de No interrumpir?"</string>
    <string name="sound_work_settings" msgid="6774324553228566442">"Sonidos del perfil de trabajo"</string>
    <string name="work_use_personal_sounds_title" msgid="1148331221338458874">"Usa los sonidos del perfil personal"</string>
    <string name="work_use_personal_sounds_summary" msgid="6207040454949823153">"Los sonidos de los perfiles de trabajo y personal son iguales"</string>
    <string name="work_ringtone_title" msgid="5806657896300235315">"Tono del teléfono laboral"</string>
    <string name="work_notification_ringtone_title" msgid="6081247402404510004">"Sonido predeterminado para notificaciones de trabajo"</string>
    <string name="work_alarm_ringtone_title" msgid="1441926676833738891">"Sonido predeterminado para alarmas de trabajo"</string>
    <string name="work_sound_same_as_personal" msgid="3123383644475266478">"Igual al del perfil personal"</string>
    <string name="work_sync_dialog_title" msgid="7123973297187354813">"¿Deseas reemplazar los sonidos?"</string>
    <string name="work_sync_dialog_yes" msgid="7243884940551635717">"Reemplazar"</string>
    <string name="work_sync_dialog_message" msgid="7841728953710863208">"Se usarán los sonidos de tu perfil personal para el perfil de trabajo"</string>
    <string name="ringtones_install_custom_sound_title" msgid="5948792721161302255">"¿Deseas agregar un sonido personalizado?"</string>
    <string name="ringtones_install_custom_sound_content" msgid="2195581481608512786">"Se copiará este archivo a la carpeta <xliff:g id="FOLDER_NAME">%s</xliff:g>"</string>
    <string name="ringtones_category_preference_title" msgid="5675912303120102366">"Tonos"</string>
    <string name="other_sound_category_preference_title" msgid="2521096636124314015">"Otros sonidos y vibraciones"</string>
    <string name="configure_notification_settings" msgid="7616737397127242615">"Notificaciones"</string>
    <string name="recent_notifications" msgid="5660639387705060156">"Enviadas recientemente"</string>
    <string name="recent_notifications_see_all_title" msgid="8572160812124540326">"Ver todas las de los últimos 7 días"</string>
    <string name="advanced_section_header" msgid="8833934850242546903">"Avanzada"</string>
    <string name="profile_section_header" msgid="2320848161066912001">"Notificaciones de trabajo"</string>
    <string name="smart_notifications_title" msgid="3702411478231865970">"Notificaciones adaptables"</string>
    <string name="asst_capability_prioritizer_title" msgid="3854208223528908688">"Prioridad de notificación adaptable"</string>
    <string name="asst_capability_prioritizer_summary" msgid="7553129095829077229">"Configurar automáticamente las notificaciones de menor prioridad a silenciosas"</string>
    <string name="asst_capabilities_actions_replies_title" msgid="8621608733904251499">"Respuestas y acciones sugeridas"</string>
    <string name="asst_capabilities_actions_replies_summary" msgid="2367828721274129806">"Mostrar automáticamente respuestas y acciones sugeridas"</string>
    <string name="snooze_options_title" msgid="7447722951050463793">"Permitir posponer alarmas"</string>
    <string name="hide_silent_icons_title" msgid="3803036978493857276">"Ocultar íconos de las notificaciones silenciosas"</string>
    <string name="hide_silent_icons_summary" msgid="8422819235336628802">"Los íconos de las notificaciones silenciosas no se muestran en la barra de estado"</string>
    <string name="notification_badging_title" msgid="5938709971403474078">"Activar puntos de notificación"</string>
    <string name="notification_bubbles_title" msgid="526545466417027926">"Cuadros"</string>
    <string name="notification_bubbles_developer_setting_summary" msgid="5044678712656329427">"Algunas notificaciones pueden aparecer como cuadros en la pantalla"</string>
    <string name="bubbles_feature_education" msgid="69923617148394578">"Algunas notificaciones y otro contenido pueden aparecer como cuadros en la pantalla. Para abrir un cuadro, presiónalo. Para descartarlo, arrástralo hacia el extremo inferior de la pantalla."</string>
    <string name="bubbles_app_toggle_title" msgid="9143702245165359360">"Burbujas"</string>
    <string name="bubbles_app_toggle_summary" msgid="7714358008428342285">"Permitir que <xliff:g id="APP_NAME">%1$s</xliff:g> muestre algunas notificaciones como cuadros"</string>
    <string name="bubbles_feature_disabled_dialog_title" msgid="8013961655723563787">"Activar cuadros"</string>
    <string name="bubbles_feature_disabled_dialog_text" msgid="3616822820657195387">"Si quieres activar los cuadros para esta app, primero debes activarlos en el dispositivo. Esto afecta a otras apps en las que ya habías activado los cuadros."</string>
    <string name="bubbles_feature_disabled_button_approve" msgid="5317196831268846883">"Activar en el dispositivo"</string>
    <string name="bubbles_feature_disabled_button_cancel" msgid="8176870537170586852">"Cancelar"</string>
    <string name="swipe_direction_title" msgid="6877543492435053137">"Acciones al deslizar el dedo"</string>
    <string name="swipe_direction_ltr" msgid="3623394320915041215">"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="4972099509548044938">"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="3976374971153475110">"Notificaciones discretas"</string>
    <string name="gentle_notifications_also_display" msgid="6455360420411828133">"También mostrar en"</string>
    <string name="gentle_notifications_display_status" msgid="2904115658980383410">"Barra de estado"</string>
    <string name="gentle_notifications_display_lock" msgid="1395567209329239992">"Pantalla de bloqueo"</string>
    <string name="gentle_notifications_education" msgid="8713358646047345762">"Las notificaciones discretas siempre son silenciosas y aparecen en el banner desplegable"</string>
    <string name="gentle_notifications_display_summary_shade" msgid="6583107817329430916">"Mostrar solo en banner desplegable"</string>
    <string name="gentle_notifications_display_summary_shade_lock" msgid="1434426811760016414">"Mostrar en banner desplegable y pantalla bloqueada"</string>
    <string name="gentle_notifications_display_summary_shade_status" msgid="6113566548809874319">"Mostrar en banner desplegable y barra de estado"</string>
    <string name="gentle_notifications_display_summary_shade_status_lock" msgid="4222628772925544654">"Mostrar en banner desplegable, barra de estado y pantalla bloqueada"</string>
    <string name="notification_pulse_title" msgid="1905382958860387030">"Luz intermitente"</string>
    <string name="lock_screen_notifications_title" msgid="7604704224172951090">"Pantalla de bloqueo"</string>
    <string name="lockscreen_bypass_title" msgid="3077831331856929085">"Omitir pantalla bloqueada"</string>
    <string name="lockscreen_bypass_summary" msgid="2767475923650816867">"Después del Desbloqueo facial, ir a la última pantalla usada"</string>
    <string name="keywords_lockscreen_bypass" msgid="250300001805572693">"Pantalla bloqueada, bloqueo de pantalla, omitir, omisión"</string>
    <string name="locked_work_profile_notification_title" msgid="8327882003361551992">"Si perfil de trabajo bloqueado"</string>
    <string name="lock_screen_notifs_title" msgid="3812061224136552712">"Notificaciones en pantalla de bloqueo"</string>
    <string name="lock_screen_notifs_show_all" msgid="5848645268278883539">"Mostrar notificaciones silenciosas y de alertas"</string>
    <string name="lock_screen_notifs_show_alerting" msgid="3085615237751195449">"Mostrar solo notificaciones de alerta"</string>
    <string name="lock_screen_notifs_show_none" msgid="3357167536259901686">"No mostrar notificaciones"</string>
    <string name="lock_screen_notifs_redact" msgid="3942294440983226225">"Notificaciones confidenciales"</string>
    <string name="lock_screen_notifs_redact_summary" msgid="3095153536179931941">"Mostrar contenido confidencial cuando el dispositivo esté bloqueado"</string>
    <string name="lock_screen_notifs_redact_work" msgid="6777821963954035608">"Notificaciones confidenciales del perfil de trabajo"</string>
    <string name="lock_screen_notifs_redact_work_summary" msgid="2179290697692276201">"Mostrar contenido confidencial del perfil de trabajo cuando el dispositivo esté bloqueado"</string>
    <string name="lock_screen_notifications_summary_show" msgid="6407527697810672847">"Mostrar todas las notificaciones"</string>
    <string name="lock_screen_notifications_summary_hide" msgid="1133085507139112569">"Mostrar contenido sensible solo al desbloquear"</string>
    <string name="lock_screen_notifications_summary_disable" msgid="859628910427886715">"No mostrar notificaciones"</string>
    <string name="lock_screen_notifications_interstitial_message" msgid="3143593517597479937">"¿Cómo quieres que se muestre la pantalla bloqueada?"</string>
    <string name="lock_screen_notifications_interstitial_title" msgid="709573564312902481">"Pantalla de bloqueo"</string>
    <string name="lock_screen_notifications_summary_show_profile" msgid="835870815661120772">"Mostrar el contenido de notificaciones de trabajo"</string>
    <string name="lock_screen_notifications_summary_hide_profile" msgid="2005907007779384635">"Ocultar contenido de trabajo confidencial"</string>
    <string name="lock_screen_notifications_interstitial_message_profile" msgid="8307705621027472346">"¿Cómo deseas ver las notificaciones de perfil cuando esté bloqueado el dispositivo?"</string>
    <string name="lock_screen_notifications_interstitial_title_profile" msgid="3169806586032521333">"Notificaciones de perfil"</string>
    <string name="notifications_title" msgid="8086372779371204971">"Notificaciones"</string>
    <string name="app_notifications_title" msgid="5810577805218003760">"Notificaciones de apps"</string>
    <string name="notification_channel_title" msgid="2260666541030178452">"Categoría de notificaciones"</string>
    <string name="notification_group_title" msgid="7180506440133859601">"Categoría del grupo de notificaciones"</string>
    <string name="notification_importance_title" msgid="4368578960344731828">"Comportamiento"</string>
    <string name="notification_importance_unspecified" msgid="6622173510486113958">"Permitir sonido"</string>
    <string name="notification_importance_blocked" msgid="7938180808339386300">"No mostrar notificaciones"</string>
    <string name="notification_importance_min" msgid="9054819132085066824">"Mostrar en silencio y minimizar"</string>
    <string name="notification_importance_low" msgid="2445139943005315690">"Mostrar sin emitir sonido"</string>
    <string name="notification_importance_default" msgid="5958338024601957516">"Emitir sonido"</string>
    <string name="notification_importance_high" msgid="2082429479238228527">"Emitir sonido y mostrar en pantalla"</string>
    <string name="notification_importance_high_silent" msgid="2667033773703765252">"Mostrar en la pantalla"</string>
    <string name="notification_importance_min_title" msgid="5024538864029341539">"Minimizar"</string>
    <string name="notification_importance_low_title" msgid="8131254047772814309">"Media"</string>
    <string name="notification_importance_default_title" msgid="9120383978536089489">"Alta"</string>
    <string name="notification_importance_high_title" msgid="8792310396497954857">"Mostrar en la pantalla"</string>
    <string name="notification_block_title" msgid="1366361048463539674">"Bloquear"</string>
    <string name="notification_silence_title" msgid="6986752165900591125">"Silencio"</string>
    <string name="notification_alert_title" msgid="2267584776990348784">"Alertas"</string>
    <string name="allow_interruption" msgid="7136150018111848721">"Permitir interrupciones"</string>
    <string name="allow_interruption_summary" msgid="7870159391333957050">"Permite que la app emita sonidos, vibre y muestre notificaciones en pantalla"</string>
    <string name="notification_channel_summary_min" msgid="2965790706738495761">"En la cortina desplegable, contraer las notificaciones en una línea"</string>
    <string name="notification_channel_summary_low" msgid="7050068866167282765">"Te ayuda a concentrarte sin sonar ni vibrar"</string>
    <string name="notification_channel_summary_default" msgid="5753454293847059695">"Capta tu atención con sonido o vibración"</string>
    <string name="notification_channel_summary_high" msgid="7737315941884569891">"Con el dispositivo desbloqueado, mostrar notificaciones como banners en la parte superior de la pantalla"</string>
    <string name="notification_switch_label" msgid="6843075654538931025">"Ver notificaciones"</string>
    <string name="default_notification_assistant" msgid="8441022088918117445">"Notificaciones adaptables"</string>
    <plurals name="notifications_sent_daily" formatted="false" msgid="6049014219388148161">
      <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="5096638662520720959">
      <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="1001964786456700536">"Nunca"</string>
    <string name="manage_notification_access_title" msgid="7510080164564944891">"Acceso a notificaciones"</string>
    <string name="work_profile_notification_access_blocked_summary" msgid="8748026238701253040">"El acceso a las notificaciones del perfil de trabajo está bloqueado"</string>
    <string name="manage_notification_access_summary_zero" msgid="2409912785614953348">"Las aplicaciones no pueden leer las notificaciones."</string>
    <!-- String.format failed for translation -->
    <!-- no translation found for manage_notification_access_summary_nonzero (7930130030691218387) -->
    <string name="notification_assistant_title" msgid="7531256823396529700">"Notificaciones adaptables"</string>
    <string name="no_notification_assistant" msgid="2818970196806227480">"Nada"</string>
    <string name="no_notification_listeners" msgid="3487091564454192821">"Ninguna aplicación instalada solicitó acceso a las notificaciones."</string>
    <string name="notification_assistant_security_warning_title" msgid="300600401595343861">"¿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="5829972610310154776">"<xliff:g id="NOTIFICATION_ASSISTANT_NAME">%1$s</xliff:g> podrá leer todas las notificaciones, incluidas las que contengan información personal, como nombres de contactos o el texto de los mensajes que recibas. También podrá modificar y descartar notificaciones, así como utilizar los botones de acción que aparezcan. \n\nLa app podrá activar y desactivar el modo No interrumpir, además de cambiar la configuración relacionada."</string>
    <string name="notification_listener_security_warning_title" msgid="5522924135145843279">"¿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="119203147791040151">"<xliff:g id="NOTIFICATION_LISTENER_NAME">%1$s</xliff:g> podrá leer todas las notificaciones, incluso las que contienen información personal, como nombres de contactos y el texto de los mensajes que recibas. También podrá descartar las notificaciones o utilizar los botones de acción que aparezcan. \n\nLa app podrá activar y desactivar el modo No interrumpir, y cambiar la configuración relacionada."</string>
    <string name="notification_listener_disable_warning_summary" msgid="6738915379642948000">"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="8333442186428083057">"Desactivar"</string>
    <string name="notification_listener_disable_warning_cancel" msgid="8586417377104211584">"Cancelar"</string>
    <string name="vr_listeners_title" msgid="1318901577754715777">"Servicio de ayuda de RV"</string>
    <string name="no_vr_listeners" msgid="2689382881717507390">"Ninguna app instalada solicitó que se la ejecutara como servicio de ayuda de RV."</string>
    <string name="vr_listener_security_warning_title" msgid="8309673749124927122">"¿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="6931541068825094653">"<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="8104485269504335481">"Cuando el dispositivo está en modo RV"</string>
    <string name="display_vr_pref_low_persistence" msgid="5707494209944718537">"Reducir desenfoque (recomendado)"</string>
    <string name="display_vr_pref_off" msgid="2190091757123260989">"Reducir parpadeo"</string>
    <string name="picture_in_picture_title" msgid="5824849294270017113">"Pantalla en pantalla"</string>
    <string name="picture_in_picture_empty_text" msgid="685224245260197779">"Ninguna de las apps instaladas es compatible con el modo Pantalla en pantalla"</string>
    <string name="picture_in_picture_keywords" msgid="8361318686701764690">"imagen en imagen"</string>
    <string name="picture_in_picture_app_detail_title" msgid="4080800421316791732">"Pantalla en pantalla"</string>
    <string name="picture_in_picture_app_detail_switch" msgid="1131910667023738296">"Permitir Pantalla en pantalla"</string>
    <string name="picture_in_picture_app_detail_summary" msgid="1264019085827708920">"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="manage_zen_access_title" msgid="2611116122628520522">"Acceso en No interrumpir"</string>
    <string name="zen_access_detail_switch" msgid="1188754646317450926">"Permitir opción No interrumpir"</string>
    <string name="zen_access_empty_text" msgid="8772967285742259540">"Ninguna aplicación instalada solicitó acceso en No interrumpir."</string>
    <string name="loading_notification_apps" msgid="5031818677010335895">"Cargando aplicaciones…"</string>
    <string name="app_notifications_off_desc" msgid="8289223211387083447">"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="9013011134681491778">"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="2315252834146837470">"Como lo solicitaste, Android bloquea este grupo de notificaciones para que no se muestren en el dispositivo"</string>
    <string name="notification_channels" msgid="5346841743182627500">"Categorías"</string>
    <string name="notification_channels_other" msgid="5645317113885788226">"Otros"</string>
    <plurals name="notification_group_summary" formatted="false" msgid="3420621520561455358">
      <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="3077375508177744586">"Esta app no publicó ninguna notificación"</string>
    <string name="app_settings_link" msgid="8894946007543660906">"Opciones de configuración adicionales de la app"</string>
    <string name="app_notification_listing_summary_zero" msgid="8046168435207424440">"Activadas para todas las apps"</string>
    <plurals name="app_notification_listing_summary_others" formatted="false" msgid="6709582776823665660">
      <item quantity="other">Desactivada 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="8028574302599397935">
      <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="650145396718191048">"Activado"</string>
    <string name="notification_toggle_off" msgid="2142010737190671762">"Inhabilitado"</string>
    <string name="app_notification_block_title" msgid="4069351066849087649">"Bloquear todos"</string>
    <string name="app_notification_block_summary" msgid="4744020456943215352">"No mostrar estas notificaciones"</string>
    <string name="notification_content_block_title" msgid="5854232570963006360">"Mostrar notificaciones"</string>
    <string name="notification_content_block_summary" msgid="7746185794438882389">"No mostrar notificaciones en el panel ni en dispositivos periféricos"</string>
    <string name="notification_badge_title" msgid="6370122441168519809">"Permitir punto de notificación"</string>
    <string name="notification_channel_badge_title" msgid="2240827899882847087">"Mostrar punto de notificación"</string>
    <string name="app_notification_override_dnd_title" msgid="7867458246395884830">"Anular No interrumpir"</string>
    <string name="app_notification_override_dnd_summary" msgid="2612502099373472686">"Permitir que se muestren estas notificaciones cuando No interrumpir esté activado"</string>
    <string name="app_notification_visibility_override_title" msgid="3618860781666494595">"Pantalla de bloqueo"</string>
    <string name="app_notification_row_banned" msgid="5983655258784814773">"Bloqueadas"</string>
    <string name="app_notification_row_priority" msgid="7723839972982746568">"Prioridad"</string>
    <string name="app_notification_row_sensitive" msgid="1809610030432329940">"Personal"</string>
    <string name="app_notifications_dialog_done" msgid="3484067728568791014">"Listo"</string>
    <string name="app_notification_importance_title" msgid="8002263131149345584">"Importancia"</string>
    <string name="notification_show_lights_title" msgid="7671781299688190532">"Luz intermitente"</string>
    <string name="notification_vibrate_title" msgid="1646667807969755957">"Vibrar"</string>
    <string name="notification_channel_sound_title" msgid="3899212238513507941">"Sonido"</string>
    <string name="zen_mode_rule_delete_button" msgid="903658142711011617">"Borrar"</string>
    <string name="zen_mode_rule_rename_button" msgid="4642843370946599164">"Cambiar nombre"</string>
    <string name="zen_mode_rule_name" msgid="5607736317244760638">"Nombre"</string>
    <string name="zen_mode_rule_name_hint" msgid="278109122579468433">"Ingresar el nombre"</string>
    <string name="zen_mode_rule_name_warning" msgid="3856485373110366912">"El nombre ya está en uso"</string>
    <string name="zen_mode_add_rule" msgid="7459154136384467057">"Agregar más"</string>
    <string name="zen_mode_add_event_rule" msgid="4454759739839069898">"Agregar programa del evento"</string>
    <string name="zen_mode_add_time_rule" msgid="7890557350868257760">"Agregar programa de tiempo"</string>
    <string name="zen_mode_delete_rule" msgid="8055032645990309096">"Borrar programa"</string>
    <string name="zen_mode_choose_rule_type" msgid="40993242338494595">"Elegir tipo de programa"</string>
    <string name="zen_mode_delete_rule_confirmation" msgid="6237882294348570283">"¿Quieres borrar la regla \"<xliff:g id="RULE">%1$s</xliff:g>\"?"</string>
    <string name="zen_mode_delete_rule_button" msgid="4248741120307752294">"Borrar"</string>
    <string name="zen_mode_rule_type_unknown" msgid="3049377282766700600">"Desconocido"</string>
    <string name="zen_mode_app_set_behavior" msgid="1534429320064381355">"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="2558968232814237874">"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="6200424436456086312">"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="6163149826036287324">"Hora"</string>
    <string name="zen_schedule_rule_enabled_toast" msgid="3379499360390382259">"Se configuró la regla automática para activar No interrumpir durante los horarios especificados."</string>
    <string name="zen_event_rule_type_name" msgid="6503468472212606158">"Evento"</string>
    <string name="zen_event_rule_enabled_toast" msgid="6910577623330811480">"Se configuró la regla automática para activar No interrumpir durante los eventos especificados."</string>
    <string name="zen_mode_event_rule_calendar" msgid="8787906563769067418">"Durante los eventos de"</string>
    <string name="zen_mode_event_rule_summary_calendar_template" msgid="5135844750232403975">"Durante eventos de <xliff:g id="CALENDAR">%1$s</xliff:g>"</string>
    <string name="zen_mode_event_rule_summary_any_calendar" msgid="4936646399126636358">"cualquier calendario"</string>
    <string name="zen_mode_event_rule_summary_reply_template" msgid="6590671260829837157">"Cuando la respuesta es <xliff:g id="REPLY">%1$s</xliff:g>."</string>
    <string name="zen_mode_event_rule_calendar_any" msgid="6485568415998569885">"Cualquier calendario"</string>
    <string name="zen_mode_event_rule_reply" msgid="5166322024212403739">"Cuando la respuesta es"</string>
    <string name="zen_mode_event_rule_reply_any_except_no" msgid="8868873496008825961">"Sí, Quizás o Sin respuesta"</string>
    <string name="zen_mode_event_rule_reply_yes_or_maybe" msgid="2769656565454495824">"Sí o Quizás"</string>
    <string name="zen_mode_event_rule_reply_yes" msgid="1003598835878784659">"Sí"</string>
    <string name="zen_mode_rule_not_found_text" msgid="8963662446092059836">"No se encontró la regla."</string>
    <string name="zen_mode_rule_summary_enabled_combination" msgid="976098744828219297">"Activado/<xliff:g id="MODE">%1$s</xliff:g>"</string>
    <string name="zen_mode_rule_summary_provider_combination" msgid="2101201392041867409">"<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="3195058680641389948">"Días"</string>
    <string name="zen_mode_schedule_rule_days_none" msgid="4954143628634166317">"Ninguno"</string>
    <string name="zen_mode_schedule_rule_days_all" msgid="146511166522076034">"Todos los días"</string>
    <string name="zen_mode_schedule_alarm_title" msgid="767054141267122030">"La alarma puede anular la hora de finalización"</string>
    <string name="zen_mode_schedule_alarm_summary" msgid="1673667979187593693">"Cuando suena la alarma, se desactiva el programa"</string>
    <string name="zen_mode_custom_behavior_title" msgid="1148856394866360783">"Comportamiento del modo No interrumpir"</string>
    <string name="zen_mode_custom_behavior_summary_default" msgid="7750128187766412708">"Usar configuración predeterminada"</string>
    <string name="zen_mode_custom_behavior_summary" msgid="7458258833216726120">"Crear opciones de configuración personalizadas"</string>
    <string name="zen_mode_custom_behavior_category_title" msgid="4070854282812755247">"Durante \"<xliff:g id="SCHEDULE_NAME">%1$s</xliff:g>\""</string>
    <string name="summary_divider_text" msgid="7228986578690919294">", "</string>
    <string name="summary_range_symbol_combination" msgid="5695218513421897027">"<xliff:g id="START">%1$s</xliff:g> - <xliff:g id="END">%2$s</xliff:g>"</string>
    <string name="summary_range_verbal_combination" msgid="8467306662961568656">"De <xliff:g id="START">%1$s</xliff:g> a <xliff:g id="END">%2$s</xliff:g>"</string>
    <string name="zen_mode_calls" msgid="4769117032399813012">"Permitir llamadas"</string>
    <string name="zen_mode_calls_title" msgid="2905770092665685857">"Llamadas"</string>
    <string name="zen_mode_calls_footer" msgid="2002070641802102110">"Para asegurarte de que el dispositivo suene cuando recibes las llamadas permitidas, verifica si está configurado para sonar, vibrar o en modo silencio."</string>
    <string name="zen_mode_custom_calls_footer" msgid="4764756801941329281">"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="1848464279786960190">"Contactos destacados"</string>
    <plurals name="zen_mode_starred_contacts_summary_additional_contacts" formatted="false" msgid="500105380255018671">
      <item quantity="other"><xliff:g id="NUM_PEOPLE">%d</xliff:g> más</item>
      <item quantity="one">1 más</item>
    </plurals>
    <string name="zen_mode_messages" msgid="6406892731721926170">"Permitir mensajes"</string>
    <string name="zen_mode_messages_footer" msgid="2616568463646674149">"Para asegurarte de que el dispositivo suene cuando recibas mensajes permitidos, verifica si está configurado para sonar, vibrar o en silencio."</string>
    <string name="zen_mode_custom_messages_footer" msgid="800067279796770040">"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_messages_title" msgid="7325983674655986445">"SMS, MMS y apps de mensajería"</string>
    <string name="zen_mode_from_anyone" msgid="2638322015361252161">"De cualquier persona"</string>
    <string name="zen_mode_from_contacts" msgid="2232335406106711637">"Solo de contactos"</string>
    <string name="zen_mode_from_starred" msgid="2678345811950997027">"Solo de contactos destacados"</string>
    <string name="zen_calls_summary_starred_repeat" msgid="4046151920710059778">"De contactos destacados y emisores repetidos"</string>
    <string name="zen_calls_summary_contacts_repeat" msgid="1528716671301999084">"De contactos y emisores repetidos"</string>
    <string name="zen_calls_summary_repeat_only" msgid="7105261473107715445">"Solo de emisores repetidos"</string>
    <string name="zen_mode_from_none" msgid="8219706639954614136">"No hay"</string>
    <string name="zen_mode_from_none_calls" msgid="7705112158761351044">"No permitir llamadas"</string>
    <string name="zen_mode_from_none_messages" msgid="3300937656725582608">"No permitir mensajes"</string>
    <string name="zen_mode_alarms" msgid="6510378757005935647">"Permitir alarmas"</string>
    <string name="zen_mode_alarms_list" msgid="1090332840207025714">"alarmas"</string>
    <string name="zen_mode_media" msgid="4529187475698084320">"Reproducir sonidos multimedia"</string>
    <string name="zen_mode_media_list" msgid="5483540766397328038">"contenido multimedia"</string>
    <string name="zen_mode_system" msgid="236278770843463810">"Permitir tonos táctiles"</string>
    <string name="zen_mode_system_list" msgid="6996104733185177115">"tonos táctiles"</string>
    <string name="zen_mode_reminders" msgid="5445657061499098675">"Permitir recordatorios"</string>
    <string name="zen_mode_reminders_list" msgid="2853975802240340190">"recordatorios"</string>
    <string name="zen_mode_events" msgid="6154853744271591007">"Permitir eventos"</string>
    <string name="zen_mode_bypassing_apps" msgid="5493729796981237881">"Permitir que las apps anulen No interrumpir"</string>
    <string name="zen_mode_bypassing_apps_title" msgid="2072590348079644482">"Excepciones de apps"</string>
    <plurals name="zen_mode_bypassing_apps_subtext" formatted="false" msgid="3726913165356014788">
      <item quantity="other">Las notificaciones de <xliff:g id="NUMBER">%1$d</xliff:g> apps pueden anular el modo No interrumpir</item>
      <item quantity="one">Las notificaciones de 1 app pueden anular el modo No interrumpir</item>
    </plurals>
    <string name="zen_mode_events_list" msgid="5571368229052715098">"eventos"</string>
    <string name="zen_mode_all_callers" msgid="2378065871253871057">"cualquiera"</string>
    <string name="zen_mode_contacts_callers" msgid="5569804103920394175">"contactos"</string>
    <string name="zen_mode_starred_callers" msgid="1023167821338514140">"contactos destacados"</string>
    <string name="zen_mode_repeat_callers" msgid="5019521886428322131">"Llamadas repetidas"</string>
    <string name="zen_mode_repeat_callers_list" msgid="2529895519653237330">"emisores de llamadas repetidas"</string>
    <string name="zen_mode_repeat_callers_title" msgid="8553876328249671783">"Permitir emisores de llamadas repetidas"</string>
    <string name="zen_mode_calls_summary_one" msgid="1711737896388108388">"Permitir de <xliff:g id="CALLER_TYPE">%1$s</xliff:g>"</string>
    <string name="zen_mode_calls_summary_two" msgid="8476861928783654064">"Permitir de <xliff:g id="CALLER_TYPE">%1$s</xliff:g> y <xliff:g id="CALLERT_TPYE">%2$s</xliff:g>"</string>
    <string name="zen_mode_repeat_callers_summary" msgid="239685342222975733">"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="168127313238020146">"Personalizado"</string>
    <string name="zen_mode_when" msgid="2767193283311106373">"Activar automáticam."</string>
    <string name="zen_mode_when_never" msgid="8809494351918405602">"Nunca"</string>
    <string name="zen_mode_when_every_night" msgid="3122486110091921009">"Todas las noches"</string>
    <string name="zen_mode_when_weeknights" msgid="8354070633893273783">"Noches entre semana"</string>
    <string name="zen_mode_start_time" msgid="8102602297273744441">"Hora de inicio"</string>
    <string name="zen_mode_end_time" msgid="8774327885892705505">"Hora de finalización"</string>
    <string name="zen_mode_end_time_next_day_summary_format" msgid="4201521691238728701">"<xliff:g id="FORMATTED_TIME">%s</xliff:g> el día siguiente"</string>
    <string name="zen_mode_summary_alarms_only_indefinite" msgid="2061973221027570123">"Cambiar a solo alarmas de forma indefinida"</string>
    <plurals name="zen_mode_summary_alarms_only_by_minute" formatted="false" msgid="6122003583875424601">
      <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="2407703455581767748">
      <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="7465525754879341907">"Cambiar a solo alarmas hasta la(s) <xliff:g id="FORMATTEDTIME">%1$s</xliff:g>"</string>
    <string name="zen_mode_summary_always" msgid="6172985102689237703">"Cambiar a interrumpir siempre"</string>
    <string name="zen_mode_screen_on" msgid="8774571998575673502">"Cuando se enciende la pantalla"</string>
    <string name="zen_mode_screen_on_summary" msgid="2208664848367443505">"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="3144446765110327937">"Cuando se apaga la pantalla"</string>
    <string name="zen_mode_screen_off_summary" msgid="7430034620565812258">"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="2826121465026642017">"Permitir que las notificaciones silenciadas por el modo \"No interrumpir\" activen la pantalla"</string>
    <string name="notification_app_settings_button" msgid="6685640230371477485">"Configuración de notificaciones"</string>
    <string name="suggestion_button_text" msgid="3275010948381252006">"Aceptar"</string>
    <string name="device_feedback" msgid="3238056036766293294">"Enviar comentarios del dispositivo"</string>
    <string name="restr_pin_enter_admin_pin" msgid="1085834515677448072">"Ingresa el PIN de administrador"</string>
    <string name="switch_on_text" msgid="1124106706920572386">"Activado"</string>
    <string name="switch_off_text" msgid="1139356348100829659">"Desactivado"</string>
    <string name="screen_pinning_title" msgid="2292573232264116542">"Fijar pantalla"</string>
    <string name="screen_pinning_description" msgid="1110847562111827766">"Si se activa esta opción, puedes fijar la pantalla para mantener la vista de la pantalla actual.\n\nPara usar esta función:\n\n1. Asegúrate de que esté activada la opción.\n\n2. Abre Recientes.\n\n3. Presiona el ícono de la app en la parte superior de la pantalla y, luego, presiona Fijar."</string>
    <string name="screen_pinning_unlock_pattern" msgid="8282268570060313339">"Solicitar desbloqueo para quitar fijación"</string>
    <string name="screen_pinning_unlock_pin" msgid="8757588350454795286">"Solicitar PIN para quitar fijación"</string>
    <string name="screen_pinning_unlock_password" msgid="2514079566873826434">"Solicitar contraseña para quitar fijación"</string>
    <string name="screen_pinning_unlock_none" msgid="3814188275713871856">"Bloquear dispositivo al quitar fijación"</string>
    <string name="opening_paragraph_delete_profile_unknown_company" msgid="2232461523882170874">"La siguiente aplicación administra este perfil de trabajo:"</string>
    <string name="managing_admin" msgid="8843802210377459055">"Administrado por <xliff:g id="ADMIN_APP_LABEL">%s</xliff:g>"</string>
    <string name="experimental_preference" msgid="7083015446690681376">"(Experimental)"</string>
    <string name="encryption_interstitial_header" msgid="468015813904595613">"Inicio seguro"</string>
    <string name="encryption_continue_button" msgid="1121880322636992402">"Continuar"</string>
    <string name="encryption_interstitial_message_pin" msgid="2317181134653424679">"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="7081249914068568570">"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="7796567133897436443">"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="4550632760119547492">"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="932184823193006087">"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="5560954719370251702">"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="2017438765366716760">"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="3551827507967661552">"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="3452793542112093614">"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_yes" msgid="4439509435889513411">"Sí"</string>
    <string name="encryption_interstitial_no" msgid="8935031349097025137">"No"</string>
    <string name="restricted_true_label" msgid="4761453839409220473">"Restringida"</string>
    <string name="restricted_false_label" msgid="3279282180297058755">"App no restringida"</string>
    <string name="encrypt_talkback_dialog_require_pin" msgid="8299960550048989807">"¿Solicitar PIN?"</string>
    <string name="encrypt_talkback_dialog_require_pattern" msgid="1499790256154146639">"¿Solicitar patrón?"</string>
    <string name="encrypt_talkback_dialog_require_password" msgid="8841994614218049215">"¿Solicitar contraseña?"</string>
    <string name="encrypt_talkback_dialog_message_pin" msgid="7582096542997635316">"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="2020083142199612743">"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="4155875981789127796">"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="2433632805847985867">"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="8499085421609752290">"Información de IMEI"</string>
    <string name="imei_information_summary" msgid="2074095606556565233">"Información relacionada con IMEI"</string>
    <string name="slot_number" msgid="3762676044904653577">"(Ranura <xliff:g id="SLOT_NUM">%1$d</xliff:g>)"</string>
    <string name="launch_by_default" msgid="1840761193189009248">"Abrir de forma predet."</string>
    <string name="app_launch_domain_links_title" msgid="1160925981363706090">"Abrir vínculos"</string>
    <string name="app_launch_open_domain_urls_title" msgid="8914721351596745701">"Abrir vínculos admitidos"</string>
    <string name="app_launch_open_domain_urls_summary" msgid="5367573364240712217">"Abrir sin preguntar"</string>
    <string name="app_launch_supported_domain_urls_title" msgid="8250695258211477480">"Vínculos admitidos"</string>
    <string name="app_launch_other_defaults_title" msgid="2516812499807835178">"Otras configuraciones predeterminadas"</string>
    <string name="storage_summary_format" msgid="5419902362347539755">"<xliff:g id="SIZE">%1$s</xliff:g> usado en <xliff:g id="STORAGE_TYPE">%2$s</xliff:g>"</string>
    <string name="storage_type_internal" msgid="6042049833565674948">"Almacenamiento interno"</string>
    <string name="storage_type_external" msgid="7738894330670001898">"Almacenamiento externo"</string>
    <string name="data_summary_format" msgid="6213211533341068366">"<xliff:g id="SIZE">%1$s</xliff:g> desde el <xliff:g id="DATE">%2$s</xliff:g>"</string>
    <string name="storage_used" msgid="7128074132917008743">"Almacenamiento utilizado"</string>
    <string name="change" msgid="6657848623929839991">"Cambiar"</string>
    <string name="change_storage" msgid="600475265207060436">"Cambiar almacenamiento"</string>
    <string name="notifications_label" msgid="2872668710589600731">"Notificaciones"</string>
    <string name="notifications_enabled" msgid="6983396130566021385">"Activadas"</string>
    <string name="notifications_enabled_with_info" msgid="5669544704839269901">"<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="1262114548434938079">"No"</string>
    <string name="notifications_partly_blocked" msgid="592071133950126656">"<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="4728603513072110381">"Silenciada"</string>
    <string name="notifications_redacted" msgid="4493588975742803160">"Sin contenido sensible en la pantalla bloqueada"</string>
    <string name="notifications_hidden" msgid="3619610536038757468">"No se muestran en la pantalla bloqueada"</string>
    <string name="notifications_priority" msgid="1066342037602085552">"Anulan \"No interrumpir\""</string>
    <string name="notifications_summary_divider" msgid="9013807608804041387">" / "</string>
    <string name="notification_summary_level" msgid="2726571692704140826">"Nivel %d"</string>
    <string name="notification_summary_channel" msgid="5831124672372023524">"<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="5583365573683409754">
      <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="6402730318075959117">
      <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="1564663886246010959">
      <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="931276038884210752">
      <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="1679758182657005375">"No se otorgaron permisos"</string>
    <string name="runtime_permissions_summary_no_permissions_requested" msgid="7655100570513818534">"No se solicitaron permisos"</string>
    <string name="filter_all_apps" msgid="1988403195820688644">"Todas las apps"</string>
    <string name="filter_enabled_apps" msgid="5395727306799456250">"Apps instaladas"</string>
    <string name="filter_instant_apps" msgid="574277769963965565">"Apps instantáneas"</string>
    <string name="filter_personal_apps" msgid="3277727374174355971">"Personales"</string>
    <string name="filter_work_apps" msgid="24519936790795574">"Trabajo"</string>
    <string name="filter_notif_all_apps" msgid="2299049859443680242">"Apps: Todas"</string>
    <string name="filter_notif_blocked_apps" msgid="3383043508771300704">"Desactivadas"</string>
    <string name="filter_notif_urgent_channels" msgid="3972473613117159653">"Categoría: Urgente"</string>
    <string name="filter_notif_low_channels" msgid="4128487387390004604">"Categoría: Poca importancia"</string>
    <string name="filter_notif_blocked_channels" msgid="5880190882221644289">"Categoría: Desactivadas"</string>
    <string name="filter_notif_dnd_channels" msgid="1817930848881696728">"Categoría: Con interrupciones"</string>
    <string name="advanced_apps" msgid="4812975097124803873">"Avanzado"</string>
    <string name="configure_apps" msgid="6685680790825882528">"Configurar apps"</string>
    <string name="unknown_app" msgid="5275921288718717656">"Aplicación desconocida"</string>
    <string name="app_permissions" msgid="5584182129908141622">"Administrador de permisos"</string>
    <string name="app_permissions_summary" msgid="5163974162150406324">"Apps que usan <xliff:g id="APPS">%1$s</xliff:g>"</string>
    <string name="tap_to_wake" msgid="7211944147196888807">"Presionar para activar"</string>
    <string name="tap_to_wake_summary" msgid="4341387904987585616">"Presiona dos veces en cualquier lugar de la pantalla para activar el dispositivo."</string>
    <string name="domain_urls_title" msgid="3132983644568821250">"Abrir vínculos"</string>
    <string name="domain_urls_summary_none" msgid="2639588015479657864">"No abrir los vínculos admitidos"</string>
    <string name="domain_urls_summary_one" msgid="3704934031930978405">"Abrir el dominio <xliff:g id="DOMAIN">%s</xliff:g>"</string>
    <string name="domain_urls_summary_some" msgid="3950089361819428455">"Abrir <xliff:g id="DOMAIN">%s</xliff:g> y otras URL"</string>
    <string name="domain_urls_apps_summary_off" msgid="1833056772600031220">"Ninguna app puede abrir los vínculos compatibles"</string>
    <plurals name="domain_urls_apps_summary_on" formatted="false" msgid="240214361240709399">
      <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="2474058700623948148">"Abrir en esta aplicación"</string>
    <string name="app_link_open_ask" msgid="7800878430190575991">"Preguntar siempre"</string>
    <string name="app_link_open_never" msgid="3407647600352398543">"No abrir en esta aplicación"</string>
    <string name="default_apps_title" msgid="1660450272764331490">"Predeterminada"</string>
    <string name="default_for_work" msgid="9152194239366247932">"Predeterminada para el trabajo"</string>
    <string name="assist_and_voice_input_title" msgid="1733165754793221197">"Asistencia y entrada de voz"</string>
    <string name="default_assist_title" msgid="8868488975409247921">"Aplicación de asistencia"</string>
    <string name="assistant_security_warning_title" msgid="8673079231955467177">"¿Deseas que <xliff:g id="ASSISTANT_APP_NAME">%s</xliff:g> sea tu asistente?"</string>
    <string name="assistant_security_warning" msgid="8498726261327239136">"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="7710290206928033908">"Aceptar"</string>
    <string name="assistant_security_warning_disagree" msgid="877419950830205913">"Rechazar"</string>
    <string name="choose_voice_input_title" msgid="975471367067718019">"Elegir la entrada de voz"</string>
    <string name="default_browser_title" msgid="8101772675085814670">"Navegador"</string>
    <string name="default_browser_title_none" msgid="2124785489953628553">"No hay un navegador predeterminado."</string>
    <string name="default_phone_title" msgid="282005908059637350">"Teléfono"</string>
    <string name="default_app" msgid="6864503001385843060">"(Predeterminada)"</string>
    <string name="system_app" msgid="9068313769550747372">"(Sistema)"</string>
    <string name="system_default_app" msgid="3091113402349739037">"(Predeterminada de sistema)"</string>
    <string name="apps_storage" msgid="4353308027210435513">"Almacenamiento de apps"</string>
    <string name="usage_access" msgid="5479504953931038165">"Acceso a datos de uso"</string>
    <string name="permit_usage_access" msgid="4012876269445832300">"Apps con acceso de uso"</string>
    <string name="app_usage_preference" msgid="7065701732733134991">"Preferencias de uso de la aplicación"</string>
    <string name="time_spent_in_app_pref_title" msgid="9124796405314626532">"Tiempo de uso"</string>
    <string name="usage_access_description" msgid="1352111094596416795">"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="7490541005204254222">"Memoria"</string>
    <string name="memory_details_title" msgid="8542565326053693320">"Detalles de la memoria"</string>
    <string name="always_running" msgid="6042448320077429656">"Siempre en ejecución (<xliff:g id="PERCENTAGE">%s</xliff:g>)"</string>
    <string name="sometimes_running" msgid="6611250683037700864">"A veces en ejecución (<xliff:g id="PERCENTAGE">%s</xliff:g>)"</string>
    <string name="rarely_running" msgid="348413460168817458">"Casi nunca en ejecución (<xliff:g id="PERCENTAGE">%s</xliff:g>)"</string>
    <string name="memory_max_use" msgid="6874803757715963097">"Máximo"</string>
    <string name="memory_avg_use" msgid="7382015389130622870">"Promedio"</string>
    <string name="memory_max_desc" msgid="2861832149718335864">"Máximo de <xliff:g id="MEMORY">%1$s</xliff:g>"</string>
    <string name="memory_avg_desc" msgid="1551240906596518412">"Promedio de <xliff:g id="MEMORY">%1$s</xliff:g>"</string>
    <string name="memory_use_running_format" msgid="4172488041800743760">"<xliff:g id="MEMORY">%1$s</xliff:g>/<xliff:g id="RUNNING">%2$s</xliff:g>"</string>
    <string name="process_format" msgid="77905604092541454">"<xliff:g id="APP_NAME">%1$s</xliff:g> (<xliff:g id="COUNT">%2$d</xliff:g>)"</string>
    <string name="high_power_apps" msgid="3459065925679828230">"Optimización de la batería"</string>
    <string name="additional_battery_info" msgid="4754099329165411970">"Alertas de uso"</string>
    <string name="show_all_apps" msgid="1512506948197818534">"Mostrar uso completo del dispositivo"</string>
    <string name="hide_extra_apps" msgid="5016497281322459633">"Mostrar uso de apps"</string>
    <plurals name="power_high_usage_summary" formatted="false" msgid="467347882627862744">
      <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="3826660033363082922">
      <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="3222265297576680099">"Sin optimizar"</string>
    <string name="high_power_on" msgid="6216293998227583810">"Sin optimizar"</string>
    <string name="high_power_off" msgid="3393904131961263278">"Optimizando el uso de la batería"</string>
    <string name="high_power_system" msgid="7362862974428225301">"Optimización de la batería no disponible"</string>
    <string name="high_power_desc" msgid="6283926163708585760">"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="6358673688590282655">"¿Deseas permitir que la app se ejecute siempre en segundo plano?"</string>
    <string name="high_power_prompt_body" msgid="1031422980602565049">"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="8044042095190688654">"Se usó el <xliff:g id="PERCENTAGE">%1$s</xliff:g> desde la última carga completa"</string>
    <string name="battery_power_management" msgid="5571519699679107523">"Administración de energía"</string>
    <string name="no_battery_summary" msgid="3528036835462846814">"No se usó la batería desde la última carga completa."</string>
    <string name="app_notification_preferences" msgid="1599319335092722613">"Configuración de la aplicación"</string>
    <string name="system_ui_settings" msgid="579824306467081123">"Mostrar sintonizador de IU del sistema"</string>
    <string name="additional_permissions" msgid="6463784193877056080">"Permisos adicionales"</string>
    <string name="additional_permissions_more" msgid="3538612272673191451">"<xliff:g id="COUNT">%1$d</xliff:g> más"</string>
    <string name="share_remote_bugreport_dialog_title" msgid="1124840737776588602">"¿Deseas compartir el informe de errores?"</string>
    <string name="share_remote_bugreport_dialog_message_finished" msgid="4973886976504823801">"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="3495929560689435496">"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="5859287696666024466">"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="532226159318779397">"Compartir"</string>
    <string name="decline_remote_bugreport_action" msgid="518720235407565134">"Rechazar"</string>
    <string name="usb_use_charging_only" msgid="4800495064747543954">"Sin transferencia de datos"</string>
    <string name="usb_use_charging_only_desc" msgid="3066256793008540627">"Solo cargar el dispositivo"</string>
    <string name="usb_use_power_only" msgid="3236391691786786070">"Cargar dispositivo conectado"</string>
    <string name="usb_use_file_transfers" msgid="1223134119354320726">"Transferencia de archivos"</string>
    <string name="usb_use_file_transfers_desc" msgid="4235764784331804488">"Transferir archivos a otro dispositivo"</string>
    <string name="usb_use_photo_transfers" msgid="8192719651229326283">"PTP"</string>
    <string name="usb_use_photo_transfers_desc" msgid="2963034811151325996">"Transferir fotos o archivos si no se admite MTP (PTP)"</string>
    <string name="usb_use_tethering" msgid="3944506882789422118">"Conexión a red por USB"</string>
    <string name="usb_use_MIDI" msgid="5116404702692483166">"MIDI"</string>
    <string name="usb_use_MIDI_desc" msgid="8473936990076693175">"Usar este dispositivo como MIDI"</string>
    <string name="usb_use" msgid="3372728031108932425">"Utilizar USB para lo siguiente:"</string>
    <string name="usb_default_label" msgid="2211094045594574774">"Configuración predeterminada de USB"</string>
    <string name="usb_default_info" msgid="8864535445796200695">"Si conectas otro dispositivo cuando tu teléfono está desbloqueado, se aplicará esta configuración. Solo debes conectar dispositivos de confianza."</string>
    <string name="usb_pref" msgid="1400617804525116158">"USB"</string>
    <string name="usb_preference" msgid="7394265019817945275">"Preferencias de USB"</string>
    <string name="usb_control_title" msgid="4404322722995917160">"USB controlado por"</string>
    <string name="usb_control_host" msgid="2276710819046647200">"Dispositivo conectado"</string>
    <string name="usb_control_device" msgid="5821511964163469463">"Este dispositivo"</string>
    <string name="usb_switching" msgid="8995313698715545619">"Cambiando…"</string>
    <string name="usb_switching_failed" msgid="4156073015692409651">"No se pudo cambiar"</string>
    <string name="usb_summary_charging_only" msgid="7544327009143659751">"Cargando este dispositivo"</string>
    <string name="usb_summary_power_only" msgid="1996391096369798526">"Cargando dispositivo conectado"</string>
    <string name="usb_summary_file_transfers" msgid="6925168380589489645">"Transferencia de archivos"</string>
    <string name="usb_summary_tether" msgid="951190049557074535">"Conexión a red por USB"</string>
    <string name="usb_summary_photo_transfers" msgid="665584667685030007">"PTP"</string>
    <string name="usb_summary_MIDI" msgid="2399066753961085360">"MIDI"</string>
    <string name="usb_summary_file_transfers_power" msgid="7700800611455849806">"Transferencia de archivos y carga"</string>
    <string name="usb_summary_tether_power" msgid="5825335393952752238">"Conexión USB y de carga"</string>
    <string name="usb_summary_photo_transfers_power" msgid="6826058111908423069">"PTP y carga"</string>
    <string name="usb_summary_MIDI_power" msgid="3308250484012677596">"Modo MIDI y carga"</string>
    <string name="background_check_pref" msgid="7550258400138010979">"Verificación en segundo plano"</string>
    <string name="background_check_title" msgid="4534254315824525593">"Acceso en segundo plano completo"</string>
    <string name="assist_access_context_title" msgid="2269032346698890257">"Utilizar el texto de la pantalla"</string>
    <string name="assist_access_context_summary" msgid="1991421283142279560">"Permitir que la aplicación de asistencia acceda a los contenidos de la pantalla como texto"</string>
    <string name="assist_access_screenshot_title" msgid="4034721336291215819">"Utilizar la captura de pantalla"</string>
    <string name="assist_access_screenshot_summary" msgid="6761636689013259901">"Permitir que la aplicación de asistencia acceda a una imagen de la pantalla"</string>
    <string name="assist_flash_title" msgid="506661221230034891">"Iluminar pantalla"</string>
    <string name="assist_flash_summary" msgid="9160668468824099262">"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="1982791172085896864">"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="829566450150198512">"Uso promedio de la memoria"</string>
    <string name="maximum_memory_use" msgid="7493720799710132496">"Uso máximo de la memoria"</string>
    <string name="memory_usage" msgid="1781358557214390033">"Uso de la memoria"</string>
    <string name="app_list_memory_use" msgid="6987417883876419338">"Uso de aplicaciones"</string>
    <string name="memory_details" msgid="5943436005716991782">"Detalles"</string>
    <string name="memory_use_summary" msgid="5608257211903075754">"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="2016900536806235588">"No se utilizó la memoria en las últimas tres horas"</string>
    <string name="sort_avg_use" msgid="3998036180505143129">"Ordenar según el uso promedio"</string>
    <string name="sort_max_use" msgid="4629247978290075124">"Ordenar según el uso máximo"</string>
    <string name="memory_performance" msgid="5661005192284103281">"Rendimiento"</string>
    <string name="total_memory" msgid="2017287600738630165">"Memoria total"</string>
    <string name="average_used" msgid="5338339266517245782">"Uso promedio (%)"</string>
    <string name="free_memory" msgid="4003936141603549746">"Libre(s)"</string>
    <string name="memory_usage_apps" msgid="5650192998273294098">"Memoria que utilizan las aplicaciones"</string>
    <plurals name="memory_usage_apps_summary" formatted="false" msgid="6089210945574265774">
      <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="6622624669948277693">"Frecuencia"</string>
    <string name="memory_maximum_usage" msgid="6513785462055278341">"Uso máximo"</string>
    <string name="no_data_usage" msgid="9131454024293628063">"No se usaron datos"</string>
    <string name="zen_access_warning_dialog_title" msgid="1198189958031157142">"¿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="4015885767653010873">"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="302820100078584431">"Debe seguir activado porque el acceso a las notificaciones está activado"</string>
    <string name="zen_access_revoke_warning_dialog_title" msgid="558779234015793950">"¿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="5518216907304930148">"Se quitarán todas las normas del modo No interrumpir que creó esta app."</string>
    <string name="ignore_optimizations_on" msgid="6915689518016285116">"No optimizar"</string>
    <string name="ignore_optimizations_off" msgid="6153196256410296835">"Optimizar"</string>
    <string name="ignore_optimizations_on_desc" msgid="3549930955839111652">"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="5255731062045426544">"Es recomendable para una mayor duración de la batería"</string>
    <string name="ignore_optimizations_title" msgid="2829637961185027768">"¿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="108006867520327904">"Ninguno"</string>
    <string name="work_profile_usage_access_warning" msgid="2918050775124911939">"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="2408292742980383166">"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="6564116025404257047">"Mostrar sobre otras apps"</string>
    <string name="system_alert_window_settings" msgid="8466613169103527868">"Mostrar sobre otras apps"</string>
    <string name="system_alert_window_apps_title" msgid="7005760279028569491">"Aplicaciones"</string>
    <string name="system_alert_window_access_title" msgid="6297115362542361241">"Mostrar sobre otras apps"</string>
    <string name="permit_draw_overlay" msgid="7456536798718633432">"Permitir mostrar sobre otras apps"</string>
    <string name="allow_overlay_description" msgid="8961670023925421358">"Permite que esta app se muestre sobre otras en uso. Es posible que interfiera con el uso de esas apps o cambie afecte su apariencia o el comportamiento."</string>
    <string name="keywords_vr_listener" msgid="7441221822576384680">"rv, procesador de realidad virtual, estéreo, servicio de ayuda"</string>
    <string name="overlay_settings" msgid="6930854109449524280">"Mostrar sobre otras apps"</string>
    <string name="system_alert_window_summary" msgid="602892301318324492">"<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="6965969283342557573">"Aplicaciones con permiso"</string>
    <string name="app_permission_summary_allowed" msgid="1505409933012886711">"Permitido"</string>
    <string name="app_permission_summary_not_allowed" msgid="2592617058101882802">"No permitida"</string>
    <string name="keywords_install_other_apps" msgid="761078076051006558">"instalar, apps, fuentes desconocidas"</string>
    <string name="write_settings" msgid="4797457275727195681">"Modificar conf. sistema"</string>
    <string name="keywords_write_settings" msgid="6415597272561105138">"editar, modificar, sistema, configuración"</string>
    <string name="write_settings_summary" msgid="4302268998611412696">"<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="3102976274848199118">"Puede instalar otras apps"</string>
    <string name="filter_write_settings_apps" msgid="2914615026197322551">"Puede modificar la configuración del sistema"</string>
    <string name="write_settings_title" msgid="4232152481902542284">"Puede modificar la configuración del sistema"</string>
    <string name="write_system_settings" msgid="3482913590601096763">"Modificar conf. sistema"</string>
    <string name="permit_write_settings" msgid="658555006453212691">"Permitir cambios en configuración del sistema"</string>
    <string name="write_settings_description" msgid="6868293938839954623">"Este permiso admite que una aplicación modifique la configuración del sistema."</string>
    <string name="write_settings_on" msgid="8230580416068832239">"Sí"</string>
    <string name="write_settings_off" msgid="5156104383386336233">"No"</string>
    <string name="external_source_switch_title" msgid="3621381992793251070">"Confiar en esta fuente"</string>
    <string name="camera_gesture_title" msgid="1075838577642393011">"Gira la muñeca dos veces para la cámara"</string>
    <string name="camera_gesture_desc" msgid="1831390075255870960">"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="1651873760405034645">"Botón de encendido dos veces para cámara"</string>
    <string name="camera_double_tap_power_gesture_desc" msgid="7355664631775680376">"Abre la cámara de forma rápida sin desbloquear la pantalla"</string>
    <string name="screen_zoom_title" msgid="5233515303733473927">"Tamaño en pantalla"</string>
    <string name="screen_zoom_short_summary" msgid="7291960817349834688">"Aumenta o reduce el tamaño de los elementos en pantalla"</string>
    <string name="screen_zoom_keywords" msgid="9176477565403352552">"densidad de la pantalla, zoom de la pantalla, escala"</string>
    <string name="screen_zoom_summary" msgid="6445488991799015407">"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="4680671508172336572">"Vista previa"</string>
    <string name="screen_zoom_make_smaller_desc" msgid="4622359904253364742">"Reducir el tamaño"</string>
    <string name="screen_zoom_make_larger_desc" msgid="2236171043607896594">"Aumentar el tamaño"</string>
    <string name="screen_zoom_conversation_icon_alex" msgid="8443032489384985820">"A"</string>
    <string name="screen_zoom_conversation_icon_pete" msgid="998709701837681129">"P"</string>
    <string name="screen_zoom_conversation_message_1" msgid="6546951024984852686">"¡Hola!"</string>
    <string name="screen_zoom_conversation_message_2" msgid="6935424214137738647">"¿Quieres que tomemos un café y nos pongamos al día?"</string>
    <string name="screen_zoom_conversation_message_3" msgid="5218221201861387402">"Me encanta la idea. Conozco un buen lugar cerca de aquí."</string>
    <string name="screen_zoom_conversation_message_4" msgid="5564676794767555447">"¡Perfecto!"</string>
    <string name="screen_zoom_conversation_timestamp_1" msgid="7453710416319650556">"Mar 6:00 p.m."</string>
    <string name="screen_zoom_conversation_timestamp_2" msgid="7107225702890747588">"Mar 6:01 p.m."</string>
    <string name="screen_zoom_conversation_timestamp_3" msgid="3785674344762707688">"Mar 6:02 p.m."</string>
    <string name="screen_zoom_conversation_timestamp_4" msgid="2511469395448561259">"Mar 6:03 p.m."</string>
    <string name="disconnected" msgid="4836600637485526329">"Sin conexión"</string>
    <string name="keyboard_disconnected" msgid="1495037256967224035">"No conectado"</string>
    <string name="data_usage_summary_format" msgid="7507047900192160585">"<xliff:g id="AMOUNT">%1$s</xliff:g> de datos usados"</string>
    <string name="data_usage_wifi_format" msgid="5417296451392612860">"Uso de datos con Wi‑Fi: <xliff:g id="AMOUNT">^1</xliff:g>"</string>
    <plurals name="notification_summary" formatted="false" msgid="3941492005316143599">
      <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="4586376436702610">"Activadas para todas las apps"</string>
    <string name="apps_summary" msgid="193158055537070092">"<xliff:g id="COUNT">%1$d</xliff:g> apps instaladas"</string>
    <string name="apps_summary_example" msgid="2118896966712746139">"Apps instaladas: 24"</string>
    <string name="storage_summary" msgid="3801281635351732202">"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="3290457009629490121">"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="6737806235882127328">"Suspender después de <xliff:g id="TIMEOUT_DESCRIPTION">%1$s</xliff:g> de inactividad"</string>
    <string name="display_dashboard_summary" msgid="4145888780290131488">"Fondo de pantalla, suspender, tamaño de fuente"</string>
    <string name="display_dashboard_summary_with_style" msgid="870920274423314524">"Estilos, fondos de pantalla, tiempo de espera de la pantalla y tamaño de fuente"</string>
    <string name="display_dashboard_nowallpaper_summary" msgid="7840559323355210111">"Suspender, tamaño de fuente"</string>
    <string name="display_summary_example" msgid="9102633726811090523">"Suspender después de 10 minutos de inactividad"</string>
    <string name="memory_summary" msgid="8080825904671961872">"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="1674864467098487328">"Accediste como <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="payment_summary" msgid="3472482669588561110">"App predeterminada: <xliff:g id="APP_NAME">%1$s</xliff:g>"</string>
    <string name="backup_disabled" msgid="485189128759595412">"Copia de seguridad inhabilitada"</string>
    <string name="android_version_summary" msgid="2935995161657697278">"Se actualizó a Android <xliff:g id="VERSION">%1$s</xliff:g>"</string>
    <string name="android_version_pending_update_summary" msgid="487831391976523090">"Actualización disponible"</string>
    <string name="disabled_by_policy_title" msgid="627023216027648534">"Acción no permitida"</string>
    <string name="disabled_by_policy_title_adjust_volume" msgid="3208724801293696486">"No se puede cambiar el volumen"</string>
    <string name="disabled_by_policy_title_outgoing_calls" msgid="7919816644946067058">"No está permitido hacer llamadas"</string>
    <string name="disabled_by_policy_title_sms" msgid="5733307423899610340">"No está permitido enviar SMS"</string>
    <string name="disabled_by_policy_title_camera" msgid="6225008536855644874">"No está permitido usar la cámara"</string>
    <string name="disabled_by_policy_title_screen_capture" msgid="4066913623298047094">"No está permitido tomar capturas de pantalla"</string>
    <string name="disabled_by_policy_title_suspend_packages" msgid="7872038990805477554">"No se puede abrir esta app"</string>
    <string name="default_admin_support_msg" msgid="4489678214035485367">"Si tienes alguna pregunta, comunícate con tu administrador de TI"</string>
    <string name="admin_support_more_info" msgid="8901377038510512654">"Más detalles"</string>
    <string name="admin_profile_owner_message" msgid="5860816886981109626">"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="3842630535450382172">"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="6232893638259790789">"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="1960945836880080298">"Desactivar"</string>
    <string name="condition_turn_on" msgid="9089876276117874591">"Activar"</string>
    <string name="condition_expand_show" msgid="608202020023489939">"Mostrar"</string>
    <string name="condition_expand_hide" msgid="948507739223760667">"Ocultar"</string>
    <string name="condition_hotspot_title" msgid="5959815393203320845">"El hotspot está activo"</string>
    <string name="condition_airplane_title" msgid="287356299107070503">"El modo de avión está activado"</string>
    <string name="condition_airplane_summary" msgid="2500054042183138980">"Redes no disponible"</string>
    <string name="condition_zen_title" msgid="2897779738211625">"\"No interrumpir\" activado"</string>
    <string name="condition_zen_summary_phone_muted" msgid="3644614024467141806">"Se silenció el teléfono"</string>
    <string name="condition_zen_summary_with_exceptions" msgid="4047564276599301064">"Con excepciones"</string>
    <string name="condition_battery_title" msgid="3272131008388575349">"Ahorro de batería activado"</string>
    <string name="condition_battery_summary" msgid="5847532902924566572">"Funciones restringidas"</string>
    <string name="condition_cellular_title" msgid="1327317003797575735">"Datos móviles desactivados"</string>
    <string name="condition_cellular_summary" msgid="816822977403022625">"Solo se puede acceder a Internet mediante Wi‑Fi"</string>
    <string name="condition_bg_data_title" msgid="5475793236997935138">"Ahorro de datos"</string>
    <string name="condition_bg_data_summary" msgid="1852811387315557164">"Funciones restringidas"</string>
    <string name="condition_work_title" msgid="7293722361184366648">"Perfil de trabajo desactivado"</string>
    <string name="condition_work_summary" msgid="9167580982244020746">"Para apps y notificaciones"</string>
    <string name="condition_device_muted_action_turn_on_sound" msgid="4930240942726349213">"Activar sonido"</string>
    <string name="condition_device_muted_title" msgid="3476439379918599716">"Se silenció el timbre"</string>
    <string name="condition_device_muted_summary" msgid="6313274406443663781">"Para llamadas y notificaciones"</string>
    <string name="condition_device_vibrate_title" msgid="8070177546359590131">"Solo vibración"</string>
    <string name="condition_device_vibrate_summary" msgid="5743200564646910423">"Para llamadas y notificaciones"</string>
    <string name="night_display_suggestion_title" msgid="6602129097059325291">"Programar Luz nocturna"</string>
    <string name="night_display_suggestion_summary" msgid="228346372178218442">"Cambiar automáticamente el tono de la pantalla por la noche"</string>
    <string name="condition_night_display_title" msgid="5599814941976856183">"\"Luz nocturna\" activada"</string>
    <string name="condition_night_display_summary" msgid="7150932917610919907">"La pantalla adopta un tono ámbar"</string>
    <string name="condition_grayscale_title" msgid="3426050703427823519">"Escala de grises"</string>
    <string name="condition_grayscale_summary" msgid="7652835784223724625">"Mostrar únicamente en color gris"</string>
    <string name="homepage_condition_footer_content_description" msgid="2335918927419018030">"Contraer"</string>
    <string name="suggestions_title_v2" msgid="5601181602924147569">"Sugerencias para ti"</string>
    <string name="suggestions_title" msgid="7280792342273268377">"Sugerencias"</string>
    <string name="suggestions_summary" msgid="2509040178581728056">"+<xliff:g id="ID_1">%1$d</xliff:g>"</string>
    <string name="suggestions_more_title" msgid="8223690393059519879">"y <xliff:g id="ID_1">%1$d</xliff:g> más"</string>
    <plurals name="suggestions_collapsed_title" formatted="false" msgid="1857433444865249823">
      <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="7680263825371165461">
      <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="904627293892092439">"Quitar"</string>
    <string name="color_temperature" msgid="2070126836910615605">"Temperatura de colores fríos"</string>
    <string name="color_temperature_desc" msgid="4793729830226404052">"Usar colores de pantalla más fríos"</string>
    <string name="color_temperature_toast" msgid="4974218172133854827">"Para aplicar el cambio de color, apaga la pantalla"</string>
    <string name="camera_laser_sensor_switch" msgid="8913588990743234440">"Sensor láser de la cámara"</string>
    <string name="ota_disable_automatic_update" msgid="2319639631655915050">"Actualizaciones automáticas del sistema"</string>
    <string name="ota_disable_automatic_update_summary" msgid="940729694354373087">"Aplicar actualizaciones al reiniciar el dispositivo"</string>
    <string name="usage" msgid="2977875522080448986">"Uso"</string>
    <string name="cellular_data_usage" msgid="2155683719898158203">"Uso de datos móviles"</string>
    <string name="app_cellular_data_usage" msgid="5468472735806533448">"Uso de datos de la app"</string>
    <string name="wifi_data_usage" msgid="771603760674507659">"Uso de datos Wi‑Fi"</string>
    <string name="ethernet_data_usage" msgid="5108764537574354616">"Uso de datos de Ethernet"</string>
    <string name="wifi" msgid="1081550856200013637">"Wi-Fi"</string>
    <string name="ethernet" msgid="6600095783781389720">"Ethernet"</string>
    <string name="cell_data_template" msgid="405684854174361041">"Datos móviles: <xliff:g id="AMOUNT">^1</xliff:g>"</string>
    <string name="wifi_data_template" msgid="6265570748799357386">"Datos de Wi-Fi: <xliff:g id="AMOUNT">^1</xliff:g>"</string>
    <string name="ethernet_data_template" msgid="5782476509881033590">"Datos de Ethernet: <xliff:g id="AMOUNT">^1</xliff:g>"</string>
    <string name="billing_cycle" msgid="6614597736285325497">"Límite y advertencia de datos"</string>
    <string name="app_usage_cycle" msgid="8877223251648092131">"Ciclo de uso de datos de las apps"</string>
    <string name="cell_data_warning" msgid="1985956818884847057">"Advertencia de datos: <xliff:g id="ID_1">^1</xliff:g>"</string>
    <string name="cell_data_limit" msgid="1578367585799358854">"Límite de datos: <xliff:g id="ID_1">^1</xliff:g>"</string>
    <string name="cell_data_warning_and_limit" msgid="6888825370687743208">"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="8231066353654583106">"El <xliff:g id="ID_1">%1$s</xliff:g> de cada mes"</string>
    <string name="network_restrictions" msgid="8234695294536675380">"Restricciones de red"</string>
    <plurals name="network_restrictions_summary" formatted="false" msgid="4301618027244595839">
      <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="1862988028996859195">"El cálculo de datos del proveedor puede diferir del que hace el dispositivo."</string>
    <string name="data_used_template" msgid="3245919669966296505">"Datos usados: <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="set_data_warning" msgid="6115364758236594593">"Configurar advertencia"</string>
    <string name="data_warning" msgid="209133958008062117">"Advertencia de datos"</string>
    <string name="data_warning_footnote" msgid="776341964125603711">"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="2901526323210516923">"Establecer límite de datos"</string>
    <string name="data_limit" msgid="1885406964934590552">"Límite de datos"</string>
    <string name="data_usage_template" msgid="2923744765873163859">"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="1029654422228677273">"Configurar"</string>
    <string name="data_usage_other_apps" msgid="3272872663517382050">"Otras apps incluidas en el uso de datos"</string>
    <plurals name="data_saver_unrestricted_summary" formatted="false" msgid="2635267833484232703">
      <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="3659356290392241789">"Datos principales"</string>
    <string name="data_usage_wifi_title" msgid="7063659423081820720">"Datos de Wi-Fi"</string>
    <string name="data_used" msgid="5116389957228457203">"Datos usados: <xliff:g id="ID_1">^1</xliff:g>"</string>
    <string name="data_used_formatted" msgid="2989129931961311051">"Se usaron <xliff:g id="ID_1">^1</xliff:g> <xliff:g id="ID_2">^2</xliff:g>"</string>
    <string name="data_overusage" msgid="1134445012475270295">"Exceso: <xliff:g id="ID_1">^1</xliff:g>"</string>
    <string name="data_remaining" msgid="8998091725895502181">"Datos restantes: <xliff:g id="ID_1">^1</xliff:g>"</string>
    <plurals name="billing_cycle_days_left" formatted="false" msgid="456503215317213651">
      <item quantity="other">Quedan %d días</item>
      <item quantity="one">Queda %d día</item>
    </plurals>
    <string name="billing_cycle_none_left" msgid="5892754995098583472">"No queda tiempo"</string>
    <string name="billing_cycle_less_than_one_day_left" msgid="825838050296069404">"Queda menos de 1 día"</string>
    <string name="carrier_and_update_text" msgid="7963409972475063897">"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="3277403390316201982">"Actualizado hace <xliff:g id="ID_1">^2</xliff:g>"</string>
    <string name="carrier_and_update_now_text" msgid="4057997726060106722">"Actualizado recién por <xliff:g id="ID_1">^1</xliff:g>"</string>
    <string name="no_carrier_update_now_text" msgid="1766859656868932996">"Actualizado recién"</string>
    <string name="launch_mdp_app_text" msgid="6751296320061773169">"Ver plan"</string>
    <string name="launch_wifi_text" msgid="2311424914664372687">"Ver detalles"</string>
    <string name="data_saver_title" msgid="8034286939200289826">"Ahorro de datos"</string>
    <string name="unrestricted_data_saver" msgid="952796077540228711">"Datos sin restricciones"</string>
    <string name="restrict_background_blacklisted" msgid="3995443391711013068">"Se desactivaron los datos en segundo plano"</string>
    <string name="data_saver_on" msgid="6774217590237934709">"Activado"</string>
    <string name="data_saver_off" msgid="6892309031162738794">"Desactivado"</string>
    <string name="data_saver_switch_title" msgid="836312690356005669">"Usar Ahorro de datos"</string>
    <string name="unrestricted_app_title" msgid="4465437191723332066">"Uso de datos sin restricción"</string>
    <string name="unrestricted_app_summary" msgid="6458008993501723912">"Acceso a datos sin restricción"</string>
    <string name="home_app" msgid="4066188520886810030">"Página principal"</string>
    <string name="no_default_home" msgid="7184117487704520238">"No hay ninguna página principal predeterminada"</string>
    <string name="lockpattern_settings_require_cred_before_startup" msgid="3832020101401318248">"Inicio seguro"</string>
    <string name="lockpattern_settings_require_pattern_before_startup_summary" msgid="7873036097628404476">"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="6022831284097476933">"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="6818285221244966231">"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="2214281455363797037">"Agregar otra huella digital"</string>
    <string name="suggestion_additional_fingerprints_summary" msgid="5471253233176471245">"Desbloquea con otro dedo"</string>
    <string name="battery_saver_on_summary" msgid="7722791295871319534">"Activado"</string>
    <string name="battery_saver_off_scheduled_summary" msgid="3953785517002197881">"Se activará cuando quede <xliff:g id="BATTERY_PERCENTAGE">%1$s</xliff:g>"</string>
    <string name="battery_saver_off_summary" msgid="784360321235698247">"Desactivado"</string>
    <string name="battery_saver_button_turn_on" msgid="3699954061337848832">"Activar ahora"</string>
    <string name="battery_saver_button_turn_off" msgid="5916996792004611890">"Desactivar ahora"</string>
    <string name="not_battery_optimizing" msgid="5362861851864837617">"La optimización de la batería no está en uso"</string>
    <string name="lockscreen_remote_input" msgid="969871538778211843">"Si el dispositivo está bloqueado, evita la escritura de respuestas y otros textos en las notificaciones"</string>
    <string name="default_spell_checker" msgid="8506899870026026660">"Corrector predeterminado"</string>
    <string name="choose_spell_checker" msgid="6596539862291699367">"Elegir corrector ortográfico"</string>
    <string name="spell_checker_master_switch_title" msgid="8763132750954344372">"Usar el corrector ortográfico"</string>
    <string name="spell_checker_not_selected" msgid="8871083796179200696">"Sin seleccionar"</string>
    <string name="notification_log_no_title" msgid="5678029849672024215">"(ninguno)"</string>
    <string name="notification_log_details_delimiter" msgid="3116559361552416747">": "</string>
    <string name="notification_log_details_package" msgid="2596495677039100284">"paquete"</string>
    <string name="notification_log_details_key" msgid="2995791937075862968">"clave"</string>
    <string name="notification_log_details_group" msgid="2430467015200368698">"grupo"</string>
    <string name="notification_log_details_group_summary" msgid="7945543958255585829">"(resumen)"</string>
    <string name="notification_log_details_visibility" msgid="2552873780715930971">"visibilidad"</string>
    <string name="notification_log_details_public_version" msgid="4247242364605495240">"versión pública"</string>
    <string name="notification_log_details_priority" msgid="8371354971235991398">"prioridad"</string>
    <string name="notification_log_details_importance" msgid="2153168790791683139">"importancia"</string>
    <string name="notification_log_details_explanation" msgid="1914295130775393551">"explicación"</string>
    <string name="notification_log_details_badge" msgid="3258183328267662285">"puede mostrar insignias"</string>
    <string name="notification_log_details_content_intent" msgid="1113554570409128083">"intent"</string>
    <string name="notification_log_details_delete_intent" msgid="905118520685297007">"borrar intent"</string>
    <string name="notification_log_details_full_screen_intent" msgid="7118560817013522978">"intent en pantalla completa"</string>
    <string name="notification_log_details_actions" msgid="242523930165118066">"acciones"</string>
    <string name="notification_log_details_title" msgid="7177091647508863295">"título"</string>
    <string name="notification_log_details_remoteinput" msgid="8328591329858827409">"entradas remotas"</string>
    <string name="notification_log_details_content_view" msgid="6638731378278561786">"vista personalizada"</string>
    <string name="notification_log_details_extras" msgid="4188418723779942047">"adicionales"</string>
    <string name="notification_log_details_icon" msgid="8939114059726188218">"ícono"</string>
    <string name="notification_log_details_parcel" msgid="243148037601903212">"tamaño del paquete"</string>
    <string name="notification_log_details_ashmem" msgid="7241814108477320636">"ashmem"</string>
    <string name="notification_log_details_alerted" msgid="6622944771989529320">"notificación enviada"</string>
    <string name="notification_log_details_sound" msgid="5506232879598808099">"sonido"</string>
    <string name="notification_log_details_vibrate" msgid="6890065466625335940">"vibrar"</string>
    <string name="notification_log_details_vibrate_pattern" msgid="6076984056201975221">"patrón"</string>
    <string name="notification_log_details_default" msgid="2345249399796730861">"predeterminado"</string>
    <string name="notification_log_details_none" msgid="184131801230614059">"ninguno"</string>
    <string name="notification_log_details_ranking_null" msgid="244660392058720919">"Falta el objeto de la clasificación."</string>
    <string name="notification_log_details_ranking_none" msgid="599607025882587844">"El objeto de la clasificación no incluye esta tecla."</string>
    <string name="theme_customization_device_default" msgid="5058147707906551368">"Opción predeterminada del dispositivo"</string>
    <string name="display_cutout_emulation" msgid="7466869822418376317">"Corte de pantalla"</string>
    <string name="display_cutout_emulation_keywords" msgid="4495418317471622562">"recorte de la pantalla, corte"</string>
    <string name="overlay_option_device_default" msgid="294510212512203638">"Opción predeterminada del dispositivo"</string>
    <string name="overlay_toast_failed_to_apply" msgid="3506731619973103346">"Error al aplicar superposición"</string>
    <string name="special_access" msgid="3458780842491881155">"Acceso especial a apps"</string>
    <plurals name="special_access_summary" formatted="false" msgid="260765309935675867">
      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> apps pueden usar datos sin restricción</item>
      <item quantity="one">1 app puede usar datos sin restricción</item>
    </plurals>
    <string name="special_access_more" msgid="6927066457969301921">"Ver más"</string>
    <string name="confirm_convert_to_fbe_warning" msgid="1487005506049137659">"¿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="7101855374850373091">"Borrar y convertir"</string>
    <string name="reset_shortcut_manager_throttling" msgid="6495066467198668994">"Restablecer la limitación de frecuencia de ShortcutManager"</string>
    <string name="reset_shortcut_manager_throttling_complete" msgid="1826770872063707900">"Se restableció la limitación de frecuencia de ShortcutManager"</string>
    <string name="notification_suggestion_title" msgid="387052719462473500">"Controlar los datos que aparecen en la pantalla bloqueada"</string>
    <string name="notification_suggestion_summary" msgid="8521159741445416875">"Ocultar o mostrar el contenido de las notificaciones"</string>
    <string name="page_tab_title_summary" msgid="4070309266374993258">"Todas"</string>
    <string name="page_tab_title_support" msgid="4407600495101788249">"Sugerencias y asistencia"</string>
    <string name="developer_smallest_width" msgid="7516950434587313360">"Ancho más pequeño"</string>
    <string name="premium_sms_none" msgid="8268105565738040566">"Ninguna app que instalaste solicitó acceso a SMS premium"</string>
    <string name="premium_sms_warning" msgid="9086859595338944882">"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="4660047004791638305">"Acceso a SMS premium"</string>
    <string name="bluetooth_disabled" msgid="6244000672828617410">"Desactivado"</string>
    <string name="bluetooth_connected_summary" msgid="7672528674593152862">"Conectado a <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="bluetooth_connected_multiple_devices_summary" msgid="9173661896296663932">"Conectado a varios dispositivos"</string>
    <string name="demo_mode" msgid="2798762752209330277">"Modo demostración de la IU del sistema"</string>
    <string name="dark_ui_mode" msgid="6795784845192720944">"Tema oscuro"</string>
    <string name="dark_ui_mode_disabled_summary_dark_theme_on" msgid="5141126532745008289">"Activado: Inhabilitado temporalmente por Ahorro de batería"</string>
    <string name="dark_ui_mode_disabled_summary_dark_theme_off" msgid="4619248181769223081">"Activado temporalmente por el Ahorro de batería"</string>
    <string name="dark_ui_settings_dark_summary" msgid="8205234847639399279">"Las apps compatibles también se cambiarán a tema oscuro"</string>
    <string name="dark_ui_settings_dialog_acknowledge" msgid="8683868642329596059">"Entendido"</string>
    <string name="quick_settings_developer_tiles" msgid="5947788063262762448">"Mosaicos de configuración rápida para programadores"</string>
    <string name="winscope_trace_quick_settings_title" msgid="1294290008255732032">"Seguimiento de Winscope"</string>
    <string name="sensors_off_quick_settings_title" msgid="1487323753632515801">"Sensores desactivados"</string>
    <string name="managed_profile_settings_title" msgid="2729481936758125054">"Configuración del perfil de trabajo"</string>
    <string name="managed_profile_contact_search_title" msgid="6034734926815544221">"Búsqueda de contactos"</string>
    <string name="managed_profile_contact_search_summary" msgid="5431253552272970512">"Permitir que tu organización busque contactos para identificar a emisores y contactos"</string>
    <string name="cross_profile_calendar_title" msgid="4414835261437899531">"Sincronizar perfiles en el calendario"</string>
    <string name="cross_profile_calendar_summary" msgid="8139424817135929870">"Mostrar eventos de trabajo en el calendario personal"</string>
    <string name="cross_profile_calendar_restricted_summary" msgid="295371538704418613">"Tu organización no permite que apps personales accedan al calendario de trabajo"</string>
    <plurals name="hours" formatted="false" msgid="7020844602875333472">
      <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="4666832442068789413">
      <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="3876307354560025025">
      <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="7819434542155181607">"Administrar el almacenamiento"</string>
    <string name="automatic_storage_manager_text" msgid="4562950476680600604">"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="2017913896160914647">"Quitar fotos y videos"</string>
    <string name="automatic_storage_manager_preference_title" msgid="5753702798151073383">"Administrador de almacenamiento"</string>
    <string name="automatic_storage_manager_master_switch_title" msgid="6792996736190821417">"Usar el Administrador de almacenamiento"</string>
    <string name="deletion_helper_automatic_title" msgid="6605660435498272520">"Automático"</string>
    <string name="deletion_helper_manual_title" msgid="7947432164411214029">"Manual"</string>
    <string name="deletion_helper_preference_title" msgid="5271510052022285884">"Liberar espacio ahora"</string>
    <string name="gesture_preference_title" msgid="5280023307132819052">"Gestos"</string>
    <string name="gesture_preference_summary" product="default" msgid="8627850388011956901">"Gestos rápidos para controlar tu teléfono"</string>
    <string name="gesture_preference_summary" product="tablet" msgid="4717535378272065510">"Gestos rápidos para controlar tu tablet"</string>
    <string name="gesture_preference_summary" product="device" msgid="4205941452664950852">"Gestos rápidos para controlar tu dispositivo"</string>
    <string name="double_tap_power_for_camera_title" msgid="64716226816032800">"Ir a la cámara"</string>
    <string name="double_tap_power_for_camera_summary" msgid="242037150983277829">"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="6500405261202883589">"Abre la cámara rápidamente"</string>
    <string name="double_twist_for_camera_mode_title" msgid="4877834147983530479">"Alternar cámara"</string>
    <string name="double_twist_for_camera_mode_summary" msgid="122977081337563340"></string>
    <string name="double_twist_for_camera_suggestion_title" msgid="4689410222517954869">"Toma selfies más rápido"</string>
    <string name="system_navigation_title" msgid="6797710220442338366">"Navegación del sistema"</string>
    <string name="swipe_up_to_switch_apps_title" msgid="7381617686249459562">"Navegación con 2 botones"</string>
    <string name="swipe_up_to_switch_apps_summary" msgid="2158312695920408870">"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="1465200107913259595">"Prueba el nuevo botón de inicio"</string>
    <string name="swipe_up_to_switch_apps_suggestion_summary" msgid="4825314186907812743">"Activa el nuevo gesto para cambiar de app"</string>
    <string name="edge_to_edge_navigation_title" msgid="4889073348091667667">"Navegación por gestos"</string>
    <string name="edge_to_edge_navigation_summary" msgid="511639046551586471">"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="2635061924638361565">"Navegación con 3 botones"</string>
    <string name="legacy_navigation_summary" msgid="5631274479304544610">"Ve atrás o a la pantalla de inicio y cambia de app con los botones de la parte inferior de la pantalla."</string>
    <string name="keywords_system_navigation" msgid="5825645072714635357">"navegación del sistema, navegación con 2 botones, navegación con 3 botones, navegación por gestos"</string>
    <string name="gesture_not_supported_dialog_message" msgid="4315436164949864999">"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="8233003373902032396">"Cambiar de app de inicio predeterminada"</string>
    <string name="information_label" msgid="8133109685432913360">"Información"</string>
    <string name="low_label" msgid="1679136861385616813">"Baja"</string>
    <string name="high_label" msgid="7278863493316447831">"Alta"</string>
    <string name="back_sensitivity_dialog_message" msgid="1742132397253621623">\n"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="5403946345652118253">"Sensibilidad posterior"</string>
    <string name="ambient_display_title" product="default" msgid="5144814600610448504">"Presiona la pantalla dos veces para consultar el teléfono"</string>
    <string name="ambient_display_title" product="tablet" msgid="8688795028609563837">"Presionar dos veces la tablet para revisarla"</string>
    <string name="ambient_display_title" product="device" msgid="3423781975742145894">"Presionar dos veces el dispositivo para revisarlo"</string>
    <string name="ambient_display_summary" msgid="8534654210539169707">"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="818688002837687268">"Levantar el teléfono para revisarlo"</string>
    <string name="ambient_display_pickup_title" product="tablet" msgid="4455864282995698097">"Levanta la tablet para revisarla"</string>
    <string name="ambient_display_pickup_title" product="device" msgid="5380534405773531175">"Levanta el dispositivo para revisarlo"</string>
    <string name="ambient_display_wake_screen_title" msgid="4091523525326925790">"Activar pantalla"</string>
    <string name="ambient_display_pickup_summary" product="default" msgid="3436302177038243869">"Para consultar la hora, las notificaciones y otra información, levanta el teléfono."</string>
    <string name="ambient_display_pickup_summary" product="tablet" msgid="4938504160398665156">"Para consultar la hora, las notificaciones y otra información, levanta la tablet."</string>
    <string name="ambient_display_pickup_summary" product="device" msgid="4264958533375250254">"Para consultar la hora, las notificaciones y otra información, levanta el dispositivo."</string>
    <string name="ambient_display_tap_screen_title" product="default" msgid="5458679563086979424">"Presionar para revisar el teléfono"</string>
    <string name="ambient_display_tap_screen_title" product="tablet" msgid="9108878716863882877">"Presiona para revisar la tablet"</string>
    <string name="ambient_display_tap_screen_title" product="device" msgid="7071150656699666085">"Presiona para revisar el dispositivo"</string>
    <string name="ambient_display_tap_screen_summary" msgid="8862155601920379979">"Para consultar la hora, las notificaciones y otra información, presiona la pantalla."</string>
    <string name="fingerprint_swipe_for_notifications_title" msgid="5816346492253270243">"Deslizar tu huella para ver notificaciones"</string>
    <string name="fingerprint_gesture_screen_title" msgid="8562169633234041196">"Deslizar huella digital"</string>
    <string name="fingerprint_swipe_for_notifications_summary" product="default" msgid="1770661868393713922">"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="902719947767712895">"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="5372926094116306647">"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="1677291167470357802">"Consulta tus notificaciones rápidamente"</string>
    <string name="gesture_setting_on" msgid="3455094265233870280">"Activado"</string>
    <string name="gesture_setting_off" msgid="5230169535435881894">"Desactivado"</string>
    <string name="oem_unlock_enable_disabled_summary_bootloader_unlocked" msgid="4265541229765635629">"El cargador de inicio está desbloqueado"</string>
    <string name="oem_unlock_enable_disabled_summary_connectivity" msgid="3361344735430813695">"Primero debes conectarte a Internet"</string>
    <string name="oem_unlock_enable_disabled_summary_connectivity_or_locked" msgid="2479038689567925511">"Conéctate a Internet o comunícate con tu proveedor"</string>
    <string name="oem_unlock_enable_disabled_summary_sim_locked_device" msgid="4149387448213399630">"No disponible en dispositivos bloqueados por el proveedor"</string>
    <string name="oem_lock_info_message" msgid="9218313722236417510">"Reinicia el dispositivo para habilitar la función de protección correspondiente."</string>
    <string name="automatic_storage_manager_freed_bytes" msgid="7517560170441007788">"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="4051513950976670853">"Apps instantáneas"</string>
    <string name="web_action_enable_summary" msgid="3108127559723396382">"Abre vínculos en apps, incluso aunque no estén instaladas"</string>
    <string name="web_action_section_title" msgid="7364647086538399136">"Apps instantáneas"</string>
    <string name="instant_apps_settings" msgid="8827777916518348213">"Preferencias de las Apps instantáneas"</string>
    <string name="domain_url_section_title" msgid="7046835219056428883">"Apps instaladas"</string>
    <string name="automatic_storage_manager_activation_warning" msgid="6353100011690933254">"Tu almacenamiento ahora está a cargo del administrador de almacenamiento"</string>
    <string name="account_for_section_header" msgid="5356566418548737121">"Cuentas de <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="configure_section_header" msgid="7391183586410814450">"Configuración"</string>
    <string name="auto_sync_account_title" msgid="898796354710116383">"Sincronizar datos automáticamente"</string>
    <string name="auto_sync_personal_account_title" msgid="8496263182646100610">"Sincronizar datos personales automáticamente"</string>
    <string name="auto_sync_work_account_title" msgid="4489172450037434152">"Sincronizar los datos de trabajo automáticamente"</string>
    <string name="auto_sync_account_summary" msgid="692499211629185107">"Permitir que las apps actualicen datos automáticamente"</string>
    <string name="account_sync_title" msgid="7214747784136106491">"Sincronización de la cuenta"</string>
    <string name="account_sync_summary_some_on" msgid="3375930757891381175">"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="570431636622254156">"Sincronización activada para todos los elementos"</string>
    <string name="account_sync_summary_all_off" msgid="8782409931761182734">"Sincronización desactivada para todos los elementos"</string>
    <string name="enterprise_privacy_settings" msgid="1177106810374146496">"Información del dispositivo administrado"</string>
    <string name="enterprise_privacy_settings_summary_generic" msgid="5853292305730761128">"Cambios y opciones de configuración que administra tu organización"</string>
    <string name="enterprise_privacy_settings_summary_with_name" msgid="4266234968317996188">"Cambios y opciones de configuración que administra <xliff:g id="ORGANIZATION_NAME">%s</xliff:g>"</string>
    <string name="enterprise_privacy_header" msgid="7402406406883832509">"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="7313392680107938517">"Tipos de información que tu organización puede ver"</string>
    <string name="enterprise_privacy_exposure_changes_category" msgid="9079283547182933771">"Cambios que realizó el administrador de tu organización"</string>
    <string name="enterprise_privacy_device_access_category" msgid="5423434164248819058">"Tu acceso a este dispositivo"</string>
    <string name="enterprise_privacy_enterprise_data" msgid="2773968662865848413">"Datos asociados a tu cuenta de trabajo, como el correo electrónico y el calendario"</string>
    <string name="enterprise_privacy_installed_packages" msgid="2313698828178764590">"Lista de apps en tu dispositivo"</string>
    <string name="enterprise_privacy_usage_stats" msgid="4398411405572759370">"Consumo de tiempo y datos de cada app"</string>
    <string name="enterprise_privacy_network_logs" msgid="161722817268849590">"Registro de tráfico de red más reciente"</string>
    <string name="enterprise_privacy_bug_reports" msgid="843225086779037863">"Informe de errores más reciente"</string>
    <string name="enterprise_privacy_security_logs" msgid="5377362481617301074">"Registro de seguridad más reciente"</string>
    <string name="enterprise_privacy_none" msgid="7706621148858381189">"Ninguno"</string>
    <string name="enterprise_privacy_enterprise_installed_packages" msgid="6353757812144878828">"Apps instaladas"</string>
    <string name="enterprise_privacy_apps_count_estimation_info" msgid="7433213592572082606">"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="3005116533873542976">
      <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="4158197200885270634">"Permisos de ubicación"</string>
    <string name="enterprise_privacy_microphone_access" msgid="5717375623568864441">"Permisos de micrófono"</string>
    <string name="enterprise_privacy_camera_access" msgid="4858146118537519375">"Permisos de cámara"</string>
    <string name="enterprise_privacy_enterprise_set_default_apps" msgid="3288495615791128724">"Apps predeterminadas"</string>
    <plurals name="enterprise_privacy_number_packages" formatted="false" msgid="2765037387436064893">
      <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="6531350246850814920">"Teclado predeterminado"</string>
    <string name="enterprise_privacy_input_method_name" msgid="4941106433683067953">"Se configuró en <xliff:g id="APP_LABEL">%s</xliff:g>"</string>
    <string name="enterprise_privacy_always_on_vpn_device" msgid="4409098287763221215">"Se activó la función \"VPN siempre activada\""</string>
    <string name="enterprise_privacy_always_on_vpn_personal" msgid="9217774730260037434">"Se activó la función \"VPN siempre activada\" en tu perfil personal"</string>
    <string name="enterprise_privacy_always_on_vpn_work" msgid="7244472958208315814">"Se activó la función \"VPN siempre activada\" en tu perfil de trabajo"</string>
    <string name="enterprise_privacy_global_http_proxy" msgid="7936664553416257333">"Se estableció el proxy HTTP global"</string>
    <string name="enterprise_privacy_ca_certs_device" msgid="2019652712782510262">"Credenciales de confianza"</string>
    <string name="enterprise_privacy_ca_certs_personal" msgid="2279084820904076599">"Credenciales de confianza en tu perfil personal"</string>
    <string name="enterprise_privacy_ca_certs_work" msgid="6187377647815301809">"Credenciales de confianza en tu perfil de trabajo"</string>
    <plurals name="enterprise_privacy_number_ca_certs" formatted="false" msgid="526375234629534165">
      <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="8791656477097208540">"El administrador puede bloquear el dispositivo y reestablecer la contraseña"</string>
    <string name="enterprise_privacy_wipe_device" msgid="2821960015797241790">"El administrador puede borrar todos los datos del dispositivo"</string>
    <string name="enterprise_privacy_failed_password_wipe_device" msgid="1001255609345002878">"Intentos fallidos para ingresar la contraseña antes de borrar los datos del dispositivo"</string>
    <string name="enterprise_privacy_failed_password_wipe_work" msgid="4040565826652951057">"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="5279099270351036696">
      <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="8653670456990823307">"Tu organización administra este dispositivo."</string>
    <string name="do_disclosure_with_name" msgid="1141081465968481380">"<xliff:g id="ORGANIZATION_NAME">%s</xliff:g> administra este dispositivo."</string>
    <string name="do_disclosure_learn_more_separator" msgid="3558079393757238670">" "</string>
    <string name="learn_more" msgid="2623878455042103404">"Más información"</string>
    <plurals name="default_camera_app_title" formatted="false" msgid="1134677050353971363">
      <item quantity="other">Apps de cámara</item>
      <item quantity="one">App de cámara</item>
    </plurals>
    <string name="default_calendar_app_title" msgid="3545972964391065220">"App de calendario"</string>
    <string name="default_contacts_app_title" msgid="3497370557378660098">"App de contactos"</string>
    <plurals name="default_email_app_title" formatted="false" msgid="42826975161049245">
      <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="7560143381633608567">"App de mapas"</string>
    <plurals name="default_phone_app_title" formatted="false" msgid="6714041230953195024">
      <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="4309216198909946380">"<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="8949045544491604376">"<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="319854636702241898">"Fotos y videos"</string>
    <string name="storage_music_audio" msgid="789779084825206838">"Música y audio"</string>
    <string name="storage_games" msgid="7703159201697117621">"Juegos"</string>
    <string name="storage_other_apps" msgid="5524321740031718083">"Otras apps"</string>
    <string name="storage_files" msgid="8581083146777364063">"Archivos"</string>
    <string name="storage_size_large_alternate" msgid="3395208658399637645">"<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="3499221850532701342">"En uso de <xliff:g id="TOTAL">%1$s</xliff:g>"</string>
    <string name="storage_percent_full" msgid="6095012055875077036">"usado"</string>
    <string name="clear_instant_app_data" msgid="2004222610585890909">"Borrar app"</string>
    <string name="clear_instant_app_confirmation" msgid="7451671214898856857">"¿Quieres quitar esta app instantánea?"</string>
    <string name="launch_instant_app" msgid="391581144859010499">"Abrir"</string>
    <string name="game_storage_settings" msgid="3410689937046696557">"Juegos"</string>
    <string name="audio_files_title" msgid="4777048870657911307">"Archivos de audio"</string>
    <string name="app_info_storage_title" msgid="5554719444625611987">"Espacio en uso"</string>
    <string name="webview_uninstalled_for_user" msgid="1819903169194420983">"(se desinstaló para <xliff:g id="USER">%s</xliff:g>)"</string>
    <string name="webview_disabled_for_user" msgid="1216426047631256825">"(se inhabilitó para <xliff:g id="USER">%s</xliff:g>)"</string>
    <string name="autofill_app" msgid="7338387238377914374">"Servicio autocompletar"</string>
    <string name="autofill_keywords" msgid="7485591824120812710">"auto, completar, autocompletar"</string>
    <string name="autofill_confirmation_message" msgid="2784869528908005194">"&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="8050326960545979035">"Autocompletar"</string>
    <string name="autofill_logging_level_title" msgid="899483289251346778">"Nivel de registro"</string>
    <string name="autofill_max_partitions" msgid="7590272120101271461">"Número máximo de solicitudes por sesión"</string>
    <string name="autofill_max_visible_datasets" msgid="4531033613378881109">"Máximo de conjuntos de datos visibles"</string>
    <string name="autofill_reset_developer_options" msgid="5819016237049525099">"Restablecer valores predeterminados"</string>
    <string name="autofill_reset_developer_options_complete" msgid="7548288932341619412">"Se restablecieron las opciones de autocompletar para desarrolladores"</string>
    <string name="device_theme" msgid="4571803018917608588">"Tema del dispositivo"</string>
    <string name="default_theme" msgid="7085644992078579076">"Predeterminado"</string>
    <string name="show_operator_name_title" msgid="805135053530442951">"Nombre de la red"</string>
    <string name="show_operator_name_summary" msgid="5962567590205757550">"Mostrar el nombre de la red en la barra de estado"</string>
    <string name="storage_manager_indicator" msgid="1516810749625915020">"Administrador de almacenamiento: <xliff:g id="STATUS">^1</xliff:g>"</string>
    <string name="storage_manager_indicator_off" msgid="7488057587180724388">"Desactivado"</string>
    <string name="storage_manager_indicator_on" msgid="8625551710194584733">"Activado"</string>
    <string name="install_type_instant" msgid="3174425974536078647">"App instantánea"</string>
    <string name="automatic_storage_manager_deactivation_warning" msgid="5605210730828410482">"¿Deseas desactivar el administrador de almacenamiento?"</string>
    <string name="storage_movies_tv" msgid="5498394447562086890">"Apps de TV y películas"</string>
    <string name="carrier_provisioning" msgid="4398683675591893169">"Información del aprovisionamiento del proveedor"</string>
    <string name="trigger_carrier_provisioning" msgid="3434865918009286187">"Activar aprovisionamiento del proveedor"</string>
    <string name="zen_suggestion_title" msgid="798067603460192693">"Actualizar el modo No interrumpir"</string>
    <string name="zen_suggestion_summary" msgid="5928686804697233014">"Pausa las notificaciones para concentrarte"</string>
    <string name="disabled_low_ram_device" msgid="3751578499721173344">"La función no está disponible en este dispositivo"</string>
    <string name="disabled_feature" msgid="3232554901854971743">"Función no disponible"</string>
    <string name="disabled_feature_reason_slow_down_phone" msgid="3557117039415422481">"Se desactivó esta función porque ralentiza el teléfono"</string>
    <string name="enable_gnss_raw_meas_full_tracking" msgid="1294470289520660584">"Forzar dimensiones GNSS completas"</string>
    <string name="enable_gnss_raw_meas_full_tracking_summary" msgid="496344699046454200">"Seguir todas las frecuencias y constelaciones de GNSS sin ciclo de funciones"</string>
    <string name="show_first_crash_dialog" msgid="8889957119867262599">"Mostrar siempre el cuadro de diálogo de bloqueos"</string>
    <string name="show_first_crash_dialog_summary" msgid="703224456285060428">"Mostrar el cuadro de diálogo cada vez que falle una app"</string>
    <string name="angle_enabled_app" msgid="1841862539745838255">"Seleccionar app compatible con ANGLE"</string>
    <string name="angle_enabled_app_not_set" msgid="864740024581634768">"No se estableció ninguna app compatible con ANGLE"</string>
    <string name="angle_enabled_app_set" msgid="226015765615525056">"App compatible con ANGLE: <xliff:g id="APP_NAME">%1$s</xliff:g>"</string>
    <string name="game_driver_dashboard_title" msgid="8804074441354504919">"Preferencias del controlador de juegos"</string>
    <string name="game_driver_dashboard_summary" msgid="2392113100578771289">"Modificar configuración del controlador de juegos"</string>
    <string name="game_driver_footer_text" msgid="3202576403048267763">"Cuando el controlador de juegos está activado, puedes elegir si quieres usar el controlador gráfico actualizado para las apps instaladas en el dispositivo."</string>
    <string name="game_driver_all_apps_preference_title" msgid="6067527642706295180">"Habilitar para todas las apps"</string>
    <string name="game_driver_app_preference_title" msgid="5072626013346650374">"Seleccionar controlador gráfico"</string>
    <string name="game_driver_app_preference_default" msgid="7686384740483216333">"Predeterminado"</string>
    <string name="game_driver_app_preference_game_driver" msgid="6426312331295324606">"Controlador de juegos"</string>
    <string name="game_driver_app_preference_prerelease_driver" msgid="1295460693830677733">"Controlador previo al lanzamiento"</string>
    <string name="game_driver_app_preference_system" msgid="8272672982113332753">"Controlador gráfico del sistema"</string>
    <!-- no translation found for game_driver_all_apps_preference_values:0 (7193648562434970105) -->
    <!-- no translation found for game_driver_all_apps_preference_values:1 (7189663725490629463) -->
    <!-- no translation found for game_driver_app_preference_values:0 (4271044622117073985) -->
    <!-- no translation found for game_driver_app_preference_values:1 (6628516810440406199) -->
    <!-- no translation found for game_driver_app_preference_values:2 (1760397725970916076) -->
    <string name="unsupported_setting_summary" product="default" msgid="11246953620654225">"Este teléfono no admite esa opción de configuración"</string>
    <string name="unsupported_setting_summary" product="tablet" msgid="6328431665635673717">"Esta tablet no admite esa opción de configuración"</string>
    <string name="unsupported_setting_summary" product="device" msgid="2348970994972110886">"Este dispositivo no admite esa opción de configuración"</string>
    <string name="disabled_for_user_setting_summary" msgid="3388525317680711262">"El usuario actual no puede cambiar la configuración"</string>
    <string name="disabled_dependent_setting_summary" msgid="8291322239940946902">"Depende de otra opción de configuración"</string>
    <string name="unknown_unavailability_setting_summary" msgid="4589584678033059435">"Configuración no disponible"</string>
    <string name="my_device_info_account_preference_title" msgid="342933638925781861">"Cuenta"</string>
    <string name="my_device_info_device_name_preference_title" msgid="7104085224684165324">"Nombre del dispositivo"</string>
    <string name="change_wifi_state_title" msgid="3261945855372885427">"Control de Wi-Fi"</string>
    <string name="change_wifi_state_app_detail_switch" msgid="7942268646980694224">"Permitir que la app controle Wi-Fi"</string>
    <string name="change_wifi_state_app_detail_summary" msgid="8434262633905502679">"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="115223550977351699">"Reproducir contenido multimedia en"</string>
    <string name="media_output_default_summary" msgid="8115153381240348279">"este dispositivo"</string>
    <string name="media_output_summary" product="default" msgid="6839458453831567167">"Teléfono"</string>
    <string name="media_output_summary" product="tablet" msgid="7217221078578554515">"Tablet"</string>
    <string name="media_output_summary" product="device" msgid="5677420090811068649">"Dispositivo"</string>
    <string name="media_out_summary_ongoing_call_state" msgid="3533731701018680693">"No disponible durante llamadas"</string>
    <string name="media_output_summary_unavailable" msgid="7970304720507697019">"No disponible"</string>
    <string name="take_call_on_title" msgid="6066362463436122655">"Atender llamada en"</string>
    <string name="cannot_change_apn_toast" msgid="4652498125702594916">"No se puede cambiar este APN."</string>
    <string name="battery_suggestion_title" product="tablet" msgid="752439050748267917">"Mejorar duración de la batería de la tablet"</string>
    <string name="battery_suggestion_title" product="device" msgid="1507272328369733005">"Mejorar duración de la batería del dispositivo"</string>
    <string name="battery_suggestion_title" product="default" msgid="4038053023336285165">"Mejorar duración de la batería del teléfono"</string>
    <string name="battery_suggestion_summary" msgid="4585677159811722359"></string>
    <string name="gesture_prevent_ringing_screen_title" msgid="7840226017975251549">"Silenciar sonidos"</string>
    <string name="gesture_prevent_ringing_title" msgid="5961391929839748111">"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="5724512060316688779">"Acceso directo para silenciar"</string>
    <string name="prevent_ringing_option_vibrate" msgid="7286821846542822661">"Vibrar"</string>
    <string name="prevent_ringing_option_mute" msgid="7551545579059879853">"Silenciar"</string>
    <string name="prevent_ringing_option_none" msgid="4656046650769569175">"No hacer nada"</string>
    <string name="prevent_ringing_option_vibrate_summary" msgid="1157524435626890116">"Activado (vibración)"</string>
    <string name="prevent_ringing_option_mute_summary" msgid="4472465110708640980">"Activado (silencio)"</string>
    <string name="prevent_ringing_option_none_summary" msgid="5013718946609276137">"Desactivado"</string>
    <string name="pref_title_network_details" msgid="7186418845727358964">"Detalles de la red"</string>
    <string name="about_phone_device_name_warning" msgid="8885670415541365348">"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 configures un hotspot de Wi-Fi."</string>
    <string name="devices_title" msgid="7701726109334110391">"Dispositivos"</string>
    <string name="homepage_all_settings" msgid="1245540304900512919">"Toda la configuración"</string>
    <string name="homepage_personal_settings" msgid="1570415428680432319">"Sugerencias"</string>
    <string name="choose_network_title" msgid="5702586742615861037">"Elegir una red"</string>
    <string name="network_disconnected" msgid="2933191767567503504">"Desconectado"</string>
    <string name="network_connected" msgid="4943925032253989621">"Conectado"</string>
    <string name="network_connecting" msgid="76404590784733557">"Conectando…"</string>
    <string name="network_could_not_connect" msgid="1113813392274155369">"No se pudo establecer conexión"</string>
    <string name="empty_networks_list" msgid="2578752112731781190">"No se encontraron redes."</string>
    <string name="network_query_error" msgid="7487714485362598410">"No se encontraron redes. Vuelve a intentarlo."</string>
    <string name="forbidden_network" msgid="4626592887509826545">"(prohibida)"</string>
    <string name="no_sim_card" msgid="1360669528113557381">"Sin tarjeta SIM"</string>
    <string name="preferred_network_mode_wcdma_perf_summary" msgid="3956515670308744433">"Modo de red preferido: WCDMA preferido"</string>
    <string name="preferred_network_mode_gsm_only_summary" msgid="5225727680228194864">"Modo de red preferido: solo GSM"</string>
    <string name="preferred_network_mode_wcdma_only_summary" msgid="8956197584659205699">"Modo de red preferido: solo WCDMA"</string>
    <string name="preferred_network_mode_gsm_wcdma_summary" msgid="4290654515569144276">"Modo de red preferido: GSM/WCDMA"</string>
    <string name="preferred_network_mode_cdma_summary" msgid="854981096234906594">"Modo de red preferido: CDMA"</string>
    <string name="preferred_network_mode_cdma_evdo_summary" msgid="2578065433446506616">"Modo de red preferido: CDMA/EvDo"</string>
    <string name="preferred_network_mode_cdma_only_summary" msgid="6604102246309629962">"Modo de red preferido: solo CDMA"</string>
    <string name="preferred_network_mode_evdo_only_summary" msgid="7558385602277592784">"Modo de red preferido: solo EvDo"</string>
    <string name="preferred_network_mode_cdma_evdo_gsm_wcdma_summary" msgid="1742638677806401815">"Modo de red preferido: CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_lte_summary" msgid="8528755811985330696">"Modo de red preferido: LTE"</string>
    <string name="preferred_network_mode_lte_gsm_wcdma_summary" msgid="6632007438739933645">"Modo de red preferido: GSM/WCDMA/LTE"</string>
    <string name="preferred_network_mode_lte_cdma_evdo_summary" msgid="5464960267483576515">"Modo de red preferido: CDMA+LTE/EVDO"</string>
    <string name="preferred_network_mode_global_summary" msgid="8552400100470153638">"Modo de red preferido: Global"</string>
    <string name="preferred_network_mode_lte_wcdma_summary" msgid="8037915274486919940">"Modo de red preferido: LTE/WCDMA"</string>
    <string name="preferred_network_mode_lte_gsm_umts_summary" msgid="104110625441127919">"Modo de red preferido: LTE/GSM/UMTS"</string>
    <string name="preferred_network_mode_lte_cdma_summary" msgid="2561159741461407053">"Modo de red preferido: LTE/CDMA"</string>
    <string name="preferred_network_mode_tdscdma_summary" msgid="1111689194136766011">"Modo de red preferido: TDSCDMA"</string>
    <string name="preferred_network_mode_tdscdma_wcdma_summary" msgid="4272515966019344433">"Modo de red preferido: TDSCDMA/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_summary" msgid="3138210224248737600">"Modo de red preferido: LTE/TDSCDMA"</string>
    <string name="preferred_network_mode_tdscdma_gsm_summary" msgid="7575595856957063853">"Modo de red preferido: TDSCDMA/GSM"</string>
    <string name="preferred_network_mode_lte_tdscdma_gsm_summary" msgid="1512046749970721629">"Modo de red preferido: LTE/GSM/TDSCDMA"</string>
    <string name="preferred_network_mode_tdscdma_gsm_wcdma_summary" msgid="1038314909945393905">"Modo de red preferido: TDSCDMA/GSM/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_wcdma_summary" msgid="3277980364222159279">"Modo de red preferido: LTE/TDSCDMA/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_gsm_wcdma_summary" msgid="1572937828071126891">"Modo de red preferido: LTE/TDSCDMA/GSM/WCDMA"</string>
    <string name="preferred_network_mode_tdscdma_cdma_evdo_gsm_wcdma_summary" msgid="8393145171649288912">"Modo de red preferido: TDSCDMA/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_cdma_evdo_gsm_wcdma_summary" msgid="5544016990994809932">"Modo de red preferido: LTE/TDSCDMA/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="network_lte" msgid="1287709529829131860">"LTE (recomendado)"</string>
    <string name="network_4G" msgid="8611758013994499559">"4G (recomendado)"</string>
    <string name="network_global" msgid="959947774831178632">"Global"</string>
    <string name="label_available" msgid="1731547832803057893">"Redes disponibles"</string>
    <string name="load_networks_progress" msgid="7709402068413190831">"Buscando…"</string>
    <string name="register_on_network" msgid="766516026652295941">"Registrando en <xliff:g id="NETWORK">%s</xliff:g>…"</string>
    <string name="not_allowed" msgid="1667079919821581706">"Tu tarjeta SIM no permite una conexión con esta red."</string>
    <string name="connect_later" msgid="978991102125216741">"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="4573820010512184521">"Se registró en la red."</string>
    <string name="select_automatically" msgid="7318032984017853975">"Seleccionar red de forma automática"</string>
    <string name="carrier_settings_title" msgid="3503012527671299886">"Config. del proveedor"</string>
    <string name="cdma_lte_data_service" msgid="8507044148856536098">"Configurar servicio de datos"</string>
    <string name="mobile_data_settings_title" msgid="7674604042461065482">"Datos móviles"</string>
    <string name="mobile_data_settings_summary" msgid="2708261377199805404">"Acceder a los datos usando la red móvil"</string>
    <string name="mobile_data_settings_summary_auto_switch" msgid="2914985502279794000">"El teléfono cambiará a este proveedor automáticamente en cuanto esté dentro del rango"</string>
    <string name="calls_preference" msgid="4628557570999372758">"Preferencia de llamadas"</string>
    <string name="sms_preference" msgid="3479810211828513772">"Preferencia de SMS"</string>
    <string name="calls_and_sms_ask_every_time" msgid="2127802836576375306">"Preguntar siempre"</string>
    <string name="mobile_network_summary_add_a_network" msgid="9148476748420654283">"Agregar una red"</string>
    <plurals name="mobile_network_summary_count" formatted="false" msgid="4505694491027023039">
      <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="6732520879241581841">"Predeterminada para llamadas"</string>
    <string name="default_for_sms" msgid="294276190503132313">"Predeterminada para SMS"</string>
    <string name="default_for_calls_and_sms" msgid="3862322027700754792">"Predeterminada para llamadas y SMS"</string>
    <string name="default_for_mobile_data" msgid="955987144209828344">"Predeterminada para datos móviles"</string>
    <string name="mobile_data_active" msgid="5108294051762397700">"Datos móviles activados"</string>
    <string name="mobile_data_off" msgid="5831854766113105657">"Datos móviles desactivados"</string>
    <string name="subscription_available" msgid="6502502298446954785">"Disponible"</string>
    <string name="mobile_network_in_range" msgid="8212440637838603215">"En el rango"</string>
    <string name="mobile_network_not_in_range" msgid="5287596455212313284">"Fuera de alcance"</string>
    <string name="mobile_network_list_add_more" msgid="4000806369124701679">"Agregar más"</string>
    <string name="mobile_network_active_sim" msgid="2375956837678169169">"Activa / SIM"</string>
    <string name="mobile_network_inactive_sim" msgid="291768076436646044">"Inactiva / SIM"</string>
    <string name="mobile_network_active_esim" msgid="4914509039134228659">"Activa / SIM descargada"</string>
    <string name="mobile_network_inactive_esim" msgid="7653631389686307842">"Inactiva / SIM descargada"</string>
    <string name="mobile_network_sim_name" msgid="6026120971523242277">"Nombre y color de la SIM"</string>
    <string name="mobile_network_sim_name_label" msgid="281403463781467324">"Nombre"</string>
    <string name="mobile_network_sim_color_label" msgid="3662112943353180621">"Color (utilizado por apps compatibles)"</string>
    <string name="mobile_network_sim_name_rename" msgid="3082357234342116252">"Guardar"</string>
    <string name="mobile_network_use_sim_on" msgid="8035448244261570189">"Usar SIM"</string>
    <string name="mobile_network_use_sim_off" msgid="889073420068380943">"Desactivado"</string>
    <string name="mobile_network_disable_sim_explanation" msgid="1515981880164339357">"Para inhabilitar esta tarjeta SIM, quítala"</string>
    <string name="mobile_network_tap_to_activate" msgid="4573431375941175566">"Presiona para activar <xliff:g id="CARRIER">%1$s</xliff:g>"</string>
    <string name="mobile_network_esim_swap_confirm_title" msgid="6546784593612512953">"¿Quieres cambiar a <xliff:g id="CARRIER">%1$s</xliff:g>?"</string>
    <string name="mobile_network_esim_swap_confirm_body" msgid="1621021150667547211">"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="8025086398614992834">"Cambiar a <xliff:g id="CARRIER">%1$s</xliff:g>"</string>
    <string name="mobile_network_erase_sim" msgid="896275511321635947">"Borrar tarjeta SIM"</string>
    <string name="mobile_network_erase_sim_dialog_title" msgid="8211945787729023193">"¿Quieres borrar esta tarjeta SIM descargada?"</string>
    <string name="mobile_network_erase_sim_dialog_body" msgid="3363079846287650684">"Si borras esta tarjeta SIM, se quitará el servicio de <xliff:g id="CARRIER_0">%1$s</xliff:g> de este dispositivo.\n\nSin embargo, no se cancelará el servicio de <xliff:g id="CARRIER_1">%2$s</xliff:g>."</string>
    <string name="mobile_network_erase_sim_dialog_ok" msgid="5130805470041783437">"Borrar"</string>
    <string name="mobile_network_erase_sim_dialog_progress" msgid="6541813899575453878">"Borrando SIM…"</string>
    <string name="mobile_network_erase_sim_error_dialog_title" msgid="730767308428197756">"No se puede borrar la tarjeta SIM"</string>
    <string name="mobile_network_erase_sim_error_dialog_body" msgid="6835262809290075813">"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="6505630109389684100">"Tipo de red preferido"</string>
    <string name="preferred_network_mode_summary" msgid="1216219115667163264">"Cambiar el modo operativo de la red"</string>
    <string name="preferred_network_mode_dialogtitle" msgid="849254040214447984">"Tipo de red preferido"</string>
    <string name="carrier_settings_euicc" msgid="8658562169133242581">"Proveedor"</string>
    <string name="carrier_settings_version" msgid="3469507893844448432">"Versión de la configuración"</string>
    <string name="call_category" msgid="8108654745239563833">"Llamadas"</string>
    <string name="video_calling_settings_title" msgid="8153216918491498505">"Videollamada con el proveedor"</string>
    <string name="cdma_system_select_title" msgid="7210256688912895790">"Sistema seleccionado"</string>
    <string name="cdma_system_select_summary" msgid="3413863051181111941">"Cambiar el modo de roaming de CDMA"</string>
    <string name="cdma_system_select_dialogtitle" msgid="1198883288864916563">"Sistema seleccionado"</string>
    <string name="network_operator_category" msgid="8451238364605724918">"Red"</string>
    <string name="network_select_title" msgid="8394621216255081026">"Red"</string>
    <string name="cdma_subscription_title" msgid="1473189596933979467">"Suscripción CDMA"</string>
    <string name="cdma_subscription_summary" msgid="7191590908367194209">"Cambiar entre RUIM/SIM y NV"</string>
    <string name="cdma_subscription_dialogtitle" msgid="9153005469617575361">"suscripción"</string>
    <string name="register_automatically" msgid="518185886971595020">"Registro automático…"</string>
    <string name="roaming_alert_title" msgid="7458177294163751484">"¿Permitir el roaming de datos?"</string>
    <string name="roaming_check_price_warning" msgid="4979418631753681300">"Para saber los precios, consulta con tu proveedor de red."</string>
    <string name="mobile_data_usage_title" msgid="7862429216994894656">"Uso de datos de las apps"</string>
    <string name="mobile_network_mode_error" msgid="4784347953600013818">"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="7610812642954395440">"Nombres de puntos de acceso"</string>
    <string name="manual_mode_disallowed_summary" msgid="2085670341790561153">"No está disponible cuando estás conectado a <xliff:g id="CARRIER">%1$s</xliff:g>"</string>
    <string name="emergency_info_contextual_card_summary" msgid="7993926837251874514">"Información médica y contactos de emergencia"</string>
    <string name="see_more" msgid="5953815986207345223">"Ver más"</string>
    <string name="see_less" msgid="1250265310929558370">"Ver menos"</string>
    <string name="network_connection_request_dialog_title" msgid="3502355504717957803">"Dispositivo para usar con <xliff:g id="APPNAME">%1$s</xliff:g>"</string>
    <string name="network_connection_timeout_dialog_message" msgid="3711556077945728716">"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="8924405960181020156">"Volver a intentarlo"</string>
    <string name="network_connection_errorstate_dialog_message" msgid="6953778550775646710">"Se produjo un error. La aplicación canceló la solicitud para elegir un dispositivo."</string>
    <string name="network_connection_connect_successful" msgid="5935510954474494928">"Conexión exitosa"</string>
    <string name="network_connection_request_dialog_showall" msgid="6938922880244567521">"Mostrar todo"</string>
    <string name="network_connection_searching_message" msgid="4638576789450817530">"Buscando dispositivo…"</string>
    <string name="network_connection_connecting_message" msgid="3740982406609245654">"Estableciendo conexión con dispositivo…"</string>
    <plurals name="show_bluetooth_devices" formatted="false" msgid="1715020480026568408">
      <item quantity="other"><xliff:g id="NUMBER_DEVICE_COUNT_1">%1$d</xliff:g> dispositivos conectados</item>
      <item quantity="one"><xliff:g id="NUMBER_DEVICE_COUNT_0">%1$d</xliff:g> dispositivo conectado</item>
    </plurals>
    <string name="no_bluetooth_devices" msgid="861861879657732058">"No hay dispositivos Bluetooth"</string>
    <string name="bluetooth_left_name" msgid="2133431890020995442">"Izquierdo"</string>
    <string name="bluetooth_right_name" msgid="525578831502355410">"Derecho"</string>
    <string name="bluetooth_middle_name" msgid="3272836932362043957">"Funda"</string>
    <string name="settings_panel_title" msgid="4688575606213055744">"Panel de Configuración"</string>
    <string name="internet_connectivity_panel_title" msgid="721392242301676444">"Conexión a Internet"</string>
    <string name="volume_connectivity_panel_title" msgid="9192664643867101356">"Volumen"</string>
    <string name="mobile_data_ap_mode_disabled" msgid="1127588179830051811">"No disponible en modo de avión"</string>
    <string name="force_desktop_mode" msgid="4303240595324847998">"Forzar modo de escritorio"</string>
    <string name="force_desktop_mode_summary" msgid="6259798246015387202">"Forzar el modo de escritorio experimental en pantallas secundarias"</string>
    <string name="hwui_force_dark_title" msgid="2466919877609396257">"Anular forzar el modo oscuro"</string>
    <string name="hwui_force_dark_summary" msgid="8705328793382981780">"Anula la función forzar el modo oscuro para que esté siempre activo"</string>
    <string name="privacy_dashboard_title" msgid="2458407399263943923">"Privacidad"</string>
    <string name="privacy_dashboard_summary" msgid="4570241983077984329">"Permisos, actividad de la cuenta, datos personales"</string>
    <string name="contextual_card_dismiss_remove" msgid="2813670241047194713">"Quitar"</string>
    <string name="contextual_card_dismiss_keep" msgid="2230740610451447340">"Guardar"</string>
    <string name="contextual_card_dismiss_confirm_message" msgid="5507487987591500742">"¿Quieres quitar esta sugerencia?"</string>
    <string name="contextual_card_removed_message" msgid="6744732110721136227">"Se quitó la sugerencia"</string>
    <string name="contextual_card_undo_dismissal_text" msgid="3564089284222177020">"Deshacer"</string>
    <string name="low_storage_summary" msgid="2077564126033530">"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="2996691837358030021">"Enviar comentarios"</string>
    <string name="contextual_card_feedback_confirm_message" msgid="8115454795160804779">"¿Te gustaría compartir tus comentarios sobre esta sugerencia?"</string>
    <string name="copyable_slice_toast" msgid="2924110841440836023">"Se copió <xliff:g id="COPY_CONTENT">%1$s</xliff:g> en el portapapeles."</string>
    <string name="search_bar_account_avatar_content_description" msgid="4718261366290530792"></string>
    <string name="permission_bar_chart_empty_text" msgid="4380731551728553852">"Ninguna aplicación usó permisos"</string>
    <string name="permission_bar_chart_title" msgid="2745425703472199837">"Uso de permisos en las últimas 24 horas"</string>
    <string name="permission_bar_chart_details" msgid="2977943114535855210">"Ver todo en el panel"</string>
    <plurals name="permission_bar_chart_label" formatted="false" msgid="5346938677887948252">
      <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="5136753034714150614">"Uso de accesibilidad"</string>
    <plurals name="accessibility_usage_summary" formatted="false" msgid="5790789101231115740">
      <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="manage_app_notification" msgid="4575452737886198216">"Administrar notificaciones de <xliff:g id="APP_NAME">%1$s</xliff:g>"</string>
    <string name="no_suggested_app" msgid="5722034393216359231">"No hay una aplicación sugerida"</string>
    <plurals name="notification_few_channel_count_summary" formatted="false" msgid="1090888820158822106">
      <item quantity="other"><xliff:g id="NOTIFICATION_CHANNEL_COUNT_1">%1$d</xliff:g> canales de notificación.</item>
      <item quantity="one"><xliff:g id="NOTIFICATION_CHANNEL_COUNT_0">%1$d</xliff:g> canal de notificación.</item>
    </plurals>
    <string name="notification_many_channel_count_summary" msgid="8647409434789898073">"<xliff:g id="NOTIFICATION_CHANNEL_COUNT">%1$d</xliff:g> canales de notificación. Presiona para administrarlos todos."</string>
    <string name="recently_installed_app" msgid="2877671740090335492">"Instalaste esta app recientemente."</string>
    <string name="media_output_panel_title" msgid="6197092814295528184">"Cambiar de salida"</string>
    <string name="media_output_panel_summary_of_playing_device" msgid="629529380940058789">"Reproduciendo en <xliff:g id="DEVICE_NAME">%1$s</xliff:g>"</string>
    <string name="wfc_disclaimer_title_text" msgid="6164569741719679613">"Información importante"</string>
    <string name="wfc_disclaimer_agree_button_text" msgid="1405773141236165542">"CONTINUAR"</string>
    <string name="wfc_disclaimer_disagree_text" msgid="2700358281438736674">"NO, GRACIAS"</string>
    <string name="wfc_disclaimer_location_title_text" msgid="6658735446562619865">"Ubicación"</string>
    <string name="wfc_disclaimer_location_desc_text" msgid="3096546236221656018">"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="7331876195857622224">"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="8252675452668954083">"captura de contenido, contenido de app"</string>
    <string name="content_capture" msgid="3210232615756364639">"Contenido de la app"</string>
    <string name="content_capture_summary" msgid="659506647507221852">"Permite que las apps envíen contenido al sistema Android"</string>
    <string name="capture_system_heap_dump_title" msgid="8043655498113164693">"Capturar volcado de pila del sistema"</string>
    <string name="capturing_system_heap_dump_message" msgid="8680086369500395131">"Capturando volcado del montón del sistema"</string>
    <string name="error_capturing_system_heap_dump_message" msgid="6346229989760615103">"No se pudo capturar el volcado de pila del sistema"</string>
    <string name="automatic_system_heap_dump_title" msgid="442496436397957988">"Capturar automáticamente volcados de pila del sistema"</string>
    <string name="automatic_system_heap_dump_summary" msgid="8253838659009241350">"Capturar automáticamente un volcado de pila para el sistema Android cuando usa demasiada memoria"</string>
    <string name="wifi_disconnect_button_text" msgid="2032651902928903819">"Desconectar"</string>
    <string name="wfc_disclaimer_emergency_limitation_title_text" msgid="3354031536141983602">"Llamadas de emergencia"</string>
    <string name="wfc_disclaimer_emergency_limitation_desc_text" msgid="6068582272230311464">"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="513599567573172420">"Usar Wi‑Fi para mejorar la calidad de las llamadas"</string>
    <string name="enable_receiving_mms_notification_title" msgid="8809328429865242752">"Mensaje MMS entrante"</string>
    <string name="enable_sending_mms_notification_title" msgid="3852773093703966351">"No se puede enviar el mensaje MMS"</string>
    <string name="enable_mms_notification_summary" msgid="7643379825980866408">"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="4402474709766126987">"Mensaje MMS"</string>
    <string name="sim_combination_warning_notification_title" msgid="3717178238465948430">"Problema con la combinación de SIM"</string>
    <string name="dual_cdma_sim_warning_notification_summary" msgid="2602011424635850202">"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="4144088600737896010">"Combinación de SIM"</string>
    <string name="work_policy_privacy_settings" msgid="2348992644755730215">"Información sobre la política de tu trabajo"</string>
    <string name="work_policy_privacy_settings_summary" msgid="2236899807429121767">"Configuración gestionada por tu administrador de TI"</string>
</resources>
