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

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

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

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

<resources xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
    <string name="yes" msgid="1999566976857398962">"Sí"</string>
    <string name="no" msgid="5541738710521607130">"No"</string>
    <string name="create" msgid="986997212165228751">"Crear"</string>
    <string name="allow" msgid="3763244945363657722">"Permitir"</string>
    <string name="deny" msgid="7326117222944479942">"Rechazar"</string>
    <string name="confirmation_turn_on" msgid="2979094011928347665">"Activar"</string>
    <string name="device_info_default" msgid="1406619232867343310">"Desconocido"</string>
    <string name="device_info_protected_single_press" msgid="3810785480060743677">"Presiona para obtener más información"</string>
    <string name="show_dev_countdown" msgid="2936506773086395069">"{count,plural, =1{Ahora estás a # paso de activar las opciones para desarrolladores}other{Ahora estás a # pasos de activar las opciones para desarrolladores}}"</string>
    <string name="show_dev_on" msgid="2840850085134853754">"¡Ya eres desarrollador!"</string>
    <string name="show_dev_already" msgid="7041756429707644630">"No es necesario, ya eres programador."</string>
    <string name="dev_settings_disabled_warning" msgid="6971867026249671244">"Primero habilita las opciones para programador."</string>
    <string name="header_category_system" msgid="1665516346845259058">"Sistema"</string>
    <string name="radioInfo_service_in" msgid="9088637745836646271">"En servicio"</string>
    <string name="radioInfo_service_out" msgid="1868347333892403287">"Fuera de servicio"</string>
    <string name="radioInfo_service_off" msgid="6184928420860868571">"Radio desactivada"</string>
    <string name="radioInfo_roaming_in" msgid="8892550453644088692">"Roaming"</string>
    <string name="radioInfo_roaming_not" msgid="3137594549464975054">"Sin roaming"</string>
    <string name="radioInfo_data_disconnected" msgid="362604130117666924">"Desconectado"</string>
    <string name="radioInfo_data_connecting" msgid="7280819598028917888">"Conectando"</string>
    <string name="radioInfo_data_connected" msgid="8816467971633020141">"Conectado"</string>
    <string name="radioInfo_data_suspended" msgid="2001254415431299603">"Suspendido"</string>
    <string name="radioInfo_unknown" msgid="2892562356748600367">"Desconocida"</string>
    <string name="preview_pager_content_description" msgid="3762247188224576303">"Vista previa"</string>
    <string name="font_size_make_smaller_desc" msgid="4978038055549590140">"Reducir el tamaño"</string>
    <string name="font_size_make_larger_desc" msgid="5583046033381722247">"Aumentar el tamaño"</string>
    <string name="auto_rotate_settings_primary_switch_title" msgid="3440951924928594520">"Girar automáticamente"</string>
    <string name="smart_rotate_text_headline" msgid="5878008933992951904">"La detección de rostro usa la cámara frontal para mejorar la exactitud de la opción Girar automáticamente. Las imágenes nunca se almacenan ni se envían a Google."</string>
    <string name="bluetooth" msgid="8898478620943459654">"Bluetooth"</string>
    <string name="bluetooth_is_discoverable" msgid="4798961627677790935">"Visible para todos los dispositivos Bluetooth cercanos (<xliff:g id="DISCOVERABLE_TIME_PERIOD">%1$s</xliff:g>)"</string>
    <string name="bluetooth_is_discoverable_always" msgid="8122823110652921674">"Visible para todos los dispositivos Bluetooth cercanos"</string>
    <string name="bluetooth_not_visible_to_other_devices" msgid="6181960579190879601">"No visible para otros dispositivos Bluetooth"</string>
    <string name="bluetooth_only_visible_to_paired_devices" msgid="3574936359739213455">"Solo visible para los dispositivos sincronizados"</string>
    <string name="bluetooth_devices" msgid="1063177983261608277">"Dispositivos Bluetooth"</string>
    <string name="bluetooth_device_name" msgid="1294669733490268384">"Nombre del dispositivo"</string>
    <string name="bluetooth_rename_device" msgid="4219655243836021443">"Cambiar nombre del dispositivo"</string>
    <string name="bluetooth_rename_button" msgid="9162500408570289545">"Cambiar nombre"</string>
    <string name="bluetooth_disconnect_title" msgid="4581951246357823044">"¿Desconectar dispositivo?"</string>
    <string name="bluetooth_pairing_pref_title" msgid="3497193027590444598">"Vincular dispositivo nuevo"</string>
    <string name="keywords_add_bt_device" msgid="4533191164203174011">"Bluetooth"</string>
    <string name="bluetooth_pair_right_ear_button" msgid="3979894494803078852">"Vincular aud. der."</string>
    <string name="bluetooth_pair_left_ear_button" msgid="1019938875726073791">"Vincular aud. izq."</string>
    <string name="bluetooth_pair_other_ear_dialog_title" msgid="3814943511999984012">"Vincula el otro audífono"</string>
    <string name="bluetooth_pair_other_ear_dialog_left_ear_message" msgid="7936892941892347102">"Se conectó tu audífono izquierdo.\n\nPara vincular el derecho, asegúrate de que esté encendido y listo para la vinculación."</string>
    <string name="bluetooth_pair_other_ear_dialog_right_ear_message" msgid="8242208936062915941">"Se conectó tu audífono derecho.\n\nPara vincular el izquierdo, asegúrate de que esté encendido y listo para la vinculación."</string>
    <string name="bluetooth_pair_other_ear_dialog_right_ear_positive_button" msgid="533612082529204078">"Vincular aud. der."</string>
    <string name="bluetooth_pair_other_ear_dialog_left_ear_positive_button" msgid="6500192653171220257">"Vincular aud. izq."</string>
    <string name="bluetooth_device_controls_general" msgid="1399214835599665488">"Para todos los dispositivos de audición disponibles"</string>
    <string name="bluetooth_device_controls_title" msgid="4293399064818086587">"Compatibilidad con audífonos y combinaciones de teclas"</string>
    <string name="bluetooth_device_controls_specific" msgid="7706863288754077107">"En este dispositivo"</string>
    <string name="bluetooth_audio_routing_title" msgid="5541729245424856226">"Salida de audio"</string>
    <string name="bluetooth_audio_routing_about_title" msgid="5773336779246891954">"Info. sobre salida de audio"</string>
    <string name="bluetooth_audio_routing_summary" msgid="7180947533985969066">"Enruta sonidos a tu audífono o bocina del teléfono"</string>
    <string name="bluetooth_screen_related" msgid="7976543255501825536">"Relacionado"</string>
    <string name="bluetooth_ringtone_title" msgid="3177308461256892085">"Tono y alarmas"</string>
    <string name="bluetooth_call_title" msgid="6851464952021874072">"Audio durante las llamadas"</string>
    <string name="bluetooth_media_title" msgid="343705257183053699">"Contenido multimedia"</string>
    <string name="bluetooth_system_sounds_title" msgid="6746938637128763205">"Notif. y otros sist. de sonido"</string>
    <string name="bluetooth_audio_routing_footer_summary" msgid="410260713589309293">"De forma predeterminada, las apps son las que determinan la salida de audio"</string>
    <string name="bluetooth_device" msgid="2217973503732544291">"Dispositivo Bluetooth sin nombre"</string>
    <string name="progress_scanning" msgid="2564746192843011826">"Buscando"</string>
    <string name="bluetooth_no_devices_found" msgid="7704539337219953182">"No se encontraron dispositivos Bluetooth cercanos."</string>
    <string name="bluetooth_notif_ticker" msgid="209515545257862858">"Solicitud de vinculación de Bluetooth"</string>
    <string name="bluetooth_notif_title" msgid="1196532269131348647">"Solicitud de vinculación"</string>
    <string name="bluetooth_notif_message" msgid="5584717784198086653">"Presiona para realizar una sincronización con <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="bluetooth_devices_card_off_title" msgid="1320149821945129127">"Bluetooth desactivado"</string>
    <string name="bluetooth_devices_card_off_summary" msgid="2276527382891105858">"Presiona para activarlo"</string>
    <string name="device_picker" msgid="2427027896389445414">"Elegir dispositivo Bluetooth"</string>
    <string name="bluetooth_ask_enablement" msgid="1529030199895339199">"<xliff:g id="APP_NAME">%1$s</xliff:g> quiere activar la conexión Bluetooth"</string>
    <string name="bluetooth_ask_disablement" msgid="1879788777942714761">"<xliff:g id="APP_NAME">%1$s</xliff:g> quiere desactivar la conexión Bluetooth"</string>
    <string name="bluetooth_ask_enablement_no_name" msgid="5091401961637405417">"Una app quiere activar la conexión Bluetooth"</string>
    <string name="bluetooth_ask_disablement_no_name" msgid="382299750909188822">"Una app quiere desactivar la conexión Bluetooth"</string>
    <string name="bluetooth_turning_on" msgid="3842613808709024730">"Activando Bluetooth..."</string>
    <string name="bluetooth_turning_off" msgid="7406309124247701148">"¿Desactivar Bluetooth?"</string>
    <string name="bluetooth_connection_permission_request" msgid="8793131019383198861">"Solicitud para establecer conexión de Bluetooth"</string>
    <string name="bluetooth_phonebook_request" msgid="1085102844577089889">"Solicitud de acceso a agenda telefónica"</string>
    <string name="bluetooth_map_request" msgid="8664081227240707479">"Solicitud de acceso a mensajes"</string>
    <string name="bluetooth_device_name_summary" msgid="8678342689845439583">"Visible como \"<xliff:g id="DEVICE_NAME">^1</xliff:g>\" para otros dispositivos"</string>
    <string name="bluetooth_off_footer" msgid="76578735660216295">"Activa el Bluetooth para establecer conexión con otros dispositivos."</string>
    <string name="bluetooth_paired_device_title" msgid="3240639218362342026">"Tus dispositivos"</string>
    <string name="bluetooth_pairing_page_title" msgid="3403981358823707692">"Vincular dispositivo nuevo"</string>
    <string name="bluetooth_disable_a2dp_hw_offload" msgid="5942913792817797541">"Inhabilitar descarga de hardware Bluetooth A2DP"</string>
    <string name="bluetooth_disable_le_audio_hw_offload" msgid="4656853795514691257">"Inhabilitar la descarga de hardware Bluetooth LE audio"</string>
    <string name="bluetooth_disable_hw_offload_dialog_title" msgid="6001142380445276918">"¿Quieres reiniciar el dispositivo?"</string>
    <string name="bluetooth_disable_hw_offload_dialog_message" msgid="1524373895333698779">"Debes reiniciar el dispositivo para cambiar este parámetro de configuración."</string>
    <string name="bluetooth_disable_hw_offload_dialog_confirm" msgid="5594859658551707592">"Reiniciar"</string>
    <string name="bluetooth_disable_hw_offload_dialog_cancel" msgid="3663690305043973720">"Cancelar"</string>
    <!-- no translation found for bluetooth_disable_leaudio (8619410595945155354) -->
    <skip />
    <!-- no translation found for bluetooth_disable_leaudio_summary (4756307633476985470) -->
    <skip />
    <string name="bluetooth_enable_leaudio_allow_list" msgid="1692999156437357534">"Habilitar la lista de permitidos de Bluetooth LE Audio"</string>
    <string name="bluetooth_enable_leaudio_allow_list_summary" msgid="725601205276008525">"Habilita la función de la lista de permitidos de Bluetooth LE Audio."</string>
    <string name="connected_device_media_device_title" msgid="3783388247594566734">"Dispositivos de medios"</string>
    <string name="connected_device_call_device_title" msgid="88732390601723608">"Dispositivos para llamar"</string>
    <string name="connected_device_other_device_title" msgid="4652120430615729193">"Otros dispositivos"</string>
    <string name="connected_device_saved_title" msgid="5607274378851905959">"Dispositivos guardados"</string>
    <string name="connected_device_add_device_summary" msgid="8671009879957120802">"Se activará el Bluetooth para vincular"</string>
    <string name="connected_device_connections_title" msgid="4164120115341579170">"Preferencias de conexión"</string>
    <string name="connected_device_previously_connected_screen_title" msgid="8823331744788100605">"Conectados anteriormente"</string>
    <string name="connected_device_bluetooth_turned_on_toast" msgid="144664089794199928">"Se activó el Bluetooth"</string>
    <string name="previous_connected_see_all" msgid="7759413145713251328">"Ver todos"</string>
    <string name="stylus_device_details_title" msgid="7618295136015480864">"Pluma stylus"</string>
    <string name="stylus_default_notes_app" msgid="3896158797687806941">"App de notas predeterminada"</string>
    <string name="stylus_textfield_handwriting" msgid="2363579035338976327">"Escribir en campos de texto"</string>
    <string name="stylus_ignore_button" msgid="7734540973145241391">"Ignorar todas las pulsaciones del botón de la pluma stylus"</string>
    <string name="stylus_connected_devices_title" msgid="2823967577941359812">"Pluma stylus"</string>
    <string name="date_and_time" msgid="1788358029823431692">"Fecha y hora"</string>
    <string name="proxy_settings_title" msgid="4201866858226087066">"Proxy"</string>
    <string name="proxy_clear_text" msgid="6529658759984031149">"Eliminar"</string>
    <string name="proxy_port_label" msgid="4647357286461712574">"Puerto del proxy"</string>
    <string name="proxy_exclusionlist_label" msgid="2598613986784917542">"Omitir proxy para"</string>
    <string name="proxy_defaultView_text" msgid="6795150505379688451">"Restaurar configuraciones predeterminadas"</string>
    <string name="proxy_action_text" msgid="1103328484441449542">"Finalizar"</string>
    <string name="proxy_hostname_label" msgid="5504327742505848063">"Nombre de host del proxy"</string>
    <string name="proxy_error" msgid="3615905975598084126">"Atención"</string>
    <string name="proxy_error_dismiss" msgid="4207430265140873078">"Aceptar"</string>
    <string name="proxy_error_invalid_host" msgid="3814412792702059247">"El nombre del host que has escrito no es válido."</string>
    <string name="proxy_error_invalid_exclusion_list" msgid="6096353559936226599">"La lista de exclusión que escribiste no está debidamente formateada. Escribe una lista de los dominios excluidos separados por comas."</string>
    <string name="proxy_error_empty_port" msgid="4250295137005082992">"Debes completar el campo de puerto."</string>
    <string name="proxy_error_empty_host_set_port" msgid="8886572276450900049">"El campo del puerto debe estar vacío si el campo de servidor está vacío."</string>
    <string name="proxy_error_invalid_port" msgid="2830054691770209166">"El puerto que has escrito no es válido."</string>
    <string name="proxy_warning_limited_support" msgid="3277104160797351942">"El navegador usa el proxy HTTP, pero tal vez las demás aplicaciones no lo usen."</string>
    <string name="proxy_url_title" msgid="3502625766036404073">"URL config. autom. proxy: "</string>
    <string name="radio_info_ping_hostname_v4" msgid="4790577760885127088">"Hacer ping a IPv4 de nombre de host (www.google.com):"</string>
    <string name="radio_info_http_client_test" msgid="5673975677271544085">"Prueba de cliente HTTP:"</string>
    <string name="ping_test_label" msgid="265427033290391845">"Ejecutar prueba de ping"</string>
    <string name="skip_label" msgid="6380034601349015895">"Omitir"</string>
    <string name="next_label" msgid="1248293387735652187">"Siguiente"</string>
    <string name="language_picker_title" msgid="4271307478263345133">"Idiomas"</string>
    <string name="language_picker_category_title" msgid="1792199453060454565">"Orden de idiomas preferidos"</string>
    <string name="desc_current_default_language" msgid="1901157141663662859">"Idioma del sistema"</string>
    <string name="locale_remove_menu" msgid="3521546263421387474">"Quitar"</string>
    <string name="add_a_language" msgid="2126220398077503271">"Agregar un idioma"</string>
    <string name="app_locale_preference_title" msgid="5513627099300360232">"Idioma"</string>
    <string name="locale_picker_category_title" msgid="6212064706962721255">"Idioma preferido"</string>
    <string name="app_locales_picker_menu_title" msgid="7617427959223831373">"Idiomas de la app"</string>
    <string name="app_locale_picker_summary" msgid="6742557329924446252">"Configura el idioma para cada app"</string>
    <string name="app_locale_picker_title" msgid="2431448962911301366">"Idioma de la app"</string>
    <string name="suggested_app_locales_title" msgid="8898358282377369405">"Idiomas sugeridos"</string>
    <string name="all_supported_app_locales_title" msgid="5479289964316009026">"Todos los idiomas"</string>
    <string name="preference_of_system_locale_title" msgid="8067226276038751504">"Idioma del sistema"</string>
    <string name="preference_of_system_locale_summary" msgid="5612241394431188535">"Predeterminado del sistema"</string>
    <string name="desc_no_available_supported_locale" msgid="7883271726226947273">"La selección de idioma para esta app no está disponible en Configuración."</string>
    <string name="desc_app_locale_disclaimer" msgid="5295933110644789052">"Puede que el idioma difiera de los idiomas disponibles en la app. Algunas apps no son compatibles con este parámetro de configuración."</string>
    <string name="desc_app_locale_selection_supported" msgid="6149467826636295127">"Aquí se muestran solo las apps que admiten la selección de idioma."</string>
    <string name="desc_introduction_of_language_picker" msgid="1038423471887102449">"El sistema, las apps y los sitios web usan el primer idioma compatible de entre los preferidos."</string>
    <string name="desc_notice_of_language_picker" msgid="3449290526457925447">"Para seleccionar un idioma para cada app, ve a la configuración del idioma de la app."</string>
    <string name="desc_locale_helper_footer_general" msgid="6112153921151780303">"Obtén más información sobre los idiomas de las apps"</string>
    <string name="title_change_system_locale" msgid="8589844586256566951">"¿Deseas cambiar el idioma del sistema a %s?"</string>
    <string name="desc_notice_device_locale_settings_change" msgid="8311132485850714160">"Cambiarán la configuración y las preferencias regionales de tu dispositivo."</string>
    <string name="button_label_confirmation_of_system_locale_change" msgid="5593798559604894733">"Cambiar"</string>
    <string name="title_unavailable_locale" msgid="2628898110416542386">"%s no está disponible"</string>
    <string name="desc_unavailable_locale" msgid="2201756477400935896">"Este idioma no se puede usar como idioma del sistema, pero permitiste que las apps y los sitios web sepan que lo prefieres."</string>
    <string name="regional_preferences_title" msgid="4304567374498629528">"Preferencias regionales"</string>
    <string name="regional_preferences_summary" msgid="1189876997389469650">"Establece tus preferencias de unidades y números"</string>
    <string name="regional_preferences_main_page_sub_title" msgid="4237109940015254725">"Permite que las apps sepan tus preferencias regionales para que puedan personalizar la experiencia."</string>
    <string name="regional_preferences_option_page_sub_title" msgid="8303661099255197036">"Las apps usarán tus preferencias regionales cuando sea posible."</string>
    <string name="temperature_preferences_title" msgid="5009881556503629058">"Temperatura"</string>
    <string name="calendar_preferences_title" msgid="8312485828206542600">"Calendario"</string>
    <string name="first_day_of_week_preferences_title" msgid="1971850087589599553">"Primer día de la semana"</string>
    <string name="numbers_preferences_title" msgid="8197418984391195446">"Preferencias de números"</string>
    <string name="default_string_of_regional_preference" msgid="7662581547334113719">"Usar la configuración predeterminada de la app"</string>
    <string name="celsius_temperature_unit" msgid="6118523647432383132">"Celsius (°C)"</string>
    <string name="fahrenheit_temperature_unit" msgid="4622209814782318725">"Fahrenheit (°F)"</string>
    <string name="sunday_first_day_of_week" msgid="7644548348295686051">"Domingo"</string>
    <string name="monday_first_day_of_week" msgid="7244698610476506771">"Lunes"</string>
    <string name="tuesday_first_day_of_week" msgid="5085370946936582391">"Martes"</string>
    <string name="wednesday_first_day_of_week" msgid="6544537589727042869">"Miércoles"</string>
    <string name="thursday_first_day_of_week" msgid="3035885630945594833">"Jueves"</string>
    <string name="friday_first_day_of_week" msgid="7074795061812083541">"Viernes"</string>
    <string name="saturday_first_day_of_week" msgid="3702282590450322727">"Sábado"</string>
    <string name="dlg_remove_locales_title" msgid="3170501604483612114">"{count,plural, =1{¿Quitar el idioma seleccionado?}other{¿Quitar los idiomas seleccionados?}}"</string>
    <string name="dlg_remove_locales_message" msgid="8110560091134252067">"Se mostrará el texto en otro idioma."</string>
    <string name="dlg_remove_locales_error_title" msgid="5875503658221562572">"No se pueden quitar todos los idiomas"</string>
    <string name="dlg_remove_locales_error_message" msgid="6504279959974675302">"Debes tener al menos un idioma preferido"</string>
    <string name="locale_not_translated" msgid="3071618135527110152">"No está disponible como idioma del sistema"</string>
    <string name="action_drag_label_move_up" msgid="3392196942330705015">"Mover hacia arriba"</string>
    <string name="action_drag_label_move_down" msgid="9069518740553953426">"Mover hacia abajo"</string>
    <string name="action_drag_label_move_top" msgid="2430471023612171619">"Mover al principio"</string>
    <string name="action_drag_label_move_bottom" msgid="6266165197792827003">"Mover al final"</string>
    <string name="action_drag_label_remove" msgid="1034900377796780568">"Quitar el idioma"</string>
    <string name="activity_picker_label" msgid="351250401590691126">"Elige actividad"</string>
    <string name="cancel" msgid="5780102414089664898">"Cancelar"</string>
    <string name="okay" msgid="4827099303045669054">"Aceptar"</string>
    <string name="forget" msgid="3754013654135912783">"Olvidar"</string>
    <string name="save" msgid="3125033126936493822">"Guardar"</string>
    <string name="done" msgid="7497982645646431310">"Listo"</string>
    <string name="apply" msgid="7834684883190163536">"Aplicar"</string>
    <string name="share" msgid="8502235338607613795">"Compartir"</string>
    <string name="add" msgid="8335206931421683426">"Agregar"</string>
    <string name="remove" msgid="1028414219245072102">"Quitar"</string>
    <string name="settings_label" msgid="943294133671632976">"Configuración"</string>
    <string name="settings_label_launcher" msgid="820982375501978609">"Configuración"</string>
    <string name="settings_shortcut" msgid="8548239727871847171">"Configuración"</string>
    <string name="airplane_mode" msgid="3196085857882526817">"Modo de avión"</string>
    <string name="wireless_networks_settings_title" msgid="8557542379234105369">"Conexiones inalámbricas y redes"</string>
    <string name="roaming" msgid="3055365654530847985">"Roaming"</string>
    <string name="roaming_enable" msgid="7845716016861535340">"Conectar a servicios de datos en roaming"</string>
    <string name="roaming_disable" msgid="729512894708689604">"Conectar a servicios de datos en roaming"</string>
    <string name="roaming_warning" msgid="7703647889040229013">"Es posible que se apliquen cargos de roaming."</string>
    <string name="date_time_auto" msgid="4239202185055225869">"Establecer la hora automáticamente"</string>
    <string name="zone_auto_title" msgid="5141692422373097957">"Establecer automáticamente"</string>
    <string name="auto_zone_requires_location_summary" msgid="4831038184260596735">"Se usará la ubicación para establecer la zona horaria cuando el botón de activación esté habilitado"</string>
    <string name="date_time_24hour_auto" msgid="6583078135067804252">"Usar configuración regional predeterminada"</string>
    <string name="date_time_24hour" msgid="286679379105653406">"Formato de 24 horas"</string>
    <string name="date_time_set_time_title" msgid="2870083415922991906">"Hora"</string>
    <string name="time_format_category_title" msgid="7108616745509689991">"Formato de hora"</string>
    <string name="date_time_set_timezone_title" msgid="790404320569600222">"Zona horaria"</string>
    <string name="date_time_set_timezone" msgid="2915125337941495746">"Zona horaria"</string>
    <string name="date_time_set_date_title" msgid="7624166157167528407">"Fecha"</string>
    <string name="date_time_search_region" msgid="1364133854952610919">"Búsqueda por región"</string>
    <string name="date_time_select_region" msgid="5449345333305056072">"Región"</string>
    <string name="date_time_select_fixed_offset_time_zones" msgid="594848300882055361">"Seleccionar compensación de UTC"</string>
    <string name="zone_info_exemplar_location_and_offset" msgid="2186042522225153092">"<xliff:g id="EXEMPLAR_LOCATION">%1$s</xliff:g> (<xliff:g id="OFFSET">%2$s</xliff:g>)"</string>
    <string name="zone_info_offset_and_name" msgid="3960192548990990152">"<xliff:g id="TIME_TYPE">%2$s</xliff:g> (<xliff:g id="OFFSET">%1$s</xliff:g>)"</string>
    <string name="zone_info_footer_first_sentence" msgid="1326664252091302458">"Usa <xliff:g id="OFFSET_AND_NAME">%1$s</xliff:g> <xliff:g id="SECOND_SENTENCE">%2$s</xliff:g>"</string>
    <string name="zone_info_footer_second_sentence" msgid="6472889173541729110">"<xliff:g id="DST_TIME_TYPE">%1$s</xliff:g> a partir del <xliff:g id="TRANSITION_DATE">%2$s</xliff:g>"</string>
    <string name="zone_info_footer_no_dst" msgid="8399585343328811158">"Zona horaria: <xliff:g id="OFFSET_AND_NAME">%1$s</xliff:g>. Sin horario de verano."</string>
    <string name="zone_time_type_dst" msgid="9189689342265305808">"Horario de verano"</string>
    <string name="zone_time_type_standard" msgid="6865420715430680352">"Hora estándar"</string>
    <string name="zone_menu_by_region" msgid="2963565278710225652">"Seleccionar por región"</string>
    <string name="zone_menu_by_offset" msgid="1257702747474426745">"Seleccionar por compensación de UTC"</string>
    <string name="lock_after_timeout" msgid="8682769000437403444">"Bloquear al finalizar el tiempo de espera de pantalla"</string>
    <string name="lock_after_timeout_summary" msgid="4869265514658147304">"<xliff:g id="TIMEOUT_STRING">%1$s</xliff:g> después de que se agote tiempo de espera"</string>
    <string name="lock_immediately_summary_with_exception" msgid="40819611828339044">"Inmediatamente después de que se agote tiempo de espera, excepto cuando <xliff:g id="TRUST_AGENT_NAME">%1$s</xliff:g> mantenga la pantalla desbloqueada"</string>
    <string name="lock_after_timeout_summary_with_exception" msgid="3441806647509073124">"<xliff:g id="TIMEOUT_STRING">%1$s</xliff:g> después de que se agote el tiempo de espera, excepto cuando <xliff:g id="TRUST_AGENT_NAME">%2$s</xliff:g> mantenga la pantalla desbloqueada"</string>
    <string name="owner_info_settings_title" msgid="3555626140700093017">"Agregar texto en pantalla de bloqueo"</string>
    <string name="owner_info_settings_summary" msgid="347238313388083297">"Ninguno"</string>
    <string name="owner_info_settings_edit_text_hint" msgid="841926875876050274">"Por ejemplo, Android de Juan"</string>
    <string name="location_settings_title" msgid="8375074508036087178">"Ubicación"</string>
    <string name="location_settings_primary_switch_title" msgid="8849081766644685127">"Usar ubicación"</string>
    <string name="location_settings_summary_location_off" msgid="4797932754681162262">"Desactivado"</string>
    <string name="location_settings_summary_location_on" msgid="7029728269719893381">"{count,plural, =1{Activada: # app tiene acceso a la ubicación}other{Activada: # apps tienen acceso a la ubicación}}"</string>
    <string name="location_settings_loading_app_permission_stats" msgid="6054103701535557342">"Cargando…"</string>
    <string name="location_settings_footer_general" msgid="1040507068701188821">"Las apps que tienen el permiso de dispositivos cercanos pueden determinar la posición relativa de los dispositivos conectados."</string>
    <string name="location_settings_footer_location_off" msgid="8568995909147566720">"El acceso a la ubicación está desactivado para las apps y los servicios. Todavía se puede enviar la ubicación del dispositivo a los servicios de emergencia cuando llamas o mandas un mensaje a un número de emergencia."</string>
    <string name="location_settings_footer_learn_more_content_description" msgid="5329024810729665156">"Obtén más información sobre la configuración de la ubicación."</string>
    <string name="account_settings_title" msgid="9138880127246241885">"Cuentas"</string>
    <string name="security_settings_title" msgid="6710768415432791970">"Seguridad"</string>
    <string name="encryption_and_credential_settings_title" msgid="5856216318961482983">"Encriptación y credenciales"</string>
    <string name="lockscreen_settings_title" msgid="4086121748092341549">"Pantalla de bloqueo"</string>
    <string name="lockscreen_settings_what_to_show_category" msgid="9205490627927741254">"Qué mostrar"</string>
    <string name="disabled_by_administrator_summary" msgid="5424846182313851124">"No disponible"</string>
    <string name="security_status_title" msgid="6958004275337618656">"Estado de seguridad"</string>
    <string name="security_dashboard_summary" msgid="7571035662779425918">"Bloqueo de pantalla, Encontrar mi dispositivo, seguridad de la app"</string>
    <string name="safety_center_title" msgid="7732397372178774777">"Seguridad y privacidad"</string>
    <string name="safety_center_summary" msgid="3554867379951053869">"Seguridad de apps, bloqueo del dispositivo, permisos"</string>
    <string name="security_settings_face_preference_summary" msgid="6675126437396914838">"Se agregó el rostro"</string>
    <!-- no translation found for security_settings_face_preference_summary_none (523320857738436024) -->
    <skip />
    <string name="security_settings_face_preference_title" msgid="2126625155005348417">"Desbloqueo facial"</string>
    <string name="security_settings_face_profile_preference_title" msgid="7519527436266375005">"Desbloqueo facial para el trabajo"</string>
    <string name="security_settings_face_enroll_education_title" msgid="6448806884597691208">"Cómo configurar Desbloqueo facial"</string>
    <string name="security_settings_face_enroll_education_title_accessibility" msgid="3701874093226957891">"Configura Desbloqueo facial"</string>
    <string name="security_settings_face_enroll_education_title_unlock_disabled" msgid="8810954233979716906">"Usa tu rostro para autenticarte"</string>
    <string name="security_settings_face_enroll_education_message" msgid="4308030157487176799"></string>
    <string name="security_settings_face_enroll_education_start" msgid="8830924400907195590">"Iniciar"</string>
    <string name="security_settings_face_enroll_education_accessibility_dialog_message" msgid="2965952386172202665">"Si Desbloqueo facial con accesibilidad está desactivado, es posible que algunos pasos de la configuración no funcionen correctamente con TalkBack."</string>
    <string name="security_settings_face_enroll_education_accessibility_dialog_negative" msgid="7872647360361245461">"Atrás"</string>
    <string name="security_settings_face_enroll_education_accessibility_dialog_positive" msgid="3148077647572203458">"Seguir configurando"</string>
    <string name="security_settings_face_enroll_introduction_accessibility" msgid="5748221179069430975">"Usar config. de accesibilidad"</string>
    <string name="security_settings_face_enroll_introduction_accessibility_diversity" msgid="2774962371839179206"></string>
    <string name="security_settings_face_enroll_introduction_accessibility_vision" msgid="7700394302162170363"></string>
    <string name="security_settings_face_enroll_introduction_cancel" msgid="7551159644361639436">"Cancelar"</string>
    <string name="security_settings_face_enroll_introduction_no_thanks" msgid="1820618982738898717">"No, gracias"</string>
    <string name="security_settings_face_enroll_introduction_agree" msgid="6319476573697497750">"Acepto"</string>
    <string name="security_settings_face_enroll_introduction_more" msgid="1970820298889710532">"Más"</string>
    <string name="security_settings_face_enroll_introduction_title" msgid="7061610077237098046">"Usa tu rostro para desbloquear"</string>
    <string name="security_settings_face_enroll_consent_introduction_title" msgid="3942331854413767814">"Permitir el uso del desbloqueo facial"</string>
    <string name="security_settings_face_enroll_introduction_title_unlock_disabled" msgid="5903924766168353113">"Usa tu rostro para autenticarte"</string>
    <string name="security_settings_face_enroll_introduction_message_unlock_disabled" msgid="5841976283789481311">"Usa tu rostro para desbloquear el teléfono o aprobar compras.\n\nNota: No puedes usarlo para desbloquear este dispositivo. Si quieres obtener más detalles, comunícate con el administrador de la organización."</string>
    <string name="security_settings_face_enroll_introduction_message_setup" msgid="765965418187421753">"Usa tu rostro para desbloquear el teléfono, autorizar compras o acceder a las apps"</string>
    <string name="security_settings_face_enroll_introduction_info_title" msgid="7120796118179406944"></string>
    <string name="security_settings_face_enroll_introduction_info_glasses" msgid="2733870453868907471"></string>
    <string name="security_settings_face_enroll_introduction_info_consent_glasses" msgid="6303917184145586880"></string>
    <string name="security_settings_face_enroll_introduction_how_title" msgid="3680193263037835600"></string>
    <string name="security_settings_face_enroll_introduction_control_title" msgid="4536951089583821051"></string>
    <string name="security_settings_face_enroll_introduction_control_consent_title" msgid="5892729331412694759"></string>
    <string name="security_settings_face_enroll_repeat_title" msgid="4446229670377418717">"Centra el rostro en el círculo"</string>
    <string name="security_settings_face_enroll_enrolling_skip" msgid="5568617401632528567">"Omitir"</string>
    <string name="face_intro_error_max" msgid="2474735057709291626">"Agregaste la cantidad máxima permitida de rostros"</string>
    <string name="face_intro_error_unknown" msgid="1626057493054989995">"No se pueden agregar más rostros"</string>
    <string name="security_settings_face_enroll_error_dialog_title" msgid="2460820099922775936">"No se completó la inscripción"</string>
    <string name="security_settings_face_enroll_dialog_ok" msgid="1674650455786434426">"Aceptar"</string>
    <string name="security_settings_face_enroll_error_timeout_dialog_message" msgid="7768349698547951750">"Se alcanzó el límite de tiempo para inscribir el rostro. Vuelve a intentarlo."</string>
    <string name="security_settings_face_enroll_error_generic_dialog_message" msgid="3186810411630091490">"No funcionó la inscripción del rostro."</string>
    <string name="security_settings_face_enroll_finish_title" msgid="5882322568359775393">"Ya terminaste. Está todo listo."</string>
    <string name="security_settings_face_enroll_done" msgid="3048687969498187442">"Listo"</string>
    <string name="security_settings_face_enroll_should_re_enroll_title" msgid="6835778900387289683">"Mejora el rendimiento de Desbloqueo facial"</string>
    <string name="security_settings_face_enroll_should_re_enroll_subtitle" msgid="7055780282999744813">"Vuelve a configurar Desbloqueo facial"</string>
    <string name="security_settings_face_enroll_must_re_enroll_title" msgid="4421818770682557621">"Vuelve a configurar Desbloqueo facial"</string>
    <string name="security_settings_face_enroll_must_re_enroll_subtitle" msgid="3584740139535177961">"Mejora la seguridad y el rendimiento"</string>
    <string name="security_settings_face_enroll_improve_face_alert_title" msgid="6194184776580066012">"Configura Desbloqueo facial"</string>
    <string name="security_settings_face_enroll_improve_face_alert_body" msgid="2670118180411127323">"Borra tu modelo actual de rostro para volver a configurar Desbloqueo facial.\n\nSe borrará tu modelo de rostro de manera permanente y segura.\n\nLuego, deberás ingresar tu PIN, patrón o contraseña para desbloquear el teléfono o autenticarte en apps."</string>
    <string name="security_settings_face_enroll_improve_face_alert_body_fingerprint" msgid="2469599074650327489">"Borra tu modelo actual de rostro para volver a configurar Desbloqueo facial.\n\nSe borrará tu modelo de rostro de manera permanente y segura.\n\nLuego, deberás ingresar tu huella dactilar, PIN, patrón o contraseña para desbloquear el teléfono o autenticarte en apps."</string>
    <string name="security_settings_face_settings_use_face_category" msgid="1638314154119800188">"Desbloq. facial para"</string>
    <string name="security_settings_face_settings_preferences_category" msgid="7628929873407280453">"Cuando usas Desbloqueo facial"</string>
    <string name="security_settings_face_settings_require_attention" msgid="4395309855914391104">"Los ojos deben estar abiertos"</string>
    <string name="security_settings_face_settings_require_attention_details" msgid="2546230511769544074">"Para desbloquear el teléfono, debes abrir los ojos"</string>
    <string name="security_settings_face_settings_require_confirmation" msgid="6603039421004198334">"Requerir siempre confirmación"</string>
    <string name="security_settings_face_settings_require_confirmation_details" msgid="3498729789625461914">"Solicitar confirmación cuando se use Desbloqueo facial en apps"</string>
    <string name="security_settings_face_settings_remove_face_model" msgid="812920481303980846">"Borrar modelo de rostro"</string>
    <string name="security_settings_face_settings_enroll" msgid="3726313826693825029">"Configura Desbloqueo facial"</string>
    <string name="security_settings_face_settings_remove_dialog_title" msgid="2899669764446232715">"¿Deseas borrar el modelo de rostro?"</string>
    <string name="security_settings_face_settings_remove_dialog_details" msgid="916131485988121592">"Se borrará tu modelo de rostro de forma permanente y segura.\n\nLuego de la eliminación, deberás ingresar tu PIN, patrón o contraseña para desbloquear el teléfono o autenticarte en apps."</string>
    <string name="security_settings_face_settings_remove_dialog_details_convenience" msgid="475568135197468990">"Se borrará tu modelo de rostro de forma permanente y segura.\n\nLuego de la eliminación, deberás usar tu PIN, patrón o contraseña para desbloquear el teléfono."</string>
    <string name="security_settings_face_settings_context_subtitle" msgid="8284262560781442403">"Usa Desbloqueo facial para desbloquear el teléfono"</string>
    <string name="security_settings_fingerprint_preference_title" msgid="2484965173528415458">"Huella dactilar"</string>
    <string name="security_settings_fingerprint_settings_preferences_category" msgid="8975029409126780752">"Cuando se usa el desbloqueo con huellas dactilares"</string>
    <string name="security_settings_work_fingerprint_preference_title" msgid="2076006873519745979">"Huella para el trabajo"</string>
    <string name="fingerprint_add_title" msgid="1837610443487902050">"Agregar huella dactilar"</string>
    <string name="security_settings_fingerprint_preference_summary" msgid="8486134175759676037">"{count,plural, =1{Se agregó la huella dactilar}other{Se agregaron # huellas dactilares}}"</string>
    <!-- no translation found for security_settings_fingerprint_preference_summary_none (1146977379031250790) -->
    <skip />
    <string name="security_settings_fingerprint_enroll_introduction_title" msgid="7931650601996313070">"Configura tu huella dactilar"</string>
    <string name="security_settings_fingerprint_enroll_consent_introduction_title" msgid="2278592030102282364">"Desbloq. con huella dactilar"</string>
    <string name="security_settings_fingerprint_enroll_introduction_title_unlock_disabled" msgid="1911710308293783998">"Usa tus huellas dactilares"</string>
    <string name="security_settings_fingerprint_settings_footer_learn_more" msgid="2508322993726483601">"Más información sobre Desbloqueo con huellas dactilares"</string>
    <string name="security_settings_fingerprint_enroll_introduction_footer_title_1" msgid="6808124116419325722">"Tú tienes el control"</string>
    <string name="security_settings_fingerprint_enroll_introduction_footer_title_consent_1" msgid="1122676690472680734">"Tanto tú como tu hijo tienen el control"</string>
    <string name="security_settings_fingerprint_enroll_introduction_footer_title_2" msgid="5663733424583416266">"Para tener en cuenta"</string>
    <string name="security_settings_fingerprint_enroll_introduction_message_unlock_disabled" msgid="8957789840251747092">"Usa tu huella dactilar para desbloquear el teléfono o aprobar compras.\n\nNota: No puedes usar tu huella dactilar 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_cancel" msgid="6086532316718920562">"Cancelar"</string>
    <string name="security_settings_fingerprint_enroll_introduction_no_thanks" msgid="6104718999323591180">"No, gracias"</string>
    <string name="security_settings_fingerprint_enroll_introduction_agree" msgid="4068276083536421828">"Acepto"</string>
    <string name="setup_fingerprint_enroll_skip_title" msgid="2473807887676247264">"¿Omitir huella dactilar?"</string>
    <string name="setup_fingerprint_enroll_skip_after_adding_lock_text" msgid="2412645723804450304">"La configuración de la huella dactilar solo toma unos minutos. Si omites este paso, puedes agregarla más tarde en la configuración."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_message_setup" msgid="6255210343107484206">"Cuando veas este ícono, usa la huella dactilar para autenticarte, como cuando accedes a apps o apruebas compras"</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_title_1" msgid="4360262371633254407">"Importante"</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_title_2" msgid="2580899232734177771">"Cómo funciona"</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_message_2" msgid="5909924864816776516">"La función Desbloqueo con huellas dactilares crea un modelo único de tu huella dactilar que permite verificar tu identidad. Para crear este modelo durante la configuración, es necesario tomar imágenes de tu huella desde diferentes posiciones."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_message_consent_2" msgid="3493356605815124807">"La función Desbloqueo con huellas dactilares crea un modelo único de la huella dactilar de tu hijo que permite verificar su identidad. Para crear este modelo durante la configuración, deberá tomar fotos de su huella desde diferentes posiciones."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_message_6" msgid="5314031490467481499">"Para obtener los mejores resultados, usa un protector de pantalla que tenga certificación Made for Google. Es posible que tu huella dactilar no funcione con otros protectores."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_message_consent_6" msgid="3563942520716110478">"Para obtener los mejores resultados, usa un protector de pantalla que tenga certificación Made for Google. Es posible que la huella dactilar de tu hijo no funcione con otros protectores."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_message_learn_more" msgid="5856010507790137793"></string>
    <string name="security_settings_activeunlock_preference_title" msgid="4257580421087062228">"Desbloqueo con reloj"</string>
    <string name="biometric_settings_intro_with_activeunlock" msgid="6583248094453119314">"Si configuras las funciones Desbloqueo facial y Desbloqueo con huellas dactilares, el teléfono te pedirá la huella dactilar en caso de que tengas puesta una mascarilla o estés en una zona oscura.\n\nPuedes usar el reloj para desbloquear el dispositivo cuando no se reconozcan tu rostro ni tu huella dactilar."</string>
    <string name="biometric_settings_intro_with_fingerprint" msgid="4312041617237493461">"Puedes desbloquear con el reloj cuando no se reconozca tu huella dactilar."</string>
    <string name="biometric_settings_intro_with_face" msgid="7658123658803417930">"Puedes desbloquear con el reloj cuando no se reconozca tu rostro."</string>
    <string name="biometric_settings_use_face_or_watch_preference_summary" msgid="4969685200340861744">"Con rostro o reloj"</string>
    <string name="biometric_settings_use_fingerprint_or_watch_preference_summary" msgid="2425628094194828407">"Con huella dactilar o reloj"</string>
    <string name="biometric_settings_use_face_fingerprint_or_watch_preference_summary" msgid="188805113048792007">"Con rostro, huella dactilar o reloj"</string>
    <string name="biometric_settings_use_watch_preference_summary" msgid="2311453276747908475">"Con reloj"</string>
    <string name="security_settings_activeunlock_require_face_fingerprint_setup_title" msgid="8776904312629209685">"Primero configura Desbloqueo facial o con huellas dactilares"</string>
    <string name="security_settings_activeunlock_require_face_fingerprint_setup_message" msgid="1669326067732567911">"Puedes usar el reloj para desbloquear el dispositivo cuando no se reconozcan tu rostro ni tu huella dactilar."</string>
    <string name="security_settings_activeunlock_require_fingerprint_setup_title" msgid="6703703635881050623">"Primero configura Desbloqueo con huellas dactilares"</string>
    <string name="security_settings_activeunlock_require_fingerprint_setup_message" msgid="4966813766409918392">"Puedes desbloquear con el reloj cuando no se reconozca tu huella dactilar"</string>
    <string name="security_settings_activeunlock_require_face_setup_title" msgid="1428795376597739880">"Primero configura Desbloqueo facial"</string>
    <string name="security_settings_activeunlock_require_face_setup_message" msgid="8904070645721933399">"Puedes desbloquear con el reloj cuando no se reconozca tu rostro"</string>
    <string name="security_settings_activeunlock_biometric_setup" msgid="8876454457817955475">"Configurar"</string>
    <string name="security_settings_fingerprint_single_watch_preference_summary" msgid="6464470096384164369">"Huella dactilar y <xliff:g id="WATCH">%s</xliff:g> agregados"</string>
    <string name="security_settings_fingerprint_multiple_watch_preference_summary" msgid="2259261786932097004">"Huellas dactilares y <xliff:g id="WATCH">%s</xliff:g> agregados"</string>
    <string name="security_settings_face_watch_preference_summary" msgid="5817376447253802793">"Rostro y <xliff:g id="WATCH">%s</xliff:g> agregados"</string>
    <string name="security_settings_fingerprint_single_face_watch_preference_summary" msgid="764951912234638192">"Rostro, huella dactilar y <xliff:g id="WATCH">%s</xliff:g> agregados"</string>
    <string name="security_settings_fingerprint_multiple_face_watch_preference_summary" msgid="3935500711366489380">"Rostro, huellas dactilares y <xliff:g id="WATCH">%s</xliff:g> agregados"</string>
    <string name="security_settings_biometric_preference_title" msgid="298146483579539448">"Desbloqueo facial y con huellas dactilares"</string>
    <string name="security_settings_work_biometric_preference_title" msgid="3121755615533533585">"Desbloqueo facial y con huellas dactilares para el trabajo"</string>
    <!-- no translation found for security_settings_biometric_preference_summary_none_enrolled (213377753727694575) -->
    <skip />
    <string name="security_settings_biometric_preference_summary_both_fp_multiple" msgid="4821859306609955966">"Se agregaron huellas dactilares y el rostro"</string>
    <string name="security_settings_biometric_preference_summary_both_fp_single" msgid="684409535278676426">"Se agregaron el rostro y la huella dactilar"</string>
    <string name="biometric_settings_intro" msgid="4263069383955676756">"Si configuras el Desbloqueo facial y con huellas dactilares, el teléfono te solicitará la huella dactilar en caso de que tengas puesta una mascarilla o estés en una zona oscura."</string>
    <string name="biometric_settings_category_ways_to_unlock" msgid="3384767901580915266">"Métodos de desbloqueo"</string>
    <string name="biometric_settings_category_use_face_fingerprint" msgid="4377659744376863913">"Usa el rostro o la huella dactilar para"</string>
    <string name="biometric_settings_use_biometric_unlock_phone" msgid="8180914579885804358">"Desbloquear el teléfono"</string>
    <string name="biometric_settings_use_biometric_for_apps" msgid="6201168728906364189">"Verificar tu identidad en las apps"</string>
    <string name="biometric_settings_use_face_preference_summary" msgid="1821648836899408477">"Con el rostro"</string>
    <string name="biometric_settings_use_fingerprint_preference_summary" msgid="6077762097826050165">"Con la huella dactilar"</string>
    <string name="biometric_settings_use_face_or_fingerprint_preference_summary" msgid="3029102492674234728">"Con el rostro o la huella dactilar"</string>
    <string name="biometric_settings_hand_back_to_guardian_ok" msgid="1763788801883247426">"Aceptar"</string>
    <string name="lock_screen_intro_skip_title" msgid="342553937472568925">"¿Omitir bloqueo de la pantalla?"</string>
    <string name="skip_anyway_button_label" msgid="3442274117023270068">"Omitir"</string>
    <string name="go_back_button_label" msgid="6139455414099035594">"Atrás"</string>
    <string name="skip_lock_screen_dialog_button_label" msgid="641984698150020591">"Omitir"</string>
    <string name="cancel_lock_screen_dialog_button_label" msgid="1801132985957491690">"Cancelar"</string>
    <string name="security_settings_fingerprint_enroll_find_sensor_title" msgid="886085239313346000">"Toca el sensor"</string>
    <string name="security_settings_sfps_enroll_find_sensor_title" msgid="8327884364635804363">"Toca el botón de encendido sin presionarlo"</string>
    <string name="security_settings_udfps_enroll_find_sensor_title" msgid="8077484429913330179">"Cómo configurar una huella dactilar"</string>
    <string name="security_settings_fingerprint_enroll_find_sensor_message" msgid="6160543980992596286">"Se encuentra en la parte posterior del teléfono. Usa el dedo índice."</string>
    <string name="security_settings_udfps_enroll_find_sensor_message" msgid="8383106460819519961">"El sensor de huellas dactilares está en la pantalla. En la próxima pantalla, se capturará tu huella dactilar."</string>
    <string name="security_settings_udfps_enroll_find_sensor_start_button" msgid="3172268783620336357">"Iniciar"</string>
    <string name="security_settings_udfps_enroll_a11y" msgid="1899453114050362235">"Mueve el dedo por la pantalla para encontrar el sensor y mantenlo presionado."</string>
    <string name="security_settings_fingerprint_enroll_find_sensor_content_description" msgid="3065850549419750523">"Ilustración del dispositivo y la ubicación del sensor de huellas dactilares"</string>
    <string name="security_settings_fingerprint_enroll_dialog_name_label" msgid="7298812463228440333">"Nombre"</string>
    <string name="security_settings_fingerprint_enroll_dialog_ok" msgid="4074335979239208021">"Aceptar"</string>
    <string name="security_settings_fingerprint_enroll_dialog_try_again" msgid="8117874972945407006">"Reintentar"</string>
    <string name="security_settings_fingerprint_enroll_dialog_delete" msgid="6027141901007342389">"Borrar"</string>
    <string name="security_settings_fingerprint_enroll_start_title" msgid="7391368057800077604">"Toca el sensor"</string>
    <string name="security_settings_fingerprint_enroll_start_message" msgid="5010227772754175346">"Coloca el dedo en el sensor y levántalo cuando sientas una vibración."</string>
    <string name="security_settings_udfps_enroll_start_message" msgid="5032954588171487566">"Mantén toda la huella dactilar en el sensor hasta que notes una vibración"</string>
    <string name="security_settings_sfps_enroll_start_message" msgid="9054672627477685212">"Sin presionar el botón, mantén la huella dactilar en el sensor hasta que sientas una vibración.\n\nMueve un poco el dedo cada vez. Esto permite capturar más superficie de tu huella dactilar."</string>
    <string name="security_settings_fingerprint_enroll_udfps_title" msgid="6665610134560896895">"Mantén presionado el sensor de huellas dactilares"</string>
    <string name="security_settings_fingerprint_enroll_repeat_title" msgid="9172202128243545021">"Levanta el dedo y vuelve a tocar"</string>
    <string name="security_settings_udfps_enroll_title_one_more_time" msgid="424937043843482410">"Una vez más"</string>
    <string name="security_settings_udfps_enroll_repeat_title_touch_icon" msgid="4096344864386190335">"Sigue el ícono de huella dactilar"</string>
    <string name="security_settings_fingerprint_enroll_repeat_message" msgid="5382958363770893577">"Sigue levantando el dedo para agregar diferentes partes de la huella dactilar."</string>
    <string name="security_settings_udfps_enroll_repeat_message" msgid="2213106975297867798">"Mantén presionado cada vez que el ícono de huella dactilar se mueva. Esto permite capturar más superficie de tu huella dactilar."</string>
    <string name="security_settings_udfps_enroll_fingertip_title" msgid="4123142574168831116">"Apoya la punta del dedo en el sensor"</string>
    <string name="security_settings_udfps_enroll_left_edge_title" msgid="1944076382202470458">"Coloca el borde izquierdo de tu dedo"</string>
    <string name="security_settings_udfps_enroll_right_edge_title" msgid="9036744264606447490">"Coloca el borde derecho de tu dedo"</string>
    <string name="security_settings_sfps_enroll_finger_center_title" msgid="1320688855767675739">"Coloca el centro del dedo en el sensor"</string>
    <string name="security_settings_sfps_enroll_fingertip_title" msgid="2737520837684516446">"Coloca la punta del dedo en el sensor"</string>
    <string name="security_settings_sfps_enroll_left_edge_title" msgid="9022963735924413343">"Coloca el borde izquierdo del dedo en el sensor"</string>
    <string name="security_settings_sfps_enroll_right_edge_title" msgid="823106857743394392">"Por último, coloca el borde derecho del dedo en el sensor"</string>
    <string name="security_settings_udfps_enroll_edge_message" msgid="4455253923746607702">"Apoya un lado de tu huella dactilar en el sensor y mantén presionado. Luego, cambia de lado."</string>
    <string name="security_settings_udfps_enroll_repeat_a11y_message" msgid="2785464357615568197">"Esto permite capturar más superficie de tu huella dactilar"</string>
    <string name="security_settings_sfps_enroll_progress_a11y_message" msgid="6450772721691523736">"Inscribiendo huella dactilar: <xliff:g id="PERCENTAGE">%d</xliff:g> por ciento"</string>
    <string name="security_settings_sfps_animation_a11y_label" msgid="8808819903730940446">"Se inscribió el <xliff:g id="PERCENTAGE">%d</xliff:g> por ciento"</string>
    <string name="security_settings_udfps_enroll_progress_a11y_message" msgid="6183535114682369699">"Inscribiendo huella dactilar: <xliff:g id="PERCENTAGE">%d</xliff:g>%%"</string>
    <string name="security_settings_fingerprint_enroll_finish_title" msgid="3606325177406951457">"Se agregó la huella dactilar"</string>
    <string name="security_settings_require_screen_on_to_auth_title" msgid="1641621458536715518">"Tocar para desbloquear en cualquier momento"</string>
    <string name="security_settings_require_screen_on_to_auth_description" msgid="4158414711168345398">"Toca el sensor para desbloquear, incluso si la pantalla está apagada. Con esta opción es más probable que se desbloquee el dispositivo accidentalmente."</string>
    <string name="security_settings_require_screen_on_to_auth_keywords" msgid="5557869560397089603">"Pantalla, desbloqueo"</string>
    <string name="security_settings_fingerprint_enroll_enrolling_skip" msgid="3004786457919122854">"Más tarde"</string>
    <string name="security_settings_udfps_tip_fingerprint_help" msgid="7580784640741217494">"Levanta el dedo y vuelve a tocar"</string>
    <string name="security_settings_udfps_side_fingerprint_help" msgid="2567232481013195191">"Apoya un lado de tu huella dactilar en el sensor y mantén presionado. Luego, cambia de lado."</string>
    <string name="setup_fingerprint_enroll_enrolling_skip_title" msgid="352947044008973812">"¿Omitir configuración de huella dactilar?"</string>
    <string name="setup_fingerprint_enroll_enrolling_skip_message" msgid="4876965433600560365">"Decidiste usar la huella dactilar 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="lock_screen_pin_skip_title" msgid="6853866579893458111">"¿Omitir configuración del PIN?"</string>
    <string name="lock_screen_pin_skip_face_title" msgid="8810770395309512358">"¿Omitir PIN y rostro?"</string>
    <string name="lock_screen_pin_skip_fingerprint_title" msgid="371214283158750976">"¿Omitir PIN y huella dactilar?"</string>
    <string name="lock_screen_pin_skip_biometrics_title" msgid="1082066572914073311">"¿Omitir PIN, rostro y huella dactilar?"</string>
    <string name="lock_screen_password_skip_title" msgid="8891463713793185768">"¿Omitir configuración de la contraseña?"</string>
    <string name="lock_screen_password_skip_face_title" msgid="8166210519462164998">"¿Omitir contraseña y rostro?"</string>
    <string name="lock_screen_password_skip_fingerprint_title" msgid="2506392546016772170">"¿Omitir contraseña y huella dactilar?"</string>
    <string name="lock_screen_password_skip_biometrics_title" msgid="900281322095862009">"¿Omitir contraseña, rostro y huella dactilar?"</string>
    <string name="lock_screen_pattern_skip_title" msgid="7214938393640060932">"¿Omitir configuración del patrón?"</string>
    <string name="lock_screen_pattern_skip_face_title" msgid="145100333454316334">"¿Omitir patrón y rostro?"</string>
    <string name="lock_screen_pattern_skip_fingerprint_title" msgid="2513110208722100495">"¿Omitir patrón y huella dactilar?"</string>
    <string name="lock_screen_pattern_skip_biometrics_title" msgid="2434258106825380187">"¿Omitir patrón, rostro y huella dactilar?"</string>
    <string name="security_settings_fingerprint_enroll_setup_screen_lock" msgid="3538784524778508018">"Configurar bloqueo de pantalla"</string>
    <string name="security_settings_fingerprint_enroll_done" msgid="9198775984215057337">"Listo"</string>
    <string name="security_settings_fingerprint_enroll_touch_dialog_title" msgid="5742429501012827526">"Ese no es el sensor"</string>
    <string name="security_settings_fingerprint_enroll_touch_dialog_message" msgid="7172969336386036998">"Toca el sensor en la parte posterior del teléfono con el dedo índice."</string>
    <string name="security_settings_fingerprint_enroll_error_unable_to_process_dialog_title" msgid="5796228438604723279">"No se completó la inscripción"</string>
    <string name="security_settings_fingerprint_enroll_error_dialog_title" msgid="8582267776559099046">"Tiempo para configurar huella dactilar agotado"</string>
    <string name="security_settings_fingerprint_enroll_error_timeout_dialog_message" msgid="467965101751652156">"Vuelve a intentarlo o hazlo más tarde en Configuración"</string>
    <string name="security_settings_fingerprint_enroll_error_generic_dialog_message" msgid="6068935528640241271">"Se produjo un error al registrar la huella dactilar. Vuelve a intentarlo o usa otro dedo."</string>
    <string name="fingerprint_enroll_button_add" msgid="6652490687672815760">"Agregar otra huella digital"</string>
    <string name="fingerprint_enroll_button_next" msgid="1034110123277869532">"Siguiente"</string>
    <string name="security_fingerprint_disclaimer_lockscreen_disabled_1" msgid="294529888220959309">"La opción de bloqueo de pantalla está inhabilitada. Para obtener más información, comunícate con el administrador de la organización."</string>
    <string name="security_fingerprint_disclaimer_lockscreen_disabled_2" msgid="8070829069640846543">"Puedes seguir usando tu huella dactilar para autorizar compras y acceder a apps."</string>
    <string name="security_settings_fingerprint_enroll_lift_touch_again" msgid="2590665137265458789">"Levanta el dedo y vuelve a tocar el sensor"</string>
    <string name="security_settings_fingerprint_bad_calibration" msgid="598502302101068608">"No se puede usar el sensor de huellas dactilares. Consulta a un proveedor de reparaciones."</string>
    <string name="security_advanced_settings" msgid="6260756619837834042">"Más parámetros de seguridad"</string>
    <string name="security_advanced_settings_work_profile_settings_summary" msgid="7295451997961973175">"Bloqueo del perfil de trabajo, encriptación y más"</string>
    <string name="security_advanced_settings_no_work_profile_settings_summary" msgid="345336447137417638">"Encriptación, credenciales y más"</string>
    <string name="security_advanced_settings_keywords" msgid="5294945170370974974">"seguridad, más configuración de seguridad, más configuración, configuración avanzada de seguridad"</string>
    <string name="privacy_advanced_settings" msgid="8828215456566937719">"Más parámetros de privacidad"</string>
    <!-- no translation found for more_security_privacy_settings (123465614090328851) -->
    <skip />
    <string name="security_header" msgid="961514795852103424">"Seguridad"</string>
    <string name="privacy_header" msgid="5526002421324257007">"Privacidad"</string>
    <string name="work_profile_category_header" msgid="85707750968948517">"Perfil de trabajo"</string>
    <string name="fingerprint_add_max" msgid="8639321019299347447">"Puedes agregar hasta <xliff:g id="COUNT">%d</xliff:g> huellas dactilares"</string>
    <string name="fingerprint_intro_error_max" msgid="4431784409732135610">"Agregaste la cantidad máxima permitida de huellas digitales"</string>
    <string name="fingerprint_intro_error_unknown" msgid="877005321503793963">"No se pueden agregar más huellas digitales"</string>
    <string name="fingerprint_delete_title" msgid="5412123164503407098">"Borrar \"<xliff:g id="FINGERPRINT_ID">%1$s</xliff:g>\""</string>
    <string name="fingerprint_last_delete_message_profile_challenge" msgid="4104208067277655068">"No podrás usar tu huella dactilar para desbloquear tu perfil de trabajo, autorizar compras ni acceder a apps de trabajo."</string>
    <string name="encryption_settings_title" msgid="2848716008695618360">"Encriptación"</string>
    <string name="encrypted_summary" msgid="545623487587251207">"Con encriptación"</string>
    <string name="no_screen_lock_issue_title" msgid="1814109590692792891">"Establecer un bloqueo de pantalla"</string>
    <string name="no_screen_lock_issue_summary" msgid="2383217853510608406">"Para mayor seguridad, establece un PIN, un patrón o una contraseña para este dispositivo."</string>
    <string name="no_screen_lock_issue_action_label" msgid="2691229130486382863">"Establecer un bloqueo de pantalla"</string>
    <string name="no_screen_lock_issue_notification_title" msgid="5718363966239208505">"El dispositivo no tiene pantalla de bloqueo"</string>
    <string name="no_screen_lock_issue_notification_text" msgid="8696194459170873345">"Para mayor seguridad, establece un PIN, un patrón o una contraseña para este dispositivo."</string>
    <string name="suggested_lock_settings_title" msgid="7836065447159730217">"Protege tu teléfono"</string>
    <string name="suggested_fingerprint_lock_settings_title" msgid="3140266181874137984">"Agrega una huella dactilar como desbloqueo"</string>
    <string name="lock_settings_picker_title" msgid="9219376327364915334">"Bloqueo de pantalla"</string>
    <string name="lock_settings_picker_new_lock_title" msgid="3113042086804290919">"Elige un bloqueo de pantalla"</string>
    <string name="lock_settings_picker_update_lock_title" msgid="536853138943415927">"Nuevo bloqueo de pantalla"</string>
    <string name="lock_settings_picker_new_profile_lock_title" msgid="2270462215256413800">"Bloqueo de apps de trabajo"</string>
    <string name="lock_settings_picker_update_profile_lock_title" msgid="5929068163516308927">"Nuevo bloqueo de trabajo"</string>
    <string name="lock_settings_picker_biometrics_added_security_message" msgid="1105247657304421299">"Para mayor seguridad, establece un bloqueo de pantalla secundario"</string>
    <string name="lock_settings_picker_biometric_message" msgid="2609666443527262781">"Elige el método secundario de bloqueo de pantalla"</string>
    <string name="lock_settings_picker_admin_restricted_personal_message" msgid="3532653662159888328">"Si olvidas tu bloqueo de pantalla, el administrador de TI no podrá restablecerlo."</string>
    <string name="lock_settings_picker_admin_restricted_personal_message_action" msgid="5956615234246626264">"Configura un bloqueo de trabajo independiente"</string>
    <string name="lock_settings_picker_profile_message" msgid="9142379549980873478">"Si olvidas este bloqueo, pídele al administrador de TI que lo restablezca"</string>
    <string name="setup_lock_settings_options_button_label" msgid="6098297461618298505">"Opciones de bloqueo de la pantalla"</string>
    <string name="setup_lock_settings_options_dialog_title" msgid="7985107300517468569">"Opciones de bloqueo de la pantalla"</string>
    <string name="lock_screen_auto_pin_confirm_title" msgid="3012128112186088375">"Desbloqueo con confirmación automática"</string>
    <string name="lock_screen_auto_pin_confirm_summary" msgid="9050818870806580819">"Desbloquear automáticamente si introduces el PIN correcto de 6 o más dígitos. Esto es menos seguro que presionar Ingresar para confirmar."</string>
    <string name="auto_pin_confirm_user_message" msgid="6194556173488939314">"Confirmar automáticamente si el PIN es correcto"</string>
    <string name="auto_pin_confirm_opt_in_security_message" msgid="580773976736184893">"Presionar Ingresar para confirmar tu PIN es más seguro que usar la confirmación automática"</string>
    <!-- no translation found for auto_confirm_on_pin_verify_description (2052240431173223502) -->
    <skip />
    <!-- no translation found for auto_confirm_off_pin_verify_description (4256219155659760047) -->
    <skip />
    <string name="unlock_set_unlock_launch_picker_title" msgid="4981063601772605609">"Bloqueo de pantalla"</string>
    <string name="unlock_set_unlock_launch_picker_title_profile" msgid="7631371082326055429">"Bloqueo del perfil"</string>
    <string name="unlock_set_unlock_off_title" msgid="2831957685685921667">"Ninguno"</string>
    <string name="unlock_set_unlock_none_title" msgid="2844029875174409728">"Deslizar"</string>
    <string name="unlock_set_unlock_pattern_title" msgid="8224895208452995332">"Patrón"</string>
    <string name="unlock_set_unlock_pin_title" msgid="5283636759362880407">"PIN"</string>
    <string name="unlock_set_unlock_password_title" msgid="2559842616268607041">"Contraseña"</string>
    <string name="unlock_set_do_later_title" msgid="6565575303676064364">"Ahora no"</string>
    <string name="current_screen_lock" msgid="1367883977261098017">"Bloqueo de pantalla actual"</string>
    <string name="fingerprint_unlock_set_unlock_pattern" msgid="4492334416059646032">"Huella dactilar y patrón"</string>
    <string name="fingerprint_unlock_set_unlock_pin" msgid="4724451168139460493">"Huella dactilar y PIN"</string>
    <string name="fingerprint_unlock_set_unlock_password" msgid="5614333047430835971">"Huella dactilar y contraseña"</string>
    <string name="fingerprint_unlock_skip_fingerprint" msgid="7631242444064287891">"Continuar sin huella dactilar"</string>
    <string name="face_unlock_set_unlock_pattern" msgid="3117316407679805330">"Desbloqueo facial y patrón"</string>
    <string name="face_unlock_set_unlock_pin" msgid="5300188327595503657">"Desbloqueo facial y PIN"</string>
    <string name="face_unlock_set_unlock_password" msgid="8395722611524617956">"Desbloqueo facial y contraseña"</string>
    <string name="face_unlock_skip_face" msgid="189695556498300008">"Continuar sin Desbloqueo facial"</string>
    <string name="biometrics_unlock_set_unlock_pattern" msgid="8084495264354847044">"Patrón • Desbloqueo facial • Huella dactilar"</string>
    <string name="biometrics_unlock_set_unlock_pin" msgid="5912980580857825894">"PIN • Desbloqueo facial • Huella dactilar"</string>
    <string name="biometrics_unlock_set_unlock_password" msgid="4612217647465743624">"Contraseña • Desbl. facial • Huella dactilar"</string>
    <string name="biometrics_unlock_skip_biometrics" msgid="7785643433551409223">"Continuar sin el desbloqueo facial ni la huella dactilar"</string>
    <string name="unlock_set_unlock_mode_off" msgid="4632139864722236359">"Ninguno"</string>
    <string name="unlock_set_unlock_mode_none" msgid="5596049938457028214">"Deslizar"</string>
    <string name="unlock_set_unlock_mode_pattern" msgid="1926480143883094896">"Patrón"</string>
    <string name="unlock_set_unlock_mode_pin" msgid="9028659554829888373">"PIN"</string>
    <string name="unlock_set_unlock_mode_password" msgid="8810609692771987513">"Contraseña"</string>
    <string name="unlock_disable_frp_warning_title" msgid="3606280046362811229">"¿Quieres borrar el bloqueo de pantalla?"</string>
    <string name="unlock_disable_frp_warning_title_profile" msgid="1005284289723910461">"¿Quieres quitar la protección del perfil?"</string>
    <string name="unlock_disable_frp_warning_content_pattern" msgid="6246242612158828147">"En caso de robo o extravío, un patrón protege tu teléfono"</string>
    <string name="unlock_disable_frp_warning_content_pattern_fingerprint" msgid="2259825377085781801">"En caso de robo o extravío, un patrón protege tu teléfono.<xliff:g id="EMPTY_LINE">

</xliff:g>También se borrará el modelo de huella dactilar almacenado en el dispositivo. No podrás usar tu huella dactilar para autenticarte en apps."</string>
    <string name="unlock_disable_frp_warning_content_pattern_face" msgid="4699508435412336378">"En caso de robo o extravío, un patrón protege tu teléfono.<xliff:g id="EMPTY_LINE">

</xliff:g>También se borrará tu modelo de rostro de forma permanente y segura. No podrás usar tu rostro para autenticarte en apps."</string>
    <string name="unlock_disable_frp_warning_content_pattern_face_fingerprint" msgid="7049706229344804972">"En caso de robo o extravío, un patrón protege tu teléfono.<xliff:g id="EMPTY_LINE">

</xliff:g>Se borrará el modelo de huella dactilar almacenado en el dispositivo. También se borrará tu modelo de rostro de forma permanente y segura. No podrás usar tu rostro ni tu huella dactilar para autenticarte en apps."</string>
    <string name="unlock_disable_frp_warning_content_pin" msgid="122154942944422284">"En caso de robo o extravío, un PIN protege tu teléfono"</string>
    <string name="unlock_disable_frp_warning_content_pin_fingerprint" msgid="983373874470746066">"En caso de robo o extravío, un PIN protege tu teléfono.<xliff:g id="EMPTY_LINE">

</xliff:g>También se borrará el modelo de huella dactilar almacenado en el dispositivo. No podrás usar tu huella dactilar para autenticarte en apps."</string>
    <string name="unlock_disable_frp_warning_content_pin_face" msgid="5607150515413131761">"En caso de robo o extravío, un PIN protege tu teléfono.<xliff:g id="EMPTY_LINE">

</xliff:g>También se borrará tu modelo de rostro de forma permanente y segura. No podrás usar tu rostro para autenticarte en apps."</string>
    <string name="unlock_disable_frp_warning_content_pin_face_fingerprint" msgid="1821792325159866312">"En caso de robo o extravío, un PIN protege tu teléfono.<xliff:g id="EMPTY_LINE">

</xliff:g>Se borrará el modelo de huella dactilar almacenado en el dispositivo. También se borrará tu modelo de rostro de forma permanente y segura. No podrás usar tu rostro ni tu huella dactilar para autenticarte en apps."</string>
    <string name="unlock_disable_frp_warning_content_password" msgid="6422723907917376210">"En caso de robo o extravío, una contraseña protege tu teléfono"</string>
    <string name="unlock_disable_frp_warning_content_password_fingerprint" msgid="8899452884016354856">"En caso de robo o extravío, una contraseña protege tu teléfono.<xliff:g id="EMPTY_LINE">

</xliff:g>También se borrará el modelo de huella dactilar almacenado en el dispositivo. No podrás usar tu huella dactilar para autenticarte en apps."</string>
    <string name="unlock_disable_frp_warning_content_password_face" msgid="1811067332335964495">"En caso de robo o extravío, una contraseña protege tu teléfono.<xliff:g id="EMPTY_LINE">

</xliff:g>También se borrará tu modelo de rostro de forma permanente y segura. No podrás usar tu rostro para autenticarte en apps."</string>
    <string name="unlock_disable_frp_warning_content_password_face_fingerprint" msgid="7063649456205159491">"En caso de robo o extravío, una contraseña protege tu teléfono.<xliff:g id="EMPTY_LINE">

</xliff:g>Se borrará el modelo de huella dactilar almacenado en el dispositivo. También se borrará tu modelo de rostro de forma permanente y segura. No podrás usar tu rostro ni tu huella dactilar para autenticarte en apps."</string>
    <string name="unlock_disable_frp_warning_content_unknown" msgid="8903568674104115231">"Las funciones de protección del dispositivo no estarán disponibles sin el bloqueo de pantalla."</string>
    <string name="unlock_disable_frp_warning_content_unknown_fingerprint" msgid="6542744110902941189">"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 borrará el modelo de huella dactilar almacenado en el dispositivo. No podrás usar tu huella dactilar para autenticarte en apps."</string>
    <string name="unlock_disable_frp_warning_content_unknown_face" msgid="4559917661432267841">"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 borrará tu modelo de rostro de forma permanente y segura. No podrás usar tu rostro para autenticarte en apps."</string>
    <string name="unlock_disable_frp_warning_content_unknown_face_fingerprint" msgid="3779582301453677644">"Las funciones de protección del dispositivo no podrán usarse sin el bloqueo de pantalla.<xliff:g id="EMPTY_LINE">

</xliff:g>Se borrará el modelo de huella dactilar almacenado en el dispositivo. También se borrará tu modelo de rostro de forma permanente y segura. No podrás usar tu rostro ni tu huella dactilar para autenticarte en apps."</string>
    <string name="unlock_disable_frp_warning_ok" msgid="6173427638951230842">"Borrar"</string>
    <string name="unlock_footer_high_complexity_requested" msgid="4471274783909915352">"<xliff:g id="APP_NAME">%1$s</xliff:g> recomienda establecer una contraseña o un patrón seguro, y es posible que no funcione como debería sin uno de estos métodos de bloqueo"</string>
    <string name="unlock_footer_medium_complexity_requested" msgid="5515870066751600640">"<xliff:g id="APP_NAME">%1$s</xliff:g> recomienda establecer un nuevo patrón o contraseña, y es posible que no funcione como debería sin uno de estos métodos de bloqueo"</string>
    <string name="unlock_footer_low_complexity_requested" msgid="2517656037576567971">"<xliff:g id="APP_NAME">%1$s</xliff:g> recomienda establecer un nuevo patrón, PIN o contraseña, y es posible que no funcione como debería sin uno de estos métodos de bloqueo"</string>
    <string name="unlock_footer_none_complexity_requested" msgid="8534900170428140529">"<xliff:g id="APP_NAME">%1$s</xliff:g> recomienda establecer un nuevo bloqueo de pantalla"</string>
    <string name="lock_failed_attempts_before_wipe" msgid="6874652886647631418">"Vuelve a intentarlo. Intento <xliff:g id="CURRENT_ATTEMPTS">%1$d</xliff:g> de <xliff:g id="TOTAL_ATTEMPTS">%2$d</xliff:g>."</string>
    <string name="lock_last_attempt_before_wipe_warning_title" msgid="7450322567217745999">"Se borrarán tus datos"</string>
    <string name="lock_last_pattern_attempt_before_wipe_device" msgid="5816668400104558952">"Si ingresas un patrón incorrecto en el próximo intento, se borrarán los datos de este dispositivo"</string>
    <string name="lock_last_pin_attempt_before_wipe_device" msgid="2815681042623708775">"Si ingresas un PIN incorrecto en el próximo intento, se borrarán los datos de este dispositivo"</string>
    <string name="lock_last_password_attempt_before_wipe_device" msgid="985126164175708507">"Si ingresas una contraseña incorrecta en el próximo intento, se borrarán los datos de este dispositivo"</string>
    <string name="lock_last_pattern_attempt_before_wipe_user" msgid="8283944727199433440">"Si ingresas un patrón incorrecto en el próximo intento, se borrará este usuario"</string>
    <string name="lock_last_pin_attempt_before_wipe_user" msgid="972834567684477451">"Si ingresas un PIN incorrecto en el próximo intento, se borrará este usuario"</string>
    <string name="lock_last_password_attempt_before_wipe_user" msgid="3797239847079686727">"Si ingresas una contraseña incorrecta en el próximo intento, se borrará este usuario"</string>
    <string name="lock_last_pattern_attempt_before_wipe_profile" msgid="2479195488386373253">"Si ingresas un patrón incorrecto en el próximo intento, se borrarán tu perfil de trabajo y sus datos"</string>
    <string name="lock_last_pin_attempt_before_wipe_profile" msgid="7086428013814722436">"Si ingresas un PIN incorrecto en el próximo intento, se borrarán tu perfil de trabajo y sus datos"</string>
    <string name="lock_last_password_attempt_before_wipe_profile" msgid="253673907244112643">"Si ingresas una contraseña incorrecta en el próximo intento, se borrarán tu perfil de trabajo y sus datos"</string>
    <string name="lockpassword_password_too_short" msgid="1938086368137797700">"{count,plural, =1{Debe tener al menos # carácter}other{Debe tener al menos # caracteres}}"</string>
    <string name="lockpassword_password_too_short_all_numeric" msgid="4301294924022401502">"{count,plural, =1{Si solo se usan números, debe ser de al menos 1 dígito}other{Si solo se usan números, deben ser de al menos # dígitos}}"</string>
    <string name="lockpassword_pin_too_short" msgid="8910105226463085689">"{count,plural, =1{El PIN debe tener al menos # dígito}other{El PIN debe tener al menos # dígitos}}"</string>
    <string name="lockpassword_pin_too_short_autoConfirm_extra_message" msgid="3271351502900762571">"{count,plural, =1{El PIN debe tener al menos # dígito, pero se recomienda un PIN de {minAutoConfirmLen} dígitos para mayor seguridad}other{El PIN debe tener al menos # dígitos, pero se recomienda un PIN de {minAutoConfirmLen} dígitos para mayor seguridad}}"</string>
    <string name="lockpassword_password_too_long" msgid="1940345313260498308">"{count,plural, =1{Debe tener menos de # carácter}other{Debe tener menos de # caracteres}}"</string>
    <string name="lockpassword_pin_too_long" msgid="1678212054564388576">"{count,plural, =1{Debe tener menos de # dígito}other{Debe tener menos de # dígitos}}"</string>
    <string name="lockpassword_pin_recently_used" msgid="6650277060998923465">"El administrador del dispositivo no permite el uso de un PIN reciente"</string>
    <string name="lockpassword_illegal_character" msgid="3434031212215886433">"No puede incluir un carácter no válido"</string>
    <string name="lockpassword_password_requires_letters" msgid="7058340182953750553">"{count,plural, =1{Debe tener al menos 1 letra}other{Debe tener al menos # letras}}"</string>
    <string name="lockpassword_password_requires_lowercase" msgid="3286121470522077547">"{count,plural, =1{Debe tener al menos 1 letra en minúscula}other{Debe tener al menos # letras en minúscula}}"</string>
    <string name="lockpassword_password_requires_uppercase" msgid="720312543910397772">"{count,plural, =1{Debe tener al menos 1 letra en mayúscula}other{Debe tener al menos # letras en mayúscula}}"</string>
    <string name="lockpassword_password_requires_numeric" msgid="3886918493600507548">"{count,plural, =1{Debe tener al menos 1 dígito numérico}other{Debe tener al menos # dígitos numéricos}}"</string>
    <string name="lockpassword_password_requires_symbols" msgid="2904870551002210131">"{count,plural, =1{Debe tener al menos 1 símbolo especial}other{Debe tener al menos # símbolos especiales}}"</string>
    <string name="lockpassword_password_requires_nonletter" msgid="1185342065898300006">"{count,plural, =1{Debe tener al menos 1 carácter que no sea una letra}other{Debe tener al menos # caracteres que no sean letras}}"</string>
    <string name="lockpassword_password_requires_nonnumerical" msgid="389687423482993365">"{count,plural, =1{Debe tener al menos 1 carácter no numérico}other{Debe tener al menos # caracteres no numéricos}}"</string>
    <string name="lockpassword_password_recently_used" msgid="5341218079730167191">"El administrador del dispositivo no permite el uso de contraseñas recientes"</string>
    <string name="lockpassword_pin_no_sequential_digits" msgid="5843639256988031272">"No se permiten secuencias de dígitos ascendentes, descendentes ni repetidas"</string>
    <string name="lockpassword_confirm_label" msgid="560897521093566777">"Confirmar"</string>
    <string name="lockpassword_clear_label" msgid="311359833434539894">"Borrar"</string>
    <string name="lockpassword_credential_changed" msgid="5934778179732392028">"Ya se cambió el bloqueo de pantalla. Vuelve a intentarlo con el nuevo bloqueo de pantalla."</string>
    <string name="lockpattern_tutorial_cancel_label" msgid="775215267818384016">"Cancelar"</string>
    <string name="lockpattern_tutorial_continue_label" msgid="1329049481210689408">"Siguiente"</string>
    <string name="manage_device_admin" msgid="1044620606203916275">"Apps de administración"</string>
    <string name="number_of_device_admins_none" msgid="152926922020437312">"No hay apps activas"</string>
    <string name="number_of_device_admins" msgid="3402909995362162876">"{count,plural, =1{# app activa}other{# apps activas}}"</string>
    <string name="manage_trust_agents" msgid="6410149930029992356">"Agentes de confianza"</string>
    <string name="disabled_because_no_backup_security" msgid="4998095356607488854">"Para usarlo, debes establecer un bloqueo de pantalla"</string>
    <string name="manage_trust_agents_summary" msgid="6423843123607674286">"Ninguno"</string>
    <string name="manage_trust_agents_summary_on" msgid="3302574418419446146">"{count,plural, =1{1 agente de confianza activo}other{# agentes de confianza activos}}"</string>
    <string name="bluetooth_settings" msgid="2967239493428695171">"Bluetooth"</string>
    <string name="bluetooth_settings_title" msgid="2642029095769509647">"Bluetooth"</string>
    <string name="bluetooth_pairing_request" msgid="7762990650683525640">"¿Vincular con <xliff:g id="DEVICE_NAME">%1$s</xliff:g>?"</string>
    <string name="bluetooth_pairing_key_msg" msgid="1329835708475701761">"Código de vinculación Bluetooth"</string>
    <string name="bluetooth_enter_passkey_msg" msgid="5806420933599368592">"Ingresa el código de sincronización y luego presiona Intro."</string>
    <string name="bluetooth_enable_alphanumeric_pin" msgid="7256286571636950635">"El PIN contiene letras o símbolos."</string>
    <string name="bluetooth_pin_values_hint" msgid="2753202519050044670">"Por lo general, 0000 o 1234"</string>
    <string name="bluetooth_pin_values_hint_16_digits" msgid="5603928271430883558">"Debe contener 16 dígitos"</string>
    <string name="bluetooth_enter_pin_other_device" msgid="6737778699899780717">"Puede que también tengas que escribir este PIN en el otro dispositivo."</string>
    <string name="bluetooth_enter_passkey_other_device" msgid="8270426446247344709">"Puede que también tengas que escribir esta clave de acceso en otro dispositivo."</string>
    <string name="bluetooth_paring_group_msg" msgid="4609515924670823316">"Confirma para vincular con el conjunto coordinado"</string>
    <string name="bluetooth_pairing_shares_phonebook" msgid="4329325125260724843">"Permitir el acceso a tus contactos y al historial de llamadas"</string>
    <string name="bluetooth_error_title" msgid="2284738188253690278"></string>
    <string name="bluetooth_connecting_error_message" msgid="3941893154784152112">"No se pudo establecer conexión con <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="bluetooth_preference_found_media_devices" msgid="830061195998352840">"Dispositivos disponibles"</string>
    <string name="bluetooth_device_context_connect" msgid="4913860372216815855">"Conectar"</string>
    <string name="bluetooth_device_context_disconnect" msgid="4464167389972513232">"Desconectar"</string>
    <string name="bluetooth_device_context_pair_connect" msgid="2406032703622371826">"Vincular y conectar"</string>
    <string name="bluetooth_empty_list_bluetooth_off" msgid="316627049372961941">"Cuando Bluetooth está activado, permite conectarse con dispositivos cercanos que tengan Bluetooth."</string>
    <string name="bluetooth_scanning_on_info_message" msgid="786648535600075223">"Cuando Bluetooth está activado, tu dispositivo puede usarlo para comunicarse con otros dispositivos Bluetooth 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 la configuración de búsqueda de Bluetooth."</string>
    <string name="bluetooth_scan_change" msgid="1744636222637390367">"Cambiar"</string>
    <string name="device_details_title" msgid="1155622417516195481">"Detalles del dispositivo"</string>
    <string name="bluetooth_device_keyboard_settings_preference_title" msgid="3411693160917620519">"Configuración del teclado"</string>
    <string name="bluetooth_device_mac_address" msgid="4873325074786732703">"Dirección Bluetooth del dispositivo: <xliff:g id="ADDRESS">%1$s</xliff:g>"</string>
    <string name="bluetooth_multuple_devices_mac_address" msgid="4974301550897923376">"Dirección Bluetooth del dispositivo:\n<xliff:g id="ADDRESS">%1$s</xliff:g>"</string>
    <string name="bluetooth_unpair_dialog_title" msgid="6943633443716052995">"¿Olvidar este dispositivo?"</string>
    <string name="remove_association_button" msgid="5004208145998061135">"Quitar asociación"</string>
    <string name="bluetooth_companion_app_remove_association_dialog_title" msgid="1344518601377991897">"¿Quieres desconectar la app?"</string>
    <string name="bluetooth_companion_app_body" msgid="8442643629075687761">"La app de <xliff:g id="APP_NAME">%1$s</xliff:g> ya no se conectará con <xliff:g id="DEVICE_NAME">%2$s</xliff:g>"</string>
    <string name="bluetooth_unpair_dialog_forget_confirm_button" msgid="9184489424930549015">"Olvidar este dispositivo"</string>
    <string name="bluetooth_companion_app_remove_association_confirm_button" msgid="76323555527926915">"Desconectar app"</string>
    <string name="bluetooth_max_connected_audio_devices_string" msgid="3114156958598821615">"Máximo de dispositivos de audio Bluetooth conectados"</string>
    <string name="bluetooth_max_connected_audio_devices_dialog_title" msgid="4056811727247312473">"Selecciona una cantidad máxima de dispositivos de audio Bluetooth conectados"</string>
    <string name="nfc_stack_debuglog_title" msgid="2926748386805740609">"Registro de depuración de la pila de NFC"</string>
    <string name="nfc_stack_debuglog_summary" msgid="7333205107551132121">"Aumenta el nivel de acceso a la pila de NFC"</string>
    <string name="nfc_verbose_vendor_log_title" msgid="5554505631122964628">"Registro detallado de depuración del proveedor de NFC"</string>
    <string name="nfc_verbose_vendor_log_summary" msgid="3049128322855928507">"Incluye registros adicionales de proveedores de dispositivos específicos en los informes de errores, los cuales pueden contener información privada."</string>
    <string name="nfc_snoop_log_title" msgid="1576197495976952388">"Registro NFC NCI sin filtrar"</string>
    <string name="nfc_snoop_log_summary" msgid="3988383328800163180">"Captura paquetes detallados de NFC, que podrían contener información privada."</string>
    <string name="nfc_reboot_dialog_title" msgid="2033983438635768169">"¿Quieres reiniciar el dispositivo?"</string>
    <string name="nfc_reboot_dialog_message" msgid="4929353168157966992">"El registro detallado de NFC está destinado únicamente a fines de desarrollo. Se incluyen datos de NFC adicionales en los informes de errores, que podrían contener información privada. Reinicia el dispositivo para cambiar la configuración."</string>
    <string name="nfc_reboot_dialog_confirm" msgid="4769763632008584567">"Reiniciar"</string>
    <string name="wifi_display_settings_title" msgid="6451625615274960175">"Transmitir"</string>
    <string name="keywords_wifi_display_settings" msgid="5753883229564422679">"duplicar"</string>
    <string name="wifi_display_enable_menu_item" msgid="7391841780777318134">"Habilitar pantalla inalámbrica"</string>
    <string name="wifi_display_no_devices_found" msgid="7904877793677102805">"No se encontraron dispositivos cercanos."</string>
    <string name="wifi_display_status_connecting" msgid="530880182560077334">"Conectando"</string>
    <string name="wifi_display_status_connected" msgid="2189925211258519539">"Conectado"</string>
    <string name="wifi_display_status_in_use" msgid="5904009697167947449">"En uso"</string>
    <string name="wifi_display_status_not_available" msgid="8463750208946968594">"No disponible"</string>
    <string name="wifi_display_options_title" msgid="7584326966240865043">"Opciones de pantalla inalámbrica"</string>
    <string name="wifi_display_options_forget" msgid="3140558691112356024">"Borrar"</string>
    <string name="wifi_display_options_done" msgid="7608851767701954020">"Listo"</string>
    <string name="wifi_display_options_name" msgid="8181334945680312228">"Nombre"</string>
    <string name="wifi_band_24ghz" msgid="7322286660245127384">"2.4 GHz"</string>
    <string name="wifi_band_5ghz" msgid="7995204987245404797">"5 GHz"</string>
    <string name="wifi_band_6ghz" msgid="8166833829829455339">"6 GHz"</string>
    <string name="wifi_sign_in_button_text" msgid="8483892122845654850">"Acceder"</string>
    <string name="wifi_venue_website_button_text" msgid="7749360432667175030">"Abrir sitio"</string>
    <string name="wifi_time_remaining" msgid="8503606272869846170">"Tiempo restante: <xliff:g id="REMAINING_TIME">%1$s</xliff:g>"</string>
    <string name="wifi_expiry_time" msgid="5419758551129267624">"Finalizará a las <xliff:g id="EXPIRY_TIME">%1$s</xliff:g>"</string>
    <string name="tx_link_speed" msgid="3071955184703668113">"<xliff:g id="TRANSMIT_LINK_SPEED">%1$d</xliff:g> Mbps"</string>
    <string name="rx_link_speed" msgid="6292229178855567783">"<xliff:g id="RECEIVE_LINK_SPEED">%1$d</xliff:g> Mbps"</string>
    <string name="link_speed" msgid="931786745741016446">"<xliff:g id="LINK_SPEED">%1$d</xliff:g> Mbps"</string>
    <string name="wifi_ask_enable" msgid="6860056048266810769">"<xliff:g id="REQUESTER">%s</xliff:g> quiere activar la conexión Wi-Fi"</string>
    <string name="wifi_ask_disable" msgid="1663208096020309639">"<xliff:g id="REQUESTER">%s</xliff:g> quiere desactivar la conexión Wi-Fi"</string>
    <string name="art_verifier_for_debuggable_title" msgid="1926445785190030479">"Verificar bytecode de apps depurables"</string>
    <string name="art_verifier_for_debuggable_summary" msgid="4802875841862652879">"Permitir que ART verifique el bytecode de apps depurables"</string>
    <string name="show_refresh_rate" msgid="5742688821872354973">"Frecuencia de actualización"</string>
    <string name="show_refresh_rate_summary" msgid="3558118122374609663">"Mostrar frecuencia de actualización actual de pantalla"</string>
    <string name="nfc_quick_toggle_title" msgid="3607620705230351666">"NFC"</string>
    <string name="nfc_secure_settings_title" msgid="4906958426927741485">"Usar NFC solo si el dispositivo está desbloqueado"</string>
    <string name="android_beam_settings_title" msgid="2797963824490671295">"Android Beam"</string>
    <string name="android_beam_on_summary" msgid="6067720758437490896">"Listo para transmitir contenido de aplicaciones por NFC"</string>
    <string name="android_beam_off_summary" msgid="5693961375631325042">"Desactivada"</string>
    <string name="nfc_disabled_summary" msgid="8737797364522502351">"No disponible porque NFC está desactivada"</string>
    <string name="android_beam_explained" msgid="5684416131846701256">"Cuando esta función está activada, puedes transmitir el contenido de las aplicaciones a otro dispositivo con NFC con solo juntar los dispositivos. Por ejemplo, puedes transmitir páginas web, videos de YouTube, contactos y mucho más.\n\nSolo tienes que juntar los dispositivos (normalmente, por la parte posterior) y, a continuación, presionar la pantalla de tu dispositivo. La app determina el contenido que se transmite."</string>
    <string name="wifi_settings" msgid="8313301946393559700">"Wi-Fi"</string>
    <string name="wifi_settings_primary_switch_title" msgid="628360786662947258">"Usar Wi-Fi"</string>
    <string name="wifi_settings_category" msgid="3523464780563778321">"Configuración de Wi-Fi"</string>
    <string name="wifi_select_network" msgid="6692897876718813259">"Seleccionar red Wi-Fi"</string>
    <string name="wifi_starting" msgid="6147022683967506341">"Activando Wi-Fi..."</string>
    <string name="wifi_stopping" msgid="4471699665741299711">"Desactivando Wi-Fi..."</string>
    <string name="wifi_error" msgid="4903954145386086899">"Error"</string>
    <string name="wifi_sap_no_channel_error" msgid="2126487622024749402">"Banda de 5 GHZ no disponible en este país"</string>
    <string name="wifi_in_airplane_mode" msgid="1235412508135267981">"En modo avión"</string>
    <string name="wifi_notify_open_networks" msgid="2610323626246818961">"Notificar si se detectan redes públicas"</string>
    <string name="wifi_notify_open_networks_summary" msgid="191058832201741013">"Notificarme cuando haya una red pública de alta calidad"</string>
    <string name="wifi_wakeup" msgid="3834327315861781611">"Activar Wi-Fi automáticamente"</string>
    <string name="wifi_wakeup_summary" msgid="5778059083790221465">"La conexión Wi-Fi se volverá a activar cerca de las redes de alta calidad guardadas, como tu red doméstica"</string>
    <string name="wifi_wakeup_summary_no_location" msgid="681323616606485096">"No se encuentra disponible porque la ubicación está desactivada. "<annotation id="link">"Actívala"</annotation>"."</string>
    <string name="wifi_install_credentials" msgid="5192903644606839972">"Instalar certificados"</string>
    <string name="wifi_scan_notify_text" msgid="7163137260385995873">"Para mejorar la precisión de la ubicación, las apps y los servicios pueden 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. Puedes cambiar esta opción en la <xliff:g id="LINK_BEGIN_0">LINK_BEGIN</xliff:g>configuración de búsqueda de Wi‑Fi<xliff:g id="LINK_END_1">LINK_END</xliff:g>."</string>
    <string name="wifi_scan_notify_text_scanning_off" msgid="7439201783168213149">"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 de Wi-Fi<xliff:g id="LINK_END_1">LINK_END</xliff:g>"</string>
    <string name="wifi_cellular_data_fallback_title" msgid="2844653839490977040">"Cambiar a datos móviles automáticamente"</string>
    <string name="wifi_cellular_data_fallback_summary" msgid="7039944853033554386">"Si la conexión Wi-Fi no puede acceder a Internet, usa los datos móviles. Es posible que se apliquen cargos por el uso de datos."</string>
    <string name="wifi_add_network" msgid="4178564862173751181">"Agregar red"</string>
    <string name="wifi_configure_settings_preference_title" msgid="2536725796700696566">"Preferencias de Wi-Fi"</string>
    <string name="wifi_configure_settings_preference_summary_wakeup_on" msgid="7822368955551467382">"La conexión Wi-Fi vuelve a activarse automáticamente"</string>
    <string name="wifi_configure_settings_preference_summary_wakeup_off" msgid="5710203586018223864">"La conexión Wi-Fi no vuelve a activarse automáticamente"</string>
    <string name="wifi_menu_p2p" msgid="5234165837732940385">"Wi-Fi directo"</string>
    <string name="wifi_empty_list_wifi_off" msgid="7697422506708419298">"Para ver las redes disponibles, activa el Wi-Fi."</string>
    <string name="wifi_empty_list_wifi_on" msgid="2448010040478321376">"Buscando redes…"</string>
    <string name="wifi_empty_list_user_restricted" msgid="454861411536708709">"No tienes permiso para cambiar la red Wi‑Fi."</string>
    <string name="wifi_settings_scanning_required_title" msgid="1088663325396007484">"¿Deseas activar la búsqueda de Wi‑Fi?"</string>
    <string name="wifi_settings_scanning_required_summary" msgid="4770243653675416569">"Para activar la conexión Wi-Fi automáticamente, primero debes activar la búsqueda de Wi-Fi."</string>
    <string name="wifi_settings_scanning_required_info" msgid="1473411566072565789">"La búsqueda de Wi-Fi permite que las apps y los servicios busquen redes de este tipo en cualquier momento, incluso cuando la conexión Wi-Fi está desactivada. Puedes usar esta función, por ejemplo, para mejorar las funciones y los servicios basados en la ubicación."</string>
    <string name="wifi_settings_scanning_required_turn_on" msgid="1112223196123955447">"Activar"</string>
    <string name="wifi_settings_scanning_required_enabled" msgid="4721729158927146365">"Se activó la búsqueda de Wi‑Fi"</string>
    <string name="wifi_show_advanced" msgid="2969378109942071741">"Opciones avanzadas"</string>
    <string name="wifi_advanced_toggle_description" msgid="7299179796727934885">"Lista desplegable \"Opciones avanzadas\""</string>
    <string name="wifi_advanced_toggle_description_collapsed" msgid="3615140699129928913">"expandir"</string>
    <string name="wifi_ssid" msgid="2713062130735103151">"Nombre de la red"</string>
    <string name="wifi_ssid_hint" msgid="1940577553241083524">"Ingresa el SSID"</string>
    <string name="wifi_security" msgid="9095934643631406913">"Seguridad"</string>
    <string name="wifi_hidden_network" msgid="6466834025375485596">"Red oculta"</string>
    <string name="wifi_hidden_network_warning" msgid="3937433813754746158">"Si el router no emite un ID de red, pero quieres conectarte a la red en el futuro, configúrala para que esté oculta.\n\nEs posible que esta acción implique riesgos de seguridad porque el teléfono emitirá la señal regularmente para buscar la red.\n\nSi configuras la red para que esté oculta, no se modificarán los ajustes del router."</string>
    <string name="wifi_signal" msgid="4442182285304271424">"Potencia de la señal"</string>
    <string name="wifi_status" msgid="5349199188871002778">"Estado"</string>
    <string name="tx_wifi_speed" msgid="2368986629172050673">"Velocidad enlace de transmisión"</string>
    <string name="rx_wifi_speed" msgid="5167966079215111232">"Velocidad enlace de recepción"</string>
    <string name="wifi_speed" msgid="6562147734565434513">"Velocidad del vínculo"</string>
    <string name="wifi_frequency" msgid="3120998420184702834">"Frecuencia"</string>
    <string name="wifi_ip_address" msgid="8903577251845268209">"Dirección IP"</string>
    <string name="passpoint_label" msgid="6513669696739302866">"Se guardó mediante"</string>
    <string name="passpoint_content" msgid="5219226173518418335">"Credenciales de <xliff:g id="NAME">%1$s</xliff:g>"</string>
    <string name="wifi_eap_method" msgid="3776009521349381742">"Método EAP"</string>
    <string name="please_select_phase2" msgid="577633852089847142">"Autenticación de fase 2"</string>
    <string name="wifi_eap_ca_cert" msgid="8033404008276298886">"Certificado de la AC"</string>
    <string name="wifi_eap_min_tls_ver" msgid="174023604103299457">"Versión mínima de TLS"</string>
    <string name="wifi_eap_ocsp" msgid="8713933962516871238">"Estado de certificado en línea"</string>
    <string name="wifi_eap_domain" msgid="8304301470752333203">"Dominio"</string>
    <string name="wifi_eap_user_cert" msgid="3569182430929173220">"Certificado del usuario"</string>
    <string name="wifi_eap_identity" msgid="3629406902174137028">"Identidad"</string>
    <string name="wifi_eap_anonymous" msgid="8630332141751267000">"Identidad anónima"</string>
    <string name="wifi_password" msgid="1458802324849513755">"Contraseña"</string>
    <string name="wifi_show_password" msgid="6865993988238157923">"Mostrar contraseña"</string>
    <string name="wifi_ap_choose_2G" msgid="1436802195991542016">"Banda de 2.4 GHz"</string>
    <string name="wifi_ap_prefer_5G" msgid="2520628479818369902">"Banda preferida: 5.0 GHz"</string>
    <string name="wifi_ip_settings" msgid="6420498748726599133">"Configuración de IP"</string>
    <string name="wifi_privacy_settings" msgid="3283946009000725698">"Privacidad"</string>
    <string name="wifi_subscription" msgid="4432423938285430113">"Suscripción"</string>
    <string name="wifi_subscription_summary" msgid="18802471063384598">"Ver o cambiar la suscripción"</string>
    <string name="wifi_privacy_settings_ephemeral_summary" msgid="8502084692297249372">"Dirección MAC aleatoria"</string>
    <string name="wifi_dpp_add_device_to_network" msgid="6141246783457722976">"Agregar un dispositivo"</string>
    <string name="wifi_dpp_center_qr_code" msgid="5270782275746178104">"Centra el código QR debajo para agregar el dispositivo a \"<xliff:g id="SSID">%1$s</xliff:g>\""</string>
    <string name="wifi_dpp_scan_qr_code" msgid="3543923817779444434">"Escanear código QR"</string>
    <string name="wifi_dpp_scan_qr_code_join_network" msgid="969985020363459133">"Centra el código QR debajo para conectarte a \"<xliff:g id="SSID">%1$s</xliff:g>\""</string>
    <string name="wifi_dpp_scan_qr_code_join_unknown_network" msgid="3180020429793614145">"Escanea un código QR para conectarte a la red Wi-Fi"</string>
    <string name="wifi_dpp_share_wifi" msgid="2431744447544057866">"Compartir Wi‑Fi"</string>
    <string name="wifi_dpp_scan_qr_code_with_another_device" msgid="6967364080214325016">"Escanea este código QR con otro dispositivo para conectarte a \"<xliff:g id="SSID">%1$s</xliff:g>\""</string>
    <string name="wifi_dpp_scan_open_network_qr_code_with_another_device" msgid="5398619697898444311">"Escanea este código QR para conectarte a \"<xliff:g id="SSID">%1$s</xliff:g>\""</string>
    <string name="wifi_dpp_failure_authentication_or_configuration" msgid="847551626830740204">"Vuelve a intentarlo. Si el problema persiste, comunícate con el fabricante del dispositivo"</string>
    <string name="wifi_dpp_failure_not_compatible" msgid="4453775826337805825">"Se produjo un error"</string>
    <string name="wifi_dpp_failure_timeout" msgid="7902971341771145564">"Asegúrate de que el dispositivo se haya enchufado, cargado y encendido"</string>
    <string name="wifi_dpp_failure_generic" msgid="6559442892600448442">"Asegúrate de que el dispositivo se haya enchufado, cargado y encendido. Si el problema persiste, comunícate con el fabricante"</string>
    <string name="wifi_dpp_failure_not_supported" msgid="2908961523550486480">"No se puede agregar \"<xliff:g id="SSID">%1$s</xliff:g>\" a este dispositivo"</string>
    <string name="wifi_dpp_failure_cannot_find_network" msgid="8519567801353014036">"Acerca el dispositivo a tu punto de acceso o router Wi-Fi"</string>
    <string name="wifi_dpp_failure_enrollee_authentication" msgid="7008840843663520852">"Revisa la contraseña y vuelve a intentarlo"</string>
    <string name="wifi_dpp_failure_enrollee_rejected_configuration" msgid="982310033782652478">"Comunícate con el fabricante del dispositivo"</string>
    <string name="wifi_dpp_check_connection_try_again" msgid="6118892932595974823">"Comprueba la conexión y vuelve a intentarlo"</string>
    <string name="wifi_dpp_choose_network" msgid="3987007684129341427">"Elegir una red"</string>
    <string name="wifi_dpp_choose_network_to_connect_device" msgid="4321618376432197593">"Selecciona una red para conectar tu dispositivo"</string>
    <string name="wifi_dpp_add_device_to_wifi" msgid="5170095438763569255">"¿Agregar este dispositivo a \"<xliff:g id="SSID">%1$s</xliff:g>\"?"</string>
    <string name="wifi_dpp_wifi_shared_with_device" msgid="4484366631307204949">"Se compartió la red Wi-Fi con el dispositivo"</string>
    <string name="wifi_dpp_add_another_device" msgid="3307575293580739604">"Agregar otro dispositivo"</string>
    <string name="wifi_dpp_choose_different_network" msgid="8963625819804792157">"Seleccionar otra red"</string>
    <string name="wifi_dpp_could_not_add_device" msgid="6865710911186601933">"No se pudo agregar el dispositivo"</string>
    <string name="wifi_dpp_device_found" msgid="633646744759830603">"Se encontró el dispositivo"</string>
    <string name="wifi_dpp_sharing_wifi_with_this_device" msgid="7250369936882080107">"Compartiendo Wi-Fi con este dispositivo…"</string>
    <string name="wifi_dpp_connecting" msgid="2312769193202897589">"Conectando…"</string>
    <string name="wifi_dpp_share_hotspot" msgid="6186452780604755316">"Compartir hotspot"</string>
    <string name="wifi_dpp_lockscreen_title" msgid="4231438175617953652">"Verifica tu identidad"</string>
    <string name="wifi_dpp_wifi_password" msgid="4992986319806934381">"Contraseña de Wi-Fi: <xliff:g id="PASSWORD">%1$s</xliff:g>"</string>
    <string name="wifi_dpp_hotspot_password" msgid="688464342650820420">"Contraseña del hotspot: <xliff:g id="PASSWORD">%1$s</xliff:g>"</string>
    <string name="wifi_auto_connect_title" msgid="1890342051674657892">"Conectar automáticamente"</string>
    <string name="wifi_auto_connect_summary" msgid="1707702705345670370">"Permitir conexión a esta red al entrar en su rango"</string>
    <string name="wifi_dpp_add_device" msgid="8695656122114721335">"Agregar dispositivo"</string>
    <string name="wifi_dpp_connect_network_using_qr_code" msgid="6975258007798254937">"Usar un código QR para agregar un dispositivo a esta red"</string>
    <string name="wifi_dpp_qr_code_is_not_valid_format" msgid="5190689503019328279">"El código QR no es un formato válido"</string>
    <string name="retry" msgid="7542103800274026915">"Reintentar"</string>
    <string name="wifi_shared" msgid="8850748923537589782">"Compartir con otros usuarios del dispositivo"</string>
    <string name="wifi_unchanged" msgid="8026045290856150191">"(sin cambios)"</string>
    <string name="wifi_unspecified" msgid="4561964943472312208">"Selecciona una opción"</string>
    <string name="wifi_multiple_cert_added" msgid="2151019652853383776">"(Se agregaron varios certificados)"</string>
    <string name="wifi_use_system_certs" msgid="5587866698144996931">"Usar certificados de sistema"</string>
    <string name="wifi_do_not_provide_eap_user_cert" msgid="6336636553673065145">"No proporcionar"</string>
    <string name="wifi_trust_on_first_use" msgid="7488431582505858774">"Confiar desde el primer uso"</string>
    <string name="wifi_ssid_too_long" msgid="5961719058705013875">"El nombre de la red es demasiado largo."</string>
    <string name="wifi_no_domain_warning" msgid="1452133316532366772">"Se debe especificar un dominio."</string>
    <string name="wifi_no_user_cert_warning" msgid="8466376918835248956">"Se requiere un certificado."</string>
    <string name="wifi_scan_always_turnon_message" msgid="2165909441512029921">"Para mejorar la precisión de la ubicación y para otros fines, <xliff:g id="APP_NAME">%1$s</xliff:g> quiere activar la búsqueda de redes, incluso cuando la conexión Wi-Fi esté desactivada.\n\n¿Quieres permitir esto para todas las aplicaciones que deseen buscar redes?"</string>
    <string name="wifi_scan_always_turn_on_message_unknown" msgid="4903345360745717385">"Para mejorar la precisión de la ubicación y para otros fines, una app desconocida quiere activar la búsqueda de redes aunque el Wi‑Fi esté desactivado.\n\n¿Permitir que todas las apps puedan hacerlo?"</string>
    <string name="wifi_scan_always_confirm_allow" msgid="4154200627800959777">"Permitir"</string>
    <string name="wifi_scan_always_confirm_deny" msgid="6997087934558839256">"Denegar"</string>
    <string name="no_internet_access_text" msgid="3611993143350310936">"Esta red no tiene acceso a Internet. ¿Deseas mantener la conexión?"</string>
    <string name="partial_connectivity_text" msgid="8874614799723694554">"Puede que algunas apps y servicios no funcionen debido a la conectividad limitada. ¿Usar igualmente?"</string>
    <string name="no_internet_access_remember" msgid="5113610157731269258">"No volver a preguntar para esta red"</string>
    <string name="lost_internet_access_title" msgid="9032463989950384698">"La red Wi-Fi no está conectada a Internet"</string>
    <string name="lost_internet_access_text" msgid="1535911323549496789">"Puedes cambiar a la red de datos móviles si no hay buena conexión Wi-Fi. Es posible que se apliquen cargos por el uso de datos."</string>
    <string name="lost_internet_access_switch" msgid="7935665847081706202">"Cambiar a datos móviles"</string>
    <string name="lost_internet_access_cancel" msgid="1981171269794585284">"Seguir usando Wi-Fi"</string>
    <string name="lost_internet_access_persist" msgid="6813604557672782197">"No volver a mostrar"</string>
    <string name="wifi_connect" msgid="2481467560349907397">"Conectar"</string>
    <string name="wifi_turned_on_message" msgid="8069855406962662881">"Wi-Fi activado"</string>
    <string name="wifi_connected_to_message" msgid="8976048616505112896">"Conectado a <xliff:g id="NETWORK_NAME">%1$s</xliff:g>"</string>
    <string name="wifi_connecting_to_message" msgid="3153205024060064551">"Estableciendo conexión con <xliff:g id="NETWORK_NAME">%1$s</xliff:g>"</string>
    <string name="wifi_connecting" msgid="7450277833386859724">"Conectando…"</string>
    <string name="wifi_failed_connect_message" msgid="8538000546604347894">"No se pudo establecer conexión con la red."</string>
    <string name="wifi_not_in_range_message" msgid="3885327464037574739">"Red fuera de alcance"</string>
    <string name="wifi_forget" msgid="3485573280364015620">"Olvidar"</string>
    <string name="wifi_modify" msgid="5127926476383659412">"Modificar"</string>
    <string name="wifi_failed_forget_message" msgid="8272732599235525880">"No se pudo borrar la red."</string>
    <string name="wifi_save" msgid="2312643132472226807">"Guardar"</string>
    <string name="wifi_failed_save_message" msgid="1830279872341387120">"No se pudo guardar la red."</string>
    <string name="wifi_cancel" msgid="6698897376888935410">"Cancelar"</string>
    <string name="wifi_forget_dialog_title" msgid="4363829200968563164">"¿Quieres olvidar la red?"</string>
    <string name="wifi_saved_access_points_summary" msgid="6637163320524940353">"{count,plural, =1{1 red}other{# redes}}"</string>
    <string name="wifi_saved_passpoint_access_points_summary" msgid="8939933724918673785">"{count,plural, =1{1 suscripción}other{# suscripciones}}"</string>
    <string name="wifi_saved_all_access_points_summary" msgid="2335870101156113858">"{count,plural, =1{1 red y suscripción}other{# redes y suscripciones}}"</string>
    <string name="wifi_advanced_ssid_title" msgid="1561437650193980185">"SSID"</string>
    <string name="wifi_advanced_device_mac_address_title" msgid="6155800851233164411">"Dirección MAC del dispositivo"</string>
    <string name="wifi_advanced_randomized_mac_address_title" msgid="3930671320234553088">"Dirección MAC aleatoria"</string>
    <string name="wifi_advanced_randomized_mac_address_disconnected_title" msgid="2755843130417523727">"Dirección MAC aleatoria (última utilizada)"</string>
    <string name="wifi_details_title" msgid="222735438574597493">"Detalles de la red"</string>
    <string name="wifi_details_subnet_mask" msgid="1619151769276260512">"Máscara de subred"</string>
    <string name="wifi_type_title" msgid="2174893488722015838">"Tipo"</string>
    <string name="wifi_details_dns" msgid="273231528073312579">"DNS"</string>
    <string name="wifi_details_ipv6_address_header" msgid="1913151339341722443">"Direcciones IPv6"</string>
    <string name="wifi_saved_access_points_label" msgid="5691340724310548151">"Redes guardadas"</string>
    <string name="wifi_subscribed_access_points_tab" msgid="7224061396195667208">"Suscripciones"</string>
    <string name="wifi_saved_other_networks_tab" msgid="7942647415716557293">"Otras redes"</string>
    <string name="wifi_ip_settings_invalid_ip_address" msgid="3622891107865052307">"Escribe una dirección IP válida."</string>
    <string name="wifi_ip_settings_invalid_gateway" msgid="1174931247370931239">"Escribe una dirección de puerta de enlace válida."</string>
    <string name="wifi_ip_settings_invalid_dns" msgid="1757402215999845975">"Escribe una dirección DNS válida."</string>
    <string name="wifi_ip_settings_invalid_network_prefix_length" msgid="5980808986926987299">"Escribe una longitud de prefijo de red entre 0 y 32."</string>
    <string name="wifi_dns1" msgid="6764769531843748514">"DNS 1 (a menos que lo anule un DNS privado)"</string>
    <string name="wifi_dns2" msgid="7273133202625326148">"DNS 2 (a menos que lo anule un DNS privado)"</string>
    <string name="wifi_gateway" msgid="3699227808616416759">"Puerta de enlace"</string>
    <string name="wifi_network_prefix_length" msgid="1003365439352276622">"Longitud de prefijo de red"</string>
    <string name="wifi_p2p_settings_title" msgid="1689918226469221870">"Wi-Fi directo"</string>
    <string name="wifi_p2p_menu_search" msgid="8383306178784876840">"Buscar dispositivos"</string>
    <string name="wifi_p2p_menu_searching" msgid="3428767661028761100">"Buscando…"</string>
    <string name="wifi_p2p_menu_rename" msgid="7059994112737743336">"Cambiar el nombre del dispositivo"</string>
    <string name="wifi_p2p_peer_devices" msgid="5158559154640283546">"Otros dispositivos"</string>
    <string name="wifi_p2p_remembered_groups" msgid="5497007770930525695">"Grupos recordados"</string>
    <string name="wifi_p2p_failed_connect_message" msgid="6767831720507440027">"No se pudo establecer conexión."</string>
    <string name="wifi_p2p_failed_rename_message" msgid="1317434386267376606">"Error al cambiar nombre del dispositivo"</string>
    <string name="wifi_p2p_disconnect_title" msgid="96361896458072463">"¿Deseas desconectarte?"</string>
    <string name="wifi_p2p_disconnect_message" msgid="1208761239498807208">"Si te desconectas, tu conexión con <xliff:g id="PEER_NAME">%1$s</xliff:g> finalizará."</string>
    <string name="wifi_p2p_disconnect_multiple_message" msgid="4490648217799144078">"Si te desconectas, tu conexión con <xliff:g id="PEER_NAME">%1$s</xliff:g> y con otros <xliff:g id="PEER_COUNT">%2$s</xliff:g> dispositivos finalizará."</string>
    <string name="wifi_p2p_cancel_connect_title" msgid="8476985132989357041">"¿Quieres cancelar la invitación?"</string>
    <string name="wifi_p2p_cancel_connect_message" msgid="2409074184473879809">"¿Quieres cancelar la invitación para conectarte con <xliff:g id="PEER_NAME">%1$s</xliff:g>?"</string>
    <string name="wifi_p2p_delete_group_message" msgid="4880242270742385699">"¿Deseas borrar este grupo?"</string>
    <string name="wifi_hotspot_checkbox_text" msgid="1549663436920597006">"Hotspot de Wi-Fi"</string>
    <string name="wifi_hotspot_off_subtext" msgid="2751383134504362078">"No se está compartiendo Internet ni contenido con otros dispositivos"</string>
    <string name="wifi_hotspot_no_password_subtext" msgid="3685689196772398783">"No se configuró una contraseña"</string>
    <string name="wifi_hotspot_name_title" msgid="6633480190014369846">"Nombre del hotspot"</string>
    <string name="wifi_hotspot_password_title" msgid="9096340919454296786">"Contraseña del hotspot"</string>
    <string name="wifi_hotspot_ap_band_title" msgid="560262446129195042">"Banda del PA"</string>
    <string name="wifi_hotspot_auto_off_title" msgid="8855711787485504882">"Desactivar hotspot automáticamente"</string>
    <string name="wifi_hotspot_auto_off_summary" msgid="8283656069997871354">"Cuando no hay dispositivos conectados"</string>
    <string name="wifi_hotspot_maximize_compatibility" msgid="6494125684420024058">"Extender la compatibilidad"</string>
    <string name="wifi_hotspot_maximize_compatibility_single_ap_summary" msgid="383355687431591441">"Ayuda a que otros dispositivos encuentren este hotspot. Disminuye la velocidad de conexión de hotspot."</string>
    <string name="wifi_hotspot_maximize_compatibility_dual_ap_summary" msgid="3579549223159056533">"Ayuda a que otros dispositivos encuentren este hotspot. Incrementa el uso de batería."</string>
    <string name="wifi_hotspot_speed_title" msgid="8629448084180512685">"Velocidad y compatibilidad"</string>
    <string name="wifi_hotspot_speed_summary_2g" msgid="2280013579858833466">"2.4 GHz/Cualquier dispositivo puede conectarse"</string>
    <string name="wifi_hotspot_speed_summary_5g" msgid="8006841294118040080">"5 GHz/La mayoría de los dispositivos pueden conectarse"</string>
    <string name="wifi_hotspot_speed_summary_6g" msgid="5398769134180715191">"6 GHz/Pocos dispositivos pueden conectarse"</string>
    <string name="wifi_hotspot_speed_summary_2g_and_5g" msgid="6471272988396018113">"2.4 y 5 GHz/Cualquier dispositivo puede conectarse"</string>
    <string name="wifi_hotspot_speed_intro" msgid="6973482196363758925">"Elige la frecuencia de tu hotspot. La frecuencia afecta la velocidad de conexión y los tipos de dispositivos que pueden encontrar tu hotspot."</string>
    <string name="wifi_hotspot_speed_category" msgid="5265655850463630286">"Frecuencia preferida"</string>
    <string name="wifi_hotspot_speed_2g" msgid="3400600834257664480">"2.4 GHz"</string>
    <string name="wifi_hotspot_speed_2g_summary" msgid="2737911775799813597">"Velocidades más lentas. Cualquier dispositivo puede conectarse."</string>
    <string name="wifi_hotspot_speed_5g" msgid="4058116867148848395">"5 GHz"</string>
    <string name="wifi_hotspot_speed_5g_summary" msgid="8979160165280825325">"Velocidades rápidas. La mayoría de los dispositivos pueden conectarse."</string>
    <string name="wifi_hotspot_speed_2g_5g" msgid="9192756255938408285">"2.4 y 5 GHz"</string>
    <string name="wifi_hotspot_speed_2g_5g_summary" msgid="2901777498770191018">"Velocidades rápidas. Cualquier dispositivo se puede conectar a este hotspot de doble banda."</string>
    <string name="wifi_hotspot_speed_6g" msgid="3787697484862730500">"6 GHz"</string>
    <string name="wifi_hotspot_speed_6g_summary" msgid="1170553321510689693">"Velocidades más rápidas. La minoría de los dispositivos pueden conectarse."</string>
    <string name="wifi_hotspot_speed_summary_unavailable" msgid="7276080644693388756">"No disponible en tu país o región"</string>
    <string name="wifi_hotspot_speed_footer" msgid="8846939503916795002">"Si tu frecuencia preferida no está disponible, es posible que el hotspot utilice una distinta. Es posible que cambie la configuración de seguridad del hotspot si modificas la frecuencia."</string>
    <string name="wifi_tether_starting" msgid="8879874184033857814">"Activando hotspot…"</string>
    <string name="wifi_tether_stopping" msgid="4416492968019409188">"Desactivando hotspot…"</string>
    <string name="wifi_tether_carrier_unsupport_dialog_title" msgid="3089432578433978073">"Conexión mediante dispositivo móvil no disponible"</string>
    <string name="wifi_tether_carrier_unsupport_dialog_content" msgid="5920421547607921112">"Comunícate con tu operador para obtener más detalles"</string>
    <string name="wifi_tether_enabled_subtext" msgid="5085002421099821056">"<xliff:g id="NETWORK_SSID">%1$s</xliff:g> está activa"</string>
    <string name="wifi_tether_configure_ssid_default" msgid="1709397571393179300">"Android Hotspot"</string>
    <string name="wifi_add_app_single_network_title" msgid="8911612806204065225">"¿Quieres guardar esta red?"</string>
    <string name="wifi_add_app_single_network_saving_summary" msgid="7366337245410388895">"Guardando…"</string>
    <string name="wifi_add_app_single_network_saved_summary" msgid="7135016314713158289">"Guardada"</string>
    <string name="wifi_add_app_network_save_failed_summary" msgid="7223817782309294652">"No se puede guardar. Vuelve a intentarlo."</string>
    <string name="wifi_add_app_networks_title" msgid="4384594865433042851">"¿Quieres guardar estas redes?"</string>
    <string name="wifi_add_app_networks_saving_summary" msgid="577680250954742033">"Guardando <xliff:g id="NUMBER">%d</xliff:g> redes…"</string>
    <string name="wifi_add_app_networks_saved_summary" msgid="1648417628665152905">"Redes guardadas"</string>
    <string name="wifi_calling_settings_title" msgid="264665264535884440">"Llamadas por Wi-Fi"</string>
    <string name="wifi_calling_suggestion_title" msgid="4791435106729906727">"Recibe más llamadas gracias a la red Wi‑Fi"</string>
    <string name="wifi_calling_suggestion_summary" msgid="5413024679599742858">"Activa Llamada con Wi‑Fi para extender la cobertura"</string>
    <string name="wifi_calling_mode_title" msgid="5145896168360825619">"Preferencia de llamada"</string>
    <string name="wifi_calling_mode_dialog_title" msgid="944146521898592440">"Preferencia de llamada"</string>
    <string name="wifi_calling_roaming_mode_title" msgid="7703305991991520773">"Preferencia de la itinerancia"</string>
    <!-- no translation found for wifi_calling_roaming_mode_summary (6061631305384464179) -->
    <skip />
    <string name="wifi_calling_roaming_mode_dialog_title" msgid="5382466713784067077">"Preferencia de la itinerancia"</string>
  <string-array name="wifi_calling_mode_choices_v2">
    <item msgid="6052353275413974742">"Wi-Fi"</item>
    <item msgid="8622872038388687383">"Móvil"</item>
    <item msgid="3027927219952052398">"Solo Wi-Fi"</item>
  </string-array>
  <string-array name="wifi_calling_mode_choices_v2_without_wifi_only">
    <item msgid="588620799769664461">"Wi-Fi"</item>
    <item msgid="7566603075659706590">"Móvil"</item>
  </string-array>
    <string name="wifi_calling_mode_wifi_preferred_summary" msgid="3240387177966098351">"Si no hay ninguna red Wi-Fi disponible, usa una red móvil"</string>
    <string name="wifi_calling_mode_cellular_preferred_summary" msgid="3746914244902314059">"Si la red móvil no está disponible, usa Wi-Fi"</string>
    <string name="wifi_calling_mode_wifi_only_summary" msgid="3155660680014892641">"Llamar mediante Wi-Fi. La llamada finalizará si se pierde la conexión."</string>
    <string name="wifi_calling_off_explanation" msgid="6295526820826322895">"Si está activada la función Llamada por Wi-Fi, el teléfono podrá hacer llamadas mediante redes Wi-Fi o la red de tu proveedor, según la preferencia que hayas elegido y la señal que tenga más intensidad. Antes de activar esta función, verifica el costo y otros detalles con el proveedor.<xliff:g id="ADDITIONAL_TEXT">%1$s</xliff:g>"</string>
    <string name="wifi_calling_off_explanation_2" msgid="3487475808574416183"></string>
    <string name="emergency_address_title" msgid="8102786488994263815">"Dirección de emergencia"</string>
    <string name="emergency_address_summary" msgid="3022628750270626473">"Se usa como tu ubicación cuando haces una llamada de emergencia mediante Wi-Fi"</string>
    <string name="private_dns_help_message" msgid="851221502063782306"><annotation id="url">"Más información"</annotation>" sobre las funciones de DNS privado"</string>
    <string name="private_dns_mode_on" msgid="8878679071975375696">"Activado"</string>
    <string name="wifi_calling_settings_activation_instructions" msgid="3936067355828542266">"Habilitar Llamada por Wi-Fi"</string>
    <string name="wifi_calling_turn_on" msgid="7687886259199428823">"Activar Llamada por Wi-Fi"</string>
    <string name="wifi_disconnected_from" msgid="5249576734324159708">"Desconectado de <xliff:g id="SSID">%1$s</xliff:g>"</string>
    <string name="sound_settings" msgid="7622986039384531304">"Sonido y vibración"</string>
    <string name="account_settings" msgid="255404935489127404">"Cuentas"</string>
    <string name="accessibility_category_work" msgid="5133894487353964944">"Cuentas de perfil de trabajo (<xliff:g id="MANAGED_BY">%s</xliff:g>)"</string>
    <string name="accessibility_category_personal" msgid="2228088849803484780">"Cuentas de perfil personal"</string>
    <string name="accessibility_work_account_title" msgid="7622485151217943839">"Cuenta de trabajo (<xliff:g id="MANAGED_BY">%s</xliff:g>)"</string>
    <string name="accessibility_personal_account_title" msgid="8535265881509557013">"Cuenta personal (<xliff:g id="MANAGED_BY">%s</xliff:g>)"</string>
    <string name="search_settings" msgid="7573686516434589771">"Buscar"</string>
    <string name="display_settings" msgid="7197750639709493852">"Pantalla"</string>
    <string name="accelerometer_title" msgid="7745991950833748909">"Girar automáticamente la pantalla"</string>
    <string name="auto_rotate_option_off" msgid="2788096269396290731">"Desactivada"</string>
    <string name="auto_rotate_option_on" msgid="5776678230808498171">"Activada"</string>
    <string name="auto_rotate_option_face_based" msgid="3438645484087953174">"Activa - En función del rostro"</string>
    <string name="auto_rotate_switch_face_based" msgid="9116123744601564320">"Detección de rostro"</string>
    <string name="auto_rotate_link_a11y" msgid="5146188567212233286">"Más información sobre girar automáticamente"</string>
    <string name="auto_rotate_summary_a11y" msgid="1505094100328581685">"Cuando muevas el tel. entre el modo vertical y el horizontal"</string>
    <string name="screen_resolution_title" msgid="2690518693139811486">"Resolución de pantalla"</string>
    <string name="screen_resolution_option_high" msgid="2617496842852992853">"Alta resolución"</string>
    <string name="screen_resolution_option_full" msgid="2694003735219114186">"Máxima resolución"</string>
    <string name="screen_resolution_footer" msgid="6772341522952795647">"La máxima resolución consume más batería. Es posible que, si cambias la resolución, algunas apps se reinicien."</string>
    <string name="screen_resolution_selected_a11y" msgid="6158451180032224977">"Seleccionada"</string>
    <string name="color_mode_title" msgid="8666690832113906028">"Colores"</string>
    <string name="color_mode_option_natural" msgid="6192875655101283303">"Naturales"</string>
    <string name="color_mode_option_boosted" msgid="4698797857766774289">"Mejorados"</string>
    <string name="color_mode_option_saturated" msgid="3413853820158447300">"Saturados"</string>
    <string name="color_mode_option_automatic" msgid="2281217686509980870">"Automáticos"</string>
    <string name="brightness" msgid="6216871641021779698">"Nivel de brillo"</string>
    <string name="auto_brightness_title" msgid="4239324728760986697">"Brillo automático"</string>
    <string name="auto_brightness_description" msgid="6807117118142381193">"El brillo de la pantalla se ajustará automáticamente según el entorno y las actividades que hagas. Puedes mover el control deslizante para que la función de brillo automático reconozca tus preferencias."</string>
    <string name="auto_brightness_summary_on" msgid="2748088951224387004">"Activado"</string>
    <string name="auto_brightness_summary_off" msgid="8077066192887677956">"Inhabilitado"</string>
    <string name="display_white_balance_title" msgid="2624544323029364713">"Mostrar balance de blancos"</string>
    <string name="display_white_balance_summary" msgid="7625456704950209050"></string>
    <string name="peak_refresh_rate_title" msgid="1878771412897140903">"Smooth Display"</string>
    <string name="peak_refresh_rate_summary" msgid="3627278682437562787">"Aumenta automáticamente la frecuencia de actualización de 60 Hz a <xliff:g id="ID_1">%1$s</xliff:g> Hz para cierto contenido. Incrementa el uso de batería."</string>
    <string name="force_high_refresh_rate_toggle" msgid="3325789621928312050">"Forzar frecuencia de actualización máxima"</string>
    <string name="force_high_refresh_rate_desc" msgid="7794566420873814875">"La máxima frecuencia de actualización mejora la respuesta táctil y la calidad de las animaciones. Incrementa el uso de batería."</string>
    <string name="adaptive_sleep_title" msgid="2987961991423539233">"Atención a la pantalla"</string>
    <string name="adaptive_sleep_title_no_permission" msgid="1719759921214237016">"Se requiere acceso a la cámara"</string>
    <string name="adaptive_sleep_summary_no_permission" msgid="5822591289468803691">"Se requiere acceso a la cámara para la atención a la pantalla. Presiona para administrar los permisos de los Servicios de personalización del dispositivo"</string>
    <string name="adaptive_sleep_manage_permission_button" msgid="1404510197847664846">"Administrar permisos"</string>
    <string name="adaptive_sleep_description" msgid="1835321775327187860">"Impide que se apague la pantalla si estás mirándola"</string>
    <string name="adaptive_sleep_privacy" msgid="7664570136417980556">"La función de atención a la pantalla usa la cámara frontal para detectar si hay alguien mirando la pantalla. Funciona en el dispositivo, y las imágenes no se almacenan ni se envían a Google."</string>
    <string name="adaptive_sleep_contextual_slice_title" msgid="7467588613212629758">"Activar la atención a la pantalla"</string>
    <string name="adaptive_sleep_contextual_slice_summary" msgid="2993867044745446094">"Mantener la pantalla encendida cuando la miras"</string>
    <string name="auto_rotate_camera_lock_title" msgid="5369003176695105872">"La cámara está bloqueada"</string>
    <string name="auto_rotate_camera_lock_summary" msgid="5699491516271544672">"La cámara debe estar desbloqueada para la detección de rostro"</string>
    <string name="adaptive_sleep_camera_lock_summary" msgid="8417541183603618098">"La cámara debe estar desbloqueada para la atención a la pantalla"</string>
    <string name="auto_rotate_summary_no_permission" msgid="1025061139746254554">"Se requiere acceso a la cámara para la detección de rostro. Presiona para administrar los permisos de los Servicios de personalización del dispositivo"</string>
    <string name="auto_rotate_manage_permission_button" msgid="2591146085906382385">"Administrar permisos"</string>
    <string name="night_display_title" msgid="8532432776487216581">"Luz nocturna"</string>
    <string name="night_display_text" msgid="4789324042428095383">"La Luz nocturna le da un tono ámbar a la pantalla. No solo te permitirá ver o leer con luz tenue, sino que también podría ayudarte a conciliar el sueño más rápido."</string>
    <string name="night_display_auto_mode_title" msgid="5869128421470824381">"Programa"</string>
    <string name="night_display_auto_mode_never" msgid="2721729920187175239">"Ninguno"</string>
    <string name="night_display_auto_mode_custom" msgid="3938791496034086916">"Activar a una hora personalizada"</string>
    <string name="night_display_auto_mode_twilight" msgid="4291855156158833997">"Activar del atardecer al amanecer"</string>
    <string name="night_display_start_time_title" msgid="2611541851596977786">"Hora de inicio"</string>
    <string name="night_display_end_time_title" msgid="5243112480391192111">"Hora de finalización"</string>
    <string name="night_display_temperature_title" msgid="857248782470764263">"Intensidad"</string>
    <string name="night_display_summary_off_auto_mode_never" msgid="7406899634169354142">"Nunca se activará automáticamente"</string>
    <string name="night_display_summary_off_auto_mode_custom" msgid="6667008039080687931">"Se activará automáticamente a las <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="night_display_summary_off_auto_mode_twilight" msgid="3669132200611324994">"Se activará automáticamente al atardecer"</string>
    <string name="night_display_summary_on_auto_mode_never" msgid="832333009202889350">"Nunca se desactivará automáticamente"</string>
    <string name="night_display_summary_on_auto_mode_custom" msgid="2096677025343425755">"Se desactivará automáticamente a las <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="night_display_summary_on_auto_mode_twilight" msgid="8070517472000680361">"Se desactivará automáticamente al amanecer"</string>
    <string name="night_display_not_currently_on" msgid="6600205753103093827">"Luz nocturna no activada ahora"</string>
    <string name="twilight_mode_location_off_dialog_message" msgid="4559150893687124801">"Se requiere la ubicación del dispositivo para determinar los horarios del amanecer y el atardecer."</string>
    <string name="twilight_mode_launch_location" msgid="7799112373591153956">"Configuración de la ubicación"</string>
    <string name="dark_ui_activation_on_manual" msgid="1541006734577325234">"Activar ahora"</string>
    <string name="dark_ui_activation_off_manual" msgid="2395333709291250065">"Desactivar ahora"</string>
    <string name="dark_ui_activation_on_auto" msgid="4824339634784765049">"Activar hasta el amanecer"</string>
    <string name="dark_ui_activation_off_auto" msgid="9136717444658505208">"Desactivar hasta el atardecer"</string>
    <string name="dark_ui_title" msgid="3373976268671557416">"Modo oscuro"</string>
    <string name="dark_ui_auto_mode_title" msgid="9027528859262295099">"Programar"</string>
    <string name="dark_ui_auto_mode_never" msgid="3980412582267787662">"Nunca"</string>
    <string name="dark_ui_auto_mode_auto" msgid="6658909029498623375">"Activar del atardecer al amanecer"</string>
    <string name="dark_ui_auto_mode_custom" msgid="3800138185265182170">"Activar a una hora personalizada"</string>
    <string name="dark_ui_auto_mode_custom_bedtime" msgid="8465023741946439266">"Se activa a la hora de dormir"</string>
    <string name="dark_ui_status_title" msgid="3505119141437774329">"Estado"</string>
    <string name="dark_ui_summary_off_auto_mode_never" msgid="5828281549475697398">"Nunca se activará automáticamente"</string>
    <string name="dark_ui_summary_off_auto_mode_auto" msgid="6766831395970887213">"Se activará automáticamente al atardecer"</string>
    <string name="dark_ui_summary_off_auto_mode_custom" msgid="1345906088326708376">"Se activará automáticamente a la(s) <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="dark_ui_summary_off_auto_mode_custom_bedtime" msgid="7759826673214624622">"Se activará automáticamente a la hora de dormir"</string>
    <string name="dark_ui_summary_on_auto_mode_never" msgid="2468597062391435521">"Nunca se desactivará automáticamente"</string>
    <string name="dark_ui_summary_on_auto_mode_auto" msgid="5553376115092648636">"Se desactivará automáticamente al amanecer"</string>
    <string name="dark_ui_summary_on_auto_mode_custom" msgid="2526935680241734784">"Se desactivará automáticamente a la(s) <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="dark_ui_summary_on_auto_mode_custom_bedtime" msgid="1976993025762551246">"Se desactivará automáticamente después de la hora de dormir"</string>
    <string name="dark_ui_text" msgid="4392646155331126666">"El Tema oscuro usa un fondo negro para conservar la batería durante más tiempo en algunas pantallas y se programa a fin de esperar a que se apague la pantalla para activarse."</string>
    <string name="dark_ui_bedtime_footer_summary" msgid="5576501833145170581">"El tema oscuro se activa o desactiva a partir del horario para dormir"</string>
    <string name="dark_ui_bedtime_footer_action" msgid="1493095487994054339">"Configuración del Modo hora de dormir"</string>
    <string name="screen_timeout" msgid="7709947617767439410">"Tiempo de espera de la pantalla"</string>
    <string name="screen_timeout_summary" msgid="5558778019594643427">"Después de <xliff:g id="TIMEOUT_DESCRIPTION">%1$s</xliff:g> de inactividad"</string>
    <string name="screen_timeout_summary_not_set" msgid="5107680774964178875">"No establecido"</string>
    <string name="wallpaper_settings_title" msgid="5635129851136006383">"Fondo de pantalla"</string>
    <string name="style_and_wallpaper_settings_title" msgid="2232042809407308946">"Fondo de pantalla y estilo"</string>
    <string name="wallpaper_dashboard_summary" msgid="2324472863981057118">"Pantalla principal, pantalla de bloqueo"</string>
    <string name="wallpaper_suggestion_title" msgid="3812842717939877330">"Cambiar fondo de pantalla"</string>
    <string name="wallpaper_suggestion_summary" msgid="9077061486716754784">"Personalizar tu pantalla"</string>
    <string name="wallpaper_settings_fragment_title" msgid="8445963841717633149">"Elegir fondo de pantalla"</string>
    <string name="style_suggestion_title" msgid="1213747484782364775">"Personaliza tu teléfono"</string>
    <string name="style_suggestion_summary" msgid="4271131877800968159">"Prueba diferentes estilos, fondos de pantalla y mucho más"</string>
    <string name="screensaver_settings_title" msgid="3588535639672365395">"Protector de pantalla"</string>
    <string name="keywords_screensaver" msgid="7249337959432229172">"protector de pantalla"</string>
    <string name="screensaver_settings_when_to_dream_bedtime" msgid="3279310576803094771">"No disponible cuando se activa modo hora de dormir"</string>
    <string name="screensaver_settings_toggle_title" msgid="6194634226897244374">"Usar protector de pantalla"</string>
    <string name="screensaver_settings_summary_either_long" msgid="371949139331896271">"Mientras se carga o está conectado"</string>
    <string name="screensaver_settings_summary_dock_and_charging" msgid="8485905100159376156">"Mientras está conectado y cargando"</string>
    <string name="screensaver_settings_summary_sleep" msgid="6555922932643037432">"Mientras se carga"</string>
    <string name="screensaver_settings_summary_dock" msgid="6997766385189369733">"Cuando está conectado"</string>
    <string name="screensaver_settings_summary_never" msgid="4988141393040918450">"Nunca"</string>
    <string name="screensaver_settings_summary_on" msgid="4210827304351483645">"Activado / <xliff:g id="SCREEN_SAVER">%1$s</xliff:g>"</string>
    <string name="screensaver_settings_summary_off" msgid="8720357504939106923">"Apagado"</string>
    <string name="screensaver_settings_when_to_dream" msgid="8145025742428940520">"Cuándo comenzar"</string>
    <string name="lift_to_wake_title" msgid="8994218158737714046">"Levantar el dispositivo para activarlo"</string>
    <string name="ambient_display_screen_title" msgid="8615947016991429325">"Pantalla Ambiente"</string>
    <string name="ambient_display_category_triggers" msgid="1216640141609270011">"Cuándo mostrar"</string>
    <string name="doze_title" msgid="1523090408230862316">"Activar pantalla para notif."</string>
    <string name="doze_summary" msgid="8252867381522942804">"Cuando la pantalla está apagada, se activa si hay notificaciones nuevas"</string>
    <string name="doze_always_on_title" msgid="7326245192352868477">"Mostrar información y hora"</string>
    <string name="doze_always_on_summary" msgid="509097829739647852">"El uso de la batería será mayor"</string>
    <string name="force_bold_text" msgid="4620929631102086716">"Texto en negrita"</string>
    <string name="title_font_size" msgid="570613010306330622">"Tamaño de fuente"</string>
    <string name="short_summary_font_size" msgid="8444689613442419978">"Aumenta o reduce el texto"</string>
    <string name="sim_lock_settings" msgid="7331982427303002613">"Configuración de bloqueo de SIM"</string>
    <string name="sim_lock_settings_category" msgid="6475255139493877786">"Bloqueo de SIM"</string>
    <string name="sim_pin_toggle" msgid="6814489621760857328">"Bloquear SIM"</string>
    <string name="sim_pin_change" msgid="5978881209990507379">"Cambiar el PIN de la tarjeta SIM"</string>
    <string name="sim_enter_pin" msgid="8235202785516053253">"PIN de tarjeta SIM"</string>
    <string name="sim_enable_sim_lock" msgid="6486354334679225748">"Bloquear SIM"</string>
    <string name="sim_disable_sim_lock" msgid="6939439812841857306">"Desbloquear SIM"</string>
    <string name="sim_enter_old" msgid="6882545610939674813">"PIN de tarjeta SIM anterior"</string>
    <string name="sim_enter_new" msgid="9010947802784561582">"Nuevo PIN de tarjeta SIM"</string>
    <string name="sim_reenter_new" msgid="6131418271490374263">"Volver a ingresar el nuevo PIN"</string>
    <string name="sim_change_pin" msgid="1104103818545005448">"PIN de tarjeta SIM"</string>
    <string name="sim_invalid_pin_hint" msgid="3376397829969578877">"Escribe un PIN de entre 4 y 8 números"</string>
    <string name="sim_pins_dont_match" msgid="1540348773896609260">"Los PIN no coinciden"</string>
    <string name="sim_change_succeeded" msgid="3516905528149069739">"El PIN de la tarjeta SIM se ha cambiado correctamente"</string>
    <string name="sim_pin_disable_failed" msgid="8719890393181032837">"No se puede inhabilitar el PIN."</string>
    <string name="sim_pin_enable_failed" msgid="5156513975085380284">"No se puede habilitar el PIN."</string>
    <string name="sim_enter_ok" msgid="3401715290135787531">"Aceptar"</string>
    <string name="sim_enter_cancel" msgid="2001859323724961490">"Cancelar"</string>
    <string name="sim_change_data_title" msgid="4663239438584588847">"¿Usar a <xliff:g id="CARRIER">%1$s</xliff:g> para datos móviles?"</string>
    <string name="sim_change_data_message" msgid="3046178883369645132">"Estás usando a <xliff:g id="CARRIER2_0">%2$s</xliff:g> para datos móviles. Si cambias a <xliff:g id="CARRIER1">%1$s</xliff:g>, ya no se usará a <xliff:g id="CARRIER2_1">%2$s</xliff:g> para los datos móviles."</string>
    <string name="sim_change_data_ok" msgid="4922114750417276560">"Usar <xliff:g id="CARRIER">%1$s</xliff:g>"</string>
    <string name="sim_preferred_title" msgid="8850185380445309835">"¿Quieres actualizar la SIM preferida?"</string>
    <string name="sim_preferred_message" msgid="6004009449266648351">"<xliff:g id="NEW_SIM">%1$s</xliff:g> es la única SIM en tu dispositivo. ¿Deseas usar esta tarjeta para datos móviles, llamadas y mensajes SMS?"</string>
    <string name="enable_auto_data_switch_dialog_title" msgid="3563043560556718994">"¿Mejorar la cobertura de datos?"</string>
    <string name="enable_auto_data_switch_dialog_message" msgid="5777287241521946883">"Permite que el dispositivo cambie automáticamente a <xliff:g id="BACKUP_CARRIER">%1$s</xliff:g> para datos móviles cuando tenga mejor disponibilidad."</string>
    <string name="auto_data_switch_dialog_managed_profile_warning" msgid="6839438290079866605">\n\n"Las llamadas, los mensajes y el tráfico de red pueden ser visibles para tu organización."</string>
    <string name="wrong_pin_code_pukked" msgid="3414172752791445033">"El código PIN de la tarjeta SIM es incorrecto. Debes comunicarte con el proveedor para desbloquear el dispositivo."</string>
    <string name="wrong_pin_code" msgid="8124222991071607958">"{count,plural, =1{El código PIN de la tarjeta SIM es incorrecto. Te queda # intento antes de que debas comunicarte con tu operador para desbloquear el dispositivo.}other{El código PIN de la tarjeta SIM es incorrecto. Te quedan # intentos.}}"</string>
    <string name="wrong_pin_code_one" msgid="6924852214263071441">"El código PIN de la tarjeta SIM es incorrecto. Te queda 1 intento antes de que debas comunicarte con tu proveedor para desbloquear el dispositivo."</string>
    <string name="pin_failed" msgid="3726505565797352255">"Error al desbloquear la tarjeta SIM con el PIN"</string>
    <string name="system_update_settings_list_item_title" msgid="3398346836439366350">"Actualiz. del sistema"</string>
    <string name="system_update_settings_list_item_summary" msgid="6703752298349642101"></string>
    <string name="firmware_version" msgid="1606901586501447275">"Versión de Android"</string>
    <string name="security_patch" msgid="4071756145347865382">"Actualización de seguridad de Android"</string>
    <string name="model_info" msgid="8997566254717810904">"Modelo"</string>
    <string name="hardware_revision" msgid="3454709180861965025">"Versión de hardware"</string>
    <string name="fcc_equipment_id" msgid="6596668314025646129">"ID del equipo"</string>
    <string name="baseband_version" msgid="2600182227599835857">"Versión de banda base"</string>
    <string name="kernel_version" msgid="3513538109381366881">"Versión de kernel"</string>
    <string name="build_number" msgid="9009733242117579826">"Número de compilación"</string>
    <string name="module_version" msgid="1787518340082046658">"Actualización del sistema de Google Play"</string>
    <string name="device_info_not_available" msgid="4804474466616712326">"No disponible"</string>
    <string name="storage_settings" msgid="7472188817781592677">"Almacenamiento"</string>
    <string name="storage_settings_for_app" msgid="229425418984637483">"Almacenamiento y caché"</string>
    <string name="storage_settings_title" msgid="486118156723194815">"Configuración de almacenamiento"</string>
    <string name="status_eid" msgid="7532406028683438634">"EID"</string>
    <string name="eid_multi_sim" msgid="9087924808336397804">"EID (ranura SIM <xliff:g id="EID_SLOT_ID">%1$d</xliff:g>)"</string>
    <string name="imei_multi_sim" msgid="9001570420423929507">"IMEI (ranura de SIM <xliff:g id="IMEI_SLOT_ID">%1$d</xliff:g>)"</string>
    <string name="imei_multi_sim_primary" msgid="7914653040843734282">"IMEI (ranura de SIM <xliff:g id="IMEI_SLOT_ID_PRIMARY">%1$d</xliff:g>) (principal)"</string>
    <string name="view_saved_network" msgid="1232387673095080910">"Elige una red guardada para verla"</string>
    <string name="status_min_number" msgid="4492899165438225714">"MIN"</string>
    <string name="status_msid_number" msgid="3871958248824595774">"MSID"</string>
    <string name="status_prl_version" msgid="9002131357502714281">"Versión de PRL"</string>
    <string name="meid_multi_sim" msgid="1460689549266621286">"MEID (ranura de SIM <xliff:g id="MEID_SLOT_ID">%1$d</xliff:g>)"</string>
    <string name="meid_multi_sim_primary" msgid="8921262417580407201">"MEID (ranura de SIM <xliff:g id="MEID_SLOT_ID_PRIMARY">%1$d</xliff:g>) (principal)"</string>
    <string name="scanning_status_text_on" msgid="3846571210578042940">"Activado"</string>
    <string name="scanning_status_text_off" msgid="4002352668313705132">"Desactivado"</string>
    <string name="status_meid_number" msgid="6040380838489162650">"MEID"</string>
    <string name="status_icc_id" msgid="7995690631650006970">"ICCID"</string>
    <string name="status_data_network_type" msgid="3689772955330665876">"Tipo de red de datos móviles"</string>
    <string name="status_voice_network_type" msgid="8700356693062562884">"Tipo de red de voz móvil"</string>
    <string name="status_latest_area_info" msgid="8288488664620741734">"Información del operador"</string>
    <string name="status_data_state" msgid="525196229491743487">"Estado de red móvil"</string>
    <string name="status_esim_id" msgid="5158916796362809133">"EID"</string>
    <string name="status_service_state" msgid="1693424422121058791">"Estado del servicio"</string>
    <string name="status_signal_strength" msgid="7644525712554444359">"Potencia de la señal"</string>
    <string name="status_roaming" msgid="1253597174715663778">"Roaming"</string>
    <string name="status_operator" msgid="4335640583552058491">"Red"</string>
    <string name="status_wifi_mac_address" msgid="4447611754614388914">"Dirección MAC de Wi-Fi"</string>
    <string name="status_device_wifi_mac_address" msgid="1896121694334176494">"Dirección MAC de Wi-Fi del dispositivo"</string>
    <string name="status_bt_address" msgid="6919660304578476547">"Dirección de Bluetooth"</string>
    <string name="status_serial_number" msgid="9060064164331466789">"Número de serie"</string>
    <string name="status_up_time" msgid="1274778533719495438">"Tiempo de actividad"</string>
    <string name="memory_calculating_size" msgid="3898240439798661242">"Calculando…"</string>
    <string name="storage_menu_rename" msgid="8549835371429159336">"Cambiar nombre"</string>
    <string name="storage_menu_mount" msgid="4760531872302820569">"Activar"</string>
    <string name="storage_menu_unmount" msgid="8171552487742912282">"Expulsar"</string>
    <string name="storage_menu_format" msgid="8903698999905354146">"Formatear tarjeta SD como almacenamiento portátil"</string>
    <string name="storage_menu_format_button" msgid="7623565190643699626">"Formatear tarjeta"</string>
    <string name="storage_menu_format_public" msgid="5567214442727034630">"Formatear como almac. portátil"</string>
    <string name="storage_menu_format_option" msgid="4886059624052908432">"Formatear"</string>
    <string name="storage_menu_migrate" msgid="2196088149560070193">"Migrar los datos"</string>
    <string name="storage_menu_forget" msgid="5154017890033638936">"Olvidar"</string>
    <string name="storage_menu_set_up" msgid="4401074025612064744">"Configurar"</string>
    <string name="storage_menu_free" msgid="616100170298501673">"Liberar espacio"</string>
    <string name="storage_menu_manage" msgid="7465522758801346408">"Administrar el almacenamiento"</string>
    <string name="storage_free_up_space_title" msgid="281047807372131975">"Liberar espacio"</string>
    <string name="storage_free_up_space_summary" msgid="6650027929735481350">"Ve a la app de Files para administrar el almacenamiento y liberar espacio"</string>
    <string name="storage_other_users" msgid="7017206190449510992">"Otros usuarios"</string>
    <string name="storage_size_large" msgid="1155308277890194878">"<xliff:g id="NUMBER">^1</xliff:g>"<small><small>" <xliff:g id="UNIT">^2</xliff:g>"</small></small>""</string>
    <string name="storage_mount_success" msgid="393972242641313135">"Se activó <xliff:g id="NAME">%1$s</xliff:g>."</string>
    <string name="storage_mount_failure" msgid="3667915814876418011">"No se pudo activar <xliff:g id="NAME">%1$s</xliff:g>."</string>
    <string name="storage_unmount_success" msgid="6406298575402936148">"<xliff:g id="NAME">%1$s</xliff:g> se expulsó de forma segura."</string>
    <string name="storage_unmount_failure" msgid="3796912279003790607">"<xliff:g id="NAME">%1$s</xliff:g> no se pudo expulsar de forma segura."</string>
    <string name="storage_rename_title" msgid="5911285992205282312">"Renombrar almacenamiento"</string>
    <string name="storage_dialog_unmountable" msgid="1761107904296941687">"El dispositivo de almacenamiento <xliff:g id="NAME_0">^1</xliff:g> está dañado. \n\nPara usar <xliff:g id="NAME_1">^1</xliff:g>, primero debes completar la configuración."</string>
    <string name="storage_internal_format_details" msgid="2399034372813686846">"Puedes formatear esta tarjeta SD para almacenar fotos, videos, música y mucho más, y acceder al contenido en otros dispositivos. \n\n"<b>"Se borrarán todos los datos almacenados en esta tarjeta SD."</b>" \n\n"<b>"Antes de formatear"</b>" \n\n"<b>"Haz una copia de seguridad de las fotos y el contenido multimedia"</b>" \nMueve tus archivos de contenido multimedia a un almacenamiento alternativo de este dispositivo o transfiérelos a una computadora usando un cable USB. \n\n"<b>"Crea una copia de seguridad de las apps"</b>" \nTodas las apps que tengas almacenadas en esta <xliff:g id="NAME">^1</xliff:g> se desinstalarán y se borrarán todos sus datos. Para conservarlas, muévelas a un almacenamiento alternativo de este dispositivo."</string>
    <string name="storage_internal_unmount_details" msgid="487689543322907311"><b>"Al expulsar este dispositivo interno <xliff:g id="NAME_0">^1</xliff:g>, las aplicaciones allí guardadas dejarán de funcionar, y los archivos multimedia almacenados no estarán disponibles hasta que vuelvas a insertarlo."</b>" \n\nEl medio de almacenamiento <xliff:g id="NAME_1">^1</xliff:g> está formateado para funcionar solo en este dispositivo; no funcionará en otro."</string>
    <string name="storage_internal_forget_details" msgid="5606507270046186691">"Para utilizar las aplicaciones, las fotos o los datos que contiene el dispositivo <xliff:g id="NAME">^1</xliff:g>, debes volver a insertarlo. \n\nDe manera alternativa, si el dispositivo no está disponible, puedes elegir borrar este almacenamiento.\n\nSi decides hacerlo, se perderán todos los datos del dispositivo de forma permanente.\n\nPodrás volver a instalar las aplicaciones en otro momento, pero se perderán los datos almacenados en este dispositivo."</string>
    <string name="storage_internal_forget_confirm_title" msgid="379238668153099015">"¿Deseas borrar <xliff:g id="NAME">^1</xliff:g>?"</string>
    <string name="storage_internal_forget_confirm" msgid="5752634604952674123">"Se perderán de forma permanente todos los datos, las fotos y las aplicaciones almacenados en <xliff:g id="NAME">^1</xliff:g>."</string>
    <string name="storage_detail_dialog_system" msgid="7461009051858709479">"El sistema incluye archivos que se usan para ejecutar la versión <xliff:g id="VERSION">%s</xliff:g> de Android."</string>
    <string name="storage_wizard_guest" msgid="5813419895687733649">"No puedes formatear tarjeta SD en Modo de Invitado"</string>
    <string name="storage_wizard_format_progress_title" msgid="9170393018855949774">"Formateando dispositivo (<xliff:g id="NAME">^1</xliff:g>)…"</string>
    <string name="storage_wizard_format_progress_body" msgid="1044024044955390417">"No extraigas <xliff:g id="NAME">^1</xliff:g> durante el proceso de formateo."</string>
    <string name="storage_wizard_ready_title" msgid="3631022511474086605">"Formateo de <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_move_confirm_title" msgid="6812469630804101590">"Transferir la aplicación <xliff:g id="APP">^1</xliff:g>"</string>
    <string name="storage_wizard_move_confirm_body" msgid="1713022828842263574">"Transferir la aplicación <xliff:g id="APP">^1</xliff:g> y los datos relacionados al dispositivo <xliff:g id="NAME_0">^2</xliff:g> solo demorará un momento. Hasta que no se complete la transferencia, no podrás usar la aplicación. \n\nNo extraigas el dispositivo <xliff:g id="NAME_1">^2</xliff:g> durante el proceso."</string>
    <string name="storage_wizard_move_unlock" msgid="14651384927767749">"Para transferir datos, debes desbloquear al usuario <xliff:g id="APP">^1</xliff:g>."</string>
    <string name="storage_wizard_move_progress_title" msgid="3912406225614672391">"Transfiriendo la aplicación <xliff:g id="APP">^1</xliff:g>…"</string>
    <string name="storage_wizard_move_progress_body" msgid="2396714553394935094">"Durante el proceso, no extraigas el dispositivo <xliff:g id="NAME">^1</xliff:g>. \n\nLa aplicación <xliff:g id="APP">^2</xliff:g> estará disponible en este dispositivo cuando se complete el proceso."</string>
    <string name="storage_wizard_init_v2_title" msgid="2538630338392381113">"¿Cómo usarás <xliff:g id="NAME">^1</xliff:g>?"</string>
    <string name="storage_wizard_init_v2_or" msgid="5558706089661158026">"O bien"</string>
    <string name="storage_wizard_init_v2_external_title" msgid="2786416384217054112">"Formatear tarjeta SD como almacenamiento portátil"</string>
    <string name="storage_wizard_init_v2_external_summary" msgid="2002761631147966185">"Guarda fotos, videos, música y mucho más, y accede al contenido en otros dispositivos. &lt;a href=https://support.google.com/android/answer/12153449&gt;Más información para configurar una tarjeta SD&lt;/a&gt;."</string>
    <string name="storage_wizard_init_v2_external_action" msgid="6140058734875839081">"Formatear"</string>
    <string name="storage_wizard_init_v2_later" msgid="5366815913892609285">"Configurar más tarde"</string>
    <string name="storage_wizard_format_confirm_v2_title" msgid="6294104100437326067">"¿Quieres formatear <xliff:g id="NAME">^1</xliff:g>?"</string>
    <string name="storage_wizard_format_confirm_v2_body" msgid="635958708974709506">"Debes formatear <xliff:g id="NAME_0">^1</xliff:g> para poder almacenar apps, archivos y contenido multimedia. \n\nEl formateo borrará todo el contenido existente en <xliff:g id="NAME_1">^2</xliff:g>. Para no perderlo, crea una copia de seguridad en otro dispositivo (como <xliff:g id="NAME_2">^3</xliff:g>)."</string>
    <string name="storage_wizard_format_confirm_v2_body_external" msgid="5810296966099830035">"Debe formatearse ste dispositivo (<xliff:g id="NAME_0">^1</xliff:g>) para almacenar fotos, videos, música y mucho más. \n\nCuando lo formatees, se borrará todo el contenido existente en <xliff:g id="NAME_1">^2</xliff:g>. Para no perder el contenido, crea una copia de seguridad en otro dispositivo (<xliff:g id="NAME_2">^3</xliff:g> u otros)."</string>
    <string name="storage_wizard_format_confirm_v2_action" msgid="5718254101386377126">"Formatear <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_migrate_v2_title" msgid="3471564531564756698">"¿Transferir el contenido a <xliff:g id="NAME">^1</xliff:g>?"</string>
    <string name="storage_wizard_migrate_v2_checklist" msgid="2618258869444553060">"Durante la transferencia:"</string>
    <string name="storage_wizard_migrate_v2_checklist_media" msgid="5867134681730723744">"No extraigas <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_migrate_v2_checklist_apps" msgid="1882077445750580783">"Algunas apps no funcionarán"</string>
    <string name="storage_wizard_migrate_v2_now" msgid="3341460117088026966">"Transferir contenido"</string>
    <string name="storage_wizard_migrate_v2_later" msgid="6067756122853315642">"Transferir contenido más tarde"</string>
    <string name="storage_wizard_migrate_progress_v2_title" msgid="8791318509516968103">"Transfiriendo contenido…"</string>
    <string name="storage_wizard_slow_v2_title" msgid="3760766921170980221">"<xliff:g id="NAME">^1</xliff:g> tiene un funcionamiento lento"</string>
    <string name="storage_wizard_slow_v2_body" msgid="7604252106419016929">"Todavía puedes usar <xliff:g id="NAME_0">^1</xliff:g>, pero su funcionamiento podría ser lento. \n\nLas apps almacenadas en <xliff:g id="NAME_1">^2</xliff:g> podrían no funcionar correctamente y las transferencias de contenido podrían demorar mucho tiempo. \n\nIntenta usar un <xliff:g id="NAME_2">^3</xliff:g> más rápido o usa <xliff:g id="NAME_3">^4</xliff:g> como almacenamiento portátil."</string>
    <string name="storage_wizard_slow_v2_start_over" msgid="1806852287668077536">"Volver a empezar"</string>
    <string name="storage_wizard_slow_v2_continue" msgid="7469713755893007901">"Continuar"</string>
    <string name="storage_wizard_ready_v2_external_body" msgid="7688457485389886923">"Para comenzar, puedes usar tu <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_ready_v2_internal_body" msgid="3520269956641115883">"Para comenzar, puedes usar tu <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_ready_v2_internal_moved_body" msgid="1163588718127651062">"Para comenzar, puedes usar tu <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="battery_status_title" msgid="4661768220545945771">"Estado de batería"</string>
    <string name="battery_level_title" msgid="1371765298786083448">"Nivel de la batería"</string>
    <string name="communal_settings_title" msgid="2845678473945902115">"Comunal"</string>
    <string name="communal_settings_summary" msgid="4923914136953940317">"Configuraciones compartidas"</string>
    <string name="apn_settings" msgid="4295467389400441299">"APN"</string>
    <string name="apn_edit" msgid="2003683641840248741">"Editar punto de acceso"</string>
    <string name="apn_not_set" msgid="8246646433109750293">"Sin establecer"</string>
    <string name="apn_not_set_for_mvno" msgid="1141490067313964640">"Sin definir"</string>
    <string name="apn_name" msgid="6677695784108157953">"Nombre"</string>
    <string name="apn_apn" msgid="5812828833797458602">"APN"</string>
    <string name="apn_http_proxy" msgid="1052464912365838007">"Proxy"</string>
    <string name="apn_http_port" msgid="9138610639873966046">"Puerto"</string>
    <string name="apn_user" msgid="5831763936428279228">"Nombre de usuario"</string>
    <string name="apn_password" msgid="7435086635953953029">"Contraseña"</string>
    <string name="apn_server" msgid="6997704279138388384">"Servidor"</string>
    <string name="apn_mmsc" msgid="4985570919581927224">"MMSC"</string>
    <string name="apn_mms_proxy" msgid="6592247653258283592">"Proxy de MMS"</string>
    <string name="apn_mms_port" msgid="6500563737462966663">"Puerto MMS"</string>
    <string name="apn_mcc" msgid="4971414138516074809">"MCC"</string>
    <string name="apn_mnc" msgid="1926382406843447854">"MNC"</string>
    <string name="apn_auth_type" msgid="4234397513494356932">"Tipo de autenticación"</string>
    <string name="apn_type" msgid="1835573305077788773">"Tipo de APN"</string>
    <string name="apn_protocol" msgid="181529867160380010">"Protocolo APN"</string>
    <string name="apn_roaming_protocol" msgid="1645131094105362513">"Protocolo de APN en itinerancia"</string>
    <string name="carrier_enabled" msgid="664074151573150130">"Activar/Desactivar el APN"</string>
    <string name="carrier_enabled_summaryOn" msgid="5212067975273903381">"APN activado"</string>
    <string name="carrier_enabled_summaryOff" msgid="8541959867953738521">"APN inhabilitado"</string>
    <string name="bearer" msgid="3231443241639159358">"Portador"</string>
    <string name="mvno_type" msgid="4734654257494971247">"Tipo de OMV"</string>
    <string name="mvno_match_data" msgid="5213193073684321156">"Valor de OMV"</string>
    <string name="menu_delete" msgid="9199740901584348273">"Eliminar APN"</string>
    <string name="menu_new" msgid="6571230342655509006">"APN nuevo"</string>
    <string name="menu_save" msgid="6611465355127483100">"Guardar"</string>
    <string name="menu_cancel" msgid="1197826697950745335">"Cancelar"</string>
    <string name="error_title" msgid="7158648377702417716"></string>
    <string name="error_name_empty" msgid="1258275899283079142">"El campo Nombre no puede estar vacío."</string>
    <string name="error_apn_empty" msgid="7657491065443746915">"El APN no puede estar vacío."</string>
    <string name="error_mcc_not3" msgid="883659545640179094">"El campo de MCC debe contener 3 dígitos."</string>
    <string name="error_mnc_not23" msgid="7642478711158474918">"El campo MNC debe contener 2 ó 3 dígitos."</string>
    <string name="error_adding_apn_type" msgid="1324263534991467943">"El proveedor no permite que se agreguen APN del tipo %s."</string>
    <string name="restore_default_apn" msgid="6596048535642130689">"Restaurando la configuración APN predeterminada"</string>
    <string name="menu_restore" msgid="4310539620115151551">"Restablecer valores predeterminados"</string>
    <string name="restore_default_apn_completed" msgid="5167505087078340256">"Se restableció la configuración predeterminada de APN."</string>
    <string name="reset_dashboard_title" msgid="7423200250697886918">"Restablecimiento"</string>
    <string name="reset_mobile_network_settings_title" msgid="5616713931258506842">"Restablecer configuración de red móvil"</string>
    <string name="reset_mobile_network_settings_desc" msgid="7292636387692165727">"Se restablecerá toda la configuración de red móvil"</string>
    <string name="reset_mobile_network_settings_confirm_title" msgid="7510965634669511241">"¿Restab. congif. de red móvil?"</string>
    <string name="reset_bluetooth_wifi_title" msgid="4113071322344697317">"Restablecer Bluetooth y Wi‑Fi"</string>
    <string name="reset_bluetooth_wifi_desc" msgid="4030295669083059711">"Esta acción restablecerá la configuración de Bluetooth y de Wi-Fi. No podrás deshacer esta acción."</string>
    <string name="reset_bluetooth_wifi_button_text" msgid="3974098137045963639">"Restablecer"</string>
    <string name="reset_bluetooth_wifi_complete_toast" msgid="5893439291030574365">"Se restablecieron el Bluetooth y el Wi-Fi"</string>
    <string name="erase_euicc_data_button" msgid="728078969563311737">"Borrar"</string>
    <string name="reset_esim_title" msgid="4194570573425902754">"Borrar eSIMs"</string>
    <string name="reset_esim_desc" msgid="3662444090563399131">"Esta acción no cancelará ningún plan de servicio móvil. Para descargar tarjetas SIM de reemplazo, comunícate con tu proveedor."</string>
    <string name="reset_network_button_text" msgid="2281476496459610071">"Restablecer configuración"</string>
    <string name="reset_network_final_desc" msgid="5304365082065278425">"¿Quieres restablecer toda la configuración de red? No podrás deshacer esta acción."</string>
    <string name="reset_network_final_desc_esim" msgid="1129251284212847939">"¿Quieres restablecer toda la configuración de red y borrar las eSIMs? No podrás deshacer esta acción."</string>
    <string name="reset_network_final_button_text" msgid="2433867118414000462">"Restablecer configuración"</string>
    <string name="reset_network_confirm_title" msgid="913014422184481270">"¿Restablecer?"</string>
    <string name="network_reset_not_available" msgid="1966334631394607829">"El restablecimiento de la red no está disponible para este usuario."</string>
    <string name="reset_network_complete_toast" msgid="1367872474130621115">"Se restableció la configuración de red."</string>
    <string name="reset_esim_error_title" msgid="4670073610967959597">"No se pueden borrar las tarjetas SIM"</string>
    <string name="reset_esim_error_msg" msgid="7279607120606365250">"No es posible borrar las eSIMs porque se produjo un error.\n\nReinicia el dispositivo y vuelve a intentarlo."</string>
    <string name="main_clear_title" msgid="277664302144837723">"Borrar todos los datos (restablecer la configuración de fábrica)"</string>
    <string name="main_clear_short_title" msgid="4752094765533020696">"Borrar todo (restablecer configuración de fábrica)"</string>
    <string name="main_clear_desc_also_erases_external" msgid="3687911419628956693"><li>"Música"</li>\n<li>"Fotos"</li>\n<li>"Otros datos del usuario"</li></string>
    <string name="main_clear_desc_also_erases_esim" msgid="4553469876411831729"><li>"eSIM"</li></string>
    <string name="main_clear_desc_no_cancel_mobile_plan" msgid="369883568059127035">\n\n"No se cancelará tu plan de servicio móvil."</string>
    <string name="main_clear_final_desc" msgid="5800877928569039580">"Se borrarán las apps que hayas descargado y tu información personal. No podrás deshacer esta acción."</string>
    <string name="main_clear_final_desc_esim" msgid="440406836793824969">"Se borrará toda tu información personal, incluidas las apps y las tarjetas SIM descargadas. No podrás deshacer esta acción."</string>
    <string name="main_clear_confirm_title" msgid="6577071819657853713">"¿Quieres borrar todos los datos?"</string>
    <string name="main_clear_not_available" msgid="3433795327146684827">"El restablecimiento de la configuración de fábrica no está disponible para este usuario"</string>
    <string name="main_clear_progress_title" msgid="7239741132015617719">"Borrando"</string>
    <string name="main_clear_progress_text" msgid="4636695115176327972">"Espera…"</string>
    <string name="call_settings_title" msgid="2531072044177194164">"Configuración"</string>
    <string name="call_settings_summary" msgid="8244293779053318053">"Establecer correo de voz, desvío de llamadas, llamada en espera, identificador de llamadas"</string>
    <string name="tether_settings_title_usb" msgid="5926474044238409099">"Conexión a red por USB"</string>
    <string name="tether_settings_title_wifi" msgid="4327056146425282159">"Hotspot portátil"</string>
    <string name="tether_settings_title_bluetooth" msgid="8878813702520141084">"Conexión Bluetooth"</string>
    <string name="tether_settings_title_usb_bluetooth" msgid="4437274151658505496">"Compartir conexión"</string>
    <string name="tether_settings_title_all" msgid="6807525590937697228">"Hotspot y conexión mediante dispositivos móviles"</string>
    <string name="tether_settings_summary_hotspot_on_tether_on" msgid="6110241048260139633">"Hotspot activado, conexión mediante dispositivo móvil"</string>
    <string name="tether_settings_summary_hotspot_on_tether_off" msgid="5057598961245943644">"Hotspot activado"</string>
    <string name="tether_settings_summary_hotspot_off_tether_on" msgid="7181518138494995888">"Conexión mediante dispositivo móvil"</string>
    <string name="tether_settings_disabled_on_data_saver" msgid="9054069463426952689">"No podrán establecerse conexiones a través del dispositivo portátil ni hotspots portátiles cuando se active el modo Ahorro de datos."</string>
    <string name="tether_settings_summary_hotspot_only" msgid="8529008147731140279">"Solo hotspot"</string>
    <string name="tether_settings_summary_usb_tethering_only" msgid="6351624505239356221">"Solo USB"</string>
    <string name="tether_settings_summary_bluetooth_tethering_only" msgid="1451008625343274930">"Solo Bluetooth"</string>
    <string name="tether_settings_summary_ethernet_tethering_only" msgid="3582266687537419309">"Solo Ethernet"</string>
    <string name="tether_settings_summary_hotspot_and_usb" msgid="5999349643653265016">"Hotspot y USB"</string>
    <string name="tether_settings_summary_hotspot_and_bluetooth" msgid="810514646401708557">"Hotspot y Bluetooth"</string>
    <string name="tether_settings_summary_hotspot_and_ethernet" msgid="5489192670354277152">"Hotspot y Ethernet"</string>
    <string name="tether_settings_summary_usb_and_bluetooth" msgid="1355680331767261967">"USB y Bluetooth"</string>
    <string name="tether_settings_summary_usb_and_ethernet" msgid="2195017679820919905">"USB y Ethernet"</string>
    <string name="tether_settings_summary_bluetooth_and_ethernet" msgid="1015253926959211012">"Bluetooth y Ethernet"</string>
    <string name="tether_settings_summary_hotspot_and_usb_and_bluetooth" msgid="2949043525073791732">"Hotspot, USB y Bluetooth"</string>
    <string name="tether_settings_summary_hotspot_and_usb_and_ethernet" msgid="5178946567323581144">"Hotspot, USB y Ethernet"</string>
    <string name="tether_settings_summary_hotspot_and_bluetooth_and_ethernet" msgid="4104425838594994441">"Hotspot, Bluetooth y Ethernet"</string>
    <string name="tether_settings_summary_usb_and_bluetooth_and_ethernet" msgid="5880591133984166550">"USB, Bluetooth y Ethernet"</string>
    <string name="tether_settings_summary_all" msgid="7565193614882005775">"Hotspot, USB, Bluetooth y Ethernet"</string>
    <string name="tether_settings_summary_off" msgid="2526164899130351968">"No se comparte Internet con otros dispositivos"</string>
    <string name="tether_preference_summary_off" msgid="6266799346319794630">"Desactivado"</string>
    <string name="tethering_interface_options" msgid="7575535888135143650">"Conexión mediante dispositivo móvil"</string>
    <string name="disable_wifi_hotspot_title" msgid="2167985468585290478">"No usar hotspot de Wi‑Fi"</string>
    <string name="disable_wifi_hotspot_when_usb_on" msgid="220439059794714583">"Solo compartir la conexión a Internet mediante USB"</string>
    <string name="disable_wifi_hotspot_when_bluetooth_on" msgid="4711723299880116345">"Solo compartir la conexión a Internet mediante Bluetooth"</string>
    <string name="disable_wifi_hotspot_when_ethernet_on" msgid="4123242400542103599">"Solo compartir mediante Ethernet"</string>
    <string name="disable_wifi_hotspot_when_usb_and_bluetooth_on" msgid="5258774769658150180">"Solo compartir la conexión a Internet mediante USB y Bluetooth"</string>
    <string name="disable_wifi_hotspot_when_usb_and_ethernet_on" msgid="7126313562907225612">"Solo compartir la conexión a Internet mediante USB y Ethernet"</string>
    <string name="disable_wifi_hotspot_when_bluetooth_and_ethernet_on" msgid="2943464651349235967">"Solo compartir la conexión a Internet mediante Bluetooth y Ethernet"</string>
    <string name="disable_wifi_hotspot_when_usb_and_bluetooth_and_ethernet_on" msgid="3934609816834760008">"Solo compartir la conexión a Internet mediante USB, Bluetooth y Ethernet"</string>
    <string name="usb_title" msgid="1157283449840612901">"USB"</string>
    <string name="usb_tethering_button_text" msgid="7364633823180913777">"Conexión a red por USB"</string>
    <string name="bluetooth_tether_checkbox_text" msgid="6108398414967813545">"Conexión Bluetooth"</string>
    <string name="ethernet_tether_checkbox_text" msgid="959743110824197356">"Conexión a Ethernet"</string>
    <string name="tethering_footer_info" msgid="6782375845587483281">"Usa la función de hotspot y conexión mediante dispositivo portátil para brindar acceso a Internet a otros dispositivos mediante tu conexión de datos móviles. Las apps también pueden crear un hotspot para compartir contenido con dispositivos cercanos."</string>
    <string name="tethering_footer_info_sta_ap_concurrency" msgid="2079039077487477676">"Usa un hotspot y una conexión mediante dispositivo móvil para brindar acceso a Internet a otros dispositivos a través de una conexión Wi-Fi o de datos móviles. Las apps también pueden crear un hotspot para compartir contenido con dispositivos cercanos."</string>
    <string name="tethering_help_button_text" msgid="2823655011510912001">"Ayuda"</string>
    <string name="network_settings_title" msgid="4663717899931613176">"Red móvil"</string>
    <string name="manage_mobile_plan_title" msgid="5616930513733409064">"Plan móvil"</string>
    <string name="sms_application_title" msgid="4791107002724108809">"SMS"</string>
    <string name="sms_change_default_dialog_title" msgid="2343439998715457307">"¿Quieres cambiar la aplicación de SMS?"</string>
    <string name="sms_change_default_dialog_text" msgid="8777606240342982531">"¿Quieres usar <xliff:g id="NEW_APP">%1$s</xliff:g> en lugar de <xliff:g id="CURRENT_APP">%2$s</xliff:g> como la aplicación de SMS?"</string>
    <string name="sms_change_default_no_previous_dialog_text" msgid="6215622785087181275">"¿Quieres usar <xliff:g id="NEW_APP">%s</xliff:g> como la aplicación de SMS?"</string>
    <string name="network_scorer_change_active_dialog_title" msgid="7005220310238618141">"¿Cambiar de asistente de Wi-Fi?"</string>
    <string name="network_scorer_change_active_dialog_text" msgid="7006057749370850706">"¿Deseas usar <xliff:g id="NEW_APP">%1$s</xliff:g> en lugar de <xliff:g id="CURRENT_APP">%2$s</xliff:g> para administrar tus conexiones de red?"</string>
    <string name="network_scorer_change_active_no_previous_dialog_text" msgid="680685773455072321">"¿Deseas usar <xliff:g id="NEW_APP">%s</xliff:g> para administrar tus conexiones de red?"</string>
    <string name="mobile_unknown_sim_operator" msgid="6650422533065760963">"Operador SIM desconocido"</string>
    <string name="mobile_no_provisioning_url" msgid="609462719893503773">"<xliff:g id="OPERATOR">%1$s</xliff:g> no tiene ningún sitio web de aprovisionamiento"</string>
    <string name="mobile_insert_sim_card" msgid="3639245241283948038">"Inserta la tarjeta SIM y reinicia."</string>
    <string name="mobile_connect_to_internet" msgid="8162654404357069060">"Conéctate a Internet."</string>
    <string name="location_category_recent_location_requests" msgid="2205900488782832082">"Solicitudes de ubicaciones recientes"</string>
    <string name="managed_profile_location_switch_title" msgid="1265007506385460066">"Ubicación de perfil de trabajo"</string>
    <string name="location_app_level_permissions" msgid="907206607664629759">"Permisos de ubicación de app"</string>
    <string name="location_app_permission_summary_location_off" msgid="2711822936853500335">"La ubicación está desactivada"</string>
    <string name="location_app_permission_summary_location_on" msgid="7552095451731948984">"{count,plural, =1{# de {total} apps tiene acceso a la ubicación}other{# de {total} apps tienen acceso a la ubicación}}"</string>
    <string name="location_category_recent_location_access" msgid="2558063524482178146">"Acceso reciente"</string>
    <string name="location_recent_location_access_see_all" msgid="4203102419355323325">"Ver todo"</string>
    <string name="location_recent_location_access_view_details" msgid="5803264082558504544">"Ver detalles"</string>
    <string name="location_no_recent_apps" msgid="6814206631456177033">"Ninguna aplicación solicitó la ubicación recientemente."</string>
    <string name="location_no_recent_accesses" msgid="6031735777805464247">"Ninguna app accedió recientemente a tu ubicación"</string>
    <string name="location_high_battery_use" msgid="4277318891200626524">"Uso de batería alto"</string>
    <string name="location_low_battery_use" msgid="5218950289737996431">"Uso de batería bajo"</string>
    <string name="location_scanning_wifi_always_scanning_title" msgid="5004781272733434794">"Búsqueda de Wi‑Fi"</string>
    <string name="location_scanning_wifi_always_scanning_description" msgid="6236055656376931306">"Permite que las apps y los servicios busquen redes Wi-Fi en cualquier momento, aunque la conexión Wi-Fi esté desactivada. Esta función puede usarse, por ejemplo, para mejorar las funciones y los servicios basados en la ubicación."</string>
    <string name="location_scanning_bluetooth_always_scanning_title" msgid="1809309545730215891">"Búsqueda de dispositivos Bluetooth"</string>
    <string name="location_scanning_bluetooth_always_scanning_description" msgid="5362988856388462841">"Permite que las apps y los servicios busquen dispositivos cercanos en cualquier momento, aunque la conexión Bluetooth esté desactivada. Esta función puede usarse, por ejemplo, para mejorar las funciones y los servicios basados en la ubicación."</string>
    <string name="location_services_preference_title" msgid="604317859531782159">"Servicios de ubicación"</string>
    <string name="location_services_screen_title" msgid="5640002489976602476">"Servicios de ubicación"</string>
    <string name="location_time_zone_detection_toggle_title" msgid="6478751613645015287">"Usar ubicación"</string>
    <string name="location_time_zone_detection_status_title" msgid="8903495354385600423">"No se puede establecer la zona horaria automát."</string>
    <string name="location_time_zone_detection_status_summary_degraded_by_settings" msgid="6198939835335841106"></string>
    <string name="location_time_zone_detection_status_summary_blocked_by_settings" msgid="5276280770344278768">"La ubicación o los Servicios de ubicación están desactivados"</string>
    <string name="location_time_zone_detection_status_summary_blocked_by_environment" msgid="2279833212923765802"></string>
    <string name="location_time_zone_detection_status_summary_temporarily_unavailable" msgid="6586801403644278967"></string>
    <string name="location_time_zone_detection_location_is_off_dialog_title" msgid="231698690198001146">"Se necesita la ubicación del dispositivo"</string>
    <string name="location_time_zone_detection_location_is_off_dialog_message" msgid="5846316326139169523">"Para configurar la zona horaria con tu ubicación, activa la ubicación y, luego, actualiza la configuración de zona horaria"</string>
    <string name="location_time_zone_detection_location_is_off_dialog_ok_button" msgid="2685647335717750297">"Configuración de la ubicación"</string>
    <string name="location_time_zone_provider_fix_dialog_ok_button" msgid="9026666001835079126">"Corregir"</string>
    <string name="location_time_zone_detection_location_is_off_dialog_cancel_button" msgid="3968729678789071154">"Cancelar"</string>
    <string name="location_time_zone_detection_auto_is_off" msgid="6264253990141650280">"La zona horaria automática está desactivada"</string>
    <string name="location_time_zone_detection_not_applicable" msgid="6757964612836952714">"Se inhabilitó la detección de la zona horaria de la ubicación"</string>
    <string name="location_time_zone_detection_not_supported" msgid="3251181656388306501">"La detección de la zona horaria de la ubicación no es compatible"</string>
    <string name="location_time_zone_detection_not_allowed" msgid="8264525161514617051">"No se permiten los cambios de detección de la zona horaria de la ubicación"</string>
    <string name="location_time_zone_detection_auto_is_on" msgid="8797434659844659323">"Se puede usar la ubicación para configurar la zona horaria"</string>
    <string name="about_settings_summary" msgid="4831942939227432513">"Ver información legal, estado, versión de software del tablet"</string>
    <string name="legal_information" msgid="7509900979811934843">"Información legal"</string>
    <string name="manual" msgid="3651593989906084868">"Manual"</string>
    <string name="regulatory_labels" msgid="5960251403367154270">"Etiquetas reglamentarias"</string>
    <string name="safety_and_regulatory_info" msgid="8285048080439298528">"Manual sobre reglamentación y seguridad"</string>
    <string name="copyright_title" msgid="83245306827757857">"Derechos de autor"</string>
    <string name="license_title" msgid="8745742085916617540">"Licencia"</string>
    <string name="module_license_title" msgid="8705484239826702828">"Licencias de actualización del sistema de Play"</string>
    <string name="terms_title" msgid="2071742973672326073">"Términos y condiciones"</string>
    <string name="webview_license_title" msgid="5832692241345780517">"Licencia de WebView del sistema"</string>
    <string name="wallpaper_attributions" msgid="4323659759250650736">"Créditos de fondo de pantalla"</string>
    <string name="wallpaper_attributions_values" msgid="987277439026021925">"Proveedores de imágenes satelitales:\n©2014 CNES / Astrium, DigitalGlobe, Bluesky"</string>
    <string name="settings_manual_activity_title" msgid="1682978148920788484">"Manual"</string>
    <string name="settings_manual_activity_unavailable" msgid="2514549851682321576">"Se produjo un error al cargar el manual."</string>
    <string name="settings_license_activity_title" msgid="7832071619364734914">"Licencias de terceros"</string>
    <string name="settings_license_activity_unavailable" msgid="9014803774391134570">"Hay un problema para cargar las licencias."</string>
    <string name="settings_license_activity_loading" msgid="1653151990366578827">"Cargando…"</string>
    <string name="settings_safetylegal_activity_loading" msgid="1757860124583063395">"Cargando…"</string>
    <string name="lockpassword_choose_your_password_header" msgid="2407205113298094824">"Establece una contraseña"</string>
    <string name="lockpassword_choose_your_profile_password_header" msgid="7038997227611893312">"Establecer una contraseña de trabajo"</string>
    <string name="lockpassword_choose_your_pin_header" msgid="7754265746504679473">"Establecer un PIN"</string>
    <string name="lockpassword_choose_your_profile_pin_header" msgid="4581749963670819048">"Establecer un PIN de trabajo"</string>
    <string name="lockpassword_choose_your_pattern_header" msgid="5674909390779586252">"Establecer un patrón"</string>
    <string name="lockpassword_choose_your_pattern_description" msgid="6808109256008481046">"Para mayor seguridad, establece un patrón para desbloquear el dispositivo."</string>
    <string name="lockpassword_choose_your_profile_pattern_header" msgid="3101811498330756641">"Establecer un patrón de trabajo"</string>
    <string name="lockpassword_choose_your_password_header_for_fingerprint" msgid="3167261267229254090">"Configura la contraseña de respaldo"</string>
    <string name="lockpassword_choose_your_pattern_header_for_fingerprint" msgid="4707788269512303400">"Para usar tu huella, configura un patrón"</string>
    <string name="lockpassword_choose_your_pin_message" msgid="7230665212172041837">"Por motivos de seguridad, establece un PIN"</string>
    <string name="lockpassword_choose_your_pin_header_for_fingerprint" msgid="2783879743691792556">"Configura el PIN para usar la huella"</string>
    <string name="lockpassword_confirm_your_password_header" msgid="6132312814563023990">"Vuelve a ingresar tu contraseña"</string>
    <string name="lockpassword_reenter_your_profile_password_header" msgid="3812040127714827685">"Vuelve a ingresar contraseña de trabajo"</string>
    <string name="lockpassword_confirm_your_work_password_header" msgid="4647071231702288305">"Ingresa tu contraseña de trabajo"</string>
    <string name="lockpassword_confirm_your_pattern_header" msgid="4037701363240138651">"Confirma el patrón"</string>
    <string name="lockpassword_confirm_your_work_pattern_header" msgid="2668883108969165844">"Ingresa tu patrón de trabajo"</string>
    <string name="lockpassword_confirm_your_pin_header" msgid="2241722970567131308">"Vuelve a ingresar el PIN"</string>
    <string name="lockpassword_reenter_your_profile_pin_header" msgid="2890233614560435538">"Vuelve a ingresar el PIN de trabajo"</string>
    <string name="lockpassword_confirm_your_work_pin_header" msgid="4229765521391960255">"Ingresa tu PIN de trabajo"</string>
    <string name="lockpassword_confirm_passwords_dont_match" msgid="2100071354970605232">"Las contraseñas no coinciden"</string>
    <string name="lockpassword_confirm_pins_dont_match" msgid="1103699575489401030">"Los PIN no coinciden"</string>
    <string name="lockpassword_draw_your_pattern_again_header" msgid="1045638030120803622">"Dibuja el patrón una vez más"</string>
    <string name="lockpassword_choose_lock_generic_header" msgid="5669348379247148696">"Desbloquear la selección"</string>
    <string name="lockpassword_password_set_toast" msgid="6615759749393973795">"Se ha configurado la contraseña."</string>
    <string name="lockpassword_pin_set_toast" msgid="5415783847198570890">"Se ha configurado el PIN."</string>
    <string name="lockpassword_pattern_set_toast" msgid="3090582314362416762">"Se ha configurado el patrón."</string>
    <string name="lockpassword_choose_your_password_header_for_face" msgid="622276003801157839">"Desbloqueo facial requiere contraseña"</string>
    <string name="lockpassword_choose_your_pattern_header_for_face" msgid="7333603579958317102">"Desbloqueo facial requiere un patrón"</string>
    <string name="lockpassword_choose_your_pin_header_for_face" msgid="704061826984851309">"Desbloqueo facial requiere un PIN"</string>
    <string name="lockpassword_choose_your_password_header_for_biometrics" msgid="2053366309272487015">"Establece una contraseña para usar rostro o huella dactilar"</string>
    <string name="lockpassword_choose_your_pattern_header_for_biometrics" msgid="4038476475293734905">"Establece un patrón para usar rostro o huella dactilar"</string>
    <string name="lockpassword_choose_your_pin_header_for_biometrics" msgid="9086039918921009380">"Establece un PIN para usar rostro o huella dactilar"</string>
    <string name="lockpassword_forgot_password" msgid="5730587692489737223">"¿Olvidaste la contraseña?"</string>
    <string name="lockpassword_forgot_pattern" msgid="1196116549051927516">"¿Olvidaste el patrón?"</string>
    <string name="lockpassword_forgot_pin" msgid="7164232234705747672">"¿Olvidaste el PIN?"</string>
    <string name="lockpassword_confirm_your_pattern_generic" msgid="7692794426682501482">"Para continuar, usa el patrón del dispositivo"</string>
    <string name="lockpassword_confirm_your_pin_generic" msgid="9206928587904701094">"Para continuar, ingresa el PIN del dispositivo"</string>
    <string name="lockpassword_confirm_your_password_generic" msgid="2616127423884477152">"Para continuar, ingresa la contraseña del dispositivo"</string>
    <string name="lockpassword_confirm_your_pattern_generic_profile" msgid="9110305410672321714">"Usa tu patrón de trabajo para continuar"</string>
    <string name="lockpassword_confirm_your_pin_generic_profile" msgid="6524208128570235127">"Para continuar, ingresa tu PIN de trabajo"</string>
    <string name="lockpassword_confirm_your_password_generic_profile" msgid="5918738487760814147">"Para continuar, ingresa la contraseña de tu perfil de trabajo"</string>
    <string name="lockpassword_strong_auth_required_device_pattern" msgid="113817518413715557">"Para mayor seguridad, usa el patrón de tu dispositivo"</string>
    <string name="lockpassword_strong_auth_required_device_pin" msgid="9163822166411129815">"Para mayor seguridad, ingresa el PIN de tu dispositivo"</string>
    <string name="lockpassword_strong_auth_required_device_password" msgid="8310047427464299337">"Para mayor seguridad, ingresa la contraseña de tu dispositivo"</string>
    <string name="lockpassword_strong_auth_required_work_pattern" msgid="6803652050512161140">"Para mayor seguridad, usa el patrón de tu perfil de trabajo"</string>
    <string name="lockpassword_strong_auth_required_work_pin" msgid="4208510396448713500">"Para mayor seguridad, ingresa el PIN de tu perfil de trabajo"</string>
    <string name="lockpassword_strong_auth_required_work_password" msgid="6119482061429323090">"Para mayor seguridad, ingresa la contraseña de tu perfil de trabajo"</string>
    <string name="lockpassword_confirm_your_pattern_header_frp" msgid="5641858015891896427">"Verificar patrón"</string>
    <string name="lockpassword_confirm_your_pin_header_frp" msgid="8285647793164729982">"Verificar PIN"</string>
    <string name="lockpassword_confirm_your_password_header_frp" msgid="7932240547542564033">"Verificar contraseña"</string>
    <string name="lockpassword_remote_validation_header" msgid="4992647285784962073">"Validar identidad"</string>
    <string name="lockpassword_remote_validation_pattern_details" msgid="4655537780358707983">"Para transferir Cuentas de Google, la configuración y más, ingresa el patrón de tu otro dispositivo. El patrón se encripta."</string>
    <string name="lockpassword_remote_validation_pin_details" msgid="2373654227583206297">"Para transferir Cuentas de Google, la configuración y más, ingresa el PIN de tu otro dispositivo. El PIN se encripta."</string>
    <string name="lockpassword_remote_validation_password_details" msgid="3482328925925888340">"Para transferir Cuentas de Google, la configuración y más, ingresa la contraseña de tu otro dispositivo. La contraseña se encripta."</string>
    <string name="lockpassword_remote_validation_set_pattern_as_screenlock" msgid="7595104317648465901">"Desbloquear este dispositivo con el patrón"</string>
    <string name="lockpassword_remote_validation_set_pin_as_screenlock" msgid="509672303005547218">"Desbloquear este dispositivo con el PIN"</string>
    <string name="lockpassword_remote_validation_set_password_as_screenlock" msgid="2066701840753591922">"Desbloquear este dispositivo con contraseña"</string>
    <string name="lockpassword_invalid_pin" msgid="7530854476819820600">"PIN incorrecto"</string>
    <string name="lockpassword_invalid_password" msgid="1588184930542221687">"Contraseña incorrecta"</string>
    <string name="lockpattern_need_to_unlock_wrong" msgid="8109305107409924083">"Patrón incorrecto"</string>
    <string name="work_challenge_emergency_button_text" msgid="5529942788380505927">"Emergencia"</string>
    <string name="lock_settings_title" msgid="665707559508132349">"Seguridad del dispositivo"</string>
    <string name="lockpattern_change_lock_pattern_label" msgid="5853706275279878879">"Cambiar patrón de desbloqueo"</string>
    <string name="lockpattern_change_lock_pin_label" msgid="7327409886587802756">"Cambiar PIN de desbloqueo"</string>
    <string name="lockpattern_recording_intro_header" msgid="8325736706877916560">"Dibuja un patrón de desbloqueo"</string>
    <string name="lockpattern_recording_intro_footer" msgid="2656868858594487197">"Presiona Menú para obtener ayuda."</string>
    <string name="lockpattern_recording_inprogress" msgid="7268008332694009191">"Levanta el dedo cuando termines."</string>
    <string name="lockpattern_recording_incorrect_too_short" msgid="3351522018450593723">"Une al menos <xliff:g id="NUMBER">%d</xliff:g> puntos. Vuelve a intentarlo."</string>
    <string name="lockpattern_pattern_entered_header" msgid="7709618312713127249">"Patrón registrado"</string>
    <string name="lockpattern_need_to_confirm" msgid="6489499109451714360">"Vuelve a trazar el patrón para confirmar"</string>
    <string name="lockpattern_pattern_confirmed_header" msgid="2969990617475456153">"Patrón de desbloqueo nuevo"</string>
    <string name="lockpattern_confirm_button_text" msgid="6122815520373044089">"Confirmar"</string>
    <string name="lockpattern_restart_button_text" msgid="255339375151895998">"Revisar"</string>
    <string name="lockpattern_retry_button_text" msgid="4229668933251849760">"Borrar"</string>
    <string name="lockpattern_continue_button_text" msgid="5253269556259503537">"Continuar"</string>
    <string name="lockpattern_settings_title" msgid="9223165804553269083">"Patrón de desbloqueo"</string>
    <string name="lockpattern_settings_enable_title" msgid="7401197111303283723">"Requiere un patrón"</string>
    <string name="lockpattern_settings_enable_summary" msgid="1116467204475387886">"Debes dibujar el patrón para desbloquear la pantalla"</string>
    <string name="lockpattern_settings_enable_visible_pattern_title" msgid="3340969054395584754">"Hacer visible el patrón"</string>
    <string name="lockpattern_settings_enhanced_pin_privacy_title" msgid="7172693275721931683">"Privacidad de PIN mejorada"</string>
    <string name="lockpattern_settings_enhanced_pin_privacy_summary" msgid="8639588868341114740">"Inhabilitar las animaciones cuando se ingresa el PIN"</string>
    <string name="lockpattern_settings_enable_visible_pattern_title_profile" msgid="5138189101808127489">"Mostrar el patrón del perfil"</string>
    <string name="lockpattern_settings_enable_tactile_feedback_title" msgid="2273374883831956787">"Vibrar al presionar"</string>
    <string name="lockpattern_settings_enable_power_button_instantly_locks" msgid="1638619728773344099">"Botón de encendido bloquea"</string>
    <string name="lockpattern_settings_power_button_instantly_locks_summary" msgid="2202430156268094229">"Excepto cuando <xliff:g id="TRUST_AGENT_NAME">%1$s</xliff:g> mantiene la pantalla desbloqueada"</string>
    <string name="lockpattern_settings_choose_lock_pattern" msgid="2193588309557281466">"Conf. patrón de desbloq."</string>
    <string name="lockpattern_settings_change_lock_pattern" msgid="7614155083815661347">"Cambiar patrón de desbloqueo"</string>
    <string name="lockpattern_settings_help_how_to_record" msgid="2093801939046625774">"Cómo dibujar un patrón de desbloqueo"</string>
    <string name="lockpattern_too_many_failed_confirmation_attempts" msgid="7891484005551794824">"Demasiados intentos incorrectos. Vuelve a intentarlo en <xliff:g id="NUMBER">%d</xliff:g> segundos."</string>
    <string name="activity_not_found" msgid="5464331414465894254">"La aplicación no está instalada en tu dispositivo."</string>
    <string name="lock_settings_profile_title" msgid="103605580492566086">"Seguridad del perfil de trabajo"</string>
    <string name="lock_settings_profile_screen_lock_title" msgid="3776275029218681815">"Bloqueo de pantalla del perfil de trabajo"</string>
    <string name="lock_settings_profile_unification_title" msgid="5777961097706546513">"Usar un mismo bloqueo"</string>
    <string name="lock_settings_profile_unification_summary" msgid="1317553536289481654">"Usa un mismo bloqueo para el perfil de trabajo y la pantalla del dispositivo"</string>
    <string name="lock_settings_profile_unification_dialog_title" msgid="5163178097464820825">"¿Deseas usar el mismo bloqueo?"</string>
    <string name="lock_settings_profile_unification_dialog_body" msgid="1222905637428672355">"El dispositivo usará el bloqueo de pantalla de tu perfil de trabajo. Las políticas del perfil de trabajo se aplicarán a ambos bloqueos."</string>
    <string name="lock_settings_profile_unification_dialog_uncompliant_body" msgid="8844682343443755895">"Tu bloqueo del perfil de trabajo no cumple con los requisitos de seguridad de tu organización. Puedes usar el mismo bloqueo para la pantalla de tu dispositivo y tu perfil de trabajo. Se aplicarán las políticas de bloqueo del perfil de trabajo."</string>
    <string name="lock_settings_profile_unification_dialog_confirm" msgid="6276915393736137843">"Usar un mismo bloqueo"</string>
    <string name="lock_settings_profile_unification_dialog_uncompliant_confirm" msgid="8509287115116369677">"Usar un mismo bloqueo"</string>
    <string name="lock_settings_profile_unified_summary" msgid="777095092175037385">"Igual al bloqueo de pantalla del dispositivo"</string>
    <string name="manageapplications_settings_title" msgid="9198876415524237657">"Administrar aplicaciones"</string>
    <string name="applications_settings" msgid="1941993743933425622">"Información de apps"</string>
    <string name="applications_settings_header" msgid="3154670675856048015">"Configuración de aplicación"</string>
    <string name="install_applications" msgid="3921609656584369901">"Fuentes desconocidas"</string>
    <string name="install_applications_title" msgid="7890233747559108106">"Permitir todas las fuentes"</string>
    <string name="recent_app_category_title" msgid="189758417804427533">"Apps abiertas recientemente"</string>
    <string name="see_all_apps_title" msgid="1650653853942381797">"{count,plural, =1{Ver todas las apps}other{Ver todas las apps (#)}}"</string>
    <string name="forgot_password_title" msgid="3967873480875239885">"Comunícate con tu administrador de TI"</string>
    <string name="forgot_password_text" msgid="2583194470767613163">"Te puede ayudar a restablecer el PIN, el patrón o la contraseña"</string>
    <string name="advanced_settings" msgid="2368905204839169094">"Configuración avanzada"</string>
    <string name="advanced_settings_summary" msgid="1823765348195530035">"Activar más opciones de configuración"</string>
    <string name="application_info_label" msgid="1015706497694165866">"Información de apps"</string>
    <string name="storage_label" msgid="2522307545547515733">"Almacenamiento"</string>
    <string name="auto_launch_label" msgid="4069860409309364872">"Abrir de forma predeterminada"</string>
    <string name="auto_launch_label_generic" msgid="5033137408273064599">"Valores predeterminados"</string>
    <string name="screen_compatibility_label" msgid="7549658546078613431">"Compatibilidad de la pantalla"</string>
    <string name="permissions_label" msgid="1708927634370314404">"Permisos"</string>
    <string name="cache_header_label" msgid="2441967971921741047">"Memoria caché"</string>
    <string name="clear_cache_btn_text" msgid="8597272828928143723">"Borrar caché"</string>
    <string name="cache_size_label" msgid="313456088966822757">"Memoria caché"</string>
    <string name="uri_permissions_text" msgid="8406345863117405105">"{count,plural, =1{1 elemento}other{# elementos}}"</string>
    <string name="clear_uri_btn_text" msgid="4828117421162495134">"Borrar acceso"</string>
    <string name="controls_label" msgid="8671492254263626383">"Controles"</string>
    <string name="force_stop" msgid="2681771622136916280">"Forzar detención"</string>
    <string name="total_size_label" msgid="2052185048749658866">"Total"</string>
    <string name="application_size_label" msgid="6407051020651716729">"Tamaño de la app"</string>
    <string name="external_code_size_label" msgid="7375146402660973743">"Aplicación en el almacenamiento USB"</string>
    <string name="data_size_label" msgid="7814478940141255234">"Datos del usuario"</string>
    <string name="uninstall_text" msgid="315764653029060126">"Desinstalar"</string>
    <string name="uninstall_all_users_text" msgid="5924715251087176474">"Desinstalar en todos los usuarios"</string>
    <string name="install_text" msgid="4558333621516996473">"Instalar"</string>
    <string name="disable_text" msgid="5146002260857428005">"Inhabilitar"</string>
    <string name="enable_text" msgid="8570798764647110430">"Habilitar"</string>
    <string name="clear_user_data_text" msgid="6773186434260397947">"Liberar espacio de almacenamiento"</string>
    <string name="app_factory_reset" msgid="8974044931667015201">"Desinstalar las actualizaciones"</string>
    <string name="app_restricted_settings_lockscreen_title" msgid="5993061278264872648">"Permitir configuración restringida"</string>
    <string name="auto_launch_enable_text" msgid="8912714475823807798">"Algunas de las actividades que seleccionaste se abren en esta app de forma predeterminada."</string>
    <string name="always_allow_bind_appwidgets_text" msgid="2069415023986858324">"Decidiste permitir que esta aplicación pueda crear widgets y acceder a sus datos."</string>
    <string name="auto_launch_disable_text" msgid="502648841250936209">"No se establecieron configuraciones predeterminadas"</string>
    <string name="clear_activities" msgid="488089228657585700">"Borrar las preferencias predeterminadas"</string>
    <string name="screen_compatibility_text" msgid="5915767835411020274">"Es posible que esta aplicación no se haya diseñado para tu pantalla. Aquí puedes controlar cómo se ajusta a la pantalla."</string>
    <string name="ask_compatibility" msgid="8388397595148476565">"Preguntar cuando se lanza"</string>
    <string name="enable_compatibility" msgid="1163387233622859712">"Aplicación en escala"</string>
    <string name="unknown" msgid="8192160131923461175">"Desconocido"</string>
    <string name="sort_order_alpha" msgid="3400680865280266582">"Ordenar por nombre"</string>
    <string name="sort_order_size" msgid="7731928486199737223">"Ordenar por tamaño"</string>
    <string name="sort_order_recent_notification" msgid="1496198895330443073">"Más recientes"</string>
    <string name="sort_order_frequent_notification" msgid="4063700985742284794">"Más frecuentes"</string>
    <string name="show_running_services" msgid="8666008279959853318">"Mostrar los servicios en ejecución"</string>
    <string name="show_background_processes" msgid="5682856012453562151">"Procesos en caché"</string>
    <string name="default_emergency_app" msgid="1929974800666613803">"Aplicación de emergencia"</string>
    <string name="reset_app_preferences" msgid="8861758340732716573">"Restablecer preferencias de apps"</string>
    <string name="reset_app_preferences_title" msgid="8935136792316050759">"¿Restablecer preferencias de apps?"</string>
    <string name="reset_app_preferences_desc" msgid="8550782670650158299">"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<li>"Configuración de uso de batería"</li>\n\n"No perderás los datos de las apps."</string>
    <string name="reset_app_preferences_button" msgid="2591318711372850058">"Restablecer apps"</string>
    <string name="filter" msgid="9039576690686251462">"Filtro"</string>
    <string name="filter_dlg_title" msgid="3086282431958601338">"Elegir opciones de filtro"</string>
    <string name="filter_apps_all" msgid="5705421199299914620">"Todas las apps"</string>
    <string name="filter_apps_disabled" msgid="5068011814871004105">"Apps inhabilitadas"</string>
    <string name="filter_apps_third_party" msgid="9049447784849114843">"Descargado"</string>
    <string name="filter_apps_running" msgid="535465683273284141">"En ejecución"</string>
    <string name="not_installed" msgid="5074606858798519449">"No instalada para este usuario"</string>
    <string name="installed" msgid="2837449358488825884">"Instalada"</string>
    <string name="no_applications" msgid="985069304755391640">"No hay aplicaciones."</string>
    <string name="internal_storage" msgid="999496851424448809">"Almacenamiento interno"</string>
    <string name="recompute_size" msgid="1098091228370999128">"Recalculando el tamaño…"</string>
    <string name="clear_data_dlg_title" msgid="180446967743732410">"¿Borrar los datos de la app?"</string>
    <string name="clear_data_dlg_text" msgid="3440011276559762619">"Los datos de esta app, incluidos archivos y parámetros de configuración, se borrarán permanentemente de este dispositivo"</string>
    <string name="dlg_ok" msgid="1421350367857960997">"Aceptar"</string>
    <string name="dlg_cancel" msgid="5164705061530774899">"Cancelar"</string>
    <string name="dlg_delete" msgid="1790919205039397659">"Borrar"</string>
    <string name="app_not_found_dlg_text" msgid="8634675268730513704">"La aplicación no está en la lista de aplicaciones instaladas."</string>
    <string name="clear_failed_dlg_text" msgid="6866741916836125732">"No se pudo liberar espacio de almacenamiento de la app."</string>
    <string name="computing_size" msgid="4915310659841174866">"Calculando..."</string>
    <string name="invalid_size_value" msgid="7017371543563259201">"No se pudo calcular el tamaño del paquete."</string>
    <string name="version_text" msgid="7628938665256107608">"versión <xliff:g id="VERSION_NUM">%1$s</xliff:g>"</string>
    <string name="move_app" msgid="5421158479447276791">"Mover"</string>
    <string name="another_migration_already_in_progress" msgid="6550546307856052261">"Hay otra migración en curso."</string>
    <string name="insufficient_storage" msgid="8115088042669030558">"No hay suficiente espacio de almacenamiento."</string>
    <string name="does_not_exist" msgid="6499163879348776120">"La aplicación no existe."</string>
    <string name="invalid_location" msgid="8013853455355520557">"La ubicación de la instalación no es válida."</string>
    <string name="system_package" msgid="7559476279008519360">"Las actualizaciones del sistema no se pueden instalar en medios externos."</string>
    <string name="move_error_device_admin" msgid="1561502976834303626">"No se puede instalar la app de administración de dispositivos en medios externos"</string>
    <string name="force_stop_dlg_title" msgid="86745852555490146">"¿Deseas forzar la detención?"</string>
    <string name="force_stop_dlg_text" msgid="1527286468544457368">"Si fuerzas la detención de una aplicación, es posible que funcione incorrectamente."</string>
    <string name="app_disable_dlg_positive" msgid="1414218905322009505">"Inhabilitar la aplicación"</string>
    <string name="app_disable_dlg_text" msgid="2449382902751908916">"Si inhabilitas esta app, es posible que Android y otras apps ya no funcionen correctamente. Ten en cuenta que no puedes borrar esta app ya que vino preinstalada en el dispositivo. Si la inhabilitas, se desactivarás y se ocultará en tu dispositivo."</string>
    <string name="app_install_details_group_title" msgid="1172114479073704677">"Tienda"</string>
    <string name="app_install_details_title" msgid="7783556181897142187">"Detalles de la app"</string>
    <string name="app_install_details_summary" msgid="2013043219249992373">"App instalada desde <xliff:g id="APP_STORE">%1$s</xliff:g>"</string>
    <string name="instant_app_details_summary" msgid="417197491598208216">"Más información en <xliff:g id="APP_STORE">%1$s</xliff:g>"</string>
    <string name="app_ops_running" msgid="6127474473137428721">"En curso"</string>
    <string name="app_ops_never_used" msgid="9038133162371204506">"(Sin utilizar)"</string>
    <string name="storageuse_settings_title" msgid="3125650750657988194">"Uso del almacenamiento"</string>
    <string name="service_restarting" msgid="5104563288155809226">"Volver a comenzar"</string>
    <string name="cached" msgid="5379485147573438201">"Proceso de fondo almacenado en memoria caché"</string>
    <string name="no_running_services" msgid="9079738069349859373">"No hay nada en ejecución."</string>
    <string name="service_started_by_app" msgid="6845028506417670179">"Iniciado por aplicación"</string>
    <!-- no translation found for service_client_name (2210898622981598861) -->
    <skip />
    <string name="service_background_processes" msgid="2800539421534521948">"<xliff:g id="MEMORY">%1$s</xliff:g> libre"</string>
    <string name="service_foreground_processes" msgid="6380905887193621704">"<xliff:g id="MEMORY">%1$s</xliff:g> en uso"</string>
    <string name="memory" msgid="5253757199926592074">"RAM"</string>
    <!-- no translation found for service_process_name (7827318358399776412) -->
    <skip />
    <string name="running_process_item_user_label" msgid="1444898861984132133">"Usuario: <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="running_process_item_removed_user_label" msgid="4812732296696662613">"Usuario eliminado"</string>
    <string name="running_processes_item_description_s_s" msgid="6835918861352501671">"<xliff:g id="NUMPROCESS">%1$d</xliff:g> proceso y <xliff:g id="NUMSERVICES">%2$d</xliff:g> servicio"</string>
    <string name="running_processes_item_description_s_p" msgid="1209371773353932361">"<xliff:g id="NUMPROCESS">%1$d</xliff:g> proceso y <xliff:g id="NUMSERVICES">%2$d</xliff:g> servicios"</string>
    <string name="running_processes_item_description_p_s" msgid="8957061449107822282">"<xliff:g id="NUMPROCESS">%1$d</xliff:g> procesos y <xliff:g id="NUMSERVICES">%2$d</xliff:g> servicio"</string>
    <string name="running_processes_item_description_p_p" msgid="3292999232897469679">"<xliff:g id="NUMPROCESS">%1$d</xliff:g> procesos y <xliff:g id="NUMSERVICES">%2$d</xliff:g> servicios"</string>
    <string name="running_processes_header_title" msgid="558961782589967366">"Memoria del dispositivo"</string>
    <string name="running_processes_header_footer" msgid="2726092156680487584">"RAM usada por las aplicaciones"</string>
    <string name="running_processes_header_system_prefix" msgid="8819527769608555124">"Sistema"</string>
    <string name="running_processes_header_apps_prefix" msgid="4151874328324238133">"Aplicaciones"</string>
    <string name="running_processes_header_free_prefix" msgid="4271100378295864738">"Libre"</string>
    <string name="running_processes_header_used_prefix" msgid="5205762402234243007">"En uso"</string>
    <string name="running_processes_header_cached_prefix" msgid="839132595831993521">"En caché"</string>
    <string name="running_processes_header_ram" msgid="3014991380467004685">"<xliff:g id="RAM_0">%1$s</xliff:g> de RAM"</string>
    <string name="runningservicedetails_settings_title" msgid="1057845389092757121">"Aplicación en ejecución"</string>
    <string name="no_services" msgid="3898812785511572899">"Inactivo"</string>
    <string name="runningservicedetails_services_title" msgid="11853795112787355">"Servicios"</string>
    <string name="runningservicedetails_processes_title" msgid="5292271587797234038">"Procesos"</string>
    <string name="service_stop" msgid="5712522600201308795">"Detener"</string>
    <string name="service_manage" msgid="3896322986828332075">"Configuración"</string>
    <string name="service_stop_description" msgid="6327742632400026677">"Servicio iniciado por su aplicación. Si se detiene, se puede producir un error en la aplicación."</string>
    <string name="heavy_weight_stop_description" msgid="3086419998820881290">"Esta aplicación no puede detenerse de forma segura. Si la detienes, puedes perder parte de tu trabajo actual."</string>
    <string name="background_process_stop_description" msgid="4792038933517438037">"Es un proceso de aplicación anterior que aún se ejecuta en caso de que sea necesario nuevamente. En general, no hay razón para detenerlo."</string>
    <string name="service_manage_description" msgid="6615788996428486121">"<xliff:g id="CLIENT_NAME">%1$s</xliff:g>: Está en uso actualmente. Presiona Configuración para controlarlo."</string>
    <string name="main_running_process_description" msgid="6685973937935027773">"Proceso principal en uso."</string>
    <string name="process_service_in_use_description" msgid="4210957264507014878">"El servicio <xliff:g id="COMP_NAME">%1$s</xliff:g> está en uso."</string>
    <string name="process_provider_in_use_description" msgid="6730020083976048028">"El proveedor <xliff:g id="COMP_NAME">%1$s</xliff:g> está en uso."</string>
    <string name="runningservicedetails_stop_dlg_title" msgid="6201041461740445113">"¿Deseas detener el servicio?"</string>
    <string name="language_input_gesture_title" msgid="3292455685728572960">"Idiomas, entrada y gestos"</string>
    <string name="language_settings" msgid="8700174277543875046">"Idiomas y entradas"</string>
    <string name="languages_settings" msgid="5784775502251770671">"Idiomas"</string>
    <string name="keyboard_settings" msgid="184185708597386454">"Teclado"</string>
    <string name="language_empty_list_user_restricted" msgid="8050367405839231863">"No tienes permiso para cambiar el idioma del dispositivo."</string>
    <string name="language_keyboard_settings_title" msgid="7934844313233544557">"Idiomas y entradas"</string>
    <string name="input_assistance" msgid="3437568284144952104">"Herramientas"</string>
    <string name="keyboard_settings_category" msgid="5392847229300117064">"Teclado y métodos de entrada"</string>
    <string name="system_language" msgid="1146762166579643257">"Idiomas del sistema"</string>
    <string name="phone_language" msgid="5986939176239963826">"Idiomas"</string>
    <string name="phone_language_summary" msgid="863041222809685325"></string>
    <string name="auto_replace" msgid="4830732960264447043">"Reemplazar automát."</string>
    <string name="auto_replace_summary" msgid="1285443414597153423">"Corregir palabras mal escritas"</string>
    <string name="auto_caps" msgid="5573583581288305355">"Uso de mayúsculas automático"</string>
    <string name="auto_caps_summary" msgid="3144141933426846665">"Escribir con mayúscula la primera letra en las oraciones"</string>
    <string name="auto_punctuate" msgid="2838809477621809507">"Puntuación automática"</string>
    <string name="hardkeyboard_category" msgid="8729780593378161071">"Configuración de teclado físico"</string>
    <string name="auto_punctuate_summary" msgid="3549190848611386748">"Presionar la tecla de espacio dos veces para insertar \".\""</string>
    <string name="show_password" msgid="7101900779571040117">"Mostrar contraseñas"</string>
    <string name="show_password_summary" msgid="9025960283785111619">"Mostrar caracteres brevemente mientras escribes"</string>
    <string name="spellchecker_security_warning" msgid="2016059050608271820">"Este corrector ortográfico puede recopilar todo el texto que escribas, incluidos los datos personales como contraseñas y números de tarjetas de crédito. Proviene de la aplicación <xliff:g id="SPELLCHECKER_APPLICATION_NAME">%1$s</xliff:g>. ¿Deseas usar este corrector ortográfico?"</string>
    <string name="spellchecker_quick_settings" msgid="6449414356743946577">"Configuración"</string>
    <string name="spellchecker_language" msgid="8905487366580285282">"Idioma"</string>
    <string name="keyboard_and_input_methods_category" msgid="5296847777802891649">"Teclados"</string>
    <string name="virtual_keyboard_category" msgid="2339505603075527212">"Teclado en pantalla"</string>
    <string name="keywords_virtual_keyboard" msgid="1494726424879503434">"Gboard"</string>
    <string name="available_virtual_keyboard_category" msgid="6930012948152749337">"Teclado en pantalla disponible"</string>
    <string name="add_virtual_keyboard" msgid="2515850206289352606">"Administrar teclados en pantalla"</string>
    <string name="keyboard_options_category" msgid="8040137073401152608">"Opciones"</string>
    <string name="physical_keyboard_title" msgid="3328134097512350958">"Teclado físico"</string>
    <string name="show_ime" msgid="4334255501724746849">"Usar teclado en pantalla"</string>
    <string name="show_ime_summary" msgid="7293345791727205975">"Mientras el teclado físico está activo"</string>
    <string name="keyboard_shortcuts_helper" msgid="2553221039203165344">"Combinaciones de teclas"</string>
    <string name="keyboard_shortcuts_helper_summary" msgid="5979507677602559203">"Mostrar lista de combinación de teclas"</string>
    <string name="language_and_input_for_work_category_title" msgid="2546950919124199743">"Teclados y herramientas del perfil de trabajo"</string>
    <string name="virtual_keyboards_for_work_title" msgid="786459157034008675">"Teclado en pantalla para el trabajo"</string>
    <string name="keyboard_default_layout" msgid="5377811770620422301">"Predeterminado"</string>
    <string name="trackpad_settings" msgid="2071131324087677005">"Panel táctil"</string>
    <string name="trackpad_mouse_settings" msgid="136226693583218429">"Panel táctil y mouse"</string>
    <string name="trackpad_settings_summary" msgid="3369855644136760402">"Velocidad del puntero, gestos"</string>
    <string name="trackpad_tap_to_click" msgid="1938230946542070746">"Presiona para hacer clic"</string>
    <string name="trackpad_touchpad_gesture_title" msgid="7568052847609914436">"Gestos del panel táctil"</string>
    <string name="trackpad_touchpad_gesture_summary" msgid="6256074591395359124">"Personaliza los gestos de navegación del panel táctil"</string>
    <string name="trackpad_reverse_scrolling_title" msgid="422877284529360866">"Invertir desplazamiento"</string>
    <string name="trackpad_reverse_scrolling_summary" msgid="6048648562887499036">"El contenido sube cuando deslizas hacia abajo"</string>
    <string name="trackpad_bottom_right_tap_title" msgid="6275428879042702880">"Toque de la parte inferior derecha"</string>
    <string name="trackpad_bottom_right_tap_summary" msgid="8734094086900680674">"Más opciones en la esquina inferior derecha del panel táctil"</string>
    <string name="trackpad_pointer_speed" msgid="7786579408631352625">"Velocidad del puntero"</string>
    <string name="trackpad_touch_gesture" msgid="8641725062131922497">"Aprende los gestos del panel táctil"</string>
    <string name="gesture_title_go_home" msgid="3682238648647225933">"Ir a la página de inicio"</string>
    <string name="gesture_summary_go_home" msgid="6409031586904205741">"Desliza hacia arriba con tres dedos en el panel táctil"</string>
    <string name="gesture_title_go_back" msgid="6619462058488419802">"Atrás"</string>
    <string name="gesture_summary_go_back" msgid="4981604277892236888">"Desliza desde la izquierda o la derecha con tres dedos"</string>
    <string name="gesture_title_recent_apps" msgid="6082688963233208761">"Ver apps recientes"</string>
    <string name="gesture_summary_recent_apps" msgid="6643179135202417509">"Desliza arriba con tres dedos, mantén presionado y suelta"</string>
    <string name="gesture_title_notifications" msgid="791717222472350194">"Ver notificaciones y Config. rápida"</string>
    <string name="gesture_summary_notifications" msgid="8419514601638387255">"Desliza hacia abajo con tres dedos en la pantalla principal"</string>
    <string name="gesture_title_switch_apps" msgid="5840994412037872157">"Cambiar de app"</string>
    <string name="gesture_summary_switch_apps" msgid="6842648062151413042">"Desliza hacia la izquierda o la derecha con cuatro dedos"</string>
    <string name="gesture_button_skip" msgid="5174842083451193213">"Omitir"</string>
    <string name="gesture_button_next" msgid="695288092704187356">"Siguiente"</string>
    <string name="gesture_button_restart" msgid="1895850891992530133">"Reiniciar"</string>
    <string name="gesture_button_done" msgid="6387900351203032188">"Listo"</string>
    <string name="trackpad_go_back_title" msgid="5312164160947491440">"Atrás"</string>
    <string name="trackpad_go_back_summary" msgid="4201901101085902768">"Desliza hacia la izquierda o la derecha con tres dedos"</string>
    <string name="trackpad_go_home_title" msgid="2146525662148291552">"Ir a la pantalla principal"</string>
    <string name="trackpad_go_home_summary" msgid="2222744701528360887">"Desliza hacia arriba con tres dedos"</string>
    <string name="trackpad_recent_apps_title" msgid="8195970908411585445">"Apps recientes"</string>
    <string name="trackpad_recent_apps_summary" msgid="2685092851677573794">"Desliza hacia arriba con tres dedos y mantén presionado"</string>
    <string name="trackpad_notifications_title" msgid="3521663305043747880">"Notificaciones"</string>
    <string name="trackpad_notifications_summary" msgid="7663647367648690040">"Desliza hacia abajo con tres dedos"</string>
    <string name="trackpad_switch_apps_title" msgid="7342032935377284039">"Cambia de app"</string>
    <string name="trackpad_switch_apps_summary" msgid="9193942041912927440">"Desliza hacia la izquierda o la derecha con cuatro dedos"</string>
    <string name="modifier_keys_settings" msgid="2537108435032034683">"Teclas modificadoras"</string>
    <string name="modifier_keys_settings_summary" msgid="6933143361657444436">"Cambia el comportamiento de las teclas"</string>
    <string name="modifier_keys_reset_title" msgid="948294258402761066">"Restablecer todas"</string>
    <string name="modifier_keys_default_summary" msgid="8701640508670973258">"Predeterminados"</string>
    <string name="modifier_keys_reset_message" msgid="5236994817619936058">"¿Confirmas que quieres restablecer todas las teclas modificadoras a su configuración predeterminada?"</string>
    <string name="modifier_keys_done" msgid="8196199314913909700">"Listo"</string>
    <string name="modifier_keys_cancel" msgid="7136520252570826772">"Cancelar"</string>
    <!-- no translation found for modifier_keys_reset (551170906710422041) -->
    <skip />
    <string name="modifier_keys_picker_title" msgid="244545904150587851">"Elegir tecla modificadora"</string>
    <string name="modifier_keys_picker_summary" msgid="739397232249560785">"Elige una nueva tecla para <xliff:g id="MODIFIER_KEY_DEFAULT_NAME">%1$s</xliff:g>:"</string>
    <string name="default_keyboard_layout" msgid="8690689331289452201">"Predeterminadas"</string>
    <string name="speech_category_title" msgid="5995161659186229742">"Voz"</string>
    <string name="pointer_speed" msgid="7398649279282675718">"Velocidad del puntero"</string>
    <string name="game_controller_settings_category" msgid="8557472715034961918">"Controlador de juegos"</string>
    <string name="vibrate_input_devices" msgid="5192591087864449142">"Redireccionar vibración"</string>
    <string name="vibrate_input_devices_summary" msgid="8791680891376689823">"Enviar la vibración al controlador de juegos cuando esté conectado"</string>
    <string name="keyboard_layout_dialog_title" msgid="8770130364048089954">"Elegir el diseño de teclado"</string>
    <string name="keyboard_layout_dialog_setup_button" msgid="6546245862744626706">"Configurar diseños de teclado"</string>
    <string name="keyboard_layout_dialog_switch_hint" msgid="3303564123674979354">"Para cambiar, presiona Ctrl+espacio."</string>
    <string name="keyboard_layout_default_label" msgid="6078569989261528039">"Predeterminado"</string>
    <string name="keyboard_layout_picker_title" msgid="240504762718562906">"Diseños de teclado"</string>
    <string name="keyboard_layout_picker_category_title" msgid="2369473692906329772">"Diseños de teclado físico"</string>
    <string name="user_dict_settings_title" msgid="680410651924276991">"Diccionario personal"</string>
    <string name="user_dict_settings_for_work_title" msgid="1245315720684961770">"Diccionario personal para el trabajo"</string>
    <string name="user_dict_settings_summary" msgid="4939694372338975081">"Agrega palabras para que se usen en apps como el Corrector ortográfico"</string>
    <string name="user_dict_settings_add_menu_title" msgid="8046882347281382968">"Agregar"</string>
    <string name="user_dict_settings_add_dialog_title" msgid="3485845465134083084">"Agregar al diccionario"</string>
    <string name="user_dict_settings_add_screen_title" msgid="1866408024073475379">"Frase"</string>
    <string name="user_dict_settings_add_dialog_more_options" msgid="2642928746425808108">"Más opciones"</string>
    <string name="user_dict_settings_add_dialog_less_options" msgid="100432503633458156">"Menos opciones"</string>
    <string name="user_dict_settings_add_dialog_confirm" msgid="1866751313790655088">"Aceptar"</string>
    <string name="user_dict_settings_add_word_option_name" msgid="2686051785623698231">"Palabra:"</string>
    <string name="user_dict_settings_add_shortcut_option_name" msgid="5722204336242646866">"Acceso directo:"</string>
    <string name="user_dict_settings_add_locale_option_name" msgid="2117468247460253346">"Idioma:"</string>
    <string name="user_dict_settings_add_word_hint" msgid="4560494723256242785">"Escribe una palabra"</string>
    <string name="user_dict_settings_add_shortcut_hint" msgid="6209624157217434640">"Acceso directo opcional"</string>
    <string name="user_dict_settings_edit_dialog_title" msgid="316493656442362284">"Modificar palabra"</string>
    <string name="user_dict_settings_context_menu_edit_title" msgid="4909198741914531509">"Editar"</string>
    <string name="user_dict_settings_context_menu_delete_title" msgid="651550824433043545">"Borrar"</string>
    <string name="user_dict_settings_empty_text" msgid="86562873609647919">"El diccionario del usuario no contiene ninguna palabra. Para agregar una, presiona el botón Agregar (+)."</string>
    <string name="user_dict_settings_all_languages" msgid="8563387437755363526">"Para todos los idiomas"</string>
    <string name="user_dict_settings_more_languages" msgid="5378870726809672319">"Más idiomas..."</string>
    <string name="testing" msgid="6294172343766732037">"Probando"</string>
    <string name="keyboard_settings_summary" msgid="2716339620942356432">"Teclado en pantalla, voz, herramientas"</string>
    <string name="keyboard_settings_with_physical_keyboard_summary" msgid="6628668004523183413">"Teclado en pantalla, teclado físico, voz, herramientas"</string>
    <string name="builtin_keyboard_settings_title" msgid="5096171620714179661">"Teclado físico"</string>
    <string name="enabled_locales_keyboard_layout" msgid="3939886151098958639">"Diseño"</string>
    <string name="gadget_picker_title" msgid="7615902510050731400">"Elegir gadget"</string>
    <string name="widget_picker_title" msgid="7641298325488989676">"Elegir control"</string>
    <string name="allow_bind_app_widget_activity_allow_bind_title" msgid="3537968409832846255">"¿Deseas crear el widget y permitir el acceso?"</string>
    <string name="allow_bind_app_widget_activity_allow_bind" msgid="5825298768068148804">"Después de crear el widget, la aplicación podrá acceder a todo lo que se muestre.\n\nAplicación: <xliff:g id="WIDGET_HOST_NAME">%1$s</xliff:g>\nWidget: <xliff:g id="WIDGET_LABEL">%2$s</xliff:g>\n"</string>
    <string name="allow_bind_app_widget_activity_always_allow_bind" msgid="7268758525344468364">"Permitir siempre que <xliff:g id="WIDGET_HOST_NAME">%1$s</xliff:g> pueda crear widgets y acceder a sus datos"</string>
    <string name="testing_usage_stats" msgid="4660643799010906365">"Estadísticas de uso"</string>
    <string name="usage_stats_sort_by_usage_time" msgid="2927310334119998301">"Ordenar por tiempo de uso"</string>
    <string name="usage_stats_sort_by_last_time_used" msgid="7039213339779884017">"Ordenar por último uso"</string>
    <string name="usage_stats_sort_by_app_name" msgid="4463833145514850478">"Ordenar por nombre de app"</string>
    <string name="last_time_used_label" msgid="2639712813493534074">"Última utilización"</string>
    <string name="usage_time_label" msgid="9105343335151559883">"Hora de uso"</string>
    <string name="accessibility_settings" msgid="4713215774904704682">"Accesibilidad"</string>
    <string name="accessibility_settings_title" msgid="6739115703615065716">"Configuración de accesibilidad"</string>
    <string name="accessibility_settings_summary" msgid="2366627644570558503">"Pantalla, interacción y audio"</string>
    <string name="vision_settings_title" msgid="8919983801864103069">"Configuración de visión"</string>
    <string name="vision_settings_description" msgid="7614894785054441991">"Personaliza este dispositivo para adaptarlo a tus necesidades. Puedes modificar las funciones de accesibilidad más tarde en Configuración."</string>
    <string name="vision_settings_suggestion_title" msgid="4689275412658803919">"Cambiar tamaño de fuente"</string>
    <string name="screen_reader_category_title" msgid="5825700839731107803">"Lector de pantalla"</string>
    <string name="captions_category_title" msgid="574490148949400274">"Subtítulos"</string>
    <string name="audio_category_title" msgid="5283853679967605826">"Audio"</string>
    <string name="general_category_title" msgid="6298579528716834157">"General"</string>
    <string name="display_category_title" msgid="6638191682294461408">"Pantalla"</string>
    <string name="accessibility_color_and_motion_title" msgid="2323301706545305874">"Color y movimiento"</string>
    <string name="accessibility_turn_screen_darker_title" msgid="5986223133285858349">"Oscurecer la pantalla"</string>
    <string name="interaction_control_category_title" msgid="2696474616743882372">"Controles de interacción"</string>
    <string name="accessibility_tap_assistance_title" msgid="1058913033421048284">"Controles de tiempo"</string>
    <string name="accessibility_system_controls_title" msgid="6403287349518987624">"Controles del sistema"</string>
    <string name="user_installed_services_category_title" msgid="2639470729311439731">"Apps descargadas"</string>
    <string name="experimental_category_title" msgid="898904396646344152">"Experimental"</string>
    <string name="feature_flags_dashboard_title" msgid="348990373716658289">"Marcas de función"</string>
    <string name="bt_hci_snoop_log_filters_dashboard_title" msgid="401330708633716596">"Filtrado del registro de Bluetooth HCI"</string>
    <string name="bt_hci_snoop_log_filters_dashboard_summary" msgid="1319792184194176235">"Configurar filtros"</string>
    <string name="bt_hci_snoop_log_filters_dashboard_footer" msgid="4158945851818483666">"Inhabilita y habilita el Bluetooth para que se apliquen los cambios"</string>
    <string name="bt_hci_snoop_log_filter_pbap_title" msgid="1735427364451634823">"PBAP de filtrado del registro de Bluetooth HCI"</string>
    <string name="bt_hci_snoop_log_filter_map_title" msgid="180092480793945544">"MAP de filtrado del registro de Bluetooth HCI"</string>
    <string name="bt_hci_snoop_log_filter_summary" msgid="7217091930762522599">"Configurar modo de filtrado (inhabilita y habilita el Bluetooth para que se apliquen los cambios)."</string>
    <string name="bt_hci_snoop_log_filtered_mode_disabled_summary" msgid="8824952559433361848">"Configura el modo del registro de Bluetooth HCI en Habilitado para cambiar esta opción"</string>
    <string name="talkback_title" msgid="8756080454514251327">"Talkback"</string>
    <string name="talkback_summary" msgid="5820927220378864281">"Lector de pantalla, principalmente, para personas con ceguera o visión reducida"</string>
    <string name="select_to_speak_summary" msgid="1995285446766920925">"Presiona los elementos en tu pantalla para escuchar la lectura en voz alta"</string>
    <string name="accessibility_captioning_title" msgid="4561871958958925225">"Preferencias de subtítulos"</string>
    <string name="accessibility_captioning_about_title" msgid="3542171637334191563">"Acerca de las preferencias de subtitulado"</string>
    <string name="accessibility_captioning_footer_learn_more_content_description" msgid="5730040700677017706">"Más información sobre las preferencias de subtítulos"</string>
    <string name="accessibility_screen_magnification_title" msgid="1211169976144629087">"Ampliación"</string>
    <string name="accessibility_screen_magnification_shortcut_title" msgid="2387963646377987780">"Combinación de accesibilidad de ampliación"</string>
    <string name="accessibility_screen_magnification_follow_typing_title" msgid="6379517513916651560">"Amplía la escritura"</string>
    <string name="accessibility_screen_magnification_follow_typing_summary" msgid="2882250257391761678">"La lupa sigue el texto a medida que escribes"</string>
    <!-- no translation found for accessibility_screen_magnification_always_on_title (3814297443759580936) -->
    <skip />
    <!-- no translation found for accessibility_screen_magnification_always_on_summary (306908451430863049) -->
    <skip />
    <string name="accessibility_screen_magnification_joystick_title" msgid="1803769708582404964">"Joystick"</string>
    <string name="accessibility_screen_magnification_joystick_summary" msgid="4640300148573982720">"Activa y mueve la lupa con un joystick en pantalla. Mantén presionado y, luego, arrastra el joystick para controlar la lupa. Presiona y arrastra para mover el joystick."</string>
    <string name="accessibility_screen_magnification_about_title" msgid="8857919020223505415">"Acerca de la ampliación"</string>
    <string name="accessibility_screen_magnification_footer_learn_more_content_description" msgid="924848332575978463">"Más información sobre la ampliación"</string>
    <string name="accessibility_magnification_mode_title" msgid="8446475127807168063">"Tipo de ampliación"</string>
    <string name="accessibility_magnification_area_settings_message" msgid="8498648925928109462">"Amplía toda la pantalla o parte de ella, o bien alterna entre ambas opciones"</string>
    <string name="accessibility_magnification_area_settings_full_screen_summary" msgid="2728962784113713010">"Pantalla completa"</string>
    <string name="accessibility_magnification_area_settings_window_screen_summary" msgid="9191632962955877019">"Parte de la pantalla"</string>
    <string name="accessibility_magnification_area_settings_all_summary" msgid="8107511976748799455">"Alternar entre pantalla completa y parcial"</string>
    <string name="accessibility_magnification_mode_dialog_title" msgid="9151027667059878578">"Elige el tipo de ampliación"</string>
    <string name="accessibility_magnification_mode_dialog_option_full_screen" msgid="4892487869954032029">"Ampliar pantalla completa"</string>
    <string name="accessibility_magnification_mode_dialog_option_window" msgid="4492443201099153362">"Ampliar parte de la pantalla"</string>
    <string name="accessibility_magnification_mode_dialog_option_switch" msgid="561043521011229424">"Alternar entre pantalla completa y parcial"</string>
    <string name="accessibility_magnification_area_settings_mode_switch_summary" msgid="2885238806099080966">"Presiona el botón para moverte entre ambas opciones"</string>
    <string name="accessibility_magnification_switch_shortcut_title" msgid="3671432048806533079">"¿Quieres cambiar al botón de accesibilidad?"</string>
    <string name="accessibility_magnification_switch_shortcut_message" msgid="7718653917415163833">"Cuando presionas tres veces para ampliar una parte de la pantalla, algunas acciones, como escribir, demoran más tiempo.\n\nEl botón de accesibilidad flota en la pantalla por encima de otras apps. Presiónalo para ampliar."</string>
    <string name="accessibility_magnification_switch_shortcut_positive_button" msgid="2446942190957296957">"Cambiar al botón de accesibilidad"</string>
    <string name="accessibility_magnification_switch_shortcut_negative_button" msgid="7115794462123071594">"Usar Presionar tres veces"</string>
    <string name="accessibility_magnification_triple_tap_warning_title" msgid="8484669851397296597">"Es posible que se ralentice el teclado"</string>
    <string name="accessibility_magnification_triple_tap_warning_message" msgid="2008671502848936410">"Cuando presionas tres veces para ampliar parte de la pantalla, es posible que notes problemas con el teclado.\n\nPara evitarlos, puedes elegir otra combinación para la ampliación.\n"<annotation id="link">"Cambiar configuración"</annotation></string>
    <string name="accessibility_magnification_triple_tap_warning_positive_button" msgid="8712304035901450010">"Continuar de todos modos"</string>
    <string name="accessibility_magnification_triple_tap_warning_negative_button" msgid="2028849736366584733">"Cancelar"</string>
    <string name="accessibility_magnification_service_settings_title" msgid="3531350704632316017">"Configuración de ampliación"</string>
    <string name="accessibility_screen_magnification_gestures_title" msgid="3121714118381882167">"Ampliar presionando tres veces"</string>
    <string name="accessibility_screen_magnification_navbar_title" msgid="480853328665484528">"Ampliar con gesto"</string>
    <string name="accessibility_screen_magnification_state_navbar_gesture" msgid="8067042663897802231">"Ampliar con acceso directo y presionar tres veces"</string>
    <string name="accessibility_introduction_title" msgid="8834950581512452348">"Información sobre <xliff:g id="SERVICE">%1$s</xliff:g>"</string>
    <string name="accessibility_text_reading_options_title" msgid="3224648909213325563">"Tamaño y texto de la pantalla"</string>
    <string name="accessibility_text_reading_options_suggestion_title" msgid="2492155642665312733">"Cambiar cómo se muestra el texto"</string>
    <string name="accessibility_text_reading_preview_mail_subject" msgid="4597374768612733616">"Asunto: Diseños de globos aerostáticos"</string>
    <string name="accessibility_text_reading_preview_mail_from" msgid="1797499780365288020">"De: Bill"</string>
    <string name="accessibility_text_reading_preview_mail_content" msgid="8078152365771951802">"¡Buenos días!\n\nSolo quería saber cómo van los diseños. ¿Estarán listos antes de que empecemos a hacer los nuevos globos?"</string>
    <string name="accessibility_text_reading_reset_button_title" msgid="5960753279788187669">"Restablecer configuración"</string>
    <string name="accessibility_text_reading_reset_message" msgid="824644303661026712">"Se restableció la configuración del tamaño de visualización y del texto"</string>
    <string name="accessibility_text_reading_confirm_dialog_title" msgid="2865331351355690389">"¿Deseas restablecer el texto y el tamaño de la pantalla?"</string>
    <string name="accessibility_text_reading_confirm_dialog_reset_button" msgid="8215800137850243736">"Restablecer"</string>
    <string name="accessibility_text_reading_conversation_message_1" msgid="7883952203831957831">"¿Tienes algún plan para el fin de semana?"</string>
    <string name="accessibility_text_reading_conversation_message_2" msgid="8112160435318635856">"Iré a la playa. ¿Quieres venir?"</string>
    <string name="accessibility_screen_option" msgid="8465307075278878145">"Opciones"</string>
    <string name="accessibility_preference_magnification_summary" msgid="2875518904115896888">"Amplía la pantalla"</string>
    <string name="accessibility_screen_magnification_short_summary" msgid="2207048420669939150">"Presiona tres veces para ampliar"</string>
    <string name="accessibility_screen_magnification_navbar_short_summary" msgid="4885018322430052037">"Presiona un botón para ampliar"</string>
    <string name="accessibility_screen_magnification_intro_text" msgid="3856180549393526339">"Acerca rápidamente la pantalla para que el contenido se muestre en un tamaño más grande"</string>
    <string name="accessibility_screen_magnification_summary" msgid="8267672508057326959">"&lt;b&gt;Para acercar, haz lo siguiente:&lt;/b&gt;&lt;br/&gt; {0,number,integer}. Usa la combinación de teclas para comenzar la ampliación.&lt;br/&gt; {1,number,integer}. Presiona la pantalla.&lt;br/&gt; {2,number,integer}. Arrastra 2 dedos para moverte por la pantalla.&lt;br/&gt; {3,number,integer}. Pellizca con 2 dedos para ajustar el zoom.&lt;br/&gt; {4,number,integer}. Usa la combinación de teclas para detener la ampliación.&lt;br/&gt;&lt;br/&gt; &lt;b&gt;Para acercar de manera temporal, haz lo siguiente:&lt;/b&gt;&lt;br/&gt; {0,number,integer}. Asegúrate de que el tipo de ampliación esté configurado en pantalla completa.&lt;br/&gt; {1,number,integer}. Usa la combinación de teclas para comenzar la ampliación.&lt;br/&gt; {2,number,integer}. Mantén presionada cualquier parte de la pantalla.&lt;br/&gt; {3,number,integer}. Arrastra un dedo para moverte por la pantalla.&lt;br/&gt; {4,number,integer}. Levanta el dedo para detener la ampliación."</string>
    <string name="accessibility_screen_magnification_navbar_summary" msgid="807985499898802296">"Cuando la ampliación esté activada, podrás acercar el contenido en pantalla.\n\n"<b>"Para usar el zoom"</b>", inicia la ampliación y, luego, presiona cualquier parte de la pantalla.\n"<ul><li>"Arrastra 2 o más dedos para desplazarte."</li>\n<li>"Pellizca con 2 o más dedos para ajustar el zoom."</li></ul>\n\n<b>"Para hacer zoom de manera temporal"</b>", inicia la ampliación y, luego, mantén presionada cualquier parte de la pantalla.\n"<ul><li>"Arrastra el dedo para moverte por la pantalla."</li>\n<li>"Levanta el dedo para alejar el contenido."</li></ul>\n\n"No puedes acercar con el teclado ni en la barra de navegación."</string>
    <string name="accessibility_tutorial_pager" msgid="8461939455728454061">"Página <xliff:g id="CURRENT_PAGE">%1$d</xliff:g> de <xliff:g id="NUM_PAGES">%2$d</xliff:g>"</string>
    <string name="accessibility_tutorial_dialog_title_button" msgid="4681164949716215131">"Usa el botón de accesibilidad para abrir"</string>
    <string name="accessibility_tutorial_dialog_title_volume" msgid="494810949830845234">"Mantén presionadas teclas de volumen para abrir"</string>
    <string name="accessibility_tutorial_dialog_title_triple" msgid="7089562919284464400">"Presiona tres veces para abrir el servicio"</string>
    <string name="accessibility_tutorial_dialog_title_gesture" msgid="4965810097646659332">"Usa el gesto para abrir"</string>
    <string name="accessibility_tutorial_dialog_title_gesture_settings" msgid="6800684770875867559">"Usa los gestos de accesibilidad"</string>
    <string name="accessibility_tutorial_dialog_message_button" msgid="7002398857479782303">"Para usar esta función, presiona el botón de accesibilidad <xliff:g id="ACCESSIBILITY_ICON">%s</xliff:g> ubicado en la parte inferior de la pantalla.\n\nSi quieres cambiar de función, mantén presionado el botón de accesibilidad."</string>
    <string name="accessibility_tutorial_dialog_message_floating_button" msgid="2551777208185138391">"Para usar esta función, presiona el botón de accesibilidad en la pantalla."</string>
    <string name="accessibility_tutorial_dialog_message_volume" msgid="5033080515460519183">"Para usar esta función, mantén presionadas las teclas de volumen."</string>
    <string name="accessibility_tutorial_dialog_message_triple" msgid="5219991116201165146">"Para iniciar y detener la ampliación, presiona tres veces en cualquier parte de la pantalla."</string>
    <string name="accessibility_tutorial_dialog_message_gesture" msgid="4148062210755434854">"Para usar esta función, desliza 2 dedos hacia arriba desde la parte inferior de la pantalla.\n\nSi quieres cambiar de función, desliza 2 dedos hacia arriba y mantén presionada la pantalla."</string>
    <string name="accessibility_tutorial_dialog_message_gesture_talkback" msgid="8142847782708562793">"Para usar esta función, desliza 3 dedos hacia arriba desde la parte inferior de la pantalla.\n\nSi quieres cambiar de función, desliza 3 dedos hacia arriba y mantén presionada la pantalla."</string>
    <string name="accessibility_tutorial_dialog_message_gesture_settings" msgid="40769674586981429">"Para usar una función de accesibilidad, desliza 2 dedos hacia arriba desde la parte inferior de la pantalla.\n\nSi quieres cambiar de función, desliza 2 dedos hacia arriba y mantén presionada la pantalla."</string>
    <string name="accessibility_tutorial_dialog_message_gesture_settings_talkback" msgid="7292969929578621958">"Para usar una función de accesibilidad, desliza 3 dedos hacia arriba desde la parte inferior de la pantalla.\n\nSi quieres cambiar de función, desliza 3 dedos hacia arriba y mantén presionada la pantalla."</string>
    <string name="accessibility_tutorial_dialog_button" msgid="2031773187678948436">"Entendido"</string>
    <string name="accessibility_tutorial_dialog_link_button" msgid="1624189347106713695">"Configuración del botón de accesibilidad"</string>
    <string name="accessibility_shortcut_title" msgid="8125867833704517463">"Combinación de accesibilidad para: <xliff:g id="SERVICE">%1$s</xliff:g>"</string>
    <string name="accessibility_shortcut_edit_summary_software" msgid="6405629977940618205">"Botón de accesibilidad"</string>
    <string name="accessibility_shortcut_edit_summary_software_gesture" msgid="5489284264414421286">"Gesto de accesibilidad"</string>
    <string name="accessibility_shortcut_edit_dialog_title_software_gesture" msgid="8078659880723370597">"Deslizar dos dedos hacia arriba"</string>
    <string name="accessibility_shortcut_edit_dialog_title_software_gesture_talkback" msgid="7422753388389160524">"Deslizar tres dedos hacia arriba"</string>
    <string name="accessibility_shortcut_edit_dialog_title_software" msgid="4796192466943479849">"Presionar el botón de accesibilidad"</string>
    <string name="accessibility_shortcut_edit_dialog_title_software_by_gesture" msgid="3981188764050497346">"Usar gestos de accesibilidad"</string>
    <string name="accessibility_shortcut_edit_dialog_summary_software" msgid="5606196352833449600">"Presiona el botón de accesibilidad <xliff:g id="ACCESSIBILITY_ICON">%s</xliff:g> en la parte inferior de la pantalla.\n\nPara cambiar de función, mantén presionado el botón de accesibilidad."</string>
    <string name="accessibility_shortcut_edit_dialog_summary_software_gesture" msgid="8292555254353761635">"Desliza dos dedos hacia arriba desde la parte inferior de la pantalla.\n\nPara cambiar de función, desliza dos dedos hacia arriba y mantén presionada la pantalla."</string>
    <string name="accessibility_shortcut_edit_dialog_summary_software_gesture_talkback" msgid="84483464524360845">"Desliza tres dedos hacia arriba desde la parte inferior de la pantalla.\n\nPara cambiar de función, desliza tres dedos hacia arriba y mantén presionada la pantalla."</string>
    <string name="accessibility_shortcut_edit_dialog_summary_software_floating" msgid="4459254227203203324"><annotation id="link">"Más opciones"</annotation></string>
    <string name="footer_learn_more_content_description" msgid="8843798273152131341">"Más información sobre <xliff:g id="SERVICE">%1$s</xliff:g>"</string>
    <string name="accessibility_shortcut_edit_dialog_title_hardware" msgid="2356853121810443026">"Mantener presionadas las teclas de volumen"</string>
    <string name="accessibility_shortcut_hardware_keyword" msgid="3921915304537166064">"mantener presionadas las teclas de volumen"</string>
    <string name="accessibility_shortcut_edit_dialog_summary_hardware" msgid="2503134386397991634">"Mantén presionadas ambas teclas de volumen."</string>
    <string name="accessibility_shortcut_edit_dialog_title_triple_tap" msgid="6672798007229795841">"Presionar tres veces la pantalla"</string>
    <string name="accessibility_shortcut_triple_tap_keyword" msgid="6863958573135995927">"presionar tres veces la pantalla"</string>
    <string name="accessibility_shortcut_edit_dialog_summary_triple_tap" msgid="2102327956423320536">"Presiona rápidamente la pantalla {0,number,integer} veces. Esta combinación de teclas podría hacer que tu dispositivo funcione más lento."</string>
    <string name="accessibility_shortcut_edit_dialog_title_advance" msgid="4567868630655591506">"Avanzada"</string>
    <string name="accessibility_screen_magnification_navbar_configuration_warning" msgid="266736851606791552">"El botón de Accesibilidad está configurado para <xliff:g id="SERVICE">%1$s</xliff:g>. Para ampliar, mantén presionado el botón y, luego, selecciona ampliación."</string>
    <string name="accessibility_screen_magnification_gesture_navigation_warning" msgid="991017769735632046">"El gesto de accesibilidad se configuró en <xliff:g id="SERVICE">%1$s</xliff:g>. Para usar la ampliación, desliza dos dedos hacia arriba desde la parte inferior de la pantalla y mantén presionado. Luego, selecciona la ampliación."</string>
    <string name="accessibility_global_gesture_preference_title" msgid="3713636732641882959">"Combinación de teclas de volumen"</string>
    <string name="accessibility_shortcut_settings" msgid="836783442658447995">"Configuración de combinación de teclas"</string>
    <string name="accessibility_shortcut_service_on_lock_screen_title" msgid="3923122834058574478">"Acceso directo desde pantalla de bloqueo"</string>
    <string name="accessibility_shortcut_description" msgid="2184693606202133549">"Permite que la combinación de teclas active las funciones desde la pantalla de bloqueo. Mantén presionadas ambas teclas de volumen durante unos segundos."</string>
    <string name="accessibility_button_title" msgid="5251235485581552614">"Botón de accesibilidad"</string>
    <string name="accessibility_button_gesture_title" msgid="3573456209050374139">"Botón de accesibilidad y gestos"</string>
    <string name="accessibility_button_intro_text" msgid="80993874471745687">"Accede rápidamente a las funciones de accesibilidad desde cualquier pantalla"</string>
    <string name="accessibility_button_about_title" msgid="3581116105084067926">"Acerca del botón de accesibilidad"</string>
    <string name="accessibility_button_gesture_about_title" msgid="8468987303602865536">"Acerca del botón de accesibilidad y los gestos"</string>
    <string name="accessibility_button_gesture_footer_learn_more_content_description" msgid="4144803517680297869">"Más información sobre el botón de accesibilidad y los gestos"</string>
    <string name="accessibility_button_intro" msgid="2601976470525277903">"Se está usando el botón de accesibilidad. El gesto no está disponible con navegación con 3 botones."</string>
    <string name="accessibility_button_summary" msgid="8510939012631455831">"Accede rápidamente a funciones de accesibilidad"</string>
    <string name="accessibility_button_gesture_description" msgid="7507097717493960397"><b>"Para comenzar"</b>\n"1. Ve a la configuración de accesibilidad.\n2. Selecciona una función y presiona el atajo.\n3. Elige si quieres usar un botón o gesto para acceder a la función."</string>
    <string name="accessibility_button_description" msgid="1261273371298608222"><b>"Para comenzar, haz lo siguiente:"</b>\n"1. Ve a la configuración de accesibilidad.\n2. Selecciona una función y presiona el atajo.\n3. Elige el botón para acceder a la función."</string>
    <string name="accessibility_button_or_gesture_title" msgid="3510075963401163529">"Usar botón o gesto"</string>
    <string name="accessibility_button_location_title" msgid="7182107846092304942">"Ubicación"</string>
    <string name="accessibility_button_size_title" msgid="5785110470538960881">"Tamaño"</string>
    <string name="accessibility_button_fade_title" msgid="8081993897680588829">"Se atenúa cuando no está en uso"</string>
    <string name="accessibility_button_fade_summary" msgid="7865950833524973709">"Se atenúa después de unos segundos para que sea más fácil ver la pantalla"</string>
    <string name="accessibility_button_opacity_title" msgid="4727355657530362289">"Transparente cuando no se usa"</string>
    <string name="accessibility_button_low_label" msgid="4193015407828927741">"Transparente"</string>
    <string name="accessibility_button_high_label" msgid="9138077512008190896">"No transparente"</string>
    <string name="accessibility_toggle_high_text_contrast_preference_title" msgid="1830189632458752698">"Texto de alto contraste"</string>
    <string name="accessibility_toggle_high_text_contrast_preference_summary" msgid="5286411556836346180">"Cambia el color del texto a blanco o negro. Maximiza el contraste con el fondo."</string>
    <string name="accessibility_toggle_screen_magnification_auto_update_preference_title" msgid="4987009529235165664">"Actualizar automáticamente la ampliación de pantalla"</string>
    <string name="accessibility_toggle_screen_magnification_auto_update_preference_summary" msgid="9034532513972547720">"Actualizar la ampliación de pantalla al cambiar de aplicaciones"</string>
    <string name="accessibility_power_button_ends_call_prerefence_title" msgid="8187306131979612144">"Cortar con el botón de encendido"</string>
    <string name="accessibility_toggle_large_pointer_icon_title" msgid="5508351959249876801">"Puntero del mouse grande"</string>
    <string name="accessibility_toggle_large_pointer_icon_summary" msgid="1480527946039237705">"Destaca más el puntero del mouse"</string>
    <string name="accessibility_disable_animations" msgid="2993529829457179058">"Quitar animaciones"</string>
    <string name="accessibility_disable_animations_summary" msgid="5828228669556554565">"Reduce el movimiento de la pantalla"</string>
    <string name="accessibility_toggle_primary_mono_title" msgid="7587152099472946571">"Audio mono"</string>
    <string name="accessibility_toggle_primary_mono_summary" msgid="1935283927319407303">"Combinar canales cuando se reproduce audio"</string>
    <string name="accessibility_toggle_primary_balance_title" msgid="7332275200153366714">"Balance de audio"</string>
    <string name="accessibility_toggle_primary_balance_left_label" msgid="6415750010517682014">"Izquierda"</string>
    <string name="accessibility_toggle_primary_balance_right_label" msgid="2987443495390104935">"Derecha"</string>
    <string name="accessibility_timeout_default" msgid="1033702739376842824">"Predeterminado"</string>
    <string name="accessibility_timeout_10secs" msgid="5072577454521239794">"10 segundos"</string>
    <string name="accessibility_timeout_30secs" msgid="7814673496724760684">"30 segundos"</string>
    <string name="accessibility_timeout_1min" msgid="4804644263166961262">"1 minuto"</string>
    <string name="accessibility_timeout_2mins" msgid="7901692984522708679">"2 minutos"</string>
    <string name="accessibility_setting_item_control_timeout_title" msgid="1600516937989217899">"Tiempo de espera para realizar acción"</string>
    <string name="accessibility_control_timeout_about_title" msgid="813588002683460837">"Acerca del tiempo de acción (tiempo de espera de accesibilidad)"</string>
    <string name="accessibility_control_timeout_footer_learn_more_content_description" msgid="8118584413220542193">"Más información sobre el tiempo de acción (tiempo de espera de accesibilidad)"</string>
    <string name="accessibility_control_timeout_preference_title" msgid="1443940538597464758">"Tiempo de acción"</string>
    <string name="accessibility_control_timeout_preference_summary" msgid="4037051091059316310">"Esta preferencia de tiempo no es compatible con todas las apps"</string>
    <string name="accessibility_control_timeout_preference_intro_text" msgid="1398116710556762245">"Selecciona el tiempo de visualización de los mensajes temporales que te solicitan que realices una acción"</string>
    <string name="accessibility_long_press_timeout_preference_title" msgid="5237764682976688855">"Tiempo de respuesta táctil"</string>
    <string name="accessibility_display_inversion_preference_title" msgid="5476133104746207952">"Inversión de colores"</string>
    <string name="accessibility_display_inversion_switch_title" msgid="7458595722552743503">"Usar inversión de colores"</string>
    <string name="accessibility_display_inversion_shortcut_title" msgid="6889624526691513462">"Acceso directo de inversión de colores"</string>
    <string name="accessibility_display_inversion_preference_intro_text" msgid="1159663288481145318">"La inversión de color oscurece la pantalla. También aclara las pantallas oscuras."</string>
    <string name="accessibility_display_inversion_preference_subtitle" msgid="4494767676482389509">"&lt;b&gt;Ten en cuenta lo siguiente:&lt;/b&gt;&lt;br/&gt; &lt;ol&gt; &lt;li&gt; Se modificarán los colores del contenido multimedia y las imágenes.&lt;/li&gt; &lt;li&gt; La inversión de colores funciona en todas las apps.&lt;/li&gt; &lt;li&gt; Para mostrar un fondo oscuro, se puede usar el Tema oscuro.&lt;/li&gt; &lt;/ol&gt;"</string>
    <string name="accessibility_autoclick_preference_title" msgid="2703143361605555752">"Clic automático (tiempo de permanencia)"</string>
    <string name="accessibility_autoclick_about_title" msgid="152923024405552594">"Clic aut. (tiempo de permanencia)"</string>
    <string name="accessibility_autoclick_footer_learn_more_content_description" msgid="7056189627042350691">"Más información sobre el clic automático (tiempo de permanencia)"</string>
    <string name="accessibility_autoclick_intro_text" msgid="8959680635470639347">"Puedes configurar un mouse conectado para que haga clic automáticamente cuando el cursor deja de moverse durante un tiempo determinado"</string>
    <string name="accessibility_autoclick_description" msgid="6695732131412361101">"El clic automático puede ser útil cuando hacer clic con el mouse resulta difícil"</string>
    <string name="accessibility_autoclick_default_title" msgid="2024730028293793490">"Clic automático desactivado"</string>
    <string name="accessibility_autoclick_short_title" msgid="7938302504358912984">"Corto"</string>
    <string name="accessibility_autoclick_short_summary" msgid="4106953930081213514">"0.2 segundos"</string>
    <string name="accessibility_autoclick_medium_title" msgid="3134175117576834320">"Medio"</string>
    <string name="accessibility_autoclick_medium_summary" msgid="1343390686514222871">"0.6 segundos"</string>
    <string name="accessibility_autoclick_long_title" msgid="6799311820641687735">"Largo"</string>
    <string name="accessibility_autoclick_long_summary" msgid="3747153151313563637">"1 segundo"</string>
    <string name="accessibility_autoclick_custom_title" msgid="4597792235546232038">"Personalizado"</string>
    <string name="accessibility_autoclick_shorter_desc" msgid="7631013255724544348">"Más corto"</string>
    <string name="accessibility_autoclick_longer_desc" msgid="2566025502981487443">"Más largo"</string>
    <string name="accessibility_autoclick_seekbar_desc" msgid="8363959277814621118">"Tiempo de clic automático"</string>
    <string name="accessibility_vibration_settings_title" msgid="936301142478631993">"Vibración y tecnología táctil"</string>
    <string name="accessibility_vibration_settings_summary" msgid="3690308537483465527">"Controla la intensidad de la vibración para diferentes usos"</string>
    <string name="accessibility_vibration_settings_state_on" msgid="5566026932372832502">"Activada"</string>
    <string name="accessibility_vibration_settings_state_off" msgid="7946588741954981703">"Desactivada"</string>
    <string name="accessibility_vibration_setting_disabled_for_silent_mode_summary" msgid="3982701772953323190">"El parámetro de configuración no está habilitado porque el dispositivo está configurado en silencio"</string>
    <string name="accessibility_call_vibration_category_title" msgid="2545607568768192318">"Llamadas"</string>
    <string name="accessibility_notification_alarm_vibration_category_title" msgid="2683635252414849417">"Notificaciones y alarmas"</string>
    <string name="accessibility_interactive_haptics_category_title" msgid="3162855291184592021">"Respuesta táctil interactiva"</string>
    <string name="accessibility_vibration_primary_switch_title" msgid="6162579254864450592">"Usar vibración y tecnología táctil"</string>
    <string name="accessibility_alarm_vibration_title" msgid="4661294337828522745">"Vibración de alarmas"</string>
    <string name="accessibility_media_vibration_title" msgid="1372073715403945428">"Vibración de contenido multimedia"</string>
    <string name="accessibility_ring_vibration_title" msgid="4689811297654320885">"Vibración del tono"</string>
    <string name="accessibility_notification_vibration_title" msgid="6205679908785776478">"Vibración de las notificaciones"</string>
    <string name="accessibility_touch_vibration_title" msgid="533931451319110741">"Respuesta táctil"</string>
    <string name="accessibility_service_primary_switch_title" msgid="437610853412159406">"Usar <xliff:g id="ACCESSIBILITY_APP_NAME">%1$s</xliff:g>"</string>
    <string name="accessibility_service_primary_open_title" msgid="8655108684769091154">"Abrir <xliff:g id="ACCESSIBILITY_APP_NAME">%1$s</xliff:g>"</string>
    <string name="accessibility_service_auto_added_qs_tooltip_content" msgid="2941824314912928072">"Se agregó <xliff:g id="ACCESSIBILITY_APP_NAME">%1$s</xliff:g> a la Configuración rápida. Desliza hacia abajo para activarla o desactivarla en cualquier momento."</string>
    <string name="accessibility_service_qs_tooltip_content" msgid="6002493441414967868">"También puedes agregar <xliff:g id="ACCESSIBILITY_APP_NAME">%1$s</xliff:g> a la Configuración rápida desde la parte superior de la pantalla"</string>
    <string name="accessibility_color_correction_auto_added_qs_tooltip_content" msgid="9092661358437404374">"Se agregó la corrección de colores a la Configuración rápida. Desliza hacia abajo para activarla o desactivarla en cualquier momento."</string>
    <string name="accessibility_color_correction_qs_tooltip_content" msgid="3258628434235475205">"También puedes agregar la corrección de colores a la Configuración rápida desde la parte superior de la pantalla"</string>
    <string name="accessibility_color_inversion_auto_added_qs_tooltip_content" msgid="7267618234972101725">"Se agregó la inversión de colores a la Configuración rápida. Desliza hacia abajo para activarla o desactivarla en cualquier momento."</string>
    <string name="accessibility_color_inversion_qs_tooltip_content" msgid="5046332142185711869">"También puedes agregar la inversión de colores a la Configuración rápida desde la parte superior de la pantalla"</string>
    <string name="accessibility_reduce_bright_colors_auto_added_qs_tooltip_content" msgid="1906588335786328512">"Se agregó la atenuación extra a la Configuración rápida. Desliza hacia abajo para activarla o desactivarla en cualquier momento."</string>
    <string name="accessibility_reduce_bright_colors_qs_tooltip_content" msgid="7522121299176176785">"También puedes agregar la atenuación extra a la Configuración rápida desde la parte superior de la pantalla"</string>
    <string name="accessibility_one_handed_mode_auto_added_qs_tooltip_content" msgid="7914554254280416532">"Se agregó el Modo de una mano a la Configuración rápida. Desliza hacia abajo para activarlo o desactivarlo en cualquier momento."</string>
    <string name="accessibility_one_handed_mode_qs_tooltip_content" msgid="2754332083184384603">"También puedes agregar el Modo de una mano a la Configuración rápida desde la parte superior de la pantalla"</string>
    <!-- no translation found for accessibility_font_scaling_auto_added_qs_tooltip_content (7229921960884718332) -->
    <skip />
    <string name="accessibility_quick_settings_tooltip_dismiss" msgid="3269120277643884190">"Descartar"</string>
    <string name="accessibility_daltonizer_primary_switch_title" msgid="32064721588910540">"Usar la corrección de colores"</string>
    <string name="accessibility_daltonizer_shortcut_title" msgid="7480360363995502369">"Acceso directo de corrección de colores"</string>
    <string name="accessibility_daltonizer_about_title" msgid="6063650804116981287">"Acerca de la corrección de colores"</string>
    <string name="accessibility_daltonizer_footer_learn_more_content_description" msgid="2091679253892040910">"Más información sobre la corrección de colores"</string>
    <string name="accessibility_color_inversion_about_title" msgid="8275754480247040136">"Acerca de la inversión de colores"</string>
    <string name="accessibility_color_inversion_footer_learn_more_content_description" msgid="5382579548498952445">"Más información sobre la inversión de colores"</string>
    <string name="accessibility_captioning_primary_switch_title" msgid="3663677340286206100">"Mostrar subtítulos"</string>
    <string name="accessibility_captioning_primary_switch_summary" msgid="2544094070306830218">"Solo para apps compatibles"</string>
    <string name="captioning_appearance_title" msgid="3128792092290011408">"Estilo y tamaño de los subtítulos"</string>
    <string name="captioning_appearance_summary" msgid="4620682807315588019">"Tamaño del texto: <xliff:g id="ACCESSIBILITY_FONT_SIZE">%1$s</xliff:g>"</string>
    <string name="captioning_more_options_title" msgid="3484496882942539652">"Más opciones"</string>
    <string name="accessibility_captioning_preference_intro" msgid="8995427146374031134">"Personaliza el tamaño y estilo de los subtítulos para que se puedan leer con más facilidad"</string>
    <string name="accessibility_captioning_preference_summary" msgid="8335768472978374255">"Estas preferencias de subtítulos no son compatibles con todas las apps multimedia"</string>
    <string name="accessibility_shortcut_type_software" msgid="2552732582767687515">"Botón de accesibilidad"</string>
    <string name="accessibility_shortcut_type_software_gesture" msgid="5608959693931019059">"Deslizar dos dedos hacia arriba desde la parte inferior"</string>
    <string name="accessibility_shortcut_type_hardware" msgid="4834144210432451916">"Mantén presionadas las teclas de volumen"</string>
    <string name="accessibility_shortcut_type_triple_tap" msgid="7717524216825494543">"Presionar tres veces la pantalla"</string>
    <string name="accessibility_hearingaid_instruction_continue_button" msgid="3367260988024430722">"Continuar"</string>
    <string name="accessibility_hearingaid_title" msgid="1263619711863375614">"Dispositivos auditivos"</string>
    <string name="accessibility_hearingaid_intro" msgid="5856992709195963850">"Puedes usar audífonos, implantes cocleares y otros dispositivos de amplificación de sonido con tu teléfono"</string>
    <string name="accessibility_hearingaid_not_connected_summary" msgid="3371427366765435743">"No hay audífonos conectados"</string>
    <string name="accessibility_hearingaid_adding_summary" msgid="999051610528600783">"Agregar audífonos"</string>
    <string name="accessibility_hearingaid_pair_instructions_title" msgid="2357706801112207624">"Vincula los audífonos"</string>
    <string name="accessibility_hearingaid_pair_instructions_message" msgid="581652489109350119">"En la siguiente pantalla, presiona tus audífonos. Es posible que debas vincular el audífono izquierdo y el derecho por separado.\n\nAsegúrate de que los audífonos estén encendidos y listos para la vinculación."</string>
    <string name="accessibility_hearingaid_active_device_summary" msgid="509703438222873967">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g> activo"</string>
    <string name="accessibility_hearingaid_left_side_device_summary" msgid="1907302799168261001">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g>, solo el izquierdo"</string>
    <string name="accessibility_hearingaid_right_side_device_summary" msgid="148257064855054376">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g>, solo el derecho"</string>
    <string name="accessibility_hearingaid_left_and_right_side_device_summary" msgid="4268221140368164452">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g>, izquierdo y derecho"</string>
    <string name="accessibility_hearingaid_more_device_summary" msgid="8092641784056942546">"Más de 1 <xliff:g id="DEVICE_NAME">%1$s</xliff:g>"</string>
    <string name="accessibility_hearing_device_pairing_title" msgid="2701812183769537320">"Vincular nuevo disp."</string>
    <string name="accessibility_pair_hearing_device_about_title" msgid="5870335480815052755">"Información para vincular un dispositivo nuevo"</string>
    <string name="accessibility_hearing_device_connected_title" msgid="3785140037249487287">"Disp. auditivos"</string>
    <string name="accessibility_hearing_device_saved_title" msgid="7573926212664909296">"Disp. guardados"</string>
    <string name="accessibility_hearing_device_control" msgid="2661965917013100611">"Controles del dispositivo auditivo"</string>
    <string name="accessibility_hearing_device_shortcut_title" msgid="7645100199603031360">"Acc. directo de disp. auditivos"</string>
    <string name="accessibility_hac_mode_title" msgid="2037950424429555652">"Compatibilidad con audífonos"</string>
    <string name="accessibility_hac_mode_summary" msgid="5198760061256669067">"Mejora la compatibilidad con el acoplamiento inductivo y reduce el ruido no deseado"</string>
    <string name="accessibility_hearing_device_about_title" msgid="7883758309646288250">"Información sobre disp. auditivos"</string>
    <string name="accessibility_hearing_device_footer_summary" msgid="7451899224828040581">"Asegúrate de que el audífono esté encendido y listo para la vinculación"</string>
    <string name="accessibility_hearing_device_pairing_page_title" msgid="6608901091770850295">"Vincular dispos. auditivo"</string>
    <string name="accessibility_found_hearing_devices" msgid="637407580358386553">"Disp. auditivos disponibles"</string>
    <string name="accessibility_found_all_devices" msgid="7817834722148556520">"¿No ves tu dispositivo auditivo?"</string>
    <string name="accessibility_list_all_devices_title" msgid="161495343959211216">"Ver más dispositivos"</string>
    <string name="accessibility_audio_adjustment_title" msgid="1332113739136802997">"Ajuste de audio"</string>
    <string name="accessibility_toggle_audio_description_preference_title" msgid="8916473886256061220">"Audiodescripción"</string>
    <string name="accessibility_audio_description_summary" msgid="2554789094873781056">"Escucha una descripción de lo que ocurre en pantalla en películas y programas compatibles"</string>
    <string name="keywords_audio_description" msgid="6202816411593281252">"audiodescripción, audio, descripción, persona con visión reducida"</string>
    <string name="accessibility_summary_shortcut_enabled" msgid="4030427268146752644">"Combinación activada"</string>
    <string name="accessibility_summary_shortcut_disabled" msgid="564005462092499068">"Combinación desactivada"</string>
    <string name="accessibility_summary_state_enabled" msgid="1065431632216039369">"Activado"</string>
    <string name="accessibility_summary_state_disabled" msgid="9173234532752799694">"Desactivado"</string>
    <string name="accessibility_summary_state_stopped" msgid="2343602489802623424">"No funciona. Presiona para obtener información."</string>
    <string name="accessibility_description_state_stopped" msgid="5364752492861199133">"Este servicio no funciona correctamente."</string>
    <string name="accessibility_shortcuts_settings_title" msgid="974740249671825145">"Combinaciones de teclas de accesibilidad"</string>
    <string name="enable_quick_setting" msgid="6648073323202243604">"Mostrar en Configuración rápida"</string>
    <string name="daltonizer_mode_deuteranomaly_title" msgid="4210949400493358650">"Rojo-verde"</string>
    <string name="daltonizer_mode_protanomaly_title" msgid="6392456967103014723">"Rojo-verde"</string>
    <string name="daltonizer_mode_tritanomaly_title" msgid="2278786218762602022">"Azul-amarillo"</string>
    <string name="daltonizer_mode_grayscale_title" msgid="152005391387952588">"Escala de grises"</string>
    <string name="daltonizer_mode_deuteranomaly_summary" msgid="2117727423019598455">"Verde claro, deuteranomalía"</string>
    <string name="daltonizer_mode_protanomaly_summary" msgid="4617032854982040748">"Rojo claro, protanomalía"</string>
    <string name="daltonizer_mode_tritanomaly_summary" msgid="2428218320118180070">"Tritanomalía"</string>
    <string name="reduce_bright_colors_preference_title" msgid="2249314004651574997">"Atenuación extra"</string>
    <string name="reduce_bright_colors_switch_title" msgid="1751678397884065312">"Atenuación extra de la pantalla"</string>
    <string name="reduce_bright_colors_shortcut_title" msgid="495648157059202745">"Acceso directo de atenuación extra"</string>
    <string name="reduce_bright_colors_about_title" msgid="503655452544934393">"Acerca de la atenuación extra"</string>
    <string name="reduce_bright_colors_preference_intro_text" msgid="3502290826747650566">"Atenúa la pantalla para que sea más cómodo leer"</string>
    <string name="reduce_bright_colors_intensity_preference_title" msgid="7455443033955118267">"Intensidad"</string>
    <string name="reduce_bright_colors_intensity_start_label" msgid="930387498396426039">"Más tenue"</string>
    <string name="reduce_bright_colors_intensity_end_label" msgid="1422600205484299860">"Más brillante"</string>
    <string name="reduce_bright_colors_persist_preference_title" msgid="4368829654993343354">"Mantener activado después de reiniciar el dispositivo"</string>
    <string name="accessibilty_autoclick_preference_subtitle_short_delay" msgid="2981206111858937724">"{count,plural, =1{Breve ({time} segundo)}other{Breve ({time} segundos)}}"</string>
    <string name="accessibilty_autoclick_preference_subtitle_medium_delay" msgid="6867395206533459204">"{count,plural, =1{Medio ({time} segundo)}other{Medio ({time} segundos)}}"</string>
    <string name="accessibilty_autoclick_preference_subtitle_long_delay" msgid="4079139970819335593">"{count,plural, =1{Largo ({time} segundo)}other{Largo ({time} segundos)}}"</string>
    <string name="accessibilty_autoclick_delay_unit_second" msgid="5979297390686370567">"{count,plural, =1{{time} segundo}other{{time} segundos}}"</string>
    <string name="accessibility_menu_item_settings" msgid="2652637954865389271">"Configuración"</string>
    <string name="accessibility_feature_state_on" msgid="1777344331063467511">"Activada"</string>
    <string name="accessibility_feature_state_off" msgid="169119895905460512">"Desactivada"</string>
    <string name="captioning_preview_title" msgid="2888561631323180535">"Vista previa"</string>
    <string name="captioning_standard_options_title" msgid="5360264497750980205">"Opciones estándar"</string>
    <string name="captioning_locale" msgid="5533303294290661590">"Idioma"</string>
    <string name="captioning_text_size" msgid="8039448543171463017">"Tamaño del texto"</string>
    <string name="captioning_preset" msgid="4174276086501638524">"Estilo de los subtítulos"</string>
    <string name="captioning_custom_options_title" msgid="3858866498893566351">"Opciones personalizadas"</string>
    <string name="captioning_background_color" msgid="5231412761368883107">"Color de fondo"</string>
    <string name="captioning_background_opacity" msgid="6453738649182382614">"Opacidad del fondo"</string>
    <string name="captioning_window_color" msgid="1406167274530183119">"Color de ventana de subtítulos"</string>
    <string name="captioning_window_opacity" msgid="4031752812991199525">"Opacidad de ventana de subtítulos"</string>
    <string name="captioning_foreground_color" msgid="9057327228286129232">"Color del texto"</string>
    <string name="captioning_foreground_opacity" msgid="1395843080697567189">"Opacidad del texto"</string>
    <string name="captioning_edge_color" msgid="6035818279902597518">"Color del borde"</string>
    <string name="captioning_edge_type" msgid="5281259280060811506">"Tipo de borde"</string>
    <string name="captioning_typeface" msgid="285325623518361407">"Familia de fuentes"</string>
    <string name="captioning_preview_text" msgid="4973475065545995704">"Así se verán los subtítulos."</string>
    <string name="captioning_preview_characters" msgid="7854812443613580460">"Aa"</string>
    <string name="locale_default" msgid="8948077172250925164">"Predeterminado"</string>
    <string name="color_title" msgid="2511586788643787427">"Color"</string>
    <string name="color_unspecified" msgid="4102176222255378320">"Predeterminado"</string>
    <string name="color_none" msgid="3703632796520710651">"Ninguno"</string>
    <string name="color_white" msgid="1896703263492828323">"Blanco"</string>
    <string name="color_gray" msgid="8554077329905747877">"Gris"</string>
    <string name="color_black" msgid="9006830401670410387">"Negro"</string>
    <string name="color_red" msgid="5210756997426500693">"Rojo"</string>
    <string name="color_green" msgid="4400462091250882271">"Verde"</string>
    <string name="color_blue" msgid="4997784644979140261">"Azul"</string>
    <string name="color_cyan" msgid="4341758639597035927">"Cian"</string>
    <string name="color_yellow" msgid="5957551912912679058">"Amarillo"</string>
    <string name="color_magenta" msgid="8943538189219528423">"Magenta"</string>
    <string name="enable_service_title" msgid="7231533866953706788">"¿Deseas permitir que la app <xliff:g id="SERVICE">%1$s</xliff:g> tenga el control total de tu dispositivo?"</string>
    <string name="capabilities_list_title" msgid="1225853611983394386">"<xliff:g id="SERVICE">%1$s</xliff:g> necesita:"</string>
    <string name="touch_filtered_warning" msgid="4225815157460318241">"Debido a que una aplicación está bloqueando una solicitud de permiso, la Configuración no puede verificar tu respuesta."</string>
    <string name="accessibility_service_warning" msgid="6779187188736432618">"<xliff:g id="SERVICE">%1$s</xliff:g> está solicitando el control total de este dispositivo. El servicio puede leer la pantalla y realizar acciones para los usuarios que necesitan accesibilidad. Este nivel de control no es apropiado para la mayoría de las apps."</string>
    <string name="accessibility_service_warning_description" msgid="6573203795976134751">"El control total es apropiado para las apps que te ayudan con las necesidades de accesibilidad, pero no para la mayoría de las apps."</string>
    <string name="accessibility_service_screen_control_title" msgid="324795030658109870">"Ver y controlar la pantalla"</string>
    <string name="accessibility_service_screen_control_description" msgid="8431940515157990426">"Puede leer todo el contenido en la pantalla y mostrar contenido sobre otras apps."</string>
    <string name="accessibility_service_action_perform_title" msgid="1449360056585337833">"Ver y realizar acciones"</string>
    <string name="accessibility_service_action_perform_description" msgid="7807832069800034738">"Puede realizar el seguimiento de tus interacciones con una app o un sensor de hardware, así como interactuar con las apps por ti."</string>
    <string name="accessibility_dialog_button_allow" msgid="8274918676473216697">"Permitir"</string>
    <string name="accessibility_dialog_button_deny" msgid="2037249860078259284">"Rechazar"</string>
    <string name="accessibility_dialog_button_stop" msgid="7295448112784528196">"Detener"</string>
    <string name="accessibility_dialog_button_cancel" msgid="4813234247237851121">"Cancelar"</string>
    <string name="disable_service_title" msgid="2909108731776956167">"¿Quieres detener <xliff:g id="SERVICE">%1$s</xliff:g>?"</string>
    <string name="disable_service_message" msgid="4814173941688548016">"Si presionas <xliff:g id="STOP">%1$s</xliff:g>, se detendrá <xliff:g id="SERVICE">%2$s</xliff:g>."</string>
    <string name="accessibility_no_services_installed" msgid="3725569493860028593">"No se instaló ningún servicio."</string>
    <string name="accessibility_no_service_selected" msgid="1310596127128379897">"No se seleccionó ningún servicio"</string>
    <string name="accessibility_service_default_description" msgid="7801435825448138526">"No se proporcionó ninguna descripción."</string>
    <string name="settings_button" msgid="2195468788019730377">"Configuración"</string>
    <string name="keywords_reduce_bright_colors" msgid="1683190961013139183">"sensibilidad a la luz, fotofobia, tema oscuro, migraña, dolor de cabeza, modo de lectura, modo nocturno, disminuir el brillo, punto blanco"</string>
    <string name="keywords_accessibility" msgid="4263443239404659143">"Facilidad de uso, facilidad de acceso, asistencia, asistivo"</string>
    <string name="keywords_magnification" msgid="3908145308269840862">"Ampliación de ventanas, zoom, ampliación, visión reducida, agrandar, hacer más grande"</string>
    <string name="keywords_talkback" msgid="2816435437095102527"></string>
    <string name="keywords_live_caption" msgid="1667203998080567556">"Subtítulos, subtítulos opcionales, subtítulos para personas sordas, Transcripción instantánea, persona con hipoacusia, pérdida de la audición, transcripción en tiempo real asistida por computadora, voz a texto, subtítulo"</string>
    <string name="keywords_live_transcribe" msgid="3226990195174890997"></string>
    <string name="keywords_sound_notifications" msgid="8183107485754075413"></string>
    <string name="keywords_sound_amplifier" msgid="939404835256246663"></string>
    <string name="keywords_display_size" msgid="5286419615221231518">"tamaño de la pantalla, pantalla grande"</string>
    <string name="keywords_bold_text" msgid="6257418169207099589">"contraste alto, visión reducida, fuente en negrita, negrita"</string>
    <string name="keywords_select_to_speak" msgid="2872704811610888719"></string>
    <string name="keywords_color_correction" msgid="8540442886990423681">"ajustar el color"</string>
    <string name="keywords_color_inversion" msgid="4291058365873221962">"oscurecer pantalla, aclarar pantalla"</string>
    <string name="keywords_accessibility_menu" msgid="4300579436464706608"></string>
    <string name="keywords_switch_access" msgid="5813094504384313402"></string>
    <string name="keywords_auto_click" msgid="7151756353013736931">"motor, mouse"</string>
    <string name="keywords_hearing_aids" msgid="4550504337687223314">"audífonos, persona con hipoacusia, pérdida auditiva, implantes cocleares, dispositivos de amplificación, procesadores de sonido"</string>
    <string name="keywords_rtt" msgid="2429130928152514402">"persona con hipoacusia, pérdida de la audición, subtítulos, Teletipo, tty"</string>
    <string name="keywords_voice_access" msgid="7807335263195876454"></string>
    <string name="print_settings" msgid="8519810615863882491">"Impresión"</string>
    <string name="print_settings_summary_no_service" msgid="6721731154917653862">"Desactivado"</string>
    <string name="print_settings_summary" msgid="1458773840720811915">"{count,plural, =1{1 servicio de impresión activado}other{# servicios de impresión activados}}"</string>
    <string name="print_jobs_summary" msgid="7040836482336577323">"{count,plural, =1{1 trabajo de impresión}other{# trabajos de impresión}}"</string>
    <string name="print_settings_title" msgid="7680498284751129935">"Servicios de impresión"</string>
    <string name="print_no_services_installed" msgid="7554057966540602692">"No se instaló ningún servicio."</string>
    <string name="print_no_printers_found" msgid="4833082484646109486">"No se encontraron impresoras"</string>
    <string name="print_menu_item_settings" msgid="8202755044784599740">"Configuración"</string>
    <string name="print_menu_item_add_printers" msgid="7958192149202584039">"Agregar impresoras"</string>
    <string name="print_feature_state_on" msgid="7132063461008624685">"Activado"</string>
    <string name="print_feature_state_off" msgid="1466195699995209446">"Desactivado"</string>
    <string name="print_menu_item_add_service" msgid="1549091062463044676">"Agregar servicio"</string>
    <string name="print_menu_item_add_printer" msgid="8711630848324870892">"Agregar impresora"</string>
    <string name="print_menu_item_search" msgid="5989979785203603169">"Buscar"</string>
    <string name="print_searching_for_printers" msgid="5401413178028348800">"Buscando impresoras"</string>
    <string name="print_service_disabled" msgid="9185935228930987786">"Servicio desactivado"</string>
    <string name="print_print_jobs" msgid="2605944855933091183">"Trabajos de impresión"</string>
    <string name="print_print_job" msgid="8477859161886726608">"Trabajo de impresión"</string>
    <string name="print_restart" msgid="4424096106141083945">"Reiniciar"</string>
    <string name="print_cancel" msgid="7611266511967568501">"Cancelar"</string>
    <string name="print_job_summary" msgid="277210060872032969">"<xliff:g id="PRINTER">%1$s</xliff:g>\n<xliff:g id="TIME">%2$s</xliff:g>"</string>
    <string name="print_configuring_state_title_template" msgid="2887013172492183045">"Configurando <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_printing_state_title_template" msgid="7367513245156603431">"Imprimiendo <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_cancelling_state_title_template" msgid="9094795458159980190">"Cancelando <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_failed_state_title_template" msgid="4751695809935404505">"Error de impresora <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_blocked_state_title_template" msgid="3134100215188411074">"La impresora bloqueó <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>."</string>
    <string name="print_search_box_shown_utterance" msgid="6215002365360341961">"Cuadro de búsqueda visible"</string>
    <string name="print_search_box_hidden_utterance" msgid="5355387966141712567">"Cuadro de búsqueda oculto"</string>
    <string name="printer_info_desc" msgid="1206872325746154206">"Más información sobre esta impresora"</string>
    <string name="power_usage_summary_title" msgid="4198312848584882113">"Batería"</string>
    <string name="power_usage_summary" msgid="6857382582534984531">"Lo que ha utilizado la batería"</string>
    <string name="power_usage_level_and_status" msgid="821521456989429593">"<xliff:g id="LEVEL">%1$s</xliff:g> - <xliff:g id="STATUS">%2$s</xliff:g>"</string>
    <string name="power_discharge_remaining" msgid="6997529817917076536">"Tiempo restante: <xliff:g id="REMAIN">%1$s</xliff:g>"</string>
    <string name="power_charge_remaining" msgid="7046064326172265116">"Carga completa en <xliff:g id="UNTIL_CHARGED">%1$s</xliff:g>"</string>
    <string name="low_battery_summary" msgid="4458925347316501953">"Batería baja"</string>
    <string name="background_activity_summary" msgid="3817376868497046016">"Permite que la app se ejecute en segundo plano"</string>
    <string name="background_activity_warning_dialog_title" msgid="3449566823290744823">"¿Limitar actividad en segundo plano?"</string>
    <string name="background_activity_warning_dialog_text" msgid="8202776985767701095">"Si limitas la actividad en segundo plano de una app, es posible que no funcione correctamente"</string>
    <string name="background_activity_disabled_dialog_text" msgid="4053170297325882494">"Como no se configuró la app para optimizar la batería, no puedes restringirla.\n\nPrimero, activa optimización de batería."</string>
    <string name="manager_battery_usage_unrestricted_title" msgid="2426486290463258032">"Sin restricciones"</string>
    <string name="manager_battery_usage_optimized_title" msgid="8080765739761921817">"Optimizado"</string>
    <string name="manager_battery_usage_restricted_title" msgid="7702863764130323118">"Restringido"</string>
    <string name="manager_battery_usage_unrestricted_summary" msgid="6819279865465667692">"Permite el uso de batería en segundo plano sin restricciones. Es posible que se use más batería."</string>
    <string name="manager_battery_usage_optimized_summary" msgid="1332545476428039900">"Optimiza la batería en función del uso. Se recomienda para la mayoría de las apps."</string>
    <string name="manager_battery_usage_restricted_summary" msgid="8324695640704416905">"Uso de batería restringido mientras se ejecuta en segundo plano. Es posible que la app no funcione como debería. Las notificaciones pueden funcionar con retraso."</string>
    <string name="manager_battery_usage_footer" msgid="2635906573922553766">"Si cambias el modo en que una app usa la batería, puede que se vea afectado el rendimiento."</string>
    <string name="manager_battery_usage_footer_limited" msgid="5180776148877306780">"Esta app requiere uso de batería <xliff:g id="STATE">%1$s</xliff:g>."</string>
    <string name="manager_battery_usage_unrestricted_only" msgid="3646162131339418216">"sin restricciones"</string>
    <string name="manager_battery_usage_optimized_only" msgid="7121785281913056432">"optimizado"</string>
    <string name="manager_battery_usage_link_a11y" msgid="374918091821438564">"Más información sobre las opciones de uso de batería"</string>
    <string name="device_screen_usage" msgid="1011630249648289909">"Uso de la pantalla desde carga completa"</string>
    <string name="advanced_battery_title" msgid="3005993394776555079">"Uso de la batería"</string>
    <string name="history_details_title" msgid="8628584613889559355">"Detalles del historial"</string>
    <string name="advanced_battery_preference_title" msgid="3790901207877260883">"Uso de batería"</string>
    <string name="advanced_battery_preference_summary_with_hours" msgid="954091349133320955">"Ver uso de las últimas 24 horas"</string>
    <string name="advanced_battery_preference_summary" msgid="2372763700477268393">"Ver uso desde la última carga completa"</string>
    <string name="battery_details_title" msgid="3289680399291090588">"Uso de batería de la app"</string>
    <string name="details_subtitle" msgid="2550872569652785527">"Detalles de uso"</string>
    <string name="controls_subtitle" msgid="3759606830916441564">"Ajustar el uso de energía"</string>
    <string name="packages_subtitle" msgid="8687690644931499428">"Paquetes incluidos"</string>
    <string name="battery_tip_summary_title" msgid="321127485145626939">"Las apps se ejecutan con normalidad"</string>
    <string name="battery_tip_low_battery_title" msgid="4155239078744100997">"Nivel de batería bajo"</string>
    <string name="battery_tip_low_battery_summary" msgid="2629633757244297436">"Activa el Ahorro de batería para extender la duración de la batería"</string>
    <string name="battery_tip_smart_battery_title" msgid="8925025450214912325">"Mejora la duración de la batería"</string>
    <string name="battery_tip_smart_battery_summary" msgid="3592965553502362965">"Activa el administrador de batería"</string>
    <string name="battery_tip_early_heads_up_title" msgid="4411387863476629452">"Activar el Ahorro de batería"</string>
    <string name="battery_tip_early_heads_up_summary" msgid="578523794827443977">"La batería podría agotarse antes de lo habitual"</string>
    <string name="battery_tip_early_heads_up_done_title" msgid="7705597228709143337">"Ahorro de batería activado"</string>
    <string name="battery_saver_link_a11y" msgid="740558184830458845">"Más información sobre el Ahorro de batería"</string>
    <string name="battery_tip_early_heads_up_done_summary" msgid="7858923105760361208">"Es posible que algunas funciones estén limitadas"</string>
    <string name="battery_tip_high_usage_title" msgid="9110720762506146697">"Mayor uso de batería"</string>
    <string name="battery_tip_high_usage_summary" msgid="3938999581403084551">"Consulta las apps que consumen más batería"</string>
    <string name="battery_tip_limited_temporarily_title" msgid="6258554134146272311">"Carga optimizada para proteger la batería"</string>
    <string name="battery_tip_limited_temporarily_summary" msgid="6836981984725209843">"Para extender la vida útil de la batería, se optimiza la carga"</string>
    <string name="battery_tip_dock_defender_future_bypass_title" msgid="4332616280495788195">"Carga optimizada para proteger la batería"</string>
    <string name="battery_tip_dock_defender_future_bypass_summary" msgid="7870758621381307597">"Para extender la vida útil de la batería, se optimiza la carga cuando el dispositivo está conectado"</string>
    <string name="battery_tip_dock_defender_active_title" msgid="1414785238383255699">"Carga optimizada para proteger la batería"</string>
    <string name="battery_tip_dock_defender_active_summary" msgid="3512082623718801459">"Para extender la vida útil de la batería, se optimiza la carga cuando el dispositivo está conectado"</string>
    <string name="battery_tip_dock_defender_temporarily_bypassed_title" msgid="1679449361090557201">"Cargando por completo"</string>
    <string name="battery_tip_dock_defender_temporarily_bypassed_summary" msgid="1099500476761333281">"Para proteger la batería, se optimizará la carga la próxima vez que se conecte la tablet"</string>
    <string name="battery_tip_limited_temporarily_sec_button_content_description" msgid="5648444926736883551">"Más información sobre por qué se pausó la carga"</string>
    <string name="battery_tip_limited_temporarily_dialog_resume_charge" msgid="2302295458913832342">"Reanudar la carga"</string>
    <string name="battery_tip_dialog_message_footer" msgid="986542164372177504">"Incluye actividad en segundo plano de alta potencia"</string>
    <string name="battery_tip_restrict_title" msgid="4537101947310626753">"{count,plural, =1{# app restringida}other{# apps restringidas}}"</string>
    <string name="battery_tip_restrict_handled_title" msgid="7142074986508706853">"{count,plural, =1{{label} restringida recientemente}other{# apps restringidas recientemente}}"</string>
    <string name="battery_tip_restrict_summary" msgid="7539469590829235277">"{count,plural, =1{{label} tiene un uso de batería elevado en segundo plano}other{# apps tienen un uso de batería elevado en segundo plano}}"</string>
    <string name="battery_tip_restrict_handled_summary" msgid="3535697154547199190">"{count,plural, =1{Esta app no se puede ejecutar en segundo plano}other{Estas apps no se pueden ejecutar en segundo plano}}"</string>
    <string name="battery_tip_restrict_app_dialog_title" msgid="1649476357343160240">"{count,plural, =1{¿Quieres restringir la app?}other{¿Quieres restringir # apps?}}"</string>
    <string name="battery_tip_restrict_app_dialog_message" msgid="137856003724730751">"Para ahorrar batería, detén el consumo en segundo plano de <xliff:g id="APP">%1$s</xliff:g>. Es posible que esta app no funcione correctamente y que se retrasen las notificaciones."</string>
    <string name="battery_tip_restrict_apps_less_than_5_dialog_message" msgid="5894648804112181324">"Para ahorrar batería, detén el consumo en segundo plano de estas apps. Es posible que las apps restringidas no funcionen correctamente y que se retrasen las notificaciones.\n\nApps:"</string>
    <string name="battery_tip_restrict_apps_more_than_5_dialog_message" msgid="4546838397423565138">"Para ahorrar batería, detén el consumo en segundo plano de estas apps. Es posible que las apps restringidas no funcionen correctamente y que se retrasen las notificaciones.\n\nApps:\n<xliff:g id="APP_LIST">%1$s</xliff:g>."</string>
    <string name="battery_tip_restrict_app_dialog_ok" msgid="7025027696689301916">"Restringir"</string>
    <string name="battery_tip_unrestrict_app_dialog_title" msgid="5501997201160532301">"¿Quitar restricción?"</string>
    <string name="battery_tip_unrestrict_app_dialog_message" msgid="215449637818582819">"Esta app podrá usar la batería en segundo plano. La batería podría agotarse antes de lo esperado."</string>
    <string name="battery_tip_unrestrict_app_dialog_ok" msgid="7940183167721998470">"Quitar"</string>
    <string name="battery_tip_unrestrict_app_dialog_cancel" msgid="4968135709160207507">"Cancelar"</string>
    <string name="battery_tip_charge_to_full_button" msgid="6701709034348116261">"Cargar por completo"</string>
    <string name="battery_tip_incompatible_charging_title" msgid="5120763575150751300">"Problema con el accesorio de carga"</string>
    <string name="battery_tip_incompatible_charging_content_description" msgid="355668467640367701">"Más información sobre la carga no compatible"</string>
    <string name="smart_battery_manager_title" msgid="3677620516657920364">"Administrador de batería"</string>
    <string name="smart_battery_title" msgid="9095903608520254254">"Administra apps automáticamente"</string>
    <string name="smart_battery_footer" msgid="8407121907452993645">"Si el administrador de batería detecta que hay apps que agotan la batería, podrás restringirlas, aunque es posible que no funcionen correctamente y que se retrasen las notificaciones."</string>
    <string name="restricted_app_title" msgid="6585080822121007436">"Apps restringidas"</string>
    <string name="restricted_app_summary" msgid="1022307922754893997">"{count,plural, =1{Limitando el uso de batería para # app}other{Limitando el uso de batería para # apps}}"</string>
    <string name="restricted_app_time_summary" msgid="3097721884155913252">"Restringida <xliff:g id="TIME">%1$s</xliff:g>"</string>
    <string name="restricted_app_detail_footer" msgid="3495725286882138803">"Se restringió el uso de batería en segundo plano para estas apps. Es posible que no funcionen correctamente y que se retrasen las notificaciones."</string>
    <string name="battery_auto_restriction_title" msgid="827206218118093357">"Usar el administrador de batería"</string>
    <string name="battery_auto_restriction_summary" msgid="2140896101984815711">"Detectar cuando las apps agotan la batería"</string>
    <string name="battery_manager_summary" msgid="255708681438809287">"Detectar cuando las apps consumen mucha batería"</string>
    <string name="battery_manager_summary_unsupported" msgid="7334173707292807964">"Detectar cuando las apps consumen mucha batería"</string>
    <string name="battery_manager_app_restricted" msgid="2583902700677009173">"{count,plural, =1{# app restringida}other{# apps restringidas}}"</string>
    <string name="battery_header_title_alternate" msgid="8371821625994616659">"<xliff:g id="NUMBER">^1</xliff:g>"<small>" "<font size="20">"<xliff:g id="UNIT">%</xliff:g>"</font></small>""</string>
    <string name="battery_missing_message" msgid="400958471814422770">"Se produjo un error al leer el medidor de batería."</string>
    <string name="battery_missing_link_message" msgid="6021565067124898074"></string>
    <string name="battery_missing_link_a11y_message" msgid="3310971406602316323">"Presiona para obtener más información sobre este error"</string>
    <string name="power_screen" msgid="3926703168513988776">"Pantalla"</string>
    <string name="power_cpu" msgid="1820472721627148746">"CPU"</string>
    <string name="power_flashlight" msgid="8993388636332573202">"Linterna"</string>
    <string name="power_camera" msgid="4778315081581293923">"Cámara"</string>
    <string name="power_gps" msgid="6352380895542498164">"GPS"</string>
    <string name="power_wifi" msgid="4614007837288250325">"Wi-Fi"</string>
    <string name="power_bluetooth" msgid="5085900180846238196">"Bluetooth"</string>
    <string name="power_cell" msgid="7793805106954398186">"Red móvil"</string>
    <string name="power_phone" msgid="2768396619208561670">"Llamadas de voz"</string>
    <string name="battery_screen_usage" msgid="90008745183187461">"Uso de la pantalla: <xliff:g id="TIME">^1</xliff:g>"</string>
    <string name="battery_used_by" msgid="6457305178016189330">"<xliff:g id="PERCENT">%1$s</xliff:g> usado por <xliff:g id="APP">%2$s</xliff:g>"</string>
    <string name="battery_overall_usage" msgid="8940140259734182014">"<xliff:g id="PERCENT">%1$s</xliff:g> de la batería total"</string>
    <string name="battery_detail_since_full_charge" msgid="5650946565524184582">"Desglose desde la última carga completa"</string>
    <string name="battery_last_full_charge" msgid="8308424441475063956">"Última carga completa"</string>
    <string name="battery_full_charge_last" msgid="465146408601016923">"La carga completa dura aproximadamente"</string>
    <string name="battery_footer_summary" msgid="6753248007004259000">"La duración de batería restante es aproximada y puede cambiar en función del uso"</string>
    <string name="battery_detail_power_usage" msgid="1492926471397355477">"Uso de la batería"</string>
    <string name="battery_not_usage" msgid="3851536644733662392">"Sin uso desde la última carga completa"</string>
    <string name="battery_not_usage_24hr" msgid="8397519536160741248">"Sin uso durante las últimas 24 h"</string>
    <string name="battery_usage_without_time" msgid="1346894834339420538"></string>
    <string name="battery_usage_since_last_full_charge" msgid="3488425008925924769">"desde la última carga completa"</string>
    <string name="battery_usage_system_apps" msgid="8659537819731575299">"Apps del sistema"</string>
    <string name="battery_usage_others" msgid="311793281613609986">"Otros"</string>
    <string name="estimated_time_left" msgid="948717045180211777">"Tiempo restante estimado"</string>
    <string name="estimated_charging_time_left" msgid="2287135413363961246">"Para completar la carga"</string>
    <string name="estimated_time_description" msgid="211058785418596009">"La estimación puede cambiar en función del uso"</string>
    <string name="process_mediaserver_label" msgid="6135260215912215092">"Servidor de medios"</string>
    <string name="process_dex2oat_label" msgid="1190208677726583153">"Optimización de las aplicaciones"</string>
    <string name="process_network_tethering" msgid="6822671758152900766">"Conexión"</string>
    <string name="process_removed_apps" msgid="6544406592678476902">"Apps que se quitaron"</string>
    <string name="battery_saver" msgid="7737147344510595864">"Ahorro de batería"</string>
    <string name="battery_saver_auto_title" msgid="6789753787070176144">"Activar automáticamente"</string>
    <string name="battery_saver_auto_no_schedule" msgid="5123639867350138893">"Sin programa"</string>
    <string name="battery_saver_auto_routine" msgid="4656495097900848608">"Según tu rutina"</string>
    <string name="battery_saver_pref_auto_routine_summary" msgid="4739240095966241508">"Se encenderá en función de tu rutina"</string>
    <string name="battery_saver_auto_percentage" msgid="558533724806281980">"Según el porcentaje"</string>
    <string name="battery_saver_auto_routine_summary" msgid="3913145448299472628">"Se activará el Ahorro de batería si es probable que tu batería esté por agotarse antes de la hora en que sueles cargarla"</string>
    <string name="battery_saver_auto_percentage_summary" msgid="6190884450723824287">"Se activará cuando quede <xliff:g id="PERCENT">%1$s</xliff:g>"</string>
    <string name="battery_saver_schedule_settings_title" msgid="3688019979950082237">"Establecer un programa"</string>
    <string name="battery_saver_turn_on_summary" msgid="1433919417587171160">"Extender la duración de la batería"</string>
    <string name="battery_saver_sticky_title_new" msgid="5942813274115684599">"Desactivar cuando la batería esté cargada"</string>
    <string name="battery_saver_sticky_title_percentage" msgid="1178162022087559148">"Desactivar a la(s) <xliff:g id="BATTERY_PERCENTAGE">%1$s</xliff:g>"</string>
    <string name="battery_saver_sticky_description_new" msgid="6472610662679038342">"Cuando el dispositivo tiene más del <xliff:g id="BATTERY_PERCENTAGE">%1$s</xliff:g> de carga, se desactiva el Ahorro de batería"</string>
    <!-- no translation found for battery_saver_seekbar_title (3712266470054006641) -->
    <skip />
    <string name="battery_saver_seekbar_title_placeholder" msgid="7141264642540687540">"Activar"</string>
    <string name="battery_saver_master_switch_title" msgid="3474312070095834915">"Usar el Ahorro de batería"</string>
    <string name="battery_saver_turn_on_automatically_title" msgid="7857393318205740864">"Activar automáticamente"</string>
    <string name="battery_saver_turn_on_automatically_never" msgid="6194649389871448663">"Nunca"</string>
    <string name="battery_saver_turn_on_automatically_pct" msgid="4294335680892392449">"con <xliff:g id="PERCENT">%1$s</xliff:g> de batería"</string>
    <string name="battery_percentage" msgid="1779934245963043490">"Porcentaje de batería"</string>
    <string name="battery_percentage_description" msgid="2321465139126125541">"Mostrar el porcentaje de batería en la barra de estado"</string>
    <string name="battery_usage_chart_graph_hint_last_full_charge" msgid="6570336408060566877">"Nivel de batería desde la última carga completa"</string>
    <string name="battery_usage_chart_graph_hint" msgid="9182079098173323005">"Nivel de batería en las últimas 24 h"</string>
    <string name="battery_app_usage" msgid="8976453608783133770">"Uso de apps desde la última carga completa"</string>
    <string name="battery_app_usage_for_past_24" msgid="1234770810563940656">"Cuánta batería se consumió en las últimas 24 h por app"</string>
    <string name="battery_system_usage" msgid="1395943945140097585">"Uso del sistema desde la última carga completa"</string>
    <string name="battery_system_usage_for_past_24" msgid="3341520273114616263">"Uso del sistema en las últimas 24 h"</string>
    <string name="battery_system_usage_for" msgid="3248552137819897140">"Uso del sistema de <xliff:g id="SLOT">%s</xliff:g>"</string>
    <string name="battery_app_usage_for" msgid="7309909074935858949">"Uso de apps de <xliff:g id="SLOT">%s</xliff:g>"</string>
    <string name="battery_usage_total_less_than_one_minute" msgid="1035425863251685509">"Total: menos de un minuto"</string>
    <string name="battery_usage_background_less_than_one_minute" msgid="3957971442554437909">"En segundo plano: menos de un minuto"</string>
    <string name="battery_usage_screen_time_less_than_one_minute" msgid="2911989465891679033">"Tiempo de uso: menos de un minuto"</string>
    <string name="battery_usage_for_total_time" msgid="8402254046930910905">"Total: <xliff:g id="TIME">%s</xliff:g>"</string>
    <string name="battery_usage_for_background_time" msgid="9109637210617095188">"En segundo plano: <xliff:g id="TIME">%s</xliff:g>"</string>
    <string name="battery_usage_screen_time" msgid="3973865893520804115">"Tiempo de uso: <xliff:g id="TIME">%s</xliff:g>"</string>
    <string name="battery_usage_screen_footer_empty" msgid="3301144846133808193">"Los datos de uso de batería estarán disponibles en unas horas, cuando la carga esté completa"</string>
    <string name="battery_usage_chart_label_now" msgid="4598282721949430165">"ahora"</string>
    <string name="battery_usage_timestamps_hyphen" msgid="7401188432989043905">"<xliff:g id="FROM_TIMESTAMP">%1$s</xliff:g>-<xliff:g id="TO_TIMESTAMP">%2$s</xliff:g>"</string>
    <string name="battery_usage_day_and_hour" msgid="1417890420844950881">"<xliff:g id="DAY">%1$s</xliff:g> <xliff:g id="HOUR">%2$s</xliff:g>"</string>
    <string name="battery_usage_chart" msgid="4114747521432440017">"Gráfico del uso de batería"</string>
    <string name="daily_battery_usage_chart" msgid="4176059567682992686">"Gráfico de uso de batería diario"</string>
    <string name="hourly_battery_usage_chart" msgid="3098314511076561272">"Gráfico de uso de batería por hora"</string>
    <string name="battery_usage_breakdown_title_since_last_full_charge" msgid="435006273323199906">"Uso de batería desde la última carga completa"</string>
    <string name="battery_usage_breakdown_title_for_slot" msgid="4823179483667671406">"Uso de batería <xliff:g id="SLOT">%s</xliff:g>"</string>
    <string name="screen_time_category_last_full_charge" msgid="8856908320256057753">"Tiempo de uso desde la última carga completa"</string>
    <string name="screen_time_category_for_slot" msgid="8287722270554654959">"Tiempo de uso <xliff:g id="SLOT">%s</xliff:g>"</string>
    <string name="battery_usage_spinner_breakdown_by_apps" msgid="7746337368402445072">"Desglose por app"</string>
    <string name="battery_usage_spinner_breakdown_by_system" msgid="4646952798665973464">"Desglose por sistema"</string>
    <string name="battery_usage_less_than_percent" msgid="5873099028895001082">"&lt; <xliff:g id="PERCENTAGE">%1$s</xliff:g>"</string>
    <string name="process_stats_summary_title" msgid="502683176231281732">"Estadísticas de procesos"</string>
    <string name="process_stats_summary" msgid="522842188571764699">"Estadísticas para geeks sobre procesos activos"</string>
    <string name="app_memory_use" msgid="7559666138324410666">"Uso de memoria"</string>
    <string name="process_stats_total_duration" msgid="3898635541254636618">"Se usaron <xliff:g id="USEDRAM">%1$s</xliff:g> de <xliff:g id="TOTALRAM">%2$s</xliff:g> durante el último <xliff:g id="TIMEDURATION">%3$s</xliff:g>."</string>
    <string name="process_stats_total_duration_percentage" msgid="4391502694312709148">"Se usaron <xliff:g id="PERCENT">%1$s</xliff:g> de RAM durante <xliff:g id="TIMEDURATION">%2$s</xliff:g>."</string>
    <string name="process_stats_type_background" msgid="4094034441562453522">"En segundo plano"</string>
    <string name="process_stats_type_foreground" msgid="5043049335546793803">"En primer plano"</string>
    <string name="process_stats_type_cached" msgid="129788969589599563">"En caché"</string>
    <string name="process_stats_os_label" msgid="2096501347732184886">"Sistema operativo Android"</string>
    <string name="process_stats_os_native" msgid="794547105037548539">"Nativo"</string>
    <string name="process_stats_os_kernel" msgid="5626269994512354996">"Kernel"</string>
    <string name="process_stats_os_zram" msgid="3067278664868354143">"Zram"</string>
    <string name="process_stats_os_cache" msgid="4753163023524305711">"Memorias caché"</string>
    <string name="process_stats_ram_use" msgid="5966645638783509937">"Uso de RAM"</string>
    <string name="process_stats_bg_ram_use" msgid="3572439697306771461">"Uso de RAM (en segundo plano)"</string>
    <string name="process_stats_run_time" msgid="8631920944819076418">"Tiempo de ejecución"</string>
    <string name="processes_subtitle" msgid="5791138718719605724">"Procesos"</string>
    <string name="services_subtitle" msgid="9136741140730524046">"Servicios"</string>
    <string name="menu_proc_stats_duration" msgid="1249684566371309908">"Duración"</string>
    <string name="mem_details_title" msgid="8064756349669711949">"Detalles de la memoria"</string>
    <string name="menu_duration_3h" msgid="9202635114831885878">"3 horas"</string>
    <string name="menu_duration_6h" msgid="2843895006519153126">"6 horas"</string>
    <string name="menu_duration_12h" msgid="9206922888181602565">"12 horas"</string>
    <string name="menu_duration_1d" msgid="8538390358158862330">"1 día"</string>
    <string name="menu_show_system" msgid="3780310384799907818">"Mostrar sistema"</string>
    <string name="menu_hide_system" msgid="5197937451381420622">"Ocultar sistema"</string>
    <string name="menu_show_percentage" msgid="6143205879027928330">"Mostrar porcentajes"</string>
    <string name="menu_use_uss" msgid="1663914348353623749">"Usar USS"</string>
    <string name="menu_proc_stats_type" msgid="5048575824389855689">"Tipo de estadística"</string>
    <string name="menu_proc_stats_type_background" msgid="6796434633192284607">"En segundo plano"</string>
    <string name="menu_proc_stats_type_foreground" msgid="9011432748521890803">"En primer plano"</string>
    <string name="menu_proc_stats_type_cached" msgid="1351321959600144622">"En caché"</string>
    <string name="voice_input_output_settings" msgid="1055497319048272051">"Entrada y salida de voz"</string>
    <string name="voice_input_output_settings_title" msgid="6449454483955543064">"Configuración entrada y salida de voz"</string>
    <string name="voice_search_settings_title" msgid="228743187532160069">"Búsqueda por voz"</string>
    <string name="keyboard_settings_title" msgid="2199286020368890114">"Teclado de Android"</string>
    <string name="voice_input_settings" msgid="105821652985768064">"Configuración de entrada de voz"</string>
    <string name="voice_input_settings_title" msgid="3708147270767296322">"Entrada de voz"</string>
    <string name="voice_service_preference_section_title" msgid="4807795449147187497">"Servicios de entrada de voz"</string>
    <string name="voice_interactor_preference_summary" msgid="3942881638813452880">"Interacción y palabra clave completa"</string>
    <string name="voice_recognizer_preference_summary" msgid="9195427725367463336">"Voz a texto simple"</string>
    <string name="voice_interaction_security_warning" msgid="7962884055885987671">"Este servicio de entrada de voz puede supervisar que siempre esté activada la voz y controlar en tu nombre las aplicaciones que pueden utilizar la entrada de voz. Procede de <xliff:g id="VOICE_INPUT_SERVICE_APP_NAME">%s</xliff:g>. ¿Quieres habilitar el uso de este servicio?"</string>
    <string name="on_device_recognition_settings" msgid="6503160369314598069">"Configuración de reconocimiento integrada en el dispositivo"</string>
    <string name="on_device_recognition_settings_title" msgid="7137599722039096545">"Reconocimiento integrado en el dispositivo"</string>
    <string name="on_device_recognition_settings_summary" msgid="3292736423223499348">"Reconocimiento de voz integrado en el dispositivo"</string>
    <string name="tts_engine_preference_title" msgid="7808775764174571132">"Motor preferido"</string>
    <string name="tts_engine_settings_title" msgid="1298093555056321577">"Configuración del motor"</string>
    <string name="tts_sliders_title" msgid="6901146958648426181">"Velocidad y tono de la voz"</string>
    <string name="tts_engine_section_title" msgid="5115035218089228451">"Motor"</string>
    <string name="tts_install_voice_title" msgid="5133545696447933812">"Voces"</string>
    <string name="tts_spoken_language" msgid="4652894245474520872">"Idioma de voz"</string>
    <string name="tts_install_voices_title" msgid="6505257816336165782">"Instalar voces"</string>
    <string name="tts_install_voices_text" msgid="902408506519246362">"Continúa a la app <xliff:g id="TTS_APP_NAME">%s</xliff:g> para instalar voces"</string>
    <string name="tts_install_voices_open" msgid="919034855418197668">"Abrir app"</string>
    <string name="tts_install_voices_cancel" msgid="5179154684379560628">"Cancelar"</string>
    <string name="tts_reset" msgid="9047681050813970031">"Restablecer"</string>
    <string name="tts_play" msgid="2945513377250757221">"Reproducir"</string>
    <string name="vpn_settings_title" msgid="9131315656202257272">"VPN"</string>
    <string name="vpn_settings_insecure_single" msgid="9012504179995045195">"No es segura"</string>
    <string name="vpn_settings_single_insecure_multiple_total" msgid="6107225844641301139">"<xliff:g id="VPN_COUNT">%d</xliff:g> no es segura"</string>
    <string name="vpn_settings_multiple_insecure_multiple_total" msgid="1706236062478680488">"<xliff:g id="VPN_COUNT">%d</xliff:g> no son seguras"</string>
    <string name="adaptive_connectivity_title" msgid="7464959640138428192">"Conectividad adaptable"</string>
    <string name="adaptive_connectivity_summary" msgid="3648731530666326885">"Extiende la duración de la batería y mejora el rendimiento del dispositivo mediante la administración automática de las conexiones de red"</string>
    <string name="adaptive_connectivity_switch_on" msgid="3653067561620745493">"Sí"</string>
    <string name="adaptive_connectivity_switch_off" msgid="5076172560836115265">"No"</string>
    <string name="adaptive_connectivity_main_switch_title" msgid="261045483524512420">"Usa la conectividad adaptable"</string>
    <string name="credentials_title" msgid="7535942196886123656">"Almacenamiento de credenciales"</string>
    <string name="credentials_install" msgid="3933218407598415827">"Instalar un certificado"</string>
    <string name="credentials_reset" msgid="4246628389366452655">"Borrar credenciales"</string>
    <string name="credentials_reset_summary" msgid="5400585520572874255">"Quitar todos los certificados"</string>
    <string name="trusted_credentials" msgid="2522784976058244683">"Credenciales de confianza"</string>
    <string name="trusted_credentials_summary" msgid="345822338358409468">"Mostrar certificados de la AC de confianza"</string>
    <string name="user_credentials" msgid="4044405430790970775">"Credenciales de usuario"</string>
    <string name="user_credentials_summary" msgid="686471637627271856">"Ver y modificar las credenciales guardadas"</string>
    <string name="advanced_security_title" msgid="7117581975877192652">"Configuración avanzada"</string>
    <string name="credentials_settings_not_available" msgid="7433088409177429600">"Las credenciales no están disponibles para este usuario."</string>
    <string name="credential_for_vpn_and_apps" msgid="2208229692860871136">"Se instaló para redes VPN y apps"</string>
    <string name="credential_for_wifi" msgid="2286560570630763556">"Se instaló para redes Wi-Fi"</string>
    <string name="credential_for_wifi_in_use" msgid="7276290656840986618">"Se instaló para redes Wi‑Fi (en uso)"</string>
    <string name="credentials_reset_hint" msgid="4054601857203464867">"¿Quieres quitar todas las credenciales?"</string>
    <string name="credentials_erased" msgid="9121052044566053345">"Credenciales borradas"</string>
    <string name="credentials_not_erased" msgid="3611058412683184031">"Imposible borrar almac credenc"</string>
    <string name="usage_access_title" msgid="1580006124578134850">"Acceso a datos de uso"</string>
    <string name="ca_certificate" msgid="3076484307693855611">"Certificado de la AC"</string>
    <string name="user_certificate" msgid="6897024598058566466">"Cert. de usuario de app y VPN"</string>
    <string name="wifi_certificate" msgid="8461905432409380387">"Certificado de Wi‑Fi"</string>
    <string name="ca_certificate_warning_title" msgid="7951148441028692619">"Tus datos no serán privados"</string>
    <string name="ca_certificate_warning_description" msgid="8409850109551028774">"Los sitios web, las apps y las VPN usan Certificados de CA para la encriptación. Instala únicamente Certificados de CA de organizaciones que sean de confianza. \n\nSi instalas un Certificado de CA, el propietario podrá acceder a tus datos, como contraseñas y detalles de tarjetas de crédito, desde sitios web que visites o apps que uses, incluso si la información está encriptada."</string>
    <string name="certificate_warning_dont_install" msgid="3794366420884560605">"No instalar"</string>
    <string name="certificate_warning_install_anyway" msgid="4633118283407228740">"Instalar de todas formas"</string>
    <string name="cert_not_installed" msgid="6725137773549974522">"No se instaló el certificado"</string>
    <string name="request_manage_credentials_title" msgid="596805634568013413">"¿Deseas permitir que "<b>"<xliff:g id="APP_NAME">^1</xliff:g>"</b>" instale certificados en este dispositivo?"</string>
    <string name="request_manage_credentials_description" msgid="8044839857171509619">"Estos certificados te verificarán compartiendo el ID único del dispositivo con las siguientes apps y URL"</string>
    <string name="request_manage_credentials_dont_allow" msgid="3630610197644877809">"No permitir"</string>
    <string name="request_manage_credentials_allow" msgid="4910940118408348245">"Permitir"</string>
    <string name="request_manage_credentials_more" msgid="6101210283534101582">"Mostrar más"</string>
    <string name="certificate_management_app" msgid="8086699498358080826">"App de admin. de certificados"</string>
    <string name="no_certificate_management_app" msgid="3025739370424406717">"Ninguna"</string>
    <string name="certificate_management_app_description" msgid="8507306554200869005">"Los certificados te verificarán cuando usas las siguientes apps y URL"</string>
    <string name="uninstall_certs_credential_management_app" msgid="4945883254446077354">"Desinstalar certificados"</string>
    <string name="remove_credential_management_app" msgid="6089291496976812786">"Quitar app"</string>
    <string name="remove_credential_management_app_dialog_title" msgid="5713525435104706772">"¿Quieres quitar esta app?"</string>
    <string name="remove_credential_management_app_dialog_message" msgid="7739474298063646935">"Esta app no administrará certificados, pero no se quitará del dispositivo. Se desinstalarán todos los certificados que la app haya instalado."</string>
    <string name="number_of_urls" msgid="1128699121050872188">"{count,plural, =1{# URL}other{# URLs}}"</string>
    <string name="emergency_tone_title" msgid="6673118505206685168">"Indicador de marcado de emergencia"</string>
    <string name="emergency_tone_summary" msgid="2519776254708767388">"Establecer el comportamiento cuando se establece una llamada de emergencia"</string>
    <string name="privacy_settings_title" msgid="6437057228255974577">"Copia de seguridad"</string>
    <string name="backup_summary_state_on" msgid="9018954639693085240">"Activado"</string>
    <string name="backup_summary_state_off" msgid="5341339397224835909">"Desactivado"</string>
    <string name="backup_section_title" msgid="6539706829848457794">"Crear copia de seguridad y Restablecer"</string>
    <string name="personal_data_section_title" msgid="6368610168625722682">"Datos personales"</string>
    <string name="backup_data_title" msgid="507663517227498525">"Hacer una copia de seguridad de mis datos"</string>
    <string name="backup_data_summary" msgid="8054551085241427531">"Crear copias de seguridad de los datos de distintas aplicaciones, de contraseñas Wi-Fi y de otros parámetros de configuración en los servidores de Google"</string>
    <string name="backup_configure_account_title" msgid="8574055186903658842">"Cuenta de copia de seguridad"</string>
    <string name="backup_data_management_title" msgid="6596830198441939702">"Administrar la cuenta de la copia de seguridad"</string>
    <string name="include_app_data_title" msgid="2969603876620594523">"Incluir datos de aplicación"</string>
    <string name="auto_restore_title" msgid="4124345897936637561">"Restaurar automáticamente"</string>
    <string name="auto_restore_summary" msgid="6830198851045584001">"Al reinstalar se restablece la configuración con copia de seguridad."</string>
    <string name="backup_inactive_title" msgid="6753265378043349277">"Servicio de copia de seguridad inactivo"</string>
    <string name="backup_configure_account_default_summary" msgid="5323225330966306690">"Ninguna cuenta está almacenando datos con copia de seguridad."</string>
    <string name="backup_erase_dialog_title" msgid="5892431263348766484"></string>
    <string name="backup_erase_dialog_message" msgid="2250872501409574331">"¿Quieres dejar de crear copias de seguridad de las contraseñas Wi-Fi, los favoritos, otros parámetros de configuración y los datos de distintas aplicaciones, además de eliminar todas las copias de los servidores de Google?"</string>
    <string name="fullbackup_erase_dialog_message" msgid="2379053988557486162">"¿Deseas dejar de crear copias de seguridad de los datos del dispositivo (como las contraseñas de Wi-Fi y el historial de llamadas) y de los datos de las aplicaciones (como las opciones de configuración y los archivos que guardaron las aplicaciones), y borrar todas las copias en servidores remotos?"</string>
    <string name="fullbackup_data_summary" msgid="971587401251601473">"Crear una copia de seguridad automática y remota de los datos del dispositivo (por ejemplo, contraseñas de Wi-Fi e historial de llamadas) y de los datos de las aplicaciones (por ejemplo, archivos y opciones de configuración que guardan las aplicaciones)\n\nCuando activas la copia de seguridad automática, los datos del dispositivo y las aplicaciones se guardan periódicamente de forma remota. Los datos de las aplicaciones pueden ser cualquier dato que guardó una aplicación (según la configuración del programador), incluso datos potencialmente confidenciales, como los contactos, los mensajes y las fotos."</string>
    <string name="device_admin_settings_title" msgid="31392408594557070">"Configuración del administrador del dispositivo"</string>
    <string name="active_device_admin_msg" msgid="7744106305636543184">"App de administración del dispositivo"</string>
    <string name="remove_device_admin" msgid="3143059558744287259">"Desactivar esta app de administración del dispositivo"</string>
    <string name="uninstall_device_admin" msgid="4481095209503956916">"Desinstalar app"</string>
    <string name="remove_and_uninstall_device_admin" msgid="707912012681691559">"Desactivar y desinstalar"</string>
    <string name="select_device_admin_msg" msgid="5501360309040114486">"Apps del dispositivo del administrador"</string>
    <string name="no_device_admins" msgid="8888779888103079854">"No hay apps de administración de dispositivo disponibles"</string>
    <string name="no_trust_agents" msgid="8659098725864191600">"No hay agentes de confianza disponibles."</string>
    <string name="add_device_admin_msg" msgid="7730006568970042119">"¿Activar la app de administración?"</string>
    <string name="add_device_admin" msgid="6252128813507932519">"Activar la app de administración de este dispositivo"</string>
    <string name="device_admin_add_title" msgid="6087481040932322289">"Administrador del dispositivo"</string>
    <string name="device_admin_warning" msgid="1889160106787280321">"Si activas esta app de administración, la app <xliff:g id="APP_NAME">%1$s</xliff:g> podrá realizar las siguientes operaciones:"</string>
    <string name="device_admin_warning_simplified" msgid="2715756519899116115">"<xliff:g id="APP_NAME">%1$s</xliff:g> administrará y supervisará este dispositivo."</string>
    <string name="device_admin_status" msgid="6332571781623084064">"Esta app de administración está activa y permite que la app <xliff:g id="APP_NAME">%1$s</xliff:g> realice las siguientes operaciones:"</string>
    <string name="profile_owner_add_title" msgid="2774489881662331549">"¿Activar el Administrador de perfiles?"</string>
    <string name="profile_owner_add_title_simplified" msgid="2320828996993774182">"¿Quieres permitir la supervisión?"</string>
    <string name="adding_profile_owner_warning" msgid="6868275476058020513">"Si continúas, el administrador controlará tu usuario y podrá almacenar datos asociados, además de tus datos personales.\n\nEl administrador puede controlar y administrar la configuración, el acceso, las apps, y los datos asociados con este usuario, incluida la información acerca de la actividad de red y la ubicación de tu dispositivo."</string>
    <string name="admin_disabled_other_options" msgid="8122039047419172139">"El administrador inhabilitó algunas opciones"</string>
    <string name="admin_more_details" msgid="4928985331640193758">"Más información"</string>
    <string name="notification_log_title" msgid="2812594935014664891">"Registro de notificaciones"</string>
    <string name="notification_history_title" msgid="8821060912502593309">"Historial de notificaciones"</string>
    <string name="notification_history_today" msgid="6081829638548808795">"Últimas %d horas"</string>
    <string name="notification_history_snooze" msgid="3980568893290512257">"Se pospusieron"</string>
    <string name="notification_history_dismiss" msgid="6180321217375722918">"Se descartaron recientemente"</string>
    <string name="notification_history_count" msgid="885305572972482838">"{count,plural, =1{# notificación}other{# notificaciones}}"</string>
    <string name="sound_category_call_ringtone_vibrate_title" msgid="9090693401915654528">"Vibración y tono de llamada"</string>
    <string name="wifi_setup_detail" msgid="2012898800571616422">"Detalles de la red"</string>
    <string name="accessibility_sync_enabled" msgid="5308864640407050209">"Sincronización habilitada"</string>
    <string name="accessibility_sync_disabled" msgid="5507600126380593611">"Sincronización inhabilitada"</string>
    <string name="accessibility_sync_in_progress" msgid="3229428197779196660">"Sincronizando ahora"</string>
    <string name="accessibility_sync_error" msgid="7248490045013170437">"Error de sincronización"</string>
    <string name="sync_failed" msgid="3806495232114684984">"Error de sincronización"</string>
    <string name="sync_active" msgid="5787407579281739975">"Sincronización activada"</string>
    <string name="account_sync_settings_title" msgid="2684888109902800966">"Sincronización"</string>
    <string name="sync_is_failing" msgid="6738004111400633331">"En este momento la sincronización experimenta problemas. Volverá en breve."</string>
    <string name="add_account_label" msgid="7134707140831385869">"Agregar cuenta"</string>
    <string name="managed_profile_not_available_label" msgid="7500578232182547365">"El perfil de trabajo aún no está disponible."</string>
    <string name="work_mode_label" msgid="1001415270126064436">"Perfil de trabajo"</string>
    <string name="work_mode_on_summary" msgid="2042885311126239961">"Administrado por tu organización"</string>
    <string name="work_mode_off_summary" msgid="4044568753909036134">"Las apps y las notificaciones están desactivadas"</string>
    <string name="remove_managed_profile_label" msgid="1294933737673830431">"Eliminar perfil de trabajo"</string>
    <string name="background_data" msgid="321903213000101158">"Datos de fondo"</string>
    <string name="background_data_summary" msgid="6572245922513522466">"Las aplicaciones pueden sincronizar, enviar y recibir datos."</string>
    <string name="background_data_dialog_title" msgid="1692005302993229867">"¿Deseas desactivar los datos en segundo plano?"</string>
    <string name="background_data_dialog_message" msgid="7760280837612824670">"Si inhabilitas los datos en segundo plano, aumenta la duración de la batería y se reduce el uso de datos. Algunas aplicaciones tal vez sigan usando la conexión de datos en segundo plano."</string>
    <string name="sync_enabled" msgid="5794103781356455043">"Sincronización activada"</string>
    <string name="sync_disabled" msgid="1636223106968593391">"Sincronización desactivada"</string>
    <string name="sync_error" msgid="846923369794727644">"Error de sincronización"</string>
    <string name="last_synced" msgid="1527008461298110443">"Última sincronización: <xliff:g id="LAST_SYNC_TIME">%1$s</xliff:g>"</string>
    <string name="sync_in_progress" msgid="6200093151211458977">"Sincronizando…"</string>
    <string name="settings_backup" msgid="5357973563989458049">"Hacer una copia de seguridad de configuraciones"</string>
    <string name="settings_backup_summary" msgid="6803046376335724034">"Realizar copia de seguridad de mi configuración"</string>
    <string name="sync_menu_sync_now" msgid="3948443642329221882">"Sincronizar ahora"</string>
    <string name="sync_menu_sync_cancel" msgid="2422994461106269813">"Cancelar sincronización"</string>
    <string name="sync_one_time_sync" msgid="8114337154112057462">"Presiona para sincronizar ahora<xliff:g id="LAST_SYNC_TIME">
%1$s</xliff:g>"</string>
    <string name="sync_gmail" msgid="228561698646018808">"Gmail"</string>
    <string name="sync_calendar" msgid="4603704438090387251">"Calendario"</string>
    <string name="sync_contacts" msgid="2376465611511325472">"Contactos"</string>
    <string name="header_application_sync_settings" msgid="7427706834875419243">"Conf. de sincronización de aplicación"</string>
    <string name="header_data_and_synchronization" msgid="453920312552838939">"Sincronización y datos"</string>
    <string name="preference_change_password_title" msgid="5465821666939825972">"Cambiar contraseña"</string>
    <string name="header_account_settings" msgid="1189339410278750008">"Configuración de la cuenta"</string>
    <string name="remove_account_label" msgid="4169490568375358010">"Quitar cuenta"</string>
    <string name="header_add_an_account" msgid="3919151542338822661">"Agregar cuenta"</string>
    <string name="really_remove_account_title" msgid="253097435885652310">"¿Deseas quitar la cuenta?"</string>
    <string name="remove_account_failed" msgid="3709502163548900644">"El administrador no permite este cambio"</string>
    <string name="cant_sync_dialog_title" msgid="2613000568881139517">"No se puede sincronizar manualmente"</string>
    <string name="cant_sync_dialog_message" msgid="7612557105054568581">"La sincronización de este elemento actualmente está desactivada. Para cambiar tu configuración, activa momentáneamente los datos en segundo plano y la sincronización automática."</string>
    <string name="delete" msgid="8330605554706263775">"Borrar"</string>
    <string name="select_all" msgid="7898929601615536401">"Seleccionar todo"</string>
    <string name="data_usage_summary_title" msgid="394067070764360142">"Uso de datos"</string>
    <string name="data_usage_app_summary_title" msgid="4933742247928064178">"Wi-Fi y datos móviles"</string>
    <string name="account_settings_menu_auto_sync_personal" msgid="2905595464540145671">"Sincronizar datos personales"</string>
    <string name="account_settings_menu_auto_sync_work" msgid="8561102487795657789">"Sincronizar datos de trabajo"</string>
    <string name="data_usage_change_cycle" msgid="4501026427365283899">"Cambiar el ciclo..."</string>
    <string name="data_usage_pick_cycle_day" msgid="3548922497494790123">"Día del mes para restablecer el ciclo de uso de datos:"</string>
    <string name="data_usage_empty" msgid="5619908658853726866">"Ninguna aplicación usó datos durante este período."</string>
    <string name="data_usage_label_foreground" msgid="8782117644558473624">"Primer plano"</string>
    <string name="data_usage_label_background" msgid="8862781660427421859">"Segundo plano"</string>
    <string name="data_usage_app_restricted" msgid="312065316274378518">"restringido"</string>
    <string name="data_usage_disable_mobile" msgid="6183809500102606801">"¿Deseas desactivar los datos móviles?"</string>
    <string name="data_usage_disable_mobile_limit" msgid="1370147078938479538">"Establecer límite datos móviles"</string>
    <string name="data_usage_disable_4g_limit" msgid="3084868504051520840">"Establecer límite de datos en 4G"</string>
    <string name="data_usage_disable_3g_limit" msgid="8867555130268898044">"Establecer límite de datos 2G-3G"</string>
    <string name="data_usage_disable_wifi_limit" msgid="7222459951785404241">"Limitar datos de Wi-Fi"</string>
    <string name="data_usage_tab_wifi" msgid="801667863336456787">"Wi-Fi"</string>
    <string name="data_usage_tab_ethernet" msgid="2951873059375493878">"Ethernet"</string>
    <string name="data_usage_tab_mobile" msgid="952231704205870928">"Móvil"</string>
    <string name="data_usage_tab_4g" msgid="3265237821331861756">"4 GB"</string>
    <string name="data_usage_tab_3g" msgid="6111070409752123049">"2 GB - 3 GB"</string>
    <string name="data_usage_list_mobile" msgid="3738130489722964291">"Celulares"</string>
    <string name="data_usage_list_none" msgid="2091924522549134855">"Ninguna"</string>
    <string name="data_usage_enable_mobile" msgid="1996943748103310201">"Datos móviles"</string>
    <string name="data_usage_enable_3g" msgid="2818189799905446932">"Datos de 2 GB - 3 GB"</string>
    <string name="data_usage_enable_4g" msgid="1526584080251993023">"Datos de 4 GB"</string>
    <string name="data_roaming_enable_mobile" msgid="5745287603577995977">"Roaming"</string>
    <string name="data_usage_forground_label" msgid="5762048187044975428">"En primer plano:"</string>
    <string name="data_usage_background_label" msgid="5363718469293175279">"En segundo plano:"</string>
    <string name="data_usage_app_settings" msgid="5693524672522122485">"Configuración de la aplicación"</string>
    <string name="data_usage_app_restrict_background" msgid="5728840276368097276">"Datos en segundo plano"</string>
    <string name="data_usage_app_restrict_background_summary" msgid="2997942775999602794">"Habilitar el uso de datos móviles en segundo plano"</string>
    <string name="data_usage_app_restrict_background_summary_disabled" msgid="8213268097024597864">"Para restringir datos en 2.° plano aquí, limita datos móviles."</string>
    <string name="data_usage_app_restrict_dialog_title" msgid="5383874438677899255">"¿Restringir el uso de datos en segundo plano?"</string>
    <string name="data_usage_app_restrict_dialog" msgid="5534272311979978297">"Esta función puede hacer que deje de funcionar una aplicación que tenga que utilizar datos en segundo plano cuando solo estén disponibles redes móviles.\n\nPuedes encontrar controles de uso de datos más adecuados en las opciones de configuración disponibles en la aplicación."</string>
    <string name="data_usage_restrict_denied_dialog" msgid="8599940395497268584">"Solo se pueden restringir los datos en segundo plano si estableciste un límite de datos móviles."</string>
    <string name="data_usage_auto_sync_on_dialog_title" msgid="2048411447974361181">"¿Activar sinc. automática?"</string>
    <string name="data_usage_auto_sync_off_dialog_title" msgid="1783917145440587470">"¿Desactivar sinc. automática?"</string>
    <string name="data_usage_auto_sync_off_dialog" msgid="6523112583569674837">"Así ahorrarás datos y batería, pero tendrás que sincronizar cada cuenta manualmente para obtener información reciente y no recibirás notificaciones cuando haya actualizaciones."</string>
    <string name="data_usage_cycle_editor_title" msgid="2019035830921480941">"Elige el día de inicio de cada ciclo"</string>
    <string name="data_usage_cycle_editor_subtitle" msgid="1026234456777365545">"Día de cada mes:"</string>
    <string name="data_usage_cycle_editor_positive" msgid="6110165528024717527">"Configurar"</string>
    <string name="data_usage_warning_editor_title" msgid="5252748452973120016">"Configurar advertencia de uso de datos"</string>
    <string name="data_usage_limit_editor_title" msgid="8826855902435008518">"Configurar límite de uso de datos"</string>
    <string name="data_usage_limit_dialog_title" msgid="2053134451707801439">"Limitar el uso de datos"</string>
    <string name="data_usage_sweep_warning" msgid="2072854703184614828"><font size="18">"<xliff:g id="NUMBER">^1</xliff:g>"</font><font size="9">"<xliff:g id="UNIT">^2</xliff:g>"</font>\n<font size="12">"advertencia"</font></string>
    <string name="data_usage_sweep_limit" msgid="6947019190890086284"><font size="18">"<xliff:g id="NUMBER">^1</xliff:g>"</font>" "<font size="9">"<xliff:g id="UNIT">^2</xliff:g>"</font>\n<font size="12">"límite"</font></string>
    <string name="data_usage_uninstalled_apps" msgid="9065885396147675694">"Aplicaciones eliminadas"</string>
    <string name="data_usage_uninstalled_apps_users" msgid="1262228664057122983">"Aplicaciones y usuarios eliminados"</string>
    <string name="wifi_metered_title" msgid="6623732965268033931">"Uso de red"</string>
    <string name="data_usage_metered_yes" msgid="4262598072030135223">"De uso medido"</string>
    <string name="vpn_name" msgid="3806456074909253262">"Nombre"</string>
    <string name="vpn_type" msgid="5533202873260826663">"Tipo"</string>
    <string name="vpn_server" msgid="2908816134941973935">"Dirección del servidor"</string>
    <string name="vpn_mppe" msgid="7366657055055114239">"Encriptación de PPP (MPPE)"</string>
    <string name="vpn_l2tp_secret" msgid="2356744369959140121">"L2TP secreto"</string>
    <string name="vpn_ipsec_identifier" msgid="8511842694369254801">"Identificador IPSec"</string>
    <string name="vpn_ipsec_secret" msgid="532007567355505963">"Clave de IPSec compartida previamente"</string>
    <string name="vpn_ipsec_user_cert" msgid="2714372103705048405">"Certificado de usuario IPSec"</string>
    <string name="vpn_ipsec_ca_cert" msgid="5558498943577474987">"Certificado de CA de IPSec"</string>
    <string name="vpn_ipsec_server_cert" msgid="1411390470454731396">"Certificado de servidor IPSec"</string>
    <string name="vpn_show_options" msgid="6105437733943318667">"Mostrar opciones avanzadas"</string>
    <string name="vpn_search_domains" msgid="1973799969613962440">"Dominios de búsqueda de DNS"</string>
    <string name="vpn_dns_servers" msgid="6505263074417737107">"Servidores DNS (por ejemplo, 8.8.8.8)"</string>
    <string name="vpn_routes" msgid="1218707725375594862">"Rutas de reenvío (por ejemplo, 10.0.0.0/8)"</string>
    <string name="vpn_username" msgid="8671768183475960068">"Nombre de usuario"</string>
    <string name="vpn_password" msgid="1183746907642628127">"Contraseña"</string>
    <string name="vpn_save_login" msgid="5986762519977472618">"Guardar información de la cuenta"</string>
    <string name="vpn_not_used" msgid="7229312881336083354">"(No se utiliza)"</string>
    <string name="vpn_no_ca_cert" msgid="3687379414088677735">"(no verificar el servidor)"</string>
    <string name="vpn_no_server_cert" msgid="8106540968643125407">"(recibido desde el servidor)"</string>
    <string name="vpn_always_on_invalid_reason_type" msgid="4699113710248872972">"Este tipo de VPN no puede permanecer conectada todo el tiempo"</string>
    <string name="vpn_always_on_invalid_reason_server" msgid="2635347740046212693">"VPN siempre activada solo es compatible con direcciones de servidor numéricas"</string>
    <string name="vpn_always_on_invalid_reason_no_dns" msgid="3980357762395272467">"Debe especificarse un servidor DNS para VPN siempre activada"</string>
    <string name="vpn_always_on_invalid_reason_dns" msgid="3934369594591801587">"Las direcciones de servidor DNS deben ser numéricas para VPN siempre activada"</string>
    <string name="vpn_always_on_invalid_reason_other" msgid="4571905303713233321">"La información ingresada no es compatible con la VPN siempre activada."</string>
    <string name="vpn_cancel" msgid="5929410618112404383">"Cancelar"</string>
    <string name="vpn_done" msgid="5137858784289564985">"Ignorar"</string>
    <string name="vpn_save" msgid="683868204634860888">"Guardar"</string>
    <string name="vpn_connect" msgid="7102335248484045354">"Conectar"</string>
    <string name="vpn_replace" msgid="1533147558671640341">"Reemplazar"</string>
    <string name="vpn_edit" msgid="5862301148429324911">"Editar perfil de VPN"</string>
    <string name="vpn_forget" msgid="2913950864877236737">"Olvidar"</string>
    <string name="vpn_connect_to" msgid="216709261691085594">"Conectar a <xliff:g id="PROFILE">%s</xliff:g>"</string>
    <string name="vpn_disconnect_confirm" msgid="6356789348816854539">"¿Deseas desconectar esta VPN?"</string>
    <string name="vpn_disconnect" msgid="7753808961085867345">"Desconectar"</string>
    <string name="vpn_version" msgid="6344167191984400976">"Versión"</string>
    <string name="vpn_forget_long" msgid="729132269203870205">"Borrar VPN"</string>
    <string name="vpn_replace_vpn_title" msgid="3994226561866340280">"¿Reemplazar VPN existente?"</string>
    <string name="vpn_set_vpn_title" msgid="1667539483005810682">"¿Configurar la VPN siempre activa?"</string>
    <string name="vpn_first_always_on_vpn_message" msgid="2769478310633047870">"Si activas esta opción de configuración, no tendrás conexión a Internet hasta que se conecte la VPN"</string>
    <string name="vpn_replace_always_on_vpn_enable_message" msgid="9154843462740876652">"Se reemplazará la VPN actual y no tendrás conexión a Internet hasta que se conecte la nueva VPN"</string>
    <string name="vpn_replace_always_on_vpn_disable_message" msgid="4299175336198481106">"Ya estás conectado a una VPN siempre activa. Si te conectas a otra, se reemplazará la VPN actual y se desactivará el modo siempre activo."</string>
    <string name="vpn_replace_vpn_message" msgid="1094297700371463386">"Ya estás conectado a una VPN. Si te conectas a otra, se reemplazará la VPN actual."</string>
    <string name="vpn_turn_on" msgid="3568307071295211187">"Activar"</string>
    <string name="vpn_cant_connect_title" msgid="5670787575925519386">"No se puede establecer conexión con <xliff:g id="VPN_NAME">%1$s</xliff:g>"</string>
    <string name="vpn_cant_connect_message" msgid="2139148820719163694">"Esta app no es compatible con VPN siempre activada"</string>
    <string name="vpn_title" msgid="3068868814145870274">"VPN"</string>
    <string name="vpn_create" msgid="7546073242936894638">"Agregar perfil VPN"</string>
    <string name="vpn_menu_edit" msgid="5100387853773792379">"Modificar perfil"</string>
    <string name="vpn_menu_delete" msgid="4455966182219039928">"Borrar perfil"</string>
    <string name="vpn_menu_lockdown" msgid="5284041663859541007">"VPN siempre activada"</string>
    <string name="vpn_no_vpns_added" msgid="7387080769821533728">"No se agregó ninguna VPN"</string>
    <string name="vpn_always_on_summary" msgid="2171252372476858166">"Mantente siempre conectado a una VPN"</string>
    <string name="vpn_always_on_summary_not_supported" msgid="9084872130449368437">"La opción no es compatible con esta app"</string>
    <string name="vpn_always_on_summary_active" msgid="175877594406330387">"Siempre activada"</string>
    <string name="vpn_insecure_summary" msgid="4450920215186742859">"No es segura"</string>
    <string name="vpn_require_connection" msgid="1027347404470060998">"Bloquear conexiones sin VPN"</string>
    <string name="vpn_require_connection_title" msgid="4186758487822779039">"¿Requerir una conexión VPN?"</string>
    <string name="vpn_insecure_dialog_subtitle" msgid="1857621742868835300">"La VPN no es segura. Actualiza a una VPN IKEv2."</string>
    <string name="vpn_lockdown_summary" msgid="4700625960550559029">"Selecciona el perfil de la VPN con la que deseas establecer una conexión ininterrumpida. El tráfico de red solo se permitirá cuando estés conectado a esta VPN."</string>
    <string name="vpn_lockdown_none" msgid="455915403560910517">"Ninguna"</string>
    <string name="vpn_lockdown_config_error" msgid="1992071316416371316">"La VPN siempre activada requiere una dirección IP tanto para el servidor como para el DNS."</string>
    <string name="vpn_no_network" msgid="7187593680049843763">"No hay conexión de red. Inténtalo de nuevo más tarde."</string>
    <string name="vpn_disconnected" msgid="7694522069957717501">"Desconectado de la VPN"</string>
    <string name="vpn_disconnected_summary" msgid="721699709491697712">"Ninguna"</string>
    <string name="vpn_missing_cert" msgid="5397309964971068272">"Falta un certificado. Edita el perfil."</string>
    <string name="trusted_credentials_system_tab" msgid="675362923690364722">"Sistema"</string>
    <string name="trusted_credentials_user_tab" msgid="4978365619630094339">"Usuario"</string>
    <string name="trusted_credentials_disable_label" msgid="6649583220519447947">"Inhabilitar"</string>
    <string name="trusted_credentials_enable_label" msgid="5551204878588237991">"Activar"</string>
    <string name="trusted_credentials_remove_label" msgid="8296330919329489422">"Desinstalar"</string>
    <string name="trusted_credentials_trust_label" msgid="4841047312274452474">"Confiar"</string>
    <string name="trusted_credentials_enable_confirmation" msgid="6686528499458144754">"¿Deseas activar el certificado de CA del sistema?"</string>
    <string name="trusted_credentials_disable_confirmation" msgid="5131642563381656676">"¿Deseas desactivar el certificado de CA del sistema?"</string>
    <string name="trusted_credentials_remove_confirmation" msgid="3420345440353248381">"¿Deseas eliminar de forma permanente el certificado de CA del usuario?"</string>
    <string name="credential_being_used_by" msgid="3682869943025283499">"En uso por"</string>
    <string name="credential_contains" msgid="3146519680449595771">"Esta entrada contiene lo siguiente"</string>
    <string name="one_userkey" msgid="6363426728683951234">"1 clave del usuario"</string>
    <string name="one_usercrt" msgid="2097644070227688983">"1 certificado del usuario"</string>
    <string name="one_cacrt" msgid="982242103604501559">"1 certificado de CA"</string>
    <string name="n_cacrts" msgid="5886462550192731627">"%d Certificados de CA"</string>
    <string name="user_credential_title" msgid="4686178602575567298">"Detalles de las credenciales"</string>
    <string name="user_credential_removed" msgid="4087675887725394743">"Credencial quitada: <xliff:g id="CREDENTIAL_NAME">%s</xliff:g>"</string>
    <string name="user_credential_none_installed" msgid="918620912366836994">"No se instalaron credenciales de usuario"</string>
    <string name="spellcheckers_settings_title" msgid="2799021700580591443">"Corrector ortográfico"</string>
    <string name="spellcheckers_settings_for_work_title" msgid="6471603934176062893">"Corrector ortográfico para el trabajo"</string>
    <string name="current_backup_pw_prompt" msgid="4962276598546381140">"Escribe tu contraseña actual de copia de seguridad completa aquí."</string>
    <string name="new_backup_pw_prompt" msgid="4884439230209419503">"Escribe una nueva contraseña para copias de seguridad completas."</string>
    <string name="confirm_new_backup_pw_prompt" msgid="5753796799743881356">"Vuelve a escribir aquí tu nueva contraseña de copia de seguridad completa."</string>
    <string name="backup_pw_set_button_text" msgid="8892357974661340070">"Definir contraseña de copia de seguridad"</string>
    <string name="backup_pw_cancel_button_text" msgid="2244399819018756323">"Cancelar"</string>
    <string name="additional_system_update_settings_list_item_title" msgid="7230385345152138051">"Actualizaciones del sistema adicionales"</string>
    <string name="ssl_ca_cert_warning" msgid="3898387588657346106">"Es posible que la red esté supervisada"</string>
    <string name="done_button" msgid="6269449526248267">"Listo"</string>
    <string name="ssl_ca_cert_dialog_title" msgid="1032088078702042090">"{count,plural, =1{Confiar en el certificado o quitarlo}other{Confiar en los certificados o quitarlos}}"</string>
    <string name="ssl_ca_cert_info_message_device_owner" msgid="7528581447864707873">"{numberOfCertificates,plural, =1{{orgName} instaló una autoridad certificadora en tu dispositivo, lo que le permitirá supervisar la actividad de la red del dispositivo, incluidos los correos electrónicos, las apps y los sitios web seguros.\n\nPara obtener más información sobre este certificado, comunícate con tu administrador.}other{{orgName} instaló autoridades certificadoras en tu dispositivo, lo que le permitirá supervisar la actividad de la red del dispositivo, incluidos los correos electrónicos, las apps y los sitios web seguros.\n\nPara obtener más información sobre estos certificados, comunícate con tu administrador.}}"</string>
    <string name="ssl_ca_cert_info_message" msgid="3111724430981667845">"{numberOfCertificates,plural, =1{{orgName} instaló una autoridad certificadora para tu perfil de trabajo, lo que le permitirá supervisar la actividad de la red laboral, incluidos los correos electrónicos, las apps y los sitios web seguros.\n\nPara obtener más información sobre este certificado, comunícate con tu administrador.}other{{orgName} instaló autoridades certificadoras para tu perfil de trabajo, lo que les permitirá supervisar la actividad de la red laboral, como los correos electrónicos, las apps y los sitios web seguros.\n\nPara obtener más información sobre estos certificados, comunícate con tu administrador.}}"</string>
    <string name="ssl_ca_cert_warning_message" msgid="4374052724815563051">"Un tercero puede supervisar tu actividad en la red, incluido el correo electrónico, las aplicaciones y los sitios web seguros.\n\nEsto ocurre porque hay una credencial de confianza instalada en el dispositivo."</string>
    <string name="ssl_ca_cert_settings_button" msgid="2044927302268394991">"{count,plural, =1{Revisar certificado}other{Revisar certificados}}"</string>
    <string name="user_settings_title" msgid="6550866465409807877">"Varios usuarios"</string>
    <string name="user_list_title" msgid="1387379079186123404">"Usuarios y perfiles"</string>
    <string name="user_add_user_or_profile_menu" msgid="305851380425838287">"Agregar usuario o perfil"</string>
    <string name="user_summary_restricted_profile" msgid="451650609582185813">"Perfil restringido"</string>
    <string name="user_summary_not_set_up" msgid="4602868481732886115">"No configurado"</string>
    <string name="user_summary_restricted_not_set_up" msgid="1658946988920104613">"Sin configurar - Perfil restringido"</string>
    <string name="user_summary_managed_profile_not_set_up" msgid="5739207307082458746">"Sin configurar: perfil de trabajo"</string>
    <string name="user_admin" msgid="4024553191395768119">"Administrador"</string>
    <string name="user_you" msgid="3070562015202859996">"Tú (<xliff:g id="NAME">%s</xliff:g>)"</string>
    <string name="user_add_max_count" msgid="3328539978480663740">"No puedes agregar más usuarios. Quita alguno para agregar nuevos."</string>
    <string name="user_cannot_add_accounts_message" msgid="2351326078338805337">"Los perfiles restringidos no pueden agregar cuentas."</string>
    <string name="user_remove_user_menu" msgid="2183714948094429367">"Borrar a <xliff:g id="USER_NAME">%1$s</xliff:g> del disp."</string>
    <string name="user_lockscreen_settings" msgid="4596612658981942092">"Configuración de pantalla bloqueada"</string>
    <string name="user_add_on_lockscreen_menu" msgid="2539059062034644966">"Agregar usuarios desde la pantalla de bloqueo"</string>
    <string name="switch_to_dock_user_when_docked" msgid="2324395443311905635">"Cambiar a usuario administrador cuando se conecte"</string>
    <string name="user_confirm_remove_self_title" msgid="926265330805361832">"¿Deseas borrarte a ti mismo?"</string>
    <string name="user_confirm_remove_title" msgid="3626559103278006002">"¿Borrar este usuario?"</string>
    <string name="user_profile_confirm_remove_title" msgid="3131574314149375354">"¿Eliminar este perfil?"</string>
    <string name="work_profile_confirm_remove_title" msgid="6229618888167176036">"¿Eliminar perfil trabajo?"</string>
    <string name="user_confirm_remove_message" msgid="362545924965977597">"Se borrarán todas las aplicaciones y todos los datos."</string>
    <string name="work_profile_confirm_remove_message" msgid="1037294114103024478">"Si continúas, se borrarán todas las aplicaciones y los datos en este perfil."</string>
    <string name="user_profile_confirm_remove_message" msgid="3641289528179850718">"Se borrarán todas las aplicaciones y todos los datos."</string>
    <string name="user_adding_new_user" msgid="7439602720177181412">"Agregando usuario nuevo..."</string>
    <string name="user_delete_user_description" msgid="7764153465503821011">"Borrar usuario"</string>
    <string name="user_delete_button" msgid="3833498650182594653">"Borrar"</string>
    <string name="user_exit_guest_confirm_message" msgid="8995296853928816554">"Se eliminarán las aplicaciones y los datos de esta sesión."</string>
    <string name="user_exit_guest_dialog_remove" msgid="7067727314172605181">"Eliminar"</string>
    <string name="guest_category_title" msgid="5562663588315329152">"Invitado (tú)"</string>
    <string name="user_category_title" msgid="4368580529662699083">"Usuarios"</string>
    <string name="other_user_category_title" msgid="7089976887307643217">"Otros usuarios"</string>
    <string name="remove_guest_on_exit" msgid="8202972371459611066">"Borrar la actividad de invitado"</string>
    <string name="remove_guest_on_exit_summary" msgid="3969962695703280353">"Borra todas las apps y los datos de invitado cuando salgas del modo de invitado"</string>
    <string name="remove_guest_on_exit_dialog_title" msgid="2310442892536079416">"¿Borrar la actividad de invitado?"</string>
    <string name="remove_guest_on_exit_dialog_message" msgid="8112409834021851883">"Las apps y los datos de esta sesión de invitado se borrarán ahora, y toda la actividad futura correspondiente se borrará cada vez que salgas del modo de invitado."</string>
    <string name="remove_guest_on_exit_keywords" msgid="4961310523576166193">"borrar, invitado, actividad, quitar, datos, visitante, eliminar"</string>
    <string name="enable_guest_calling" msgid="8300355036005240911">"Permite que el invitado use el teléfono"</string>
    <string name="enable_guest_calling_summary" msgid="4748224917641204782">"Se compartirá el historial de llamadas con el usuario invitado"</string>
    <string name="user_enable_calling_sms" msgid="8546430559552381324">"Activar llamadas telefónicas y SMS"</string>
    <string name="user_grant_admin" msgid="6511342422361803820">"Otorgar privilegios de admin. a este usuario"</string>
    <string name="user_remove_user" msgid="8468203789739693845">"Borrar usuario"</string>
    <string name="user_enable_calling_and_sms_confirm_title" msgid="4041510268838725520">"¿Activar llamadas telefónicas y SMS?"</string>
    <string name="user_enable_calling_and_sms_confirm_message" msgid="367792286597449922">"Se compartirá el historial de llamadas y SMS con este usuario."</string>
    <string name="user_revoke_admin_confirm_title" msgid="3057842401861731863">"¿Quitar los privilegios de administrador?"</string>
    <string name="user_revoke_admin_confirm_message" msgid="2719667217562982318">"¿Confirmas que quieres quitar los privilegios de administrador de este usuario?"</string>
    <string name="emergency_info_title" msgid="8233682750953695582">"Información de emergencia"</string>
    <string name="emergency_info_summary" msgid="8463622253016757697">"Información y contactos de <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="open_app_button" msgid="5025229765547191710">"Abrir <xliff:g id="APP_NAME">%1$s</xliff:g>"</string>
    <string name="application_restrictions" msgid="276179173572729205">"Permitir aplicaciones y contenido"</string>
    <string name="apps_with_restrictions_header" msgid="5277698582872267931">"Aplicaciones con restricciones"</string>
    <string name="apps_with_restrictions_settings_button" msgid="2648355133416902221">"Expandir config. a aplicación"</string>
    <string name="user_choose_copy_apps_to_another_user" msgid="5914037067347012870">"Selecciona las apps que quieres instalar"</string>
    <string name="user_copy_apps_menu_title" msgid="5354300105759670300">"Instalar apps disponibles"</string>
    <string name="nfc_payment_settings_title" msgid="2043139180030485500">"Pagos sin contacto"</string>
    <string name="nfc_default_payment_settings_title" msgid="2150504446774382261">"App de pagos predeterminada"</string>
    <string name="nfc_default_payment_footer" msgid="978535088340021360">"Para hacer un pago con una app de pagos, sostén la parte posterior del dispositivo en una terminal."</string>
    <string name="nfc_more_details" msgid="1700713533074275233">"Más información"</string>
    <string name="nfc_default_payment_workapp_confirmation_title" msgid="746921251872504687">"¿Establecer app de trabajo como app de pagos predet.?"</string>
    <string name="nfc_default_payment_workapp_confirmation_message_title" msgid="1533022606333010329">"Para hacer pagos con una app de trabajo:"</string>
    <string name="nfc_default_payment_workapp_confirmation_message_1" msgid="2917430119080702912">"El perfil de trabajo debe estar activado."</string>
    <string name="nfc_default_payment_workapp_confirmation_message_2" msgid="8161184137833245628">"Deberás ingresar tu PIN, patrón o contraseña de trabajo, si tienes uno."</string>
    <string name="nfc_payment_how_it_works" msgid="3658253265242662010">"Cómo funciona"</string>
    <string name="nfc_payment_no_apps" msgid="6840001883471438798">"Paga en las tiendas con tu teléfono"</string>
    <string name="nfc_payment_default" msgid="3769788268378614608">"App de pagos predeterminada"</string>
    <string name="nfc_payment_default_not_set" msgid="6471905683119084622">"Sin establecer"</string>
    <string name="nfc_payment_app_and_desc" msgid="2607417639227030398">"<xliff:g id="APP">%1$s</xliff:g>: <xliff:g id="DESCRIPTION">%2$s</xliff:g>"</string>
    <string name="nfc_payment_use_default" msgid="6127665705799658860">"Usa la app de pagos predeterminada"</string>
    <string name="nfc_payment_use_default_dialog" msgid="8556328090777785383">"Usa la app de pagos predeterminada"</string>
    <string name="nfc_payment_favor_default" msgid="4508491832174644772">"Siempre"</string>
    <string name="nfc_payment_favor_open" msgid="8554643344050373346">"Excepto cuando esté abierta otra app de pagos"</string>
    <string name="nfc_payment_pay_with" msgid="3001320460566523453">"En una terminal para pagar sin contacto, utilizar:"</string>
    <string name="nfc_how_it_works_title" msgid="1363791241625771084">"Cómo pagar en la terminal"</string>
    <string name="nfc_how_it_works_content" msgid="1141382684788210772">"Configura una aplicación para efectuar pagos. A continuación, solo tienes que sostener la parte posterior del teléfono sobre cualquier terminal con el símbolo de pago sin contacto."</string>
    <string name="nfc_how_it_works_got_it" msgid="4717868843368296630">"Entendido"</string>
    <string name="nfc_more_title" msgid="1041094244767216498">"Más…"</string>
    <string name="nfc_payment_set_default_label" msgid="7395939287766230293">"Establecer app de pagos predeterminada"</string>
    <string name="nfc_payment_update_default_label" msgid="8201975914337221246">"Actualizar app de pagos predeterminada"</string>
    <string name="nfc_payment_set_default" msgid="4101484767872365195">"En una terminal para pagar sin contacto, usar <xliff:g id="APP">%1$s</xliff:g>"</string>
    <string name="nfc_payment_set_default_instead_of" msgid="565237441045013280">"En una terminal para pagar sin contacto, usa <xliff:g id="APP_0">%1$s</xliff:g>.\n\nEsto reemplazará a <xliff:g id="APP_1">%2$s</xliff:g> como la app de pagos predeterminada."</string>
    <string name="nfc_payment_btn_text_set_deault" msgid="1821065137209590196">"Establecer como predeterminada"</string>
    <string name="nfc_payment_btn_text_update" msgid="5159700960497443832">"Actualizar"</string>
    <string name="nfc_work_text" msgid="2496515165821504077">"Trabajo"</string>
    <string name="restriction_settings_title" msgid="4293731103465972557">"Restricciones"</string>
    <string name="restriction_menu_reset" msgid="92859464456364092">"Eliminar restricciones"</string>
    <string name="restriction_menu_change_pin" msgid="2505923323199003718">"Cambiar PIN"</string>
    <string name="help_label" msgid="2896538416436125883">"Ayuda y comentarios"</string>
    <string name="user_account_title" msgid="6389636876210834864">"Cuenta para contenido"</string>
    <string name="user_picture_title" msgid="7176437495107563321">"ID de foto"</string>
    <string name="extreme_threats_title" msgid="1098958631519213856">"Amenazas extremas"</string>
    <string name="extreme_threats_summary" msgid="3560742429496902008">"Recibir alertas de amenazas extremas contra la vida y propiedad"</string>
    <string name="severe_threats_title" msgid="8962959394373974324">"Amenazas graves"</string>
    <string name="severe_threats_summary" msgid="4982256198071601484">"Recibir alertas de amenazas graves contra la vida y la propiedad"</string>
    <string name="amber_alerts_title" msgid="5238275758191804575">"Alertas AMBER"</string>
    <string name="amber_alerts_summary" msgid="5755221775246075883">"Recibir boletines sobre secuestros de menores"</string>
    <string name="repeat_title" msgid="8676570486899483606">"Repetir"</string>
    <string name="call_manager_enable_title" msgid="1214301265395158720">"Habilitar el Administrador de llamadas"</string>
    <string name="call_manager_enable_summary" msgid="7362506369604163030">"Permitir que este servicio administre la forma de hacer llamadas"</string>
    <string name="call_manager_title" msgid="3397433159509629466">"Administrador de llamadas"</string>
    <!-- no translation found for call_manager_summary (2558839230880919191) -->
    <skip />
    <string name="cell_broadcast_settings" msgid="2416980110093867199">"Alertas de emergencia inalámbricas"</string>
    <string name="network_operators_settings" msgid="5105453353329748954">"Proveedores de red"</string>
    <string name="access_point_names" msgid="5768430498022188057">"Nombres de puntos de acceso"</string>
    <string name="enhanced_4g_lte_mode_title" msgid="6624700245232361149">"VoLTE"</string>
    <string name="enhanced_4g_lte_mode_title_advanced_calling" msgid="7066009898031465265">"Llamadas avanzadas"</string>
    <string name="enhanced_4g_lte_mode_title_4g_calling" msgid="7445853566718786195">"Llamadas mediante 4G"</string>
    <string name="enhanced_4g_lte_mode_summary" msgid="1067066329756036427">"Usar servicios de LTE para mejorar las llamadas de voz (recomendado)"</string>
    <string name="enhanced_4g_lte_mode_summary_4g_calling" msgid="2575004054914178405">"Usar servicios de 4G para mejorar las llamadas de voz (recomendado)"</string>
    <string name="nr_advanced_calling_title" msgid="6106286679535355939">"Vo5G"</string>
    <string name="nr_advanced_calling_summary" msgid="6926192539172030330">"Usar 5G para llamadas de voz"</string>
    <string name="contact_discovery_opt_in_title" msgid="8708034790649773814">"Enviar contactos al proveedor"</string>
    <string name="contact_discovery_opt_in_summary" msgid="6539010458256667300">"Enviar los números de teléfono de tus contactos para brindar funciones mejoradas"</string>
    <string name="contact_discovery_opt_in_dialog_title" msgid="2230536282911854114">"¿Quieres enviar los contactos a <xliff:g id="CARRIER">%1$s</xliff:g>?"</string>
    <string name="contact_discovery_opt_in_dialog_title_no_carrier_defined" msgid="2028983133745990320">"¿Quieres enviar los contactos a tu proveedor?"</string>
    <string name="contact_discovery_opt_in_dialog_message" msgid="8818310894782757538">"Se enviarán regularmente a <xliff:g id="CARRIER">%1$s</xliff:g> los números de teléfono de tus contactos.<xliff:g id="EMPTY_LINE">

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

</xliff:g>Esta información te avisa si tus contactos pueden usar determinadas funciones, como videollamadas o mensajes."</string>
    <string name="preferred_network_type_title" msgid="812509938714590857">"Tipo de red preferido"</string>
    <string name="preferred_network_type_summary" msgid="8786291927331323061">"LTE (recomendado)"</string>
    <string name="mms_message_title" msgid="6624505196063391964">"Mensajes MMS"</string>
    <string name="mms_message_summary" msgid="2855847140141698341">"Enviar y recibir con los datos móviles desactivados"</string>
    <string name="auto_data_switch_title" msgid="5862200603753603464">"Cambiar a datos móviles automáticamente"</string>
    <string name="auto_data_switch_summary" msgid="1934340931995429057">"Usar esta red cuando tenga mejor disponibilidad"</string>
    <string name="work_sim_title" msgid="8999872928646924429">"SIM de trabajo"</string>
    <string name="user_restrictions_title" msgid="4068914244980335993">"Acceso a aplicaciones y contenido"</string>
    <string name="user_rename" msgid="8735940847878484249">"CAMBIAR NOMBRE"</string>
    <string name="app_restrictions_custom_label" msgid="6949268049087435132">"Definir restricciones de aplicación"</string>
    <string name="user_restrictions_controlled_by" msgid="2821526006742851624">"Controladas por <xliff:g id="APP">%1$s</xliff:g>"</string>
    <string name="app_sees_restricted_accounts" msgid="3526008344222566318">"Esta aplicación puede acceder a tus cuentas."</string>
    <string name="app_sees_restricted_accounts_and_controlled_by" msgid="8338520379923447143">"Esta aplicación puede acceder a tus cuentas. Controlada por <xliff:g id="APP">%1$s</xliff:g>"</string>
    <string name="restriction_wifi_config_title" msgid="2630656989926554685">"Wi‑Fi y red de celulares"</string>
    <string name="restriction_wifi_config_summary" msgid="920419010472168694">"Permitir modificar la configuración de la red Wi‑Fi y de la red de celulares"</string>
    <string name="restriction_bluetooth_config_title" msgid="220586273589093821">"Bluetooth"</string>
    <string name="restriction_bluetooth_config_summary" msgid="7558879931011271603">"Permitir modificar la sincronización y configuración de Bluetooth"</string>
    <string name="restriction_location_enable_title" msgid="4872281754836538066">"Ubicación"</string>
    <string name="restriction_location_enable_summary" msgid="7139292323897390221">"Permitir que las aplicaciones usen la información de tu ubicación"</string>
    <string name="wizard_back" msgid="8257697435061870191">"Atrás"</string>
    <string name="wizard_next" msgid="3884832431439072471">"Siguiente"</string>
    <string name="wizard_back_adoptable" msgid="1447814356855134183">"Formatear de otra manera"</string>
    <string name="regulatory_info_text" msgid="1154461023369976667"></string>
    <string name="sim_settings_title" msgid="2254609719033946272">"SIMs"</string>
    <string name="sim_cellular_data_unavailable" msgid="4653591727755387534">"Datos móviles no disponibles"</string>
    <string name="sim_cellular_data_unavailable_summary" msgid="6505871722911347881">"Presiona para seleccionar una SIM de datos"</string>
    <string name="sim_calls_always_use" msgid="967857230039768111">"Usar siempre para llamadas"</string>
    <string name="select_sim_for_data" msgid="2642305487659432499">"Elige una SIM para datos móviles"</string>
    <string name="select_sim_for_sms" msgid="5335510076282673497">"Selecciona una SIM para los SMS"</string>
    <string name="data_switch_started" msgid="6292759843974720112">"Cambiando SIM de datos. Este proceso puede tardar hasta un minuto."</string>
    <string name="select_specific_sim_for_data_title" msgid="5851980301321577985">"¿Quieres usar <xliff:g id="NEW_SIM">%1$s</xliff:g> para datos móviles?"</string>
    <string name="select_specific_sim_for_data_msg" msgid="7401698123430573637">"Si cambias a <xliff:g id="NEW_SIM">%1$s</xliff:g>, ya no se utilizará <xliff:g id="OLD_SIM">%2$s</xliff:g> para los datos móviles."</string>
    <string name="select_specific_sim_for_data_button" msgid="6571935548920603512">"Usar <xliff:g id="NEW_SIM">%1$s</xliff:g>"</string>
    <string name="select_sim_for_calls" msgid="7843107015635189868">"Llamar con"</string>
    <string name="sim_name_hint" msgid="8231524869124193119">"Ingresar nombre de tarjeta SIM"</string>
    <string name="sim_editor_title" msgid="918655391915256859">"Ranura de SIM %1$d"</string>
    <string name="color_orange" msgid="216547825489739010">"Naranja"</string>
    <string name="color_purple" msgid="6603701972079904843">"Púrpura"</string>
    <string name="sim_status_title" msgid="6188770698037109774">"Estado de SIM"</string>
    <string name="sim_status_title_sim_slot" msgid="4932996839194493313">"Estado de SIM (ranura de SIM %1$d)"</string>
    <string name="sim_signal_strength" msgid="6351052821700294501">"<xliff:g id="DBM">%1$d</xliff:g> dBm y <xliff:g id="ASU">%2$d</xliff:g> asu"</string>
    <string name="sim_notification_title" msgid="2819551384383504031">"Se cambiaron las SIMs"</string>
    <string name="sim_notification_summary" msgid="5593339846307029991">"Presiona para configurar"</string>
    <string name="sim_calls_ask_first_prefs_title" msgid="3077694594349657933">"Preguntar siempre"</string>
    <string name="sim_selection_required_pref" msgid="231437651041498359">"Selección requerida"</string>
    <string name="sim_selection_channel_title" msgid="3193666315607572484">"Selección de SIM"</string>
    <string name="dashboard_title" msgid="5660733037244683387">"Configuración"</string>
    <string name="network_dashboard_title" msgid="788543070557731240">"Internet y redes"</string>
    <string name="network_dashboard_summary_mobile" msgid="7750924671970583670">"Datos móviles, Wi‑Fi y hotspot"</string>
    <string name="network_dashboard_summary_no_mobile" msgid="4022575916334910790">"Wi‑Fi y hotspot"</string>
    <string name="connected_devices_dashboard_title" msgid="19868275519754895">"Dispositivos conectados"</string>
    <string name="connected_devices_dashboard_default_summary" msgid="7211769956193710397">"Bluetooth y vinculación"</string>
    <string name="connected_devices_dashboard_summary" msgid="6927727617078296491">"Bluetooth, En automóvil, NFC"</string>
    <string name="connected_devices_dashboard_no_nfc_summary" msgid="8424794257586524040">"Bluetooth, En automóvil"</string>
    <string name="connected_devices_dashboard_no_driving_mode_summary" msgid="7155882619333726331">"Bluetooth, NFC"</string>
    <string name="connected_devices_dashboard_no_driving_mode_no_nfc_summary" msgid="1175254057213044560">"Bluetooth"</string>
    <string name="connected_devices_dashboard_android_auto_summary" msgid="8179090809275818804">"Bluetooth, Android Auto, modo en automóvil, NFC"</string>
    <string name="connected_devices_dashboard_android_auto_no_nfc_summary" msgid="2532811870469405527">"Bluetooth, Android Auto, modo en automóvil"</string>
    <string name="connected_devices_dashboard_android_auto_no_driving_mode_summary" msgid="6426996842202276640">"Bluetooth, Android Auto, NFC"</string>
    <string name="connected_devices_dashboard_android_auto_no_nfc_no_driving_mode" msgid="1672426693308438634">"Bluetooth, Android Auto"</string>
    <string name="nfc_and_payment_settings_payment_off_nfc_off_summary" msgid="7132040463607801625">"No disponible porque NFC está desactivada"</string>
    <string name="nfc_and_payment_settings_no_payment_installed_summary" msgid="4879818114908207465">"Para usar esta opción, debes instalar una app de pagos"</string>
    <string name="app_and_notification_dashboard_summary" msgid="8047683010984186106">"Apps recientes y predeterminadas"</string>
    <string name="notification_settings_work_profile" msgid="6076211850526353975">"Las apps del perfil de trabajo no tienen acceso a las notificaciones."</string>
    <string name="account_dashboard_title" msgid="8228773251948253914">"Cuentas y contraseñas"</string>
    <string name="account_dashboard_default_summary" msgid="1730719656099599488">"Contraseñas guardadas, autocompletar y cuentas sincronizadas"</string>
    <string name="app_default_dashboard_title" msgid="4071015747629103216">"Apps predeterminadas"</string>
    <string name="cloned_apps_dashboard_title" msgid="5542076801222950921">"Apps clonadas"</string>
    <string name="desc_cloned_apps_intro_text" msgid="1369621522882622476">"Crea una segunda instancia de una app para usar dos cuentas al mismo tiempo."</string>
    <string name="desc_cloneable_app_list_text" msgid="3354586725814708688">"Apps que pueden clonarse."</string>
    <string name="cloned_apps_summary" msgid="8805362440770795709">"<xliff:g id="CLONED_APPS_COUNT">%1$s</xliff:g> clonadas, <xliff:g id="ALLOWED_APPS_COUNT">%2$d</xliff:g> disponibles para clonar"</string>
    <string name="delete_all_app_clones" msgid="3489053361980624999">"Borra todas las apps clonadas"</string>
    <string name="delete_all_app_clones_failure" msgid="6821033414547132335">"Borra todas las apps clonadas"</string>
    <string name="cloned_app_creation_summary" msgid="4642627294993918502">"Creando…"</string>
    <string name="cloned_app_created_summary" msgid="7277912971544890710">"Clonada"</string>
    <string name="cloned_app_creation_toast_summary" msgid="3854494347144867870">"Creando una clonación de <xliff:g id="PACKAGE_LABEL">%1$s</xliff:g>"</string>
    <string name="cloned_app_created_toast_summary" msgid="755225403495544163">"Se creó una clonación de <xliff:g id="PACKAGE_LABEL">%1$s</xliff:g>"</string>
    <string name="system_dashboard_summary" msgid="7400745270362833832">"Idiomas, gestos, hora, copia de seguridad"</string>
    <string name="languages_setting_summary" msgid="4924440599794956443">"Idiomas del sistema, idiomas de las apps"</string>
    <string name="keywords_wifi" msgid="8156528242318351490">"Wi-Fi, wi-fi, conexión de red, Internet, inalámbrico, datos, wifi"</string>
    <string name="keywords_wifi_notify_open_networks" msgid="6580896556389306636">"notificación de Wi-Fi, notificación de wifi"</string>
    <string name="keywords_wifi_data_usage" msgid="4718555409695862085">"uso de datos"</string>
    <string name="keywords_time_format" msgid="5384803098766166820">"Usar formato de 24 horas"</string>
    <string name="keywords_app_default" msgid="8977706259156428770">"Abrir con"</string>
    <string name="keywords_applications_settings" msgid="999926810912037792">"Apps"</string>
    <string name="keywords_time_zone" msgid="6402919157244589055">"zona horaria"</string>
    <string name="keywords_draw_overlay" msgid="3170036145197260392">"burbuja de chat, sistema, alerta, ventana, diálogo, mostrar, sobre otras apps, dibujo"</string>
    <string name="keywords_flashlight" msgid="2133079265697578183">"Linterna, luz"</string>
    <string name="keywords_change_wifi_state" msgid="7573039644328488165">"Wi-Fi, activar o desactivar, control"</string>
    <string name="keywords_more_mobile_networks" msgid="5041272719326831744">"celular, móvil, operador de telefonía celular, inalámbrico, datos, 4G, 3G, 2G, LTE"</string>
    <string name="keywords_wifi_calling" msgid="4319184318421027136">"wifi, wi-fi, llamar, llamada"</string>
    <string name="keywords_display" msgid="874738809280751745">"pantalla, pantalla táctil"</string>
    <string name="keywords_display_brightness_level" msgid="850742707616318056">"atenuar pantalla, pantalla táctil, batería, brillo"</string>
    <string name="keywords_display_night_display" msgid="4711054330804250058">"atenuar pantalla, luz nocturna, tono, modo nocturno, brillo, color de pantalla, color, colores"</string>
    <string name="keywords_display_wallpaper" msgid="8478137541939526564">"fondo, personalizar, personalizar pantalla"</string>
    <string name="keywords_display_font_size" msgid="3593317215149813183">"tamaño del texto"</string>
    <string name="keywords_display_cast_screen" msgid="2572331770299149370">"proyectar, transmitir, duplicar pantalla, compartir pantalla, duplicar pantalla compartida, transmitir pantalla"</string>
    <string name="keywords_storage" msgid="3004667910133021783">"espacio, disco, disco duro, uso de dispositivo"</string>
    <string name="keywords_battery" msgid="7040323668283600530">"uso de energía, carga"</string>
    <string name="keywords_battery_usage" msgid="1763573071014260220">"ver uso de batería, uso de batería, uso de energía"</string>
    <string name="keywords_battery_saver" msgid="6289682844453234359">"ahorro de batería, ahorro de energía, ahorro"</string>
    <string name="keywords_battery_adaptive_preferences" msgid="1774870663426502938">"preferencias adaptables, batería adaptable"</string>
    <string name="keywords_spell_checker" msgid="5148906820603481657">"ortografía, diccionario, corrector ortográfico, corrección automática"</string>
    <string name="keywords_voice_input" msgid="7534900094659358971">"herramienta de reconocimiento, entrada, voz, hablar, idioma, manos libres, mano libre, reconocimiento, ofensiva, palabra, historial, audio, auriculares Bluetooth"</string>
    <string name="keywords_text_to_speech_output" msgid="6728080502619011668">"tarifa, idioma, predeterminado, hablar, texto a voz, accesibilidad, lector de pantalla, ciego"</string>
    <string name="keywords_date_and_time" msgid="4402136313104901312">"reloj, horario militar"</string>
    <string name="keywords_network_reset" msgid="4075670452112218042">"restablecer, configuración de fábrica"</string>
    <string name="keywords_factory_data_reset" msgid="4979623326958976773">"borrar, eliminar, restaurar, quitar, restablecer a la configuración de fábrica"</string>
    <string name="keywords_printing" msgid="3528250034669909466">"impresora"</string>
    <string name="keywords_sounds" msgid="187191900698371911">"sonido de la bocina, bocina, volumen, silenciar, silencio, audio, música, táctil, vibrador, vibrar"</string>
    <string name="keywords_sounds_and_notifications_interruptions" msgid="1500312884808362467">"no interrumpir, interrumpir, interrupción, descanso"</string>
    <string name="keywords_app" msgid="7983814237980258061">"RAM"</string>
    <string name="keywords_location" msgid="8016374808099706213">"nearby, ubicación, historial, informe, GPS"</string>
    <string name="keywords_accounts" msgid="3013897982630845506">"cuenta, agregar una cuenta, perfil de trabajo, agregar cuenta, quitar, borrar"</string>
    <string name="keywords_users" msgid="3497517660077620843">"restricción, restringir, restringido"</string>
    <string name="keywords_keyboard_and_ime" msgid="4741098648730042570">"corrección de texto, corregir, sonido, vibrar, automático, idioma, gesto, sugerir, sugerencia, tema, ofensivo, palabra, tipo, emoji, internacional"</string>
    <string name="keywords_reset_apps" msgid="8254315757754930862">"restablecer, preferencias, predeterminadas"</string>
    <string name="keywords_all_apps" msgid="9016323378609007166">"apps, descarga, aplicaciones, sistema"</string>
    <string name="keywords_app_permissions" msgid="2061773665663541610">"apps, permisos, seguridad"</string>
    <string name="keywords_default_apps" msgid="4601664230800605416">"apps, predeterminado"</string>
    <string name="keywords_ignore_optimizations" msgid="8967142288569785145">"ignorar optimizaciones, descanso, app standby"</string>
    <string name="keywords_color_mode" msgid="1193896024705705826">"vibrante, RGB, sRGB, color, natural, estándar"</string>
    <string name="keywords_screen_resolution" msgid="6652125115386722875">"FHD, QHD, resolución, 1080p, 1440p"</string>
    <string name="keywords_color_temperature" msgid="8159539138837118453">"color, temperatura, D65, D73, blanco, amarillo, azul, cálido, frío"</string>
    <string name="keywords_lockscreen" msgid="3656926961043485797">"desliza para desbloquear, contraseña, patrón, PIN"</string>
    <string name="keywords_app_pinning" msgid="1564144561464945019">"fijar pantalla"</string>
    <string name="keywords_profile_challenge" msgid="5135555521652143612">"desafíos de trabajo, trabajo, perfil"</string>
    <string name="keywords_unification" msgid="2677472004971453468">"perfil de trabajo, perfil administrado, unificar, unificación, trabajo, perfil"</string>
    <string name="keywords_gesture" msgid="3456930847450080520">"gestos"</string>
    <string name="keywords_wallet" msgid="3757421969956996972">"billetera"</string>
    <string name="keywords_payment_settings" msgid="6268791289277000043">"pagar, presionar, pagos"</string>
    <string name="keywords_backup" msgid="707735920706667685">"copia de seguridad, copia"</string>
    <string name="keywords_assist_gesture_launch" msgid="7710762655355161924">"gesto"</string>
    <string name="keywords_face_unlock" msgid="545338452730885392">"rostro, desbloqueo, autorización, acceder"</string>
    <string name="keywords_biometric_unlock" msgid="8569545388717753692">"rostro, desbloqueo, autenticación, acceder, huella dactilar, datos biométricos"</string>
    <string name="keywords_imei_info" msgid="8848791606402333514">"imei, meid, min, versión de prl, imei sv"</string>
    <string name="keywords_sim_status" msgid="4221401945956122228">"red, estado de la red móvil, estado del servicio, potencia de la señal, tipo de red móvil, roaming"</string>
    <string name="keywords_sim_status_esim" msgid="3338719238556853609">"red, estado de la red móvil, estado del servicio, potencia de la señal, tipo de red móvil, roaming, eid"</string>
    <string name="keywords_sim_status_iccid" msgid="4775398796251969759">"red, estado de la red móvil, estado del servicio, potencia de la señal, tipo de red móvil, roaming, iccid"</string>
    <string name="keywords_sim_status_iccid_esim" msgid="4634015619840979184">"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_esim_eid" msgid="8128175058237372457">"eid"</string>
    <string name="keywords_model_and_hardware" msgid="4723665865709965044">"número de serie, versión de hardware"</string>
    <string name="keywords_android_version" msgid="1629882125290323070">"nivel de parche de seguridad de android, versión de banda base, versión de kernel"</string>
    <string name="keywords_dark_ui_mode" msgid="6373999418195344014">"tema, claro, oscuro, modo, sensibilidad a la luz, fotofobia, oscurecer, modo oscuro, migraña"</string>
    <string name="keywords_systemui_theme" msgid="6341194275296707801">"tema oscuro"</string>
    <string name="keywords_device_feedback" msgid="5489930491636300027">"error"</string>
    <string name="keywords_ambient_display_screen" msgid="661492302323274647">"Pantalla Ambiente, pantalla bloqueada"</string>
    <string name="keywords_lock_screen_notif" msgid="6363144436467429932">"notificación en pantalla bloqueada, notificaciones"</string>
    <string name="keywords_face_settings" msgid="1360447094486865058">"rostro"</string>
    <string name="keywords_fingerprint_settings" msgid="7345121109302813358">"huella dactilar, agregar huella dactilar"</string>
    <string name="keywords_biometric_settings" msgid="2173605297939326549">"rostro, huella dactilar, agregar huella dactilar"</string>
    <string name="keywords_active_unlock_settings" msgid="4511320720304388889">"desbloqueo del reloj, agregar desbloqueo del reloj"</string>
    <string name="keywords_display_auto_brightness" msgid="7162942396941827998">"atenuar pantalla, pantalla táctil, batería, brillo inteligente, brillo dinámico, brillo automático"</string>
    <string name="keywords_display_adaptive_sleep" msgid="4905300860114643966">"inteligente, atenuar pantalla, suspender, batería, tiempo de espera, atención, pantalla, inactividad"</string>
    <string name="keywords_auto_rotate" msgid="7288697525101837071">"cámara, inteligente, girar automáticamente, rotar, girar, rotación, vertical, paisaje, orientación, vertical, horizontal"</string>
    <string name="keywords_system_update_settings" msgid="5769003488814164931">"actualizar, Android"</string>
    <string name="keywords_zen_mode_settings" msgid="7810203406522669584">"no interrumpir, programar, notificaciones, bloquear, silenciar, vibrar, suspender, trabajar, enfocar, sonido, silencio, día, día de la semana, fin de semana, noche de la semana, evento"</string>
    <string name="keywords_screen_timeout" msgid="8921857020437540572">"pantalla, tiempo de bloqueo, tiempo de espera de la pantalla, bloqueo de pantalla"</string>
    <string name="keywords_storage_settings" msgid="6018856193950281898">"memoria, caché, datos, eliminar, borrar, liberar, espacio"</string>
    <string name="keywords_bluetooth_settings" msgid="2588159530959868188">"conectado, dispositivo, audífonos, auriculares, bocina, inalámbrico, vincular, auricular, música, multimedia"</string>
    <string name="keywords_wallpaper" msgid="7332890404629446192">"fondo, tema, cuadrícula, personalizar"</string>
    <string name="keywords_styles" msgid="5291614313348476068">"ícono, acento, color"</string>
    <string name="keywords_assist_input" msgid="3086289530227075593">"predeterminado, asistente"</string>
    <string name="keywords_default_payment_app" msgid="5162298193637362104">"pago, predeterminado"</string>
    <string name="keywords_ambient_display" msgid="3149287105145443697">"notificación entrante"</string>
    <string name="keywords_hotspot_tethering" msgid="3688439689671232627">"conexión USB, conexión Bluetooth, hotspot de Wi-Fi"</string>
    <string name="keywords_accessibility_vibration_primary_switch" msgid="730692154347231253">"tecnología táctil, vibrar, vibración"</string>
    <string name="keywords_touch_vibration" msgid="1125291201902251273">"tecnología táctil, vibrar, pantalla, sensibilidad"</string>
    <string name="keywords_ring_vibration" msgid="1736301626537417541">"tecnología táctil, vibrar, teléfono, llamada, sensibilidad, tono"</string>
    <string name="keywords_ramping_ringer_vibration" msgid="3678966746742257366">"tecnología táctil, vibrar, teléfono, llamada, hacer sonar, gradual"</string>
    <string name="keywords_notification_vibration" msgid="2620799301276142183">"tecnología táctil, vibrar, sensibilidad, notificación"</string>
    <string name="keywords_alarm_vibration" msgid="4833220371621521817">"tecnología táctil, vibrar, sensibilidad, alarma"</string>
    <string name="keywords_media_vibration" msgid="723896490102792327">"tecnología táctil, vibrar, sensibilidad, contenido multimedia"</string>
    <string name="keywords_vibration" msgid="670455132028025952">"tecnología táctil, vibrar, vibración"</string>
    <string name="keywords_battery_saver_sticky" msgid="1646191718840975110">"ahorro de batería, fijo, permanente, ahorro de energía, batería"</string>
    <string name="keywords_battery_saver_schedule" msgid="8240483934368455930">"rutina, programa, ahorro de batería, ahorro de energía, batería, automático, porcentaje"</string>
    <string name="keywords_enhance_4g_lte" msgid="658889360486800978">"volte, llamadas avanzadas, llamadas mediante 4G"</string>
    <string name="keywords_nr_advanced_calling" msgid="4157823099610141014">"Vo5G, VoNR, llamadas avanzadas, llamadas 5G"</string>
    <string name="keywords_add_language" msgid="1882751300359939436">"agregar idioma, agregar un idioma"</string>
    <string name="keywords_font_size" msgid="1643198841815006447">"tamaño del texto, letra grande, fuente grande, texto grande, visión reducida, agrandar el texto, agrandar la fuente, agrandamiento de la fuente"</string>
    <string name="keywords_always_show_time_info" msgid="645658129239452778">"pantalla siempre activa, PSA"</string>
    <string name="keywords_change_nfc_tag_apps_state" msgid="9032287964590554366">"nfc, etiqueta, lector"</string>
    <string name="sound_dashboard_summary" msgid="6574444810552643312">"Volumen, vibración, No interrumpir"</string>
    <string name="media_volume_option_title" msgid="5966569685119475630">"Volumen multimedia"</string>
    <string name="remote_media_volume_option_title" msgid="8760846743943305764">"Volumen de transmisión"</string>
    <string name="call_volume_option_title" msgid="1461105986437268924">"Volumen de llamada"</string>
    <string name="alarm_volume_option_title" msgid="6398641749273697140">"Volumen de alarma"</string>
    <string name="ring_volume_option_title" msgid="1520802026403038560">"Volumen de tono y notificaciones"</string>
    <string name="separate_ring_volume_option_title" msgid="2212910223857375951">"Volumen de tono"</string>
    <string name="notification_volume_option_title" msgid="4838818791683615978">"Volumen de notificación"</string>
    <string name="notification_volume_disabled_summary" msgid="8679988555852056079">"No disponible porque el timbre está silenciado"</string>
    <string name="ringtone_title" msgid="3271453110387368088">"Tono de llamada"</string>
    <string name="notification_ringtone_title" msgid="6924501621312095512">"Sonido de notificación predeterminado"</string>
    <string name="notification_unknown_sound_title" msgid="1319708450698738980">"Sonido que proporcionó la app"</string>
    <string name="notification_sound_default" msgid="8630353701915294299">"Sonido de notificaciones predeterminado"</string>
    <string name="alarm_ringtone_title" msgid="6680761007731764726">"Sonido de alarma predeterminado"</string>
    <string name="vibrate_when_ringing_option_ramping_ringer" msgid="2798848945803840348">"Primero vibrar, luego sonar gradualmente"</string>
    <string name="spatial_audio_title" msgid="6591051622375191603">"Audio espacial"</string>
    <string name="dial_pad_tones_title" msgid="3536945335367914892">"Tonos del teclado"</string>
    <string name="screen_locking_sounds_title" msgid="5695030983872787321">"Sonido de bloqueo de pantalla"</string>
    <string name="charging_sounds_title" msgid="5261683808537783668">"Vibración y sonidos de carga"</string>
    <string name="docking_sounds_title" msgid="5341616179210436159">"Sonidos al conectar"</string>
    <string name="touch_sounds_title" msgid="2200734041857425078">"Sonidos de teclas y botones"</string>
    <string name="vibrate_icon_title" msgid="1281100105045362530">"Mostrar siempre el ícono en el modo de vibración"</string>
    <string name="dock_audio_media_title" msgid="6474579339356398330">"Reprod. parlantes conector"</string>
    <string name="dock_audio_media_disabled" msgid="8499927008999532341">"Todo el audio"</string>
    <string name="dock_audio_media_enabled" msgid="4039126523653131281">"Solo audio multimedia"</string>
    <string name="emergency_tone_silent" msgid="5048069815418450902">"Silencio"</string>
    <string name="emergency_tone_alert" msgid="1977698889522966589">"Tonos"</string>
    <string name="emergency_tone_vibrate" msgid="6282296789406984698">"Vibraciones"</string>
    <string name="boot_sounds_title" msgid="5033062848948884111">"Activar los sonidos"</string>
    <string name="live_caption_title" msgid="8617086825712756983">"Subtitulado instantáneo"</string>
    <string name="live_caption_summary" msgid="2898451867595161809">"Muestra subtítulos automáticos"</string>
    <string name="spatial_audio_speaker" msgid="9145233652433523302">"Bocina del teléfono"</string>
    <string name="spatial_audio_wired_headphones" msgid="2237355789145828648">"Auriculares con cable"</string>
    <string name="spatial_audio_text" msgid="8201387855375146000">"El audio del contenido multimedia compatible se hace más envolvente"</string>
    <string name="spatial_summary_off" msgid="8272678804629774378">"No"</string>
    <string name="spatial_summary_on_one" msgid="6239933399496282994">"Sí (<xliff:g id="OUTPUT_DEVICE">%1$s</xliff:g>)"</string>
    <string name="spatial_summary_on_two" msgid="4526919818832483883">"Sí (<xliff:g id="OUTPUT_DEVICE_0">%1$s</xliff:g> y <xliff:g id="OUTPUT_DEVICE_1">%2$s</xliff:g>)"</string>
    <string name="spatial_audio_footer_title" msgid="8775010547623606088">"También puedes activar el audio espacial para dispositivos Bluetooth."</string>
    <string name="spatial_audio_footer_learn_more_text" msgid="3826811708094366301">"Parámetros de configuración de dispositivos conectados"</string>
    <string name="zen_mode_settings_schedules_summary" msgid="2047688589286811617">"{count,plural, =0{Ninguno}=1{Se estableció 1 programa}other{Se establecieron # programas}}"</string>
    <string name="zen_mode_settings_title" msgid="682676757791334259">"No interrumpir"</string>
    <string name="zen_mode_settings_summary" msgid="6040862775514495191">"Solo recibe notificaciones de las personas y apps que más te interesan"</string>
    <string name="zen_mode_slice_subtitle" msgid="6849372107272604160">"Limitar las interrupciones"</string>
    <string name="zen_mode_settings_turn_on_dialog_title" msgid="7500702838426404527">"Activar No interrumpir"</string>
    <string name="zen_mode_behavior_alarms_only" msgid="2956938533859578315">"Los sonidos multimedia y las alarmas pueden interrumpir"</string>
    <string name="zen_mode_automation_settings_title" msgid="3709324184191870926">"Programaciones"</string>
    <string name="zen_mode_delete_automatic_rules" msgid="5020468289267191765">"Borrar programas"</string>
    <string name="zen_mode_schedule_delete" msgid="5383420576833765114">"Borrar"</string>
    <string name="zen_mode_rule_name_edit" msgid="1053237022416700481">"Editar"</string>
    <string name="zen_mode_automation_settings_page_title" msgid="6217433860514433311">"Programas"</string>
    <string name="zen_mode_automatic_rule_settings_page_title" msgid="5264835276518295033">"Programa"</string>
    <string name="zen_mode_schedule_category_title" msgid="1381879916197350988">"Programa"</string>
    <string name="zen_mode_automation_suggestion_title" msgid="7776129050500707960">"Silenciar en ciertos momentos"</string>
    <string name="zen_mode_automation_suggestion_summary" msgid="1946750790084170826">"Definir reglas de No interrumpir"</string>
    <string name="zen_mode_schedule_title" msgid="7064866561892906613">"Programa"</string>
    <string name="zen_mode_use_automatic_rule" msgid="733850322530002484">"Usar programa"</string>
    <string name="zen_mode_summary_combination" msgid="5944689309915947828">"<xliff:g id="MODE">%1$s</xliff:g>: <xliff:g id="EXIT_CONDITION">%2$s</xliff:g>"</string>
    <string name="zen_mode_settings_category" msgid="3794956668816783447">"Habilitar interrupciones con sonido"</string>
    <string name="zen_mode_visual_interruptions_settings_title" msgid="7806181124566937214">"Bloquear alteraciones visuales"</string>
    <string name="zen_mode_visual_signals_settings_subtitle" msgid="7433077540895876672">"Permitir señales visuales"</string>
    <string name="zen_mode_restrict_notifications_title" msgid="4169952466106040297">"Opciones de visualización de notificaciones ocultas"</string>
    <string name="zen_mode_restrict_notifications_category" msgid="5870944770935394566">"Cuando se activa No interrumpir"</string>
    <string name="zen_mode_restrict_notifications_mute" msgid="6692072837485018287">"Notificaciones sin sonido"</string>
    <string name="zen_mode_restrict_notifications_mute_summary" msgid="966597459849580949">"Verás las notificaciones en la pantalla"</string>
    <string name="zen_mode_restrict_notifications_mute_footer" msgid="2152115038156049608">"El teléfono no sonará ni vibrará cuando recibas notificaciones."</string>
    <string name="zen_mode_restrict_notifications_hide" msgid="5997930361607752541">"Notificaciones sin sonido ni elementos visuales"</string>
    <string name="zen_mode_restrict_notifications_hide_summary" msgid="6005445725686969583">"No verás ni oirás notificaciones"</string>
    <string name="zen_mode_restrict_notifications_hide_footer" msgid="3761837271201073330">"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 dispositivo.\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="5469078057954463796">"Personalizada"</string>
    <string name="zen_mode_restrict_notifications_enable_custom" msgid="4303255634151330401">"Habilitar configuración personalizada"</string>
    <string name="zen_mode_restrict_notifications_disable_custom" msgid="5062332754972217218">"Quitar configuración personalizada"</string>
    <string name="zen_mode_restrict_notifications_summary_muted" msgid="4750213316794189968">"Notificaciones sin sonido"</string>
    <string name="zen_mode_restrict_notifications_summary_custom" msgid="3918461289557316364">"Parcialmente ocultas"</string>
    <string name="zen_mode_restrict_notifications_summary_hidden" msgid="636494600775773296">"Notificaciones sin sonido ni elementos visuales"</string>
    <string name="zen_mode_what_to_block_title" msgid="5692710098205334164">"Restricciones personalizadas"</string>
    <string name="zen_mode_block_effects_screen_on" msgid="8780668375194500987">"Cuando la pantalla esté encendida"</string>
    <string name="zen_mode_block_effects_screen_off" msgid="2291988790355612826">"Cuando la pantalla esté apagada"</string>
    <string name="zen_mode_block_effect_sound" msgid="7929909410442858327">"Silenciar el sonido y la vibración"</string>
    <string name="zen_mode_block_effect_intent" msgid="7621578645742903531">"No activar la pantalla"</string>
    <string name="zen_mode_block_effect_light" msgid="1997222991427784993">"No encender luz intermitente"</string>
    <string name="zen_mode_block_effect_peek" msgid="2525844009475266022">"No mostrar notificaciones en pantalla"</string>
    <string name="zen_mode_block_effect_status" msgid="5765965061064691918">"Ocultar íconos de la barra de estado de la parte superior"</string>
    <string name="zen_mode_block_effect_badge" msgid="332151258515152429">"Ocultar puntos de notificación en íconos de apps"</string>
    <string name="zen_mode_block_effect_ambient" msgid="1247740599476031543">"No activar la pantalla con las notificaciones"</string>
    <string name="zen_mode_block_effect_list" msgid="7549367848660137118">"Ocultar del panel desplegable"</string>
    <string name="zen_mode_block_effect_summary_none" msgid="6688519142395714659">"Nunca"</string>
    <string name="zen_mode_block_effect_summary_screen_off" msgid="6989818116297061488">"Cuando la pantalla está apagada"</string>
    <string name="zen_mode_block_effect_summary_screen_on" msgid="4876016548834916087">"Cuando la pantalla está encendida"</string>
    <string name="zen_mode_block_effect_summary_sound" msgid="1559968890497946901">"Sonido y vibración"</string>
    <string name="zen_mode_block_effect_summary_some" msgid="2730383453754229650">"Sonido, vibración y algunos signos visuales de notificaciones"</string>
    <string name="zen_mode_block_effect_summary_all" msgid="3131918059492425222">"Sonido, vibración y signos visuales de notificaciones"</string>
    <string name="zen_mode_blocked_effects_footer" msgid="6403365663466620328">"Nunca se ocultarán las notificaciones necesarias sobre el estado y las actividades básicas del dispositivo."</string>
    <string name="zen_mode_no_exceptions" msgid="1580136061336585873">"Nada"</string>
    <string name="zen_mode_other_options" msgid="3399967231522580421">"otras opciones"</string>
    <string name="zen_mode_add" msgid="8789024026733232566">"Agregar"</string>
    <string name="zen_mode_enable_dialog_turn_on" msgid="1971034397501675078">"Activar"</string>
    <string name="zen_mode_button_turn_on" msgid="6583862599681052347">"Activar ahora"</string>
    <string name="zen_mode_button_turn_off" msgid="2060862413234857296">"Desactivar ahora"</string>
    <string name="zen_mode_settings_dnd_manual_end_time" msgid="8251503918238985549">"El modo \"No interrumpir\" estará activado hasta la(s) <xliff:g id="FORMATTED_TIME">%s</xliff:g>"</string>
    <string name="zen_mode_settings_dnd_manual_indefinite" msgid="1436568478062106132">"El modo \"No interrumpir\" permanecerá activado hasta que lo desactives"</string>
    <string name="zen_mode_settings_dnd_automatic_rule" msgid="1958092329238152236">"Una acción programada (<xliff:g id="RULE_NAME">%s</xliff:g>) activó automáticamente el modo No interrumpir"</string>
    <string name="zen_mode_settings_dnd_automatic_rule_app" msgid="3401685760954156067">"Una app (<xliff:g id="APP_NAME">%s</xliff:g>) activó el modo \"No interrumpir\" automáticamente"</string>
    <string name="zen_mode_settings_dnd_custom_settings_footer" msgid="6566115866660865385">"El modo No interrumpir está activado para <xliff:g id="RULE_NAMES">%s</xliff:g> con opciones de configuración personalizadas."</string>
    <string name="zen_mode_settings_dnd_custom_settings_footer_link" msgid="8255159194653341835">" "<annotation id="link">"Ver configuración personalizada"</annotation></string>
    <string name="zen_interruption_level_priority" msgid="4854123502362861192">"Solo prioridad"</string>
    <string name="zen_mode_and_condition" msgid="8580896862841920031">"<xliff:g id="ZEN_MODE">%1$s</xliff:g>. <xliff:g id="EXIT_CONDITION">%2$s</xliff:g>"</string>
    <string name="zen_mode_sound_summary_on_with_info" msgid="4803606180235742003">"Activado/<xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="zen_mode_sound_summary_on" msgid="9077659040104989899">"Activado"</string>
    <string name="zen_mode_duration_summary_always_prompt" msgid="7658172853423383037">"Preguntar siempre"</string>
    <string name="zen_mode_duration_summary_forever" msgid="5551992961329998606">"Hasta que lo desactives"</string>
    <string name="zen_mode_duration_summary_time_hours" msgid="2602655749780428308">"{count,plural, =1{1 hora}other{# horas}}"</string>
    <string name="zen_mode_duration_summary_time_minutes" msgid="5755536844016835693">"{count,plural, =1{1 minuto}other{# minutos}}"</string>
    <string name="zen_mode_sound_summary_off" msgid="7350437977839985836">"{count,plural, =0{Desactivado}=1{Desactivado/1 programa se puede activar automáticamente}other{Desactivado/# programas se pueden activar automáticamente}}"</string>
    <string name="zen_category_behavior" msgid="3214056473947178507">"Pueden suspender la función No interrumpir:"</string>
    <string name="zen_category_people" msgid="8252926021894933047">"Personas"</string>
    <string name="zen_category_apps" msgid="1167374545618451925">"Apps"</string>
    <string name="zen_category_exceptions" msgid="1316097981052752811">"Alarmas y otras interrupciones"</string>
    <string name="zen_category_schedule" msgid="2003707171924226212">"Programas"</string>
    <string name="zen_category_duration" msgid="7515850842082631460">"Duración para la Configuración rápida"</string>
    <string name="zen_settings_general" msgid="2704932194620124153">"General"</string>
    <string name="zen_sound_footer" msgid="4090291351903631977">"Si activas el modo No interrumpir, se silenciarán el sonido y la vibración, excepto para los elementos que habilites arriba."</string>
    <string name="zen_custom_settings_dialog_title" msgid="4613603772432720380">"Configuración personalizada"</string>
    <string name="zen_custom_settings_dialog_review_schedule" msgid="4674671820584759928">"Revisar programa"</string>
    <string name="zen_custom_settings_dialog_ok" msgid="8842373418878278246">"Entendido"</string>
    <string name="zen_custom_settings_notifications_header" msgid="7635280645171095398">"Notificaciones"</string>
    <string name="zen_custom_settings_duration_header" msgid="5065987827522064943">"Duración"</string>
    <string name="zen_msg_event_reminder_title" msgid="5362025129007417554">"Mensajes, eventos y recordatorios"</string>
    <string name="zen_msg_event_reminder_footer" msgid="2700459146293750387">"Si activas el modo No interrumpir, se silenciarán los mensajes, recordatorios y eventos, excepto los elementos que habilites arriba. También puedes ajustar la configuración de los mensajes para permitir que amigos, familiares y otros contactos se comuniquen contigo."</string>
    <string name="zen_onboarding_ok" msgid="8764248406533833392">"Listo"</string>
    <string name="zen_onboarding_settings" msgid="2815839576245114342">"Configuración"</string>
    <string name="zen_onboarding_new_setting_title" msgid="8813308612916316657">"Notificaciones sin sonido ni elementos visuales"</string>
    <string name="zen_onboarding_current_setting_title" msgid="5024603685220407195">"Notificaciones sin sonido"</string>
    <string name="zen_onboarding_new_setting_summary" msgid="7695808354942143707">"No verás ni oirás notificaciones. Sí se permiten las llamadas de contactos destacados y emisores repetidos."</string>
    <string name="zen_onboarding_current_setting_summary" msgid="8864567406905990095">"(Configuración actual)"</string>
    <string name="zen_onboarding_dnd_visual_disturbances_header" msgid="8639698336231314609">"¿Quieres cambiar la configuración de notificaciones de No interrumpir?"</string>
    <string name="sound_work_settings" msgid="752627453846309092">"Sonidos del perfil de trabajo"</string>
    <string name="work_use_personal_sounds_title" msgid="7729428677919173609">"Usa los sonidos del perfil personal"</string>
    <string name="work_use_personal_sounds_summary" msgid="608061627969077231">"Usa los mismos sonidos que el perfil personal"</string>
    <string name="work_ringtone_title" msgid="4810802758746102589">"Tono del teléfono de trabajo"</string>
    <string name="work_notification_ringtone_title" msgid="2955312017013255515">"Sonido predeterminado para notificaciones de trabajo"</string>
    <string name="work_alarm_ringtone_title" msgid="3369293796769537392">"Sonido predeterminado para alarmas de trabajo"</string>
    <string name="work_sound_same_as_personal" msgid="1836913235401642334">"Igual al del perfil personal"</string>
    <string name="work_sync_dialog_title" msgid="7810248132303515469">"¿Quieres usar los sonidos del perfil personal?"</string>
    <string name="work_sync_dialog_yes" msgid="5785488304957707534">"Confirmar"</string>
    <string name="work_sync_dialog_message" msgid="5066178064994040223">"Tu perfil de trabajo usará los mismos sonidos que el perfil personal"</string>
    <string name="configure_notification_settings" msgid="1492820231694314376">"Notificaciones"</string>
    <string name="notification_dashboard_summary" msgid="7530169251902320652">"Historial de notificaciones y conversaciones"</string>
    <string name="conversation_notifs_category" msgid="2549844862379963273">"Conversación"</string>
    <string name="general_notification_header" msgid="3669031068980713359">"Administrar"</string>
    <string name="app_notification_field" msgid="3208079070539894909">"Notificaciones de la app"</string>
    <string name="app_notification_field_summary" msgid="5981393613897713471">"Controlar notificaciones de apps individuales"</string>
    <string name="advanced_section_header" msgid="6478709678084326738">"General"</string>
    <string name="profile_section_header" msgid="4970209372372610799">"Notificaciones de trabajo"</string>
    <string name="profile_section_header_for_advanced_privacy" msgid="8385775428904838579">"Perfil de trabajo"</string>
    <string name="asst_capability_prioritizer_title" msgid="1181272430009156556">"Prioridad de notificación adaptable"</string>
    <string name="asst_capability_prioritizer_summary" msgid="954988212366568737">"Configurar automáticamente las notificaciones de menor prioridad a silenciosas"</string>
    <string name="asst_capability_ranking_title" msgid="312998580233257581">"Clasificación de notificaciones adaptables"</string>
    <string name="asst_capability_ranking_summary" msgid="2293524677144599450">"Clasificar las notificaciones automáticamente por relevancia"</string>
    <string name="asst_feedback_indicator_title" msgid="5169801869752395354">"Comentarios sobre notificaciones adaptables"</string>
    <string name="asst_feedback_indicator_summary" msgid="5862082842073307900">"Indica los ajustes realizados a las notificaciones y muestra la opción para enviar comentarios al sistema"</string>
    <string name="asst_importance_reset_title" msgid="6191265591976440115">"Restablece la prioridad de notificaciones"</string>
    <string name="asst_importance_reset_summary" msgid="684794589254282667">"Restablece la configuración de importancia cambiada por el usuario y permite que el asistente de notificaciones establezca las prioridades"</string>
    <string name="asst_capabilities_actions_replies_title" msgid="4392470465646394289">"Respuestas y acciones sugeridas"</string>
    <string name="asst_capabilities_actions_replies_summary" msgid="416234323365645871">"Mostrar automáticamente respuestas y acciones sugeridas"</string>
    <string name="notification_history_summary" msgid="5434741516307706892">"Mostrar notificaciones recientes y pospuestas"</string>
    <string name="notification_history" msgid="8663811361243456201">"Historial de notificaciones"</string>
    <string name="notification_history_toggle" msgid="9093762294928569030">"Usar el historial de notificaciones"</string>
    <string name="notification_history_off_title_extended" msgid="853807652537281601">"El historial de notificaciones está desactivado"</string>
    <string name="notification_history_off_summary" msgid="671359587084797617">"Activa el historial de notificaciones para ver las notificaciones recientes y las pospuestas"</string>
    <string name="history_toggled_on_title" msgid="4518001110492652830">"No hay notificaciones recientes"</string>
    <string name="history_toggled_on_summary" msgid="9034278971358282728">"Las notificaciones recientes y pospuestas aparecerán aquí"</string>
    <string name="notification_history_view_settings" msgid="5269317798670449002">"ver configuración de notificaciones"</string>
    <string name="notification_history_open_notification" msgid="2655071846911258371">"notificación abierta"</string>
    <string name="snooze_options_title" msgid="2109795569568344617">"Permitir posponer alarmas"</string>
    <string name="notification_badging_title" msgid="5469616894819568917">"Punto de notificación en ícono de app"</string>
    <string name="notification_bubbles_title" msgid="5681506665322329301">"Burbujas"</string>
    <string name="bubbles_app_toggle_title" msgid="5319021259954576150">"Burbujas"</string>
    <string name="bubbles_conversation_toggle_title" msgid="5225039214083311316">"Mostrar esta conversación en una burbuja"</string>
    <string name="bubbles_conversation_toggle_summary" msgid="720229032254323578">"Mostrar ícono flotante sobre las apps"</string>
    <string name="bubbles_feature_disabled_dialog_title" msgid="1794193899792284007">"¿Quieres activar las burbujas para el dispositivo?"</string>
    <string name="bubbles_feature_disabled_dialog_text" msgid="5275666953364031055">"Si activas las burbujas para esta app, también se activarán para el dispositivo.\n\nEsto afecta otras apps o conversaciones que pueden crear burbujas."</string>
    <string name="bubbles_feature_disabled_button_approve" msgid="2042628067101419871">"Activar"</string>
    <string name="bubbles_feature_disabled_button_cancel" msgid="8963409459448350600">"Cancelar"</string>
    <string name="notifications_bubble_setting_on_summary" msgid="4641572377430901196">"Burbujas activadas: Las conversaciones pueden aparecer como elementos flotantes"</string>
    <string name="notifications_bubble_setting_title" msgid="8287649393774855268">"Permitir que las apps muestren burbujas"</string>
    <string name="notifications_bubble_setting_description" msgid="7336770088735025981">"Algunas conversaciones aparecerán como elementos flotantes encima de otras apps"</string>
    <string name="bubble_app_setting_all" msgid="312524752846978277">"Se pueden crear burbujas de todas las conversaciones"</string>
    <string name="bubble_app_setting_selected" msgid="4324386074198040675">"Se pueden crear burbujas de las conversaciones seleccionadas"</string>
    <string name="bubble_app_setting_none" msgid="8643594711863996418">"No se pueden crear burbujas"</string>
    <string name="bubble_app_setting_selected_conversation_title" msgid="3060958976857529933">"Conversaciones"</string>
    <string name="bubble_app_setting_excluded_conversation_title" msgid="324818960338773945">"Todas las conversaciones pueden crear burbujas, excepto"</string>
    <string name="bubble_app_setting_unbubble_conversation" msgid="1769789500566080427">"Desactiva las burbujas para esta conversación"</string>
    <string name="bubble_app_setting_bubble_conversation" msgid="1461981680982964285">"Activa las burbujas para esta conversación"</string>
    <string name="swipe_direction_ltr" msgid="5137180130142633085">"Desliza el dedo hacia la derecha para cerrar la notificación o hacia la izquierda para mostrar el menú"</string>
    <string name="swipe_direction_rtl" msgid="1707391213940663992">"Desliza el dedo hacia la izquierda para cerrar la notificación y hacia la derecha para mostrar el menú"</string>
    <string name="silent_notifications_status_bar" msgid="6113307620588767516">"Ocultar las notificaciones silenciosas en la barra de estado"</string>
    <string name="notification_pulse_title" msgid="8013178454646671529">"Luz intermitente"</string>
    <string name="lock_screen_notifications_title" msgid="2876323153692406203">"Privacidad"</string>
    <string name="lockscreen_bypass_title" msgid="6519964196744088573">"Omitir pantalla de bloqueo"</string>
    <string name="lockscreen_bypass_summary" msgid="4578154430436224161">"Después del desbloqueo, ir a la última pantalla usada. No se mostrarán notificaciones en la pantalla de bloqueo. Desliza desde arriba para verlas."</string>
    <string name="keywords_lockscreen_bypass" msgid="41035425468915498">"Pantalla bloqueada, bloqueo de pantalla, omitir, omisión"</string>
    <string name="locked_work_profile_notification_title" msgid="279367321791301499">"Con el perfil de trabajo bloqueado"</string>
    <string name="unseen_notifs_lock_screen" msgid="6910701117021324612">"Mostrar solo notificaciones nuevas en la pantalla de bloqueo"</string>
    <string name="unseen_notifs_lock_screen_summary" msgid="5996722793868021391">"Quita automáticamente las notificaciones ya vistas de la pantalla de bloqueo"</string>
    <string name="lock_screen_notifs_title" msgid="3412042692317304449">"Notificaciones en pantalla de bloqueo"</string>
    <string name="lock_screen_notifs_show_all_summary" msgid="4226586018375762117">"Mostrar conversaciones predeterminadas y silenciosas"</string>
    <string name="lock_screen_notifs_show_all" msgid="1300418674456749664">"Mostrar conversaciones predeterminadas y silenciosas"</string>
    <string name="lock_screen_notifs_show_alerting" msgid="6584682657382684566">"Ocultar conversaciones y notificaciones silenciosas"</string>
    <string name="lock_screen_notifs_show_none" msgid="1941044980403067101">"No mostrar notificaciones"</string>
    <string name="lock_screen_notifs_redact" msgid="9024158855454642296">"Notificaciones sensibles"</string>
    <string name="lock_screen_notifs_redact_summary" msgid="1395483766035470612">"Mostrar contenido sensible cuando el dispositivo esté bloqueado"</string>
    <string name="lock_screen_notifs_redact_work" msgid="3833920196569208430">"Notificaciones sensibles del perfil de trabajo"</string>
    <string name="lock_screen_notifs_redact_work_summary" msgid="3238238380405430156">"Mostrar contenido confidencial del perfil de trabajo cuando el dispositivo esté bloqueado"</string>
    <string name="lock_screen_notifications_summary_show" msgid="6540443483088311328">"Mostrar todo el contenido de las notificaciones"</string>
    <string name="lock_screen_notifications_summary_hide" msgid="7837303171531166789">"Mostrar contenido sensible solo al desbloquear"</string>
    <string name="lock_screen_notifications_summary_disable" msgid="3388290397947365744">"No mostrar notificaciones"</string>
    <string name="lock_screen_notifications_interstitial_message" msgid="4688399629301178487">"¿Cómo quieres que se muestren las notificaciones en la pantalla de bloqueo?"</string>
    <string name="lock_screen_notifications_interstitial_title" msgid="1360388192096354315">"Pantalla de bloqueo"</string>
    <string name="lock_screen_notifications_summary_show_profile" msgid="8373401288962523946">"Mostrar el contenido de notificaciones de trabajo"</string>
    <string name="lock_screen_notifications_summary_hide_profile" msgid="2183455323048921579">"Ocultar contenido de trabajo confidencial"</string>
    <string name="lock_screen_notifications_interstitial_message_profile" msgid="1456262034599029028">"¿Cómo deseas ver las notificaciones de perfil cuando esté bloqueado el dispositivo?"</string>
    <string name="lock_screen_notifications_interstitial_title_profile" msgid="6950124772255324448">"Notificaciones de perfil"</string>
    <string name="notifications_title" msgid="4221655533193721131">"Notificaciones"</string>
    <string name="app_notifications_title" msgid="248374669037385148">"Notificaciones de apps"</string>
    <string name="notification_channel_title" msgid="8859880871692797611">"Categoría de notificaciones"</string>
    <string name="notification_importance_title" msgid="1545158655988342703">"Comportamiento"</string>
    <string name="conversations_category_title" msgid="5586541340846847798">"Conversaciones"</string>
    <string name="conversation_section_switch_title" msgid="3332885377659473775">"Sección de conversaciones"</string>
    <string name="conversation_section_switch_summary" msgid="6123587625929439674">"Permite que la app use la sección de conversaciones"</string>
    <string name="demote_conversation_title" msgid="6355383023376508485">"No es una conversación"</string>
    <string name="demote_conversation_summary" msgid="4319929331165604112">"Quitar de la sección de conversaciones"</string>
    <string name="promote_conversation_title" msgid="4731148769888238722">"Esta es una conversación"</string>
    <string name="promote_conversation_summary" msgid="3890724115743515035">"Agregar a la sección de conversaciones"</string>
    <string name="priority_conversation_count_zero" msgid="3862289535537564713">"No hay conversaciones prioritarias"</string>
    <string name="priority_conversation_count" msgid="7291234530844412077">"{count,plural, =1{# conversación prioritaria}other{# conversaciones prioritarias}}"</string>
    <string name="important_conversations" msgid="1233893707189659401">"Conversaciones prioritarias"</string>
    <string name="important_conversations_summary_bubbles" msgid="614327166808117644">"Se muestran en la parte superior de la sección de conversaciones como burbujas flotantes."</string>
    <string name="important_conversations_summary" msgid="3184022761562676418">"Se mostrarán en la parte superior de la sección de conversaciones"</string>
    <string name="other_conversations" msgid="551178916855139870">"Conversaciones no prioritarias"</string>
    <string name="other_conversations_summary" msgid="3487426787901236273">"Conversaciones que modificaste"</string>
    <string name="recent_conversations" msgid="471678228756995274">"Conversaciones recientes"</string>
    <string name="conversation_settings_clear_recents" msgid="8940398397663307054">"Conversaciones claras recientes"</string>
    <string name="recent_convos_removed" msgid="2122932798895714203">"Se quitaron las conversaciones recientes"</string>
    <string name="recent_convo_removed" msgid="8686414146325958281">"Se quitó la conversación"</string>
    <string name="clear" msgid="5092178335409471100">"Borrar"</string>
    <string name="conversation_onboarding_title" msgid="5194559958353468484">"Las conversaciones prioritarias y modificadas aparecerán aquí"</string>
    <string name="conversation_onboarding_summary" msgid="2484845363368486941">"Las conversaciones que marques como prioritarias o modifiques aparecerán aquí. \n\nPara cambiar la configuración de las conversaciones, haz lo siguiente: \nDesliza el dedo hacia abajo desde la parte superior de la pantalla para abrir el panel desplegable y mantén presionada una conversación."</string>
    <string name="notification_importance_min_title" msgid="7676541266705442501">"Minimizar"</string>
    <string name="notification_importance_high_title" msgid="394129291760607808">"Mostrar en la pantalla"</string>
    <string name="notification_silence_title" msgid="4085829874452944989">"Silenciada"</string>
    <string name="notification_alert_title" msgid="1632401211722199217">"Predeterminada"</string>
    <string name="allow_interruption" msgid="5237201780159482716">"Permitir interrupciones"</string>
    <string name="allow_interruption_summary" msgid="9044131663518112543">"Permite que la app emita sonidos, vibre y muestre notificaciones en pantalla"</string>
    <string name="notification_priority_title" msgid="5554834239080425229">"Prioritaria"</string>
    <string name="notification_channel_summary_priority" msgid="7225362351439076913">"Aparece en la parte superior de la sección de conversaciones, en forma de burbuja flotante, y muestra la foto de perfil en la pantalla de bloqueo."</string>
    <string name="convo_not_supported_summary" msgid="4285471045268268048">"<xliff:g id="APP_NAME">%1$s</xliff:g> no es compatible con la mayoría de las funciones de conversaciones. No podrás establecer una conversación como prioritaria y las conversaciones no aparecerán como burbujas flotantes."</string>
    <string name="notification_channel_summary_min" msgid="8823399508450176842">"En el panel desplegable, mostrar las notificaciones en una línea"</string>
    <string name="notification_channel_summary_low" msgid="5549662596677692000">"Sin sonido ni vibración"</string>
    <string name="notification_conversation_summary_low" msgid="6352818857388412326">"No suena ni vibra, y aparece en la parte inferior de la sección de conversaciones."</string>
    <string name="notification_channel_summary_default" msgid="3674057458265438896">"Puede sonar o vibrar en función de la configuración del teléfono."</string>
    <string name="notification_channel_summary_high" msgid="3411637309360617621">"Con el dispositivo desbloqueado, mostrar notificaciones como banner en la parte superior de la pantalla"</string>
    <string name="notification_switch_label" msgid="8029371325967501557">"Todas las notificaciones de \"<xliff:g id="APP_NAME">%1$s</xliff:g>\""</string>
    <string name="notification_app_switch_label" msgid="4422902423925084193">"Todas las notificaciones de <xliff:g id="APP_NAME">%1$s</xliff:g>"</string>
    <string name="notifications_sent_daily" msgid="10274479224185437">"{count,plural, =1{Aproximadamente # notificación por día}other{Aproximadamente # notificaciones por día}}"</string>
    <string name="notifications_sent_weekly" msgid="7895656213187555346">"{count,plural, =1{Aproximadamente # notificación por semana}other{Aproximadamente # notificaciones por semana}}"</string>
    <string name="notifications_sent_never" msgid="9081278709126812062">"Nunca"</string>
    <string name="manage_notification_access_title" msgid="6481256069087219982">"Notificaciones de apps y dispositivos"</string>
    <string name="manage_notification_access_summary" msgid="2907135226478903997">"Controla qué apps y dispositivos pueden leer notificaciones"</string>
    <string name="work_profile_notification_access_blocked_summary" msgid="8643809206612366067">"El acceso a las notificaciones del perfil de trabajo está bloqueado"</string>
    <string name="notification_assistant_title" msgid="5889201903272393099">"Notificaciones mejoradas"</string>
    <string name="notification_assistant_summary" msgid="1957783114840908887">"Recibe acciones sugeridas, respuestas y mucho más"</string>
    <string name="no_notification_assistant" msgid="2533323397091834096">"Ninguna"</string>
    <string name="no_notification_listeners" msgid="2839354157349636000">"Ninguna aplicación instalada solicitó acceso a las notificaciones."</string>
    <string name="notification_access_detail_switch" msgid="46386786409608330">"Permitir acceso a las notificaciones"</string>
    <string name="notification_assistant_security_warning_summary" msgid="4846559755787348129">"Las notificaciones mejoradas reemplazaron a las notificaciones adaptables en Android 12. Esta función muestra respuestas y acciones sugeridas, y organiza tus notificaciones. \n\nLas notificaciones mejoradas pueden acceder a todo el contenido de notificaciones, lo que incluye información personal, como nombres de contactos y mensajes. También puede descartar o responder notificaciones (como contestar llamadas) y controlar la función No interrumpir."</string>
    <string name="notification_listener_security_warning_title" msgid="5791700876622858363">"¿Deseas permitir que <xliff:g id="SERVICE">%1$s</xliff:g> tenga acceso a las notificaciones?"</string>
    <string name="notification_listener_security_warning_summary" msgid="1131986567509818121">"La app de <xliff:g id="NOTIFICATION_LISTENER_NAME">%1$s</xliff:g> podrá leer todas las notificaciones, incluidas las que contengan información personal, como nombres de contactos, fotos y el texto de los mensajes que recibas. Esta app también podrá posponer o descartar notificaciones y realizar acciones en botones de notificaciones (por ejemplo, para responder llamadas). \n\nAdemás, podrá activar y desactivar No interrumpir y cambiar la configuración relacionada."</string>
    <string name="nls_warning_prompt" msgid="1486887096703743841">"La app de <xliff:g id="NOTIFICATION_LISTENER_NAME">%1$s</xliff:g> podrá:"</string>
    <string name="nls_feature_read_title" msgid="7629713268744220437">"Lee notificaciones"</string>
    <string name="nls_feature_read_summary" msgid="1064698238110273593">"Puede leer tus notificaciones, incluidas las que contienen información personal como contactos, mensajes y fotos."</string>
    <string name="nls_feature_reply_title" msgid="7925455553821362039">"Responde los mensajes"</string>
    <string name="nls_feature_reply_summary" msgid="4492543411395565556">"Puede responder a mensajes y realizar acciones en los botones de las notificaciones, como posponerlas o descartarlas, y responder llamadas."</string>
    <string name="nls_feature_settings_title" msgid="8208164329853194414">"Cambia parámetros de configuración"</string>
    <string name="nls_feature_settings_summary" msgid="3770028705648985689">"Puede activar o desactivar el modo No interrumpir y cambia los parámetros de configuración relacionados."</string>
    <string name="notification_listener_disable_warning_summary" msgid="8373396293802088961">"Si desactivas el acceso a las notificaciones de <xliff:g id="NOTIFICATION_LISTENER_NAME">%1$s</xliff:g>, es posible que también se desactive el modo No interrumpir."</string>
    <string name="notification_listener_disable_warning_confirm" msgid="841492108402184976">"Desactivar"</string>
    <string name="notification_listener_disable_warning_cancel" msgid="8802784105045594324">"Cancelar"</string>
    <string name="notif_type_ongoing" msgid="135675014223627555">"Tiempo real"</string>
    <string name="notif_type_ongoing_summary" msgid="2348867528527573574">"Comunicación continua de las apps en uso, navegación, llamadas telefónicas y mucho más"</string>
    <string name="notif_type_conversation" msgid="4383931408641374979">"Conversaciones"</string>
    <string name="notif_type_conversation_summary" msgid="179142405410217101">"SMS, mensajes de texto y otras comunicaciones"</string>
    <string name="notif_type_alerting" msgid="4713073696855718576">"Notificaciones"</string>
    <string name="notif_type_alerting_summary" msgid="4681068287836313604">"Pueden sonar o vibrar en función de la configuración"</string>
    <string name="notif_type_silent" msgid="6273951794420331010">"Silencio"</string>
    <string name="notif_type_silent_summary" msgid="7820923063105060844">"Notificaciones que nunca suenan ni vibran"</string>
    <string name="notification_listener_allowed" msgid="5536962633536318551">"Con permiso"</string>
    <string name="notification_listener_not_allowed" msgid="3352962779597846538">"No permitida"</string>
    <string name="notif_listener_excluded_app_title" msgid="6679316209330349730">"Ver todas las apps"</string>
    <string name="notif_listener_excluded_app_summary" msgid="2914567678047195396">"Cambia la configuración de cada una de las apps que envían notificaciones"</string>
    <string name="notif_listener_excluded_app_screen_title" msgid="8636196723227432994">"Apps que se muestran en el dispositivo"</string>
    <string name="notif_listener_not_migrated" msgid="6265206376374278226">"Esta app no admite opciones de configuración mejoradas"</string>
    <string name="notif_listener_more_settings" msgid="1348409392307208921">"Más parámetros de configuración"</string>
    <string name="notif_listener_more_settings_desc" msgid="7995492074281663658">"Puedes encontrar más parámetros de configuración disponibles dentro de esta app"</string>
    <string name="vr_listeners_title" msgid="4960357292472540964">"Servicio de ayuda de RV"</string>
    <string name="no_vr_listeners" msgid="8442646085375949755">"Ninguna app instalada solicitó que se la ejecutara como servicio de ayuda de RV."</string>
    <string name="vr_listener_security_warning_title" msgid="7026351795627615177">"¿Quieres permitir que el servicio de RV acceda a <xliff:g id="SERVICE">%1$s</xliff:g>?"</string>
    <string name="vr_listener_security_warning_summary" msgid="1888843557687017791">"<xliff:g id="VR_LISTENER_NAME">%1$s</xliff:g> se podrá ejecutar cuando uses aplicaciones en modo de realidad virtual."</string>
    <string name="display_vr_pref_title" msgid="4850474436291113569">"Cuando el dispositivo está en modo RV"</string>
    <string name="display_vr_pref_low_persistence" msgid="7039841277157739871">"Reducir desenfoque (recomendado)"</string>
    <string name="display_vr_pref_off" msgid="4008841566387432721">"Reducir parpadeo"</string>
    <string name="picture_in_picture_title" msgid="9001594281840542493">"Pantalla en pantalla"</string>
    <string name="picture_in_picture_empty_text" msgid="9123600661268731579">"Ninguna de las apps instaladas es compatible con el modo Pantalla en pantalla"</string>
    <string name="picture_in_picture_keywords" msgid="3605379820551656253">"imagen en imagen"</string>
    <string name="picture_in_picture_app_detail_title" msgid="4442235098255164650">"Pantalla en pantalla"</string>
    <string name="picture_in_picture_app_detail_switch" msgid="8544190716075624017">"Permitir pantalla en pantalla"</string>
    <string name="picture_in_picture_app_detail_summary" msgid="2503211101305358849">"Permite que esta app cree una ventana de Pantalla en pantalla mientras esté abierta o después de que hayas salido de ella (por ejemplo, para seguir viendo un video). Esta ventana se muestra sobre otras apps que estés usando."</string>
    <string name="interact_across_profiles_title" msgid="7285906999927669971">"Apps personales y de trabajo conectadas"</string>
    <string name="interact_across_profiles_summary_allowed" msgid="1365881452153799092">"Conectada"</string>
    <string name="interact_across_profiles_summary_not_allowed" msgid="5802674212788171790">"No conectadas"</string>
    <string name="interact_across_profiles_empty_text" msgid="419061031064397168">"No hay apps conectadas"</string>
    <string name="interact_across_profiles_keywords" msgid="5996472773111665049">"apps personales y de trabajo conectadas al perfil sincronizado"</string>
    <string name="interact_across_profiles_switch_enabled" msgid="7294719120282287495">"Conectadas"</string>
    <string name="interact_across_profiles_switch_disabled" msgid="4312196170211463988">"Conectar estas apps"</string>
    <string name="interact_across_profiles_summary_1" msgid="6093976896137600231">"Las apps conectadas comparten permisos y cada una puede acceder a los datos de la otra."</string>
    <string name="interact_across_profiles_summary_2" msgid="505748305453633885">"Solo conecta apps si confías en que no compartirán datos personales con tu administrador de TI."</string>
    <string name="interact_across_profiles_summary_3" msgid="444428694843299854">"Puedes desconectar apps cuando quieras en la configuración de privacidad del dispositivo."</string>
    <string name="interact_across_profiles_consent_dialog_title" msgid="8530621211216508681">"¿Quieres confiarle tus datos personales a la app de trabajo <xliff:g id="NAME">%1$s</xliff:g>?"</string>
    <string name="interact_across_profiles_consent_dialog_summary" msgid="3949870271562055048">"Solo conecta apps si confías en que no compartirán datos personales con tu administrador de TI."</string>
    <string name="interact_across_profiles_consent_dialog_app_data_title" msgid="8436318876213958940">"Datos de apps"</string>
    <string name="interact_across_profiles_consent_dialog_app_data_summary" msgid="6057019384328088311">"Esta app puede acceder a los datos de tu app personal de <xliff:g id="NAME">%1$s</xliff:g>."</string>
    <string name="interact_across_profiles_consent_dialog_permissions_title" msgid="2316852600280487055">"Permisos"</string>
    <string name="interact_across_profiles_consent_dialog_permissions_summary" msgid="995051542847604039">"Esta app puede usar los permisos de tu app personal de <xliff:g id="NAME">%1$s</xliff:g>, como el acceso a la ubicación, el almacenamiento o los contactos."</string>
    <string name="interact_across_profiles_number_of_connected_apps_none" msgid="8573289199942092964">"No hay apps conectadas"</string>
    <string name="interact_across_profiles_number_of_connected_apps" msgid="4000424798291479207">"{count,plural, =1{# app conectada}other{# apps conectadas}}"</string>
    <string name="interact_across_profiles_install_work_app_title" msgid="2821669067014436056">"Para conectar estas apps, instala <xliff:g id="NAME">%1$s</xliff:g> en tu perfil de trabajo"</string>
    <string name="interact_across_profiles_install_personal_app_title" msgid="4790651223324866344">"Para conectar estas apps, instala <xliff:g id="NAME">%1$s</xliff:g> en tu perfil personal"</string>
    <string name="interact_across_profiles_install_app_summary" msgid="7715324358034968657">"Presiona para descargar la app"</string>
    <string name="manage_zen_access_title" msgid="1562322900340107269">"Acceso en No interrumpir"</string>
    <string name="zen_access_detail_switch" msgid="4183681772666138993">"Permitir opción No interrumpir"</string>
    <string name="zen_access_empty_text" msgid="3779921853282293080">"Ninguna aplicación instalada solicitó acceso en No interrumpir."</string>
    <string name="app_notifications_off_desc" msgid="2484843759466874201">"No permitiste las notificaciones de esta app"</string>
    <string name="channel_notifications_off_desc" msgid="6202042207121633488">"Como lo solicitaste, Android bloquea esta categoría de notificaciones para que no se muestren en el dispositivo"</string>
    <string name="channel_group_notifications_off_desc" msgid="9096417708500595424">"Como lo solicitaste, Android bloquea este grupo de notificaciones para que no se muestren en el dispositivo"</string>
    <string name="app_notifications_not_send_desc" msgid="5683060986735070528">"Esta app no envía notificaciones"</string>
    <string name="notification_channels" msgid="1502969522886493799">"Categorías"</string>
    <string name="notification_channels_other" msgid="18159805343647908">"Otros"</string>
    <string name="no_channels" msgid="4716199078612071915">"Esta app no publicó ninguna notificación"</string>
    <string name="app_settings_link" msgid="6725453466705333311">"Opciones de configuración adicionales de la app"</string>
    <string name="deleted_channels" msgid="8489800381509312964">"{count,plural, =1{# categoría borrada}other{# categorías borradas}}"</string>
    <string name="app_notification_block_title" msgid="3880322745749900296">"Bloquear todos"</string>
    <string name="app_notification_block_summary" msgid="1804611676339341551">"No mostrar estas notificaciones"</string>
    <string name="notification_content_block_title" msgid="6689085826061361351">"Mostrar notificaciones"</string>
    <string name="notification_content_block_summary" msgid="329171999992248925">"No mostrar notificaciones en el panel ni en dispositivos periféricos"</string>
    <string name="notification_badge_title" msgid="6854537463548411313">"Permitir punto de notificación"</string>
    <string name="notification_channel_badge_title" msgid="6505542437385640049">"Mostrar punto de notificación"</string>
    <string name="app_notification_override_dnd_title" msgid="3769539356442226691">"Anular No interrumpir"</string>
    <string name="app_notification_override_dnd_summary" msgid="4894641191397562920">"Permitir que se muestren estas notificaciones cuando esté activada la función No interrumpir"</string>
    <string name="app_notification_visibility_override_title" msgid="7778628150022065920">"Pantalla de bloqueo"</string>
    <string name="app_notifications_dialog_done" msgid="573716608705273004">"Listo"</string>
    <string name="notification_show_lights_title" msgid="5564315979007438583">"Luz intermitente"</string>
    <string name="notification_vibrate_title" msgid="1422330728336623351">"Vibración"</string>
    <string name="notification_channel_sound_title" msgid="9018031231387273476">"Sonido"</string>
    <string name="notification_conversation_important" msgid="4365437037763608045">"Prioritaria"</string>
    <string name="zen_mode_rule_name" msgid="7303080427006917702">"Nombre"</string>
    <string name="zen_mode_rule_name_hint" msgid="7029432803855827697">"Ingresar el nombre"</string>
    <string name="zen_mode_rule_name_warning" msgid="1244435780807634954">"El nombre ya está en uso"</string>
    <string name="zen_mode_add_rule" msgid="4217731747959400770">"Agregar más"</string>
    <string name="zen_mode_add_event_rule" msgid="9179404395950854471">"Agregar programa del evento"</string>
    <string name="zen_mode_add_time_rule" msgid="2621320450155364432">"Agregar programa de hora"</string>
    <string name="zen_mode_choose_rule_type" msgid="7656308563653982975">"Elige el tipo de programa"</string>
    <string name="zen_mode_delete_rule_confirmation" msgid="6195069346439736688">"¿Quieres borrar la regla \"<xliff:g id="RULE">%1$s</xliff:g>\"?"</string>
    <string name="zen_mode_delete_rule_button" msgid="8328729110756882244">"Borrar"</string>
    <string name="zen_mode_app_set_behavior" msgid="4319517270279704677">"No se puede cambiar la configuración en este momento. Una app (<xliff:g id="APP_NAME">%1$s</xliff:g>) activó el modo \"No interrumpir\" automáticamente con comportamiento personalizado."</string>
    <string name="zen_mode_unknown_app_set_behavior" msgid="8544413884273894104">"No se puede cambiar la configuración en este momento. Una app activó el modo \"No interrumpir\" automáticamente con comportamiento personalizado."</string>
    <string name="zen_mode_qs_set_behavior" msgid="3805244555649172848">"No se puede cambiar la configuración en este momento. Se activó el modo \"No interrumpir\" de forma manual con comportamiento personalizado."</string>
    <string name="zen_schedule_rule_type_name" msgid="8071428540221112090">"Hora"</string>
    <string name="zen_event_rule_type_name" msgid="1921166617081971754">"Evento"</string>
    <string name="zen_mode_event_rule_calendar" msgid="6279460374929508907">"Durante los eventos de"</string>
    <string name="zen_mode_event_rule_calendar_any" msgid="5152139705998281205">"Cualquier calendario"</string>
    <string name="zen_mode_event_rule_reply" msgid="6099405414361340225">"Cuando la respuesta es"</string>
    <string name="zen_mode_event_rule_reply_any_except_no" msgid="4672746760505346596">"Sí, Quizás o Sin respuesta"</string>
    <string name="zen_mode_event_rule_reply_yes_or_maybe" msgid="6584448788100186574">"Sí o Quizás"</string>
    <string name="zen_mode_event_rule_reply_yes" msgid="7812120982734551236">"Sí"</string>
    <string name="zen_mode_rule_not_found_text" msgid="5303667326973891036">"No se encontró la regla."</string>
    <string name="zen_mode_rule_summary_enabled_combination" msgid="1183604368083885789">"Activado/<xliff:g id="MODE">%1$s</xliff:g>"</string>
    <string name="zen_mode_rule_summary_provider_combination" msgid="785343032708491365">"<xliff:g id="PACKAGE">%1$s</xliff:g>\n<xliff:g id="SUMMARY">%2$s</xliff:g>"</string>
    <string name="zen_mode_schedule_rule_days" msgid="8633770815307716351">"Días"</string>
    <string name="zen_mode_schedule_rule_days_none" msgid="5636604196262227070">"Ninguno"</string>
    <string name="zen_mode_schedule_alarm_title" msgid="305237266064819345">"La alarma puede anular la hora de finalización"</string>
    <string name="zen_mode_schedule_alarm_summary" msgid="9162760856136645133">"Cuando suena la alarma, se desactiva el programa"</string>
    <string name="zen_mode_custom_behavior_title" msgid="92525364576358085">"Comportamiento del modo No interrumpir"</string>
    <string name="zen_mode_custom_behavior_summary_default" msgid="3259312823717839148">"Usar configuración predeterminada"</string>
    <string name="zen_mode_custom_behavior_summary" msgid="5390522750884328843">"Crear opciones de configuración personalizadas"</string>
    <string name="zen_mode_custom_behavior_category_title" msgid="7815612569425733764">"Durante \"<xliff:g id="SCHEDULE_NAME">%1$s</xliff:g>\""</string>
    <string name="summary_divider_text" msgid="8836285171484563986">", "</string>
    <string name="summary_range_symbol_combination" msgid="8447490077794415525">"<xliff:g id="START">%1$s</xliff:g> - <xliff:g id="END">%2$s</xliff:g>"</string>
    <string name="zen_mode_conversations_title" msgid="5491912973456026379">"Conversaciones"</string>
    <string name="zen_mode_from_all_conversations" msgid="3447000451361857061">"Todas las conversaciones"</string>
    <string name="zen_mode_from_important_conversations" msgid="528050873364229253">"Conversaciones prioritarias"</string>
    <string name="zen_mode_from_important_conversations_second" msgid="7588299891972136599">"conversaciones prioritarias"</string>
    <string name="zen_mode_from_no_conversations" msgid="3924593219855567165">"Ninguna"</string>
    <string name="zen_mode_conversations_count" msgid="3199310723073707153">"{count,plural, =0{Ninguna}=1{1 conversación}other{# conversaciones}}"</string>
    <string name="zen_mode_people_calls_messages_section_title" msgid="6815202112413762206">"Quiénes pueden interrumpir"</string>
    <string name="zen_mode_people_footer" msgid="7710707353004137431">"Incluso si las apps de mensajería o llamadas no pueden notificarte, las personas que selecciones aquí podrán comunicarse contigo mediante esas apps"</string>
    <string name="zen_mode_calls_title" msgid="2078578043677037740">"Llamadas"</string>
    <string name="zen_mode_calls" msgid="7653245854493631095">"Llamadas"</string>
    <string name="zen_mode_calls_list" msgid="5044730950895749093">"llamadas"</string>
    <string name="zen_mode_calls_header" msgid="8379225445095856726">"Llamadas que pueden interrumpir"</string>
    <string name="zen_mode_calls_footer" msgid="2008079711083701243">"A fin de asegurarte de que el dispositivo suene cuando recibes llamadas permitidas, verifica que esté configurado para emitir un sonido"</string>
    <string name="zen_mode_custom_calls_footer" msgid="6521283204577441053">"Se bloquearán las llamadas entrantes durante \"<xliff:g id="SCHEDULE_NAME">%1$s</xliff:g>\". Puedes ajustar la configuración para permitir que tus amigos, familia y otros contactos se comuniquen contigo."</string>
    <string name="zen_mode_starred_contacts_title" msgid="630299631659575589">"Contactos destacados"</string>
    <string name="zen_mode_starred_contacts_summary_contacts" msgid="1629467178444895094">"{count,plural,offset:2 =0{Ninguno}=1{{contact_1}}=2{{contact_1} y {contact_2}}=3{{contact_1}, {contact_2} y {contact_3}}other{{contact_1}, {contact_2} y # más}}"</string>
    <string name="zen_mode_starred_contacts_empty_name" msgid="2906404745550293688">"(Sin nombre)"</string>
    <string name="zen_mode_messages" msgid="7315084748885170585">"Mensajes"</string>
    <string name="zen_mode_messages_list" msgid="5431014101342361882">"mensajes"</string>
    <string name="zen_mode_messages_title" msgid="1777598523485334405">"Mensajes"</string>
    <string name="zen_mode_messages_header" msgid="253721635061451577">"Mensajes que pueden interrumpir"</string>
    <string name="zen_mode_messages_footer" msgid="6002468050854126331">"A fin de asegurarte de que el dispositivo suene cuando recibas mensajes permitidos, verifica que esté configurado para emitir un sonido"</string>
    <string name="zen_mode_custom_messages_footer" msgid="7545180036949550830">"Se bloquearán los mensajes entrantes durante \"<xliff:g id="SCHEDULE_NAME">%1$s</xliff:g>\". Puedes ajustar la configuración para permitir que tus amigos, familiares y otros contactos se comuniquen contigo."</string>
    <string name="zen_mode_all_messages_summary" msgid="3756267858343104554">"Puedes recibir todos los mensajes"</string>
    <string name="zen_mode_all_calls_summary" msgid="7337907849083824698">"Puedes recibir todas las llamadas"</string>
    <string name="zen_mode_contacts_count" msgid="6568631261119795799">"{count,plural, =0{Ninguno}=1{1 contacto}other{# contactos}}"</string>
    <string name="zen_mode_from_anyone" msgid="6027004263046694174">"Cualquier usuario"</string>
    <string name="zen_mode_from_contacts" msgid="2989933306317064818">"Contactos"</string>
    <string name="zen_mode_from_starred" msgid="8616516644241652287">"Contactos destacados"</string>
    <string name="zen_mode_none_calls" msgid="2047166006414016327">"Ninguna"</string>
    <string name="zen_mode_none_messages" msgid="1386626352943268342">"Ninguno"</string>
    <string name="zen_mode_alarms" msgid="5989343060100771099">"Alarmas"</string>
    <string name="zen_mode_alarms_summary" msgid="3388679177457223967">"De temporizadores, alarmas, sistemas de seguridad y otras apps"</string>
    <string name="zen_mode_alarms_list" msgid="334782233067365405">"alarmas"</string>
    <string name="zen_mode_alarms_list_first" msgid="2780418316613576610">"Alarmas"</string>
    <string name="zen_mode_media" msgid="885017672250984735">"Sonidos multimedia"</string>
    <string name="zen_mode_media_summary" msgid="7174081803853351461">"Sonidos de videos, juegos y otro contenido multimedia"</string>
    <string name="zen_mode_media_list" msgid="2006413476596092020">"contenido multimedia"</string>
    <string name="zen_mode_media_list_first" msgid="7824427062528618442">"Contenido multimedia"</string>
    <string name="zen_mode_system" msgid="7301665021634204942">"Sonidos de teclas y botones"</string>
    <string name="zen_mode_system_summary" msgid="7225581762792177522">"Sonidos del teclado y otros botones"</string>
    <string name="zen_mode_system_list" msgid="2256218792042306434">"Sonidos de teclas y botones"</string>
    <string name="zen_mode_system_list_first" msgid="8590078626001067855">"Sonidos de teclas y botones"</string>
    <string name="zen_mode_reminders" msgid="1970224691551417906">"Recordatorios"</string>
    <string name="zen_mode_reminders_summary" msgid="3961627037429412382">"De tareas y recordatorios"</string>
    <string name="zen_mode_reminders_list" msgid="3133513621980999858">"recordatorios"</string>
    <string name="zen_mode_reminders_list_first" msgid="1130470396012190814">"Recordatorios"</string>
    <string name="zen_mode_events" msgid="7425795679353531794">"Eventos del calendario"</string>
    <string name="zen_mode_events_summary" msgid="3241903481309766428">"De próximos eventos del calendario"</string>
    <string name="zen_mode_events_list" msgid="7191316245742097229">"eventos"</string>
    <string name="zen_mode_events_list_first" msgid="7425369082835214361">"Eventos"</string>
    <string name="zen_mode_bypassing_apps" msgid="625309443389126481">"Permitir que las apps anulen No interrumpir"</string>
    <string name="zen_mode_bypassing_apps_header" msgid="60083006963906906">"Apps que pueden interrumpir"</string>
    <string name="zen_mode_bypassing_apps_add_header" msgid="3201829605075172536">"Seleccionar más apps"</string>
    <string name="zen_mode_bypassing_apps_none" msgid="7944221631721778096">"No se seleccionó ninguna app"</string>
    <string name="zen_mode_bypassing_apps_subtext_none" msgid="5128770411598722200">"Ninguna app puede interrumpir"</string>
    <string name="zen_mode_bypassing_apps_add" msgid="5031919618521327102">"Agregar apps"</string>
    <string name="zen_mode_bypassing_apps_summary_all" msgid="4684544706511555744">"Todas las notificaciones"</string>
    <string name="zen_mode_bypassing_apps_summary_some" msgid="5315750826830358230">"Algunas notificaciones"</string>
    <string name="zen_mode_bypassing_apps_footer" msgid="1454862989340760124">"Las personas seleccionadas podrán comunicarse contigo, incluso si no permites que las apps causen interrupciones"</string>
    <string name="zen_mode_bypassing_apps_subtext" msgid="5258652366929842710">"{count,plural,offset:2 =0{Ninguna app puede interrumpir}=1{{app_1} puede interrumpir}=2{{app_1} y {app_2} pueden interrumpir}=3{{app_1}, {app_2} y {app_3} pueden interrumpir}other{{app_1}, {app_2} y # más pueden interrumpir}}"</string>
    <string name="zen_mode_bypassing_apps_title" msgid="371050263563164059">"Apps"</string>
    <string name="zen_mode_bypassing_app_channels_header" msgid="4011017798712587373">"Notificaciones que pueden interrumpir"</string>
    <string name="zen_mode_bypassing_app_channels_toggle_all" msgid="1449462656358219116">"Permitir todas las notificaciones"</string>
    <string name="zen_mode_other_sounds_summary" msgid="8784400697494837032">"{count,plural,offset:2 =0{Nada puede interrumpir}=1{{sound_category_1} puede interrumpir}=2{{sound_category_1} y {sound_category_2} pueden interrumpir}=3{{sound_category_1}, {sound_category_2} y {sound_category_3} pueden interrumpir}other{{sound_category_1}, {sound_category_2} y # más pueden interrumpir}}"</string>
    <string name="zen_mode_sounds_none" msgid="6557474361948269420">"Nada puede interrumpir"</string>
    <string name="zen_mode_people_none" msgid="4613147461974255046">"Ninguna persona puede interrumpir"</string>
    <string name="zen_mode_people_some" msgid="9101872681298810281">"Algunas personas pueden interrumpir"</string>
    <string name="zen_mode_people_all" msgid="311036110283015205">"Cualquier persona puede interrumpir"</string>
    <string name="zen_mode_repeat_callers" msgid="2270356100287792138">"Llamadas repetidas"</string>
    <string name="zen_mode_repeat_callers_title" msgid="8016699240338264781">"Permitir llamadas repetidas de un mismo emisor"</string>
    <string name="zen_mode_all_callers" msgid="8104755389401941875">"cualquiera"</string>
    <string name="zen_mode_contacts_callers" msgid="5429267704011896833">"contactos"</string>
    <string name="zen_mode_starred_callers" msgid="1002370699564211178">"contactos destacados"</string>
    <string name="zen_mode_repeat_callers_list" msgid="181819778783743847">"emisores repetidos"</string>
    <!-- no translation found for zen_mode_calls_summary_one (1928015516061784276) -->
    <skip />
    <string name="zen_mode_calls_summary_two" msgid="6351563496898410742">"<xliff:g id="CALLER_TYPE_0">%1$s</xliff:g> y <xliff:g id="CALLER_TYPE_1">%2$s</xliff:g>"</string>
    <string name="zen_mode_repeat_callers_summary" msgid="4121054819936083025">"Si la misma persona llama por segunda vez en un plazo de <xliff:g id="MINUTES">%d</xliff:g> minuto(s)"</string>
    <string name="zen_mode_start_time" msgid="1252665038977523332">"Hora de inicio"</string>
    <string name="zen_mode_end_time" msgid="223502560367331706">"Hora de finalización"</string>
    <string name="zen_mode_end_time_next_day_summary_format" msgid="419683704068360804">"<xliff:g id="FORMATTED_TIME">%s</xliff:g> el día siguiente"</string>
    <string name="zen_mode_summary_alarms_only_indefinite" msgid="910047326128154945">"Cambiar a solo alarmas de forma indefinida"</string>
    <string name="zen_mode_summary_alarms_only_by_minute" msgid="6673649005494939311">"{count,plural, =1{Cambiar a solo alarmas durante un minuto hasta la hora {time}}other{Cambiar a solo alarmas durante # minutos hasta la hora {time}}}"</string>
    <string name="zen_mode_summary_alarms_only_by_hour" msgid="7400910210950788163">"{count,plural, =1{Cambiar a solo alarmas durante una hora hasta la hora {time}}other{Cambiar a solo alarmas durante # horas hasta la hora {time}}}"</string>
    <string name="zen_mode_summary_alarms_only_by_time" msgid="8140619669703968810">"Cambiar a solo alarmas hasta la(s) <xliff:g id="FORMATTEDTIME">%1$s</xliff:g>"</string>
    <string name="zen_mode_summary_always" msgid="722093064250082317">"Cambiar a interrumpir siempre"</string>
    <string name="warning_button_text" msgid="1274234338874005639">"Advertencia"</string>
    <string name="suggestion_button_close" msgid="6865170855573283759">"Cerrar"</string>
    <string name="device_feedback" msgid="5351614458411688608">"Enviar comentarios del dispositivo"</string>
    <string name="restr_pin_enter_admin_pin" msgid="4435410646541671918">"Ingresa el PIN de administrador"</string>
    <string name="switch_on_text" msgid="5664542327776075105">"Activado"</string>
    <string name="switch_off_text" msgid="1315547447393646667">"Sin activar"</string>
    <string name="nfc_setting_on" msgid="7701896496026725772">"Activada"</string>
    <string name="nfc_setting_off" msgid="7142103438532732309">"Desactivada"</string>
    <string name="screen_pinning_switch_on_text" msgid="6971386830247542552">"Activada"</string>
    <string name="screen_pinning_switch_off_text" msgid="5032105155623003875">"Desactivada"</string>
    <string name="screen_pinning_title" msgid="6927227272780208966">"Fijación de apps"</string>
    <string name="app_pinning_intro" msgid="6409063008733004245">"Al fijar una app, esta se mantiene visible hasta que dejas de fijarla. Esta función se puede utilizar, por ejemplo, para dejar que alguien de confianza juegue un juego específico."</string>
    <string name="screen_pinning_description" msgid="4305370471370474846">"Si fijas una app, esta podrá abrir otras apps y acceder a tus datos personales. \n\nPara usar la fijación de apps, sigue estos pasos: 	\n1. Activa la fijación de apps. 	\n2. Abre Recientes. 	\n3. Presiona el icono de la app que se encuentra en la parte superior de la pantalla y, luego, Fijar."</string>
    <string name="screen_pinning_guest_user_description" msgid="2465729370037556955">"Si fijas una app, esta podrá abrir otras apps y acceder a tus datos personales. \n\nSi quieres compartir tu dispositivo con alguien de forma segura, usa un perfil de invitado. \n\nPara fijar una app, sigue estos pasos: 	\n1. Activa fijar apps. 	\n2. Abre Recientes. 	\n3. Presiona el icono de la app que se encuentra en la parte superior de la pantalla y, luego, Fijar."</string>
    <string name="screen_pinning_dialog_message" msgid="8144925258679476654">"Cuando fijas una app, puede ocurrir lo siguiente: \n\n•		Esta podrá acceder a datos personales (como contactos y contenido de los correos electrónicos). \n•	 Es posible que las apps fijadas abran otras apps.		 \n\nUsa la función para fijar apps solo con personas de confianza.\n"</string>
    <string name="screen_pinning_unlock_pattern" msgid="1345877794180829153">"Solicitar desbloqueo para quitar fijación"</string>
    <string name="screen_pinning_unlock_pin" msgid="8716638956097417023">"Solicitar PIN para quitar fijación"</string>
    <string name="screen_pinning_unlock_password" msgid="4957969621904790573">"Solicitar contraseña para quitar fijación"</string>
    <string name="screen_pinning_unlock_none" msgid="2474959642431856316">"Bloquear dispositivo al quitar fijación"</string>
    <string name="confirm_sim_deletion_title" msgid="9199369003530237871">"Confirmar eliminación de SIM"</string>
    <string name="confirm_sim_deletion_description" msgid="4439657901673639063">"Verifica tu identidad antes de borrar una eSIM"</string>
    <string name="memtag_title" msgid="5096176296797727201">"Protección de mem. avanzada beta"</string>
    <string name="memtag_toggle" msgid="8695028758462939212">"Protección de memoria avanzada"</string>
    <string name="memtag_intro" msgid="579408691329568953">"Esta función beta te ayuda a proteger tu dispositivo de errores que pueden poner en riesgo tu seguridad."</string>
    <string name="memtag_on" msgid="824938319141503923">"Activada"</string>
    <string name="memtag_off" msgid="4835589640091709019">"Desactivada"</string>
    <string name="memtag_on_pending" msgid="1592053425431532361">"Se activará después de reiniciar"</string>
    <string name="memtag_off_pending" msgid="1543177181383593726">"Se desactivará después de reiniciar"</string>
    <string name="memtag_force_off" msgid="1143468955988138470">"Ahora no disponible para tu disp."</string>
    <string name="memtag_force_on" msgid="3254349938627883664">"Siempre activada para tu dispositivo"</string>
    <string name="memtag_footer" msgid="8480784485124271376">"Tendrás que reiniciar el dispositivo para activar o desactivar la protección de memoria avanzada. Cuando esté activada, es posible que observes que el dispositivo funciona más lento."</string>
    <string name="memtag_reboot_title" msgid="1413471876903578769">"¿Reiniciar el dispositivo?"</string>
    <string name="memtag_reboot_message_on" msgid="3270256606602439418">"Tendrás que reiniciar el dispositivo para activar la protección de memoria avanzada."</string>
    <string name="memtag_reboot_message_off" msgid="2567062468140476451">"Tendrás que reiniciar el dispositivo para desactivar la protección de memoria avanzada."</string>
    <string name="memtag_reboot_yes" msgid="5788896350697141429">"Reiniciar"</string>
    <string name="memtag_reboot_no" msgid="2860671356184849330">"Ahora no"</string>
    <string name="memtag_learn_more" msgid="1596145970669119776">"Obtén más información sobre la protección de memoria avanzada."</string>
    <string name="opening_paragraph_delete_profile_unknown_company" msgid="2951348192319498135">"La siguiente aplicación administra este perfil de trabajo:"</string>
    <string name="managing_admin" msgid="2633920317425356619">"Administrado por <xliff:g id="ADMIN_APP_LABEL">%s</xliff:g>"</string>
    <string name="launch_by_default" msgid="892824422067985734">"Abrir de forma predeterminada"</string>
    <string name="app_launch_open_domain_urls_title" msgid="4805388403977096285">"Abrir vínculos admitidos"</string>
    <string name="app_launch_top_intro_message" msgid="137370923637482459">"Permitir que se abran vínculos web en esta app"</string>
    <string name="app_launch_links_category" msgid="2380467163878760037">"Vínculos que se pueden abrir en esta app"</string>
    <string name="app_launch_supported_domain_urls_title" msgid="5088779668667217369">"Vínculos admitidos"</string>
    <string name="app_launch_other_defaults_title" msgid="5674385877838735586">"Otras preferencias predeterminadas"</string>
    <string name="app_launch_add_link" msgid="8622558044530305811">"Agregar vínculo"</string>
    <string name="app_launch_footer" msgid="4521865035105622557">"Una app puede verificar los vínculos para que se abran automáticamente en la app."</string>
    <string name="app_launch_verified_links_title" msgid="621908751569155356">"{count,plural, =1{# vínculo verificado}other{# vínculos verificados}}"</string>
    <string name="app_launch_verified_links_message" msgid="190871133877476176">"{count,plural, =1{Este vínculo está verificado y se abre de forma automática en esta app.}other{Estos vínculos están verificados y se abren de forma automática en esta app.}}"</string>
    <string name="app_launch_dialog_ok" msgid="1446157681861409861">"Aceptar"</string>
    <string name="app_launch_verified_links_info_description" msgid="7514750232467132117">"Mostrar lista de vínculos verificados"</string>
    <string name="app_launch_checking_links_title" msgid="6119228853554114201">"Comprobando otros vínculos admitidos…"</string>
    <string name="app_launch_dialog_cancel" msgid="6961071841814898663">"Cancelar"</string>
    <string name="app_launch_supported_links_title" msgid="2457931321701095763">"{count,plural, =1{# vínculo admitido}other{# vínculos admitidos}}"</string>
    <string name="app_launch_supported_links_add" msgid="3271247750388016131">"Agregar"</string>
    <string name="app_launch_supported_links_subtext" msgid="4268004019469184113">"Se abre en <xliff:g id="APP_LABEL">%s</xliff:g>"</string>
    <string name="storage_summary_format" msgid="5721782272185284276">"<xliff:g id="SIZE">%1$s</xliff:g> en uso en <xliff:g id="STORAGE_TYPE">%2$s</xliff:g>"</string>
    <string name="storage_type_internal" msgid="979243131665635278">"almacenamiento interno"</string>
    <string name="storage_type_external" msgid="125078274000280821">"almacenamiento externo"</string>
    <string name="data_summary_format" msgid="8802057788950096650">"<xliff:g id="SIZE">%1$s</xliff:g> desde el <xliff:g id="DATE">%2$s</xliff:g>"</string>
    <string name="storage_used" msgid="2591194906751432725">"Almacenamiento utilizado"</string>
    <string name="change" msgid="273206077375322595">"Cambiar"</string>
    <string name="change_storage" msgid="8773820275624113401">"Cambiar almacenamiento"</string>
    <string name="notifications_label" msgid="8471624476040164538">"Notificaciones"</string>
    <string name="notifications_enabled" msgid="7743168481579361019">"Activadas"</string>
    <string name="notifications_enabled_with_info" msgid="1808946629277684308">"<xliff:g id="NOTIFICATIONS_SENT">%1$s</xliff:g>/<xliff:g id="NOTIFICATIONS_CATEGORIES_OFF">%2$s</xliff:g>"</string>
    <string name="notifications_disabled" msgid="5603160425378437143">"No"</string>
    <string name="notifications_categories_off" msgid="7712037485557237328">"{count,plural, =1{# categoría desactivada}other{# categorías desactivadas}}"</string>
    <string name="runtime_permissions_additional_count" msgid="6071909675951786523">"{count,plural, =1{# permiso adicional}other{# permisos adicionales}}"</string>
    <string name="runtime_permissions_summary_no_permissions_granted" msgid="7456745929035665029">"No se otorgaron permisos"</string>
    <string name="runtime_permissions_summary_no_permissions_requested" msgid="7174876170116073356">"No se solicitaron permisos"</string>
    <string name="runtime_permissions_summary_control_app_access" msgid="3744591396348990500">"Controla el acceso de apps a tus datos"</string>
    <string name="permissions_usage_title" msgid="2942741460679049132">"Panel de privacidad"</string>
    <string name="permissions_usage_summary" msgid="6784310472062516454">"Muestra qué apps usaron permisos recientemente"</string>
    <string name="unused_apps" msgid="4566272194756830656">"Apps que no usas"</string>
    <string name="unused_apps_summary" msgid="4236371818881973021">"{count,plural, =1{# app en desuso}other{# apps en desuso}}"</string>
    <string name="unused_apps_category" msgid="8954930958175500851">"Configuración de app sin usar"</string>
    <string name="unused_apps_switch" msgid="7595419855882245772">"Pausar actividad en la app si no se usa"</string>
    <string name="unused_apps_switch_summary" msgid="2171098908014596802">"Quitar permisos, borrar archivos temporales y detener notificaciones"</string>
    <string name="filter_all_apps" msgid="6645539744080251371">"Todas las apps"</string>
    <string name="filter_enabled_apps" msgid="8868356616126759124">"Apps instaladas"</string>
    <string name="filter_instant_apps" msgid="2292108467020380068">"Apps instantáneas"</string>
    <string name="filter_notif_blocked_apps" msgid="1065653868850012325">"Desactivadas"</string>
    <string name="advanced_apps" msgid="7643010673326578815">"Avanzado"</string>
    <string name="app_permissions" msgid="8666537659217653626">"Administrador de permisos"</string>
    <string name="app_data_sharing_updates_title" msgid="1694297952320402788">"Actualizaciones del uso compartido de los datos de ubicación"</string>
    <string name="app_data_sharing_updates_summary" msgid="4465929918457739443">"Revisa las apps que cambiaron la forma en que comparten tus datos de ubicación"</string>
    <string name="tap_to_wake" msgid="3313433536261440068">"Presionar para activar"</string>
    <string name="tap_to_wake_summary" msgid="6641039858241611072">"Presiona dos veces en cualquier lugar de la pantalla para activar el dispositivo."</string>
    <string name="domain_urls_title" msgid="7012209752049678876">"Abrir vínculos"</string>
    <string name="domain_urls_summary_none" msgid="1132578967643384733">"No abrir los vínculos admitidos"</string>
    <string name="domain_urls_summary_one" msgid="3312008753802762892">"Abrir el dominio <xliff:g id="DOMAIN">%s</xliff:g>"</string>
    <string name="domain_urls_summary_some" msgid="1197692164421314523">"Abrir <xliff:g id="DOMAIN">%s</xliff:g> y otras URL"</string>
    <string name="app_link_open_always" msgid="9167065494930657503">"Permitir que la app abra vínculos compatibles"</string>
    <string name="app_link_open_ask" msgid="2422450109908936371">"Preguntar siempre"</string>
    <string name="app_link_open_never" msgid="5299808605386052350">"No permitir que la app abra vínculos compatible"</string>
    <string name="app_link_open_always_summary" msgid="4524005594295855117">"{count,plural, =1{La app indica que procesa # vínculo}other{La app indica que procesa # vínculos}}"</string>
    <string name="open_supported_links_footer" msgid="3188808142432787933">"La app indica que procesa los siguientes vínculos:"</string>
    <string name="assist_and_voice_input_title" msgid="6317935163145135914">"Asistencia y entrada de voz"</string>
    <string name="default_assist_title" msgid="1182435129627493758">"App de asistente digital"</string>
    <string name="default_digital_assistant_title" msgid="5654663086385490838">"App de asistente digital pred."</string>
    <string name="assistant_security_warning_agree" msgid="9013334158753473359">"Aceptar"</string>
    <string name="default_browser_title" msgid="8342074390782390458">"Navegador"</string>
    <string name="default_phone_title" msgid="7616730756650803827">"Teléfono"</string>
    <string name="system_app" msgid="1863291702508355041">"(Sistema)"</string>
    <string name="apps_storage" msgid="643866814746927111">"Almacenamiento de apps"</string>
    <string name="usage_access" msgid="5487993885373893282">"Acceso a datos de uso"</string>
    <string name="permit_usage_access" msgid="179630895262172674">"Apps con acceso de uso"</string>
    <string name="time_spent_in_app_pref_title" msgid="25327097913383330">"Tiempo de uso"</string>
    <string name="usage_access_description" msgid="8547716253713890707">"El acceso a los datos de uso permite que una aplicación controle qué otras aplicaciones utilizas y con qué frecuencia, así como el operador, la configuración de idioma y otros detalles."</string>
    <string name="memory_settings_title" msgid="6582588646363308430">"Memoria"</string>
    <string name="always_running" msgid="9012705720688200252">"Siempre en ejecución (<xliff:g id="PERCENTAGE">%s</xliff:g>)"</string>
    <string name="sometimes_running" msgid="7954947311082655448">"A veces en ejecución (<xliff:g id="PERCENTAGE">%s</xliff:g>)"</string>
    <string name="rarely_running" msgid="2704869567353196798">"Casi nunca en ejecución (<xliff:g id="PERCENTAGE">%s</xliff:g>)"</string>
    <string name="memory_use_running_format" msgid="4376086847362492613">"<xliff:g id="MEMORY">%1$s</xliff:g>/<xliff:g id="RUNNING">%2$s</xliff:g>"</string>
    <string name="high_power_apps" msgid="5623152700992102510">"Optimización de la batería"</string>
    <string name="high_power_filter_on" msgid="447849271630431531">"Sin optimizar"</string>
    <string name="high_power_on" msgid="8778058701270819268">"Sin optimizar"</string>
    <string name="high_power_off" msgid="317000444619279018">"Optimizando el uso de la batería"</string>
    <string name="high_power_system" msgid="3966701453644915787">"Optimización de la batería no disponible"</string>
    <string name="high_power_prompt_title" msgid="2574478825228409124">"¿Permitir que la app se ejecute siempre en segundo plano?"</string>
    <string name="high_power_prompt_body" msgid="6029266540782139941">"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 batería. \n\nPuedes cambiar esta opción más tarde en Configuración &gt; Apps."</string>
    <string name="battery_summary" msgid="2491764359695671207">"Se usó el <xliff:g id="PERCENTAGE">%1$s</xliff:g> desde la última carga completa"</string>
    <string name="battery_summary_24hr" msgid="7656033283282656551">"<xliff:g id="PERCENTAGE">%1$s</xliff:g> de uso en las últimas 24 horas"</string>
    <string name="no_battery_summary" msgid="5769159953384122003">"No se usó la batería desde la última carga completa"</string>
    <string name="share_remote_bugreport_dialog_title" msgid="1575283098565582433">"¿Deseas compartir el informe de errores?"</string>
    <string name="share_remote_bugreport_dialog_message_finished" msgid="4869053468609007680">"El administrador de TI solicitó un informe de errores para solucionar los problemas de este dispositivo. Es posible que se compartan apps y datos."</string>
    <string name="share_remote_bugreport_dialog_message" msgid="8714439220818865391">"El administrador de TI solicitó un informe de errores para solucionar los problemas de este dispositivo. Es posible que se compartan apps y datos, y que el dispositivo se ralentice temporalmente."</string>
    <string name="sharing_remote_bugreport_dialog_message" msgid="3523877008096439251">"Este informe de errores se compartirá con tu administrador de TI. Para obtener más información, comunícate con él."</string>
    <string name="share_remote_bugreport_action" msgid="7173093464692893276">"Compartir"</string>
    <string name="decline_remote_bugreport_action" msgid="1276509879613158895">"Rechazar"</string>
    <string name="usb_use_charging_only" msgid="1743303747327057947">"Sin transferencia de datos"</string>
    <string name="usb_use_power_only" msgid="3408055485802114621">"Cargar dispositivo conectado"</string>
    <string name="usb_use_file_transfers" msgid="483915710802018503">"Transferencia de archivos"</string>
    <string name="usb_use_photo_transfers" msgid="4641181628966036093">"PTP"</string>
    <string name="usb_use_uvc_webcam" msgid="6595429508472038732">"Cámara web"</string>
    <string name="usb_transcode_files" msgid="2441954752105119109">"Convertir videos a AVC"</string>
    <string name="usb_transcode_files_summary" msgid="307102635711961513">"Los videos se reproducirán en más reproductores multimedia, pero podría disminuir la calidad"</string>
    <string name="usb_use_tethering" msgid="2897063414491670531">"Conexión a red por USB"</string>
    <string name="usb_use_MIDI" msgid="8621338227628859789">"MIDI"</string>
    <string name="usb_use" msgid="6783183432648438528">"Utilizar USB para lo siguiente:"</string>
    <string name="usb_default_label" msgid="3372838450371060750">"Configuración predeterminada de USB"</string>
    <string name="usb_default_info" msgid="167172599497085266">"Si conectas otro dispositivo cuando tu teléfono está desbloqueado, se aplicará esta configuración. Solo debes conectar dispositivos de confianza."</string>
    <string name="usb_power_title" msgid="5602112548385798646">"Opciones de encendido"</string>
    <string name="usb_file_transfer_title" msgid="2261577861371481478">"Opciones de transferencia de archivos"</string>
    <string name="usb_pref" msgid="8521832005703261700">"USB"</string>
    <string name="usb_preference" msgid="5084550082591493765">"Preferencias de USB"</string>
    <string name="usb_control_title" msgid="1946791559052157693">"USB controlado por"</string>
    <string name="usb_control_host" msgid="7404215921555021871">"Dispositivo conectado"</string>
    <string name="usb_control_device" msgid="527916783743021577">"Este dispositivo"</string>
    <string name="usb_switching" msgid="3654709188596609354">"Cambiando…"</string>
    <string name="usb_switching_failed" msgid="5721262697715454137">"No se pudo cambiar"</string>
    <string name="usb_summary_charging_only" msgid="678095599403565146">"Cargando este dispositivo"</string>
    <string name="usb_summary_power_only" msgid="4901734938857822887">"Cargando dispositivo conectado"</string>
    <string name="usb_summary_file_transfers" msgid="5498487271972556431">"Transferencia de archivos"</string>
    <string name="usb_summary_tether" msgid="2554569836525075702">"Conexión a red por USB"</string>
    <string name="usb_summary_photo_transfers" msgid="7331503733435780492">"PTP"</string>
    <string name="usb_summary_MIDI" msgid="2372443732675899571">"MIDI"</string>
    <string name="usb_summary_UVC" msgid="8733131110899174299">"Cámara web"</string>
    <string name="usb_summary_file_transfers_power" msgid="2788374660532868630">"Transferencia de archivos y carga"</string>
    <string name="usb_summary_tether_power" msgid="4853034392919904792">"Conexión USB y de carga"</string>
    <string name="usb_summary_photo_transfers_power" msgid="9077173567697482239">"PTP y carga"</string>
    <string name="usb_summary_MIDI_power" msgid="1184681982025435815">"Modo MIDI y carga"</string>
    <string name="usb_summary_UVC_power" msgid="226810354412154061">"Cámara web y su fuente de alimentación"</string>
    <string name="background_check_pref" msgid="5304564658578987535">"Verificación en segundo plano"</string>
    <string name="assist_access_context_title" msgid="5201495523514096201">"Utilizar el texto de la pantalla"</string>
    <string name="assist_access_context_summary" msgid="6951814413185646275">"Permitir que la aplicación de asistencia acceda a los contenidos de la pantalla como texto"</string>
    <string name="assist_access_screenshot_title" msgid="4395902231753643633">"Utilizar la captura de pantalla"</string>
    <string name="assist_access_screenshot_summary" msgid="5276593070956201863">"Permitir que la aplicación de asistencia acceda a una imagen de la pantalla"</string>
    <string name="assist_flash_title" msgid="5449512572885550108">"Iluminar pantalla"</string>
    <string name="assist_flash_summary" msgid="3032289860177784594">"Iluminar los bordes de la pantalla cuando la app de asistencia acceda al texto desde la pantalla o una captura de pantalla"</string>
    <string name="assist_footer" msgid="8248015363806299068">"Las aplicaciones de asistencia pueden brindarte ayuda en función de la pantalla que estás viendo. Para ofrecerte asistencia integrada, algunas aplicaciones son compatibles con los servicios de selector y entrada de voz."</string>
    <string name="average_memory_use" msgid="717313706368825388">"Uso promedio de la memoria"</string>
    <string name="maximum_memory_use" msgid="2171779724001152933">"Uso máximo de la memoria"</string>
    <string name="memory_usage" msgid="5594133403819880617">"Uso de la memoria"</string>
    <string name="app_list_memory_use" msgid="3178720339027577869">"Uso de aplicaciones"</string>
    <string name="memory_details" msgid="6133226869214421347">"Detalles"</string>
    <string name="memory_use_summary" msgid="3915964794146424142">"Se utilizó un promedio de <xliff:g id="SIZE">%1$s</xliff:g> de memoria en las últimas tres horas"</string>
    <string name="no_memory_use_summary" msgid="6708111974923274436">"No se utilizó la memoria en las últimas tres horas"</string>
    <string name="sort_avg_use" msgid="4416841047669186903">"Ordenar según el uso promedio"</string>
    <string name="sort_max_use" msgid="3370552820889448484">"Ordenar según el uso máximo"</string>
    <string name="memory_performance" msgid="5448274293336927570">"Rendimiento"</string>
    <string name="total_memory" msgid="5244174393008910567">"Memoria total"</string>
    <string name="average_used" msgid="690235917394070169">"Uso promedio (%)"</string>
    <string name="free_memory" msgid="439783742246854785">"Libre(s)"</string>
    <string name="memory_usage_apps" msgid="5776108502569850579">"Memoria que utilizan las aplicaciones"</string>
    <string name="memory_usage_apps_summary" msgid="7168292864155527974">"{count,plural, =1{1 app usó la memoria en las últimas {time}}other{# apps usaron la memoria en las últimas {time}}}"</string>
    <string name="running_frequency" msgid="7260225121706316639">"Frecuencia"</string>
    <string name="memory_maximum_usage" msgid="2047013391595835607">"Uso máximo"</string>
    <string name="no_data_usage" msgid="4665617440434654132">"No se usaron datos"</string>
    <string name="zen_access_warning_dialog_title" msgid="6323325813123130154">"¿Quieres que la app <xliff:g id="APP">%1$s</xliff:g> tenga acceso a No interrumpir?"</string>
    <string name="zen_access_warning_dialog_summary" msgid="8468714854067428987">"La aplicación podrá activar y desactivar la función No interrumpir y realizar cambios de configuración relacionados."</string>
    <string name="zen_access_disabled_package_warning" msgid="6565908224294537889">"Debe seguir activado porque el acceso a las notificaciones está activado"</string>
    <string name="zen_access_revoke_warning_dialog_title" msgid="7377261509261811449">"¿Quieres revocar el acceso de la app <xliff:g id="APP">%1$s</xliff:g> en No interrumpir?"</string>
    <string name="zen_access_revoke_warning_dialog_summary" msgid="8689801842914183595">"Se quitarán todas las normas del modo No interrumpir que creó esta app."</string>
    <string name="ignore_optimizations_on" msgid="6865583039303804932">"No optimizar"</string>
    <string name="ignore_optimizations_off" msgid="9186557038453586295">"Optimizar"</string>
    <string name="ignore_optimizations_on_desc" msgid="1280043916460939932">"Es posible que la batería se agote más rápido. La app ya no tendrá restricciones para usar batería en segundo plano."</string>
    <string name="ignore_optimizations_off_desc" msgid="3324571675983286177">"Es recomendable para una mayor duración de la batería"</string>
    <string name="app_list_preference_none" msgid="1635406344616653756">"Ninguna"</string>
    <string name="work_profile_usage_access_warning" msgid="3477719910927319122">"Desactivar el acceso al uso de datos para esta app no evitará que el administrador realice el seguimiento del uso de datos de las apps de tu perfil de trabajo"</string>
    <string name="draw_overlay" msgid="7902083260500573027">"Mostrar sobre otras apps"</string>
    <string name="system_alert_window_settings" msgid="6458633954424862521">"Mostrar sobre otras apps"</string>
    <string name="permit_draw_overlay" msgid="4468994037192804075">"Permitir mostrar sobre otras apps"</string>
    <string name="allow_overlay_description" msgid="1607235723669496298">"Permite que esta app se muestre sobre otras en uso. La app podrá ver si tocas o cambias lo que aparece en la pantalla."</string>
    <string name="manage_external_storage_title" msgid="8024521099838816100">"Acceso a todos los archivos"</string>
    <string name="permit_manage_external_storage" msgid="6928847280689401761">"Permitir administrar todos los archivos"</string>
    <string name="allow_manage_external_storage_description" msgid="5707948153603253225">"Permite que esta app lea, modifique y borre todos los archivos en el dispositivo o cualquier volumen de almacenamiento conectado. Si habilitas el permiso, es posible que la app acceda a archivos sin tu conocimiento explícito."</string>
    <string name="filter_manage_external_storage" msgid="6751640571715343804">"Pueden acceder a todos los archivos"</string>
    <string name="full_screen_intent_title" msgid="1068024949389956404">"Administrar intents de pantalla completa"</string>
    <string name="permit_full_screen_intent" msgid="2251949245519201421">"Permitir que las apps envíen intents de pantalla completa"</string>
    <string name="footer_description_full_screen_intent" msgid="8322826300555418227">"Permite que esta app envíe notificaciones de intents de pantalla completa que cubran toda la pantalla."</string>
    <string name="media_management_apps_title" msgid="8222942355578724582">"Apps de administración de multimedia"</string>
    <string name="media_management_apps_toggle_label" msgid="166724270857067456">"Permitir que app administre cont. multimedia"</string>
    <string name="media_management_apps_description" msgid="8000565658455268524">"Si lo permites, esta app puede modificar o borrar archivos multimedia creados con otras apps sin preguntarte. La app debe tener permiso para acceder a los archivos y al contenido multimedia."</string>
    <string name="keywords_media_management_apps" msgid="7499959607583088690">"Multimedia, Archivo, Administración, Administrador, Administrar, Editar, Editor, App, Aplicación, Programa"</string>
    <string name="keywords_vr_listener" msgid="902737490270081131">"rv, procesador de realidad virtual, estéreo, servicio de ayuda"</string>
    <string name="overlay_settings" msgid="2030836934139139469">"Mostrar sobre otras apps"</string>
    <string name="filter_overlay_apps" msgid="2483998217116789206">"Aplicaciones con permiso"</string>
    <string name="app_permission_summary_allowed" msgid="1155115629167757278">"Con permiso"</string>
    <string name="app_permission_summary_not_allowed" msgid="2673793662439097900">"No permitido"</string>
    <string name="keywords_install_other_apps" msgid="563895867658775580">"instalar, apps, fuentes desconocidas"</string>
    <string name="write_settings" msgid="6864794401614425894">"Modificar configuración del sistema"</string>
    <string name="keywords_write_settings" msgid="6908708078855507813">"editar, modificar, sistema, configuración"</string>
    <string name="filter_install_sources_apps" msgid="6930762738519588431">"Puede instalar otras apps"</string>
    <string name="filter_write_settings_apps" msgid="4754994984909024093">"Puede modificar la configuración del sistema"</string>
    <string name="write_settings_title" msgid="3011034187823288557">"Puede modificar la configuración del sistema"</string>
    <string name="write_system_settings" msgid="5555707701419757421">"Modificar configuración del sistema"</string>
    <string name="permit_write_settings" msgid="3113056800709924871">"Permitir cambios en configuración del sistema"</string>
    <string name="write_settings_description" msgid="1474881759793261146">"Este permiso admite que una aplicación modifique la configuración del sistema."</string>
    <string name="external_source_switch_title" msgid="101571983954849473">"Confiar en esta fuente"</string>
    <string name="camera_gesture_title" msgid="5559439253128696180">"Gira la muñeca dos veces para la cámara"</string>
    <string name="camera_gesture_desc" msgid="7557645057320805328">"Gira la muñeca dos veces para abrir la aplicación de la cámara"</string>
    <string name="screen_zoom_title" msgid="6928045302654960559">"Tamaño de visualización"</string>
    <string name="screen_zoom_short_summary" msgid="756254364808639194">"Amplía o reduce todo"</string>
    <string name="screen_zoom_keywords" msgid="5964023524422386592">"densidad de la pantalla, zoom de la pantalla, escala"</string>
    <string name="screen_zoom_preview_title" msgid="5288355628444562735">"Vista previa"</string>
    <string name="screen_zoom_make_smaller_desc" msgid="2628662648068995971">"Reducir el tamaño"</string>
    <string name="screen_zoom_make_larger_desc" msgid="7268794713428853139">"Aumentar el tamaño"</string>
    <string name="disconnected" msgid="3469373726996129247">"Sin conexión"</string>
    <string name="keyboard_disconnected" msgid="796053864561894531">"No conectado"</string>
    <string name="apps_summary" msgid="4007416751775414252">"<xliff:g id="COUNT">%1$d</xliff:g> apps instaladas"</string>
    <string name="storage_summary" msgid="5903562203143572768">"En uso: <xliff:g id="PERCENTAGE">%1$s</xliff:g> - Libre: <xliff:g id="FREE_SPACE">%2$s</xliff:g>"</string>
    <string name="display_dashboard_summary" msgid="1599453894989339454">"Tema oscuro, tamaño de fuente y brillo"</string>
    <string name="memory_summary" msgid="8221954450951651735">"Se usó un promedio de <xliff:g id="USED_MEMORY">%1$s</xliff:g> de <xliff:g id="TOTAL_MEMORY">%2$s</xliff:g> de memoria"</string>
    <string name="users_summary" msgid="8473589474976307510">"Accediste como <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="android_version_summary" msgid="7818952662015042768">"Se actualizó a Android <xliff:g id="VERSION">%1$s</xliff:g>"</string>
    <string name="android_version_pending_update_summary" msgid="5404532347171027730">"Actualización disponible"</string>
    <string name="disabled_by_policy_title" msgid="6852347040813204503">"Bloqueado por política laboral"</string>
    <string name="disabled_by_policy_title_adjust_volume" msgid="1669689058213728099">"No se puede cambiar el volumen"</string>
    <string name="disabled_by_policy_title_outgoing_calls" msgid="400089720689494562">"No se pueden realizar llamadas"</string>
    <string name="disabled_by_policy_title_sms" msgid="8951840850778406831">"No se pueden enviar mensajes SMS"</string>
    <string name="disabled_by_policy_title_camera" msgid="6616508876399613773">"No se puede usar la cámara"</string>
    <string name="disabled_by_policy_title_screen_capture" msgid="6085100101044105811">"No se pueden tomar capturas de pantalla"</string>
    <string name="disabled_by_policy_title_suspend_packages" msgid="4223983156635729793">"No se puede abrir esta app"</string>
    <string name="disabled_by_policy_title_financed_device" msgid="2328740314082888228">"Opción bloqueada por tu proveedor de crédito"</string>
    <string name="disabled_by_policy_title_biometric_parental_consent" msgid="2463673997797134678">"Se requiere un padre o madre"</string>
    <string name="disabled_by_policy_content_biometric_parental_consent" msgid="7124116806784305206">"Dale el teléfono a tu madre o padre para iniciar la configuración"</string>
    <string name="disabled_by_policy_parental_consent" msgid="9166060049019018978">"Dale el teléfono a tu madre o padre para que permita el cambio de este parámetro de configuración."</string>
    <string name="default_admin_support_msg" msgid="8816296554831532033">"Para obtener más información, comunícate con el administrador de TI."</string>
    <string name="admin_support_more_info" msgid="8407433155725898290">"Más detalles"</string>
    <string name="admin_profile_owner_message" msgid="8860709969532649195">"El administrador puede controlar y administrar las apps y los datos asociados con tu perfil de trabajo, incluida la configuración, los permisos, el acceso corporativo, la actividad de la red y la información de la ubicación del dispositivo."</string>
    <string name="admin_profile_owner_user_message" msgid="4929926887231544950">"El administrador puede controlar y administrar las apps y los datos asociados con este usuario, incluida la configuración, los permisos, el acceso corporativo, la actividad de la red y la información de la ubicación del dispositivo."</string>
    <string name="admin_device_owner_message" msgid="5503131744126520590">"El administrador puede controlar y administrar las apps y los datos asociados con este dispositivo, incluida la configuración, los permisos, el acceso corporativo, la actividad de red y la información de la ubicación del dispositivo."</string>
    <string name="admin_financed_message" msgid="1156197630834947884">"Es posible que el administrador del dispositivo pueda acceder a los datos asociados, cambie la configuración y administre las apps."</string>
    <string name="condition_turn_off" msgid="402707350778441939">"Desactivar"</string>
    <string name="condition_turn_on" msgid="3911077299444314791">"Activar"</string>
    <string name="condition_expand_show" msgid="1501084007540953213">"Mostrar"</string>
    <string name="condition_expand_hide" msgid="8347564076209121058">"Ocultar"</string>
    <string name="condition_hotspot_title" msgid="7903918338790641071">"El hotspot está activo"</string>
    <string name="condition_airplane_title" msgid="5847967403687381705">"El modo de avión está activado"</string>
    <string name="condition_airplane_summary" msgid="1964500689287879888">"Redes no disponibles"</string>
    <string name="condition_zen_title" msgid="7674761111934567490">"\"No interrumpir\" activado"</string>
    <string name="condition_zen_summary_phone_muted" msgid="6516753722927681820">"Se silenció el teléfono"</string>
    <string name="condition_zen_summary_with_exceptions" msgid="9019937492602199663">"Con excepciones"</string>
    <string name="condition_battery_title" msgid="6395113995454385248">"Ahorro de batería activado"</string>
    <string name="condition_battery_summary" msgid="8436806157833107886">"Funciones restringidas"</string>
    <string name="condition_cellular_title" msgid="155474690792125747">"Datos móviles desactivados"</string>
    <string name="condition_cellular_summary" msgid="1678098728303268851">"Solo se puede acceder a Internet mediante Wi‑Fi"</string>
    <string name="condition_bg_data_title" msgid="2719263664589753094">"Ahorro de datos"</string>
    <string name="condition_bg_data_summary" msgid="1736255283216193834">"Funciones restringidas"</string>
    <string name="condition_work_title" msgid="174326145616998813">"Perfil de trabajo desactivado"</string>
    <string name="condition_work_summary" msgid="7113473121312772398">"Para apps y notificaciones"</string>
    <string name="condition_device_muted_action_turn_on_sound" msgid="4078406807327674934">"Activar sonido"</string>
    <string name="condition_device_muted_title" msgid="2446306263428466378">"Se silenció el timbre"</string>
    <string name="condition_device_muted_summary" msgid="3772178424510397327">"Para llamadas y notificaciones"</string>
    <string name="condition_device_vibrate_title" msgid="9058943409545158583">"Solo vibración"</string>
    <string name="condition_device_vibrate_summary" msgid="7537724181691903202">"Para llamadas y notificaciones"</string>
    <string name="night_display_suggestion_title" msgid="5418911386429667704">"Programar Luz nocturna"</string>
    <string name="night_display_suggestion_summary" msgid="4218017907425509769">"Cambiar automáticamente el tono de la pantalla por la noche"</string>
    <string name="condition_night_display_title" msgid="1072880897812554421">"\"Luz nocturna\" activada"</string>
    <string name="condition_night_display_summary" msgid="3278349775875166984">"La pantalla adopta un tono ámbar"</string>
    <string name="condition_grayscale_title" msgid="9029271080007984542">"Escala de grises"</string>
    <string name="condition_grayscale_summary" msgid="1306034149271251292">"Mostrar únicamente en color gris"</string>
    <string name="homepage_condition_footer_content_description" msgid="1568313430995646108">"Contraer"</string>
    <string name="color_temperature" msgid="8256912135746305176">"Temperatura de colores fríos"</string>
    <string name="color_temperature_desc" msgid="6713259535885669622">"Usar colores de pantalla más fríos"</string>
    <string name="color_temperature_toast" msgid="7611532183532407342">"Para aplicar el cambio de color, apaga la pantalla"</string>
    <string name="camera_laser_sensor_switch" msgid="7097842750947187671">"Sensor láser de la cámara"</string>
    <string name="ota_disable_automatic_update" msgid="1953894421412420231">"Actualizaciones automáticas del sistema"</string>
    <string name="ota_disable_automatic_update_summary" msgid="7803279951533276841">"Aplicar actualizaciones al reiniciar el dispositivo"</string>
    <string name="usage" msgid="287782903846013936">"Uso"</string>
    <string name="cellular_data_usage" msgid="5874156338825285334">"Uso de datos móviles"</string>
    <string name="app_cellular_data_usage" msgid="7603292978956033926">"Uso de datos de la app"</string>
    <string name="wifi_data_usage" msgid="6868503699134605707">"Uso de datos Wi‑Fi"</string>
    <string name="non_carrier_data_usage" msgid="6494603202578414755">"Uso de datos que no corresponde al proveedor"</string>
    <string name="ethernet_data_usage" msgid="4552227880905679761">"Uso de datos de Ethernet"</string>
    <string name="wifi" msgid="2932584495223243842">"Wi-Fi"</string>
    <string name="ethernet" msgid="4665162609974492983">"Ethernet"</string>
    <string name="cell_data_template" msgid="6077963976103260821">"Datos móviles: <xliff:g id="AMOUNT">^1</xliff:g>"</string>
    <string name="wifi_data_template" msgid="935934798340307438">"Datos de Wi-Fi: <xliff:g id="AMOUNT">^1</xliff:g>"</string>
    <string name="ethernet_data_template" msgid="1429173767445201145">"Datos de Ethernet: <xliff:g id="AMOUNT">^1</xliff:g>"</string>
    <string name="billing_cycle" msgid="6618424022653876279">"Advertencia de límite de datos"</string>
    <string name="app_usage_cycle" msgid="341009528778520583">"Ciclo de uso de datos móviles"</string>
    <string name="cell_data_warning" msgid="5664921950473359634">"Advertencia de datos: <xliff:g id="ID_1">^1</xliff:g>"</string>
    <string name="cell_data_limit" msgid="256855024790622112">"Límite de datos: <xliff:g id="ID_1">^1</xliff:g>"</string>
    <string name="cell_data_warning_and_limit" msgid="8393200831986035724">"Advertencia de datos: <xliff:g id="ID_1">^1</xliff:g>/Límite de datos: <xliff:g id="ID_2">^2</xliff:g>"</string>
    <string name="operator_warning" msgid="5672761970087591211">"El cálculo de datos del proveedor puede diferir del que hace el dispositivo."</string>
    <string name="non_carrier_data_usage_warning" msgid="4707184871368847697">"Excluye los datos que usan las redes de los proveedores"</string>
    <string name="data_used_template" msgid="8229342096562327646">"Datos usados: <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="set_data_warning" msgid="1685771882794205462">"Configurar advertencia"</string>
    <string name="data_warning" msgid="2925054658166062884">"Advertencia de datos"</string>
    <string name="data_warning_footnote" msgid="5991901765915710592">"El dispositivo mide la advertencia y el límite de datos, que pueden diferir de los que registra tu proveedor."</string>
    <string name="set_data_limit" msgid="9010326815874642680">"Establecer límite de datos"</string>
    <string name="data_limit" msgid="8731731657513652363">"Límite de datos"</string>
    <string name="data_usage_template" msgid="3822452362629968010">"Se usaron <xliff:g id="ID_1">%1$s</xliff:g> en el período: <xliff:g id="ID_2">%2$s</xliff:g>"</string>
    <string name="configure" msgid="1499586749829665889">"Configurar"</string>
    <string name="data_usage_other_apps" msgid="5649047093607329537">"Otras apps incluidas en el uso de datos"</string>
    <string name="data_saver_unrestricted_summary" msgid="7343571401172437542">"{count,plural, =1{1 app tiene permiso para usar datos sin restricción cuando Ahorro de datos está activado}other{# apps tienen permiso para usar datos sin restricción cuando Ahorro de datos está activado}}"</string>
    <string name="data_usage_title" msgid="4039024073687469094">"Datos principales"</string>
    <string name="data_usage_wifi_title" msgid="1060495519280456926">"Datos de Wi-Fi"</string>
    <string name="data_used_formatted" msgid="7913920278059077938">"Se usaron <xliff:g id="ID_1">^1</xliff:g> <xliff:g id="ID_2">^2</xliff:g>"</string>
    <string name="data_overusage" msgid="3680477320458707259">"Exceso: <xliff:g id="ID_1">^1</xliff:g>"</string>
    <string name="data_remaining" msgid="6316251496381922837">"Datos restantes: <xliff:g id="ID_1">^1</xliff:g>"</string>
    <string name="data_usage_chart_brief_content_description" msgid="5548074070258881530">"Un gráfico que muestra el uso de datos entre el <xliff:g id="START_DATE">%1$s</xliff:g> y el <xliff:g id="END_DATE">%2$s</xliff:g>"</string>
    <string name="data_usage_chart_no_data_content_description" msgid="5481968839079467231">"No hay datos en este período"</string>
    <string name="billing_cycle_days_left" msgid="174337287346866400">"{count,plural, =1{# día restante}other{# días restantes}}"</string>
    <string name="billing_cycle_none_left" msgid="1694844019159277504">"No queda tiempo"</string>
    <string name="billing_cycle_less_than_one_day_left" msgid="1210202399053992163">"Queda menos de 1 día"</string>
    <string name="carrier_and_update_text" msgid="5363656651921656280">"Actualizado hace <xliff:g id="ID_2">^2</xliff:g> por <xliff:g id="ID_1">^1</xliff:g>"</string>
    <string name="no_carrier_update_text" msgid="5432798085593055966">"Actualizado hace <xliff:g id="ID_1">^2</xliff:g>"</string>
    <string name="carrier_and_update_now_text" msgid="5075861262344398849">"Actualizado recién por <xliff:g id="ID_1">^1</xliff:g>"</string>
    <string name="no_carrier_update_now_text" msgid="7898004907837200752">"Actualizado recién"</string>
    <string name="launch_mdp_app_text" msgid="8791816789749304897">"Ver plan"</string>
    <string name="launch_wifi_text" msgid="976421974332512894">"Ver detalles"</string>
    <string name="data_saver_title" msgid="2593804270788863815">"Ahorro de datos"</string>
    <string name="unrestricted_data_saver" msgid="7922563266857367495">"Datos sin restricciones"</string>
    <string name="restrict_background_blocklisted" msgid="2308345280442438232">"Se desactivaron los datos en segundo plano"</string>
    <string name="data_saver_on" msgid="7848893946018448793">"Activado"</string>
    <string name="data_saver_off" msgid="5891210864117269045">"Desactivado"</string>
    <string name="data_saver_switch_title" msgid="7111538580123722959">"Usar Ahorro de datos"</string>
    <string name="unrestricted_app_title" msgid="7117585996574329284">"Uso de datos sin restricción"</string>
    <string name="unrestricted_app_summary" msgid="282698963532000403">"Acceso a datos sin restricción"</string>
    <string name="home_app" msgid="6056850504746902747">"Página principal"</string>
    <string name="suggestion_additional_fingerprints" msgid="4726777300101156208">"Agregar otra huella dactilar"</string>
    <string name="suggestion_additional_fingerprints_summary" msgid="2825364645039666674">"Desbloquea con otro dedo"</string>
    <string name="battery_saver_on_summary" msgid="4605146593966255848">"Activado"</string>
    <string name="battery_saver_off_scheduled_summary" msgid="2193875981740829819">"Se activará cuando quede <xliff:g id="BATTERY_PERCENTAGE">%1$s</xliff:g>"</string>
    <string name="battery_saver_off_summary" msgid="4411561435493109261">"Desactivado"</string>
    <string name="app_battery_usage_title" msgid="346558380609793334">"Uso de batería de la app"</string>
    <string name="app_battery_usage_summary" msgid="6349965904306339539">"Establecer uso de batería para apps"</string>
    <string name="filter_battery_unrestricted_title" msgid="821027369424198223">"Sin restricciones"</string>
    <string name="filter_battery_optimized_title" msgid="8236647176487754796">"Optimizada"</string>
    <string name="filter_battery_restricted_title" msgid="5886859505802563232">"Restringido"</string>
    <string name="default_spell_checker" msgid="7108373288347014351">"Corrector predeterminado"</string>
    <string name="choose_spell_checker" msgid="7402513404783243675">"Elegir corrector ortográfico"</string>
    <string name="spell_checker_primary_switch_title" msgid="529240542284039243">"Usar el corrector ortográfico"</string>
    <string name="spell_checker_not_selected" msgid="8818618543474481451">"Sin seleccionar"</string>
    <string name="notification_log_details_delimiter" msgid="2475986465985309821">": "</string>
    <string name="notification_log_details_package" msgid="3205243985502010202">"paquete"</string>
    <string name="notification_log_details_key" msgid="2690467272328709046">"clave"</string>
    <string name="notification_log_details_group" msgid="1765952974599794393">"grupo"</string>
    <string name="notification_log_details_group_summary" msgid="4364622087007803822">"(resumen)"</string>
    <string name="notification_log_details_public_version" msgid="3057653571018432759">"versión pública"</string>
    <string name="notification_log_details_importance" msgid="8516198274667183446">"importancia"</string>
    <string name="notification_log_details_explanation" msgid="6966274549873070059">"explicación"</string>
    <string name="notification_log_details_badge" msgid="648647240928645446">"puede mostrar insignias"</string>
    <string name="notification_log_details_content_intent" msgid="2768423554375629089">"intent"</string>
    <string name="notification_log_details_delete_intent" msgid="8296434571041573503">"borrar intent"</string>
    <string name="notification_log_details_full_screen_intent" msgid="4151243693072002296">"intent en pantalla completa"</string>
    <string name="notification_log_details_actions" msgid="2269605330470905236">"acciones"</string>
    <string name="notification_log_details_title" msgid="8365761340979164197">"título"</string>
    <string name="notification_log_details_remoteinput" msgid="264204203044885921">"entradas remotas"</string>
    <string name="notification_log_details_content_view" msgid="7193602999512479112">"vista personalizada"</string>
    <string name="notification_log_details_extras" msgid="8602887256103970989">"adicionales"</string>
    <string name="notification_log_details_icon" msgid="6728710746466389675">"ícono"</string>
    <string name="notification_log_details_parcel" msgid="2098454650154230531">"tamaño del paquete"</string>
    <string name="notification_log_details_ashmem" msgid="6163312898302809015">"ashmem"</string>
    <string name="notification_log_details_alerted" msgid="5285078967825048406">"notificación enviada"</string>
    <string name="notification_log_channel" msgid="3406738695621767204">"canal"</string>
    <string name="notification_log_details_ranking_null" msgid="6607596177723101524">"Falta el objeto de la clasificación."</string>
    <string name="notification_log_details_ranking_none" msgid="2484105338466675261">"El objeto de la clasificación no incluye esta tecla."</string>
    <string name="display_cutout_emulation" msgid="1421648375408281244">"Corte de pantalla"</string>
    <string name="display_cutout_emulation_keywords" msgid="4506580703807358127">"recorte de la pantalla, corte"</string>
    <string name="overlay_option_device_default" msgid="7986355499809313848">"Opción predeterminada del dispositivo"</string>
    <string name="overlay_toast_failed_to_apply" msgid="4839587811338164960">"Error al aplicar superposición"</string>
    <string name="special_access" msgid="1767980727423395147">"Acceso especial de apps"</string>
    <plurals name="special_access_summary" formatted="false" msgid="4995506406763570815">
      <item quantity="other"><xliff:g id="COUNT">%d</xliff:g> apps pueden usar datos ilimitados</item>
      <item quantity="one">1 app puede usar datos ilimitados</item>
    </plurals>
    <string name="special_access_more" msgid="132919514147475846">"Ver más"</string>
    <string name="long_background_tasks_label" msgid="3169590134850226687">"Tareas largas en segundo plano"</string>
    <string name="long_background_tasks_switch_title" msgid="2491623894899492543">"Permitir tareas largas en segundo plano"</string>
    <string name="long_background_tasks_title" msgid="3272230637974707490">"Tareas largas en segundo plano"</string>
    <string name="long_background_tasks_footer_title" msgid="9117342254914743097">"Permite que esta app ejecute tareas largas en segundo plano. De esta manera, la app puede ejecutar tareas que podrían tardar más de un minuto en finalizar, como descargas y subidas de archivos. \n\nSi se niega este permiso, el sistema limitará el tiempo que la app puede realizar esas tareas en segundo plano."</string>
    <string name="keywords_long_background_tasks" msgid="5788956269136054574">"tareas largas, transferencia de datos, tareas en segundo plano"</string>
    <string name="reset_shortcut_manager_throttling" msgid="2183940254903144298">"Restablecer la limitación de frecuencia de ShortcutManager"</string>
    <string name="reset_shortcut_manager_throttling_complete" msgid="8949943009096885470">"Se restableció la limitación de frecuencia de ShortcutManager"</string>
    <string name="notification_suggestion_title" msgid="6309263655965785411">"Controlar qué aparece en la pantalla de bloqueo"</string>
    <string name="notification_suggestion_summary" msgid="7615611244249276113">"Ocultar o mostrar el contenido de las notificaciones"</string>
    <string name="page_tab_title_support" msgid="3235725053332345773">"Sugerencias y asistencia"</string>
    <string name="developer_smallest_width" msgid="632354817870920911">"Ancho más pequeño"</string>
    <string name="premium_sms_none" msgid="8737045049886416739">"Ninguna app que instalaste solicitó acceso a SMS premium"</string>
    <string name="premium_sms_warning" msgid="2192300872411073324">"SMS Premium podría implicar cargos en la factura de tu proveedor. Si otorgaste permiso a alguna app, podrás enviar SMS premium con esa app."</string>
    <string name="premium_sms_access" msgid="5605970342699013212">"Acceso a SMS premium"</string>
    <string name="bluetooth_disabled" msgid="835838280837359514">"Desactivado"</string>
    <string name="bluetooth_connected_summary" msgid="8043167194934315712">"Conectado a <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="bluetooth_connected_multiple_devices_summary" msgid="2294954614327771844">"Conectado a varios dispositivos"</string>
    <string name="demo_mode" msgid="6566167465451386728">"Modo demostración de la IU del sistema"</string>
    <string name="dark_ui_mode" msgid="898146394425795281">"Tema oscuro"</string>
    <string name="dark_ui_mode_disabled_summary_dark_theme_on" msgid="4554134480159161533">"Se inhabilitó temporalmente debido al Ahorro de batería"</string>
    <string name="ambient_camera_summary_battery_saver_on" msgid="1787784892047029560">"Se inhabilitó temporalmente debido al Ahorro de batería"</string>
    <string name="ambient_camera_battery_saver_off" msgid="689825730569761613">"Desactivar Ahorro de batería"</string>
    <string name="dark_ui_mode_disabled_summary_dark_theme_off" msgid="4154227921313505702">"Activado temporalmente por el Ahorro de batería"</string>
    <string name="dark_theme_slice_title" msgid="4684222119481114062">"Prueba el Tema oscuro"</string>
    <string name="dark_theme_slice_subtitle" msgid="5555724345330434268">"Extiende la duración de la batería"</string>
    <string name="quick_settings_developer_tiles" msgid="7336007844525766623">"Azulejos de configuración rápida para desarrolladores"</string>
    <string name="adb_authorization_timeout_title" msgid="6996844506783749754">"Inhabilitar tiempo de espera de autorización ADB"</string>
    <string name="adb_authorization_timeout_summary" msgid="409931540424019778">"Inhabilita la revocación automática de autorizaciones ADB para sistemas que no se volvieron a conectar dentro de un período predeterminado (7 días) o uno configurado por el usuario (mínimo de 1 día)."</string>
    <string name="winscope_trace_quick_settings_title" msgid="4104768565053226689">"Seguimiento de Winscope"</string>
    <string name="sensors_off_quick_settings_title" msgid="8472151847125917167">"Sensores desactivados"</string>
    <string name="managed_profile_settings_title" msgid="3400923723423564217">"Configuración del perfil de trabajo"</string>
    <string name="managed_profile_contact_search_title" msgid="6562061740814513737">"Buscar contactos del directorio de trabajo en apps personales"</string>
    <string name="managed_profile_contact_search_summary" msgid="4974727886709219105">"Es posible que el administrador de TI pueda ver las búsquedas y las llamadas entrantes"</string>
    <string name="cross_profile_calendar_title" msgid="7570277841490216947">"Sincronizar perfiles en el calendario"</string>
    <string name="cross_profile_calendar_summary" msgid="8856185206722860069">"Mostrar eventos de trabajo en el calendario personal"</string>
    <string name="automatic_storage_manager_settings" msgid="519158151463974656">"Administrar el almacenamiento"</string>
    <string name="automatic_storage_manager_text" msgid="6900593059927987273">"El administrador de almacenamiento quita de tu dispositivo las fotos y los videos con copia de seguridad para liberar espacio de almacenamiento."</string>
    <string name="automatic_storage_manager_days_title" msgid="5077286114860539367">"Quitar fotos y videos"</string>
    <string name="automatic_storage_manager_preference_title" msgid="3483357910142595444">"Administrador de almacenamiento"</string>
    <string name="automatic_storage_manager_primary_switch_title" msgid="9131959126462101994">"Usar el Administrador de almacenamiento"</string>
    <string name="gesture_preference_title" msgid="8291899281322647187">"Gestos"</string>
    <string name="double_tap_power_for_camera_title" msgid="7982364144330923683">"Abrir cámara rápidamente"</string>
    <string name="double_tap_power_for_camera_summary" msgid="1100926048598415509">"Para abrir la cámara rápidamente, presiona dos veces el botón de encendido. Funciona desde cualquier pantalla."</string>
    <string name="double_twist_for_camera_mode_title" msgid="472455236910935684">"Girar cámara para selfie"</string>
    <string name="double_twist_for_camera_mode_summary" msgid="592503740044744951"></string>
    <string name="system_navigation_title" msgid="4890381153527184636">"Modo de navegación"</string>
    <string name="swipe_up_to_switch_apps_title" msgid="6677266952021118342">"Navegación con 2 botones"</string>
    <string name="swipe_up_to_switch_apps_summary" msgid="1415457307836359560">"Para cambiar de app, desliza el dedo hacia arriba sobre el botón de inicio. Para ver todas las apps, vuelve a deslizar el dedo hacia arriba. Para volver, presiona el botón \"Atrás\"."</string>
    <string name="emergency_settings_preference_title" msgid="6183455153241187148">"Seguridad y emergencia"</string>
    <string name="emergency_dashboard_summary" msgid="401033951074039302">"Emergencia SOS, información médica y alertas"</string>
    <string name="edge_to_edge_navigation_title" msgid="714427081306043819">"Navegación por gestos"</string>
    <string name="edge_to_edge_navigation_summary" msgid="8497033810637690561">"Para ir a la pantalla principal, desliza el dedo hacia arriba desde la parte inferior de la pantalla. Para cambiar de app, desliza el dedo hacia arriba desde la parte inferior, sostenlo y, luego, suéltalo. Para ir atrás, desliza el dedo desde el borde izquierdo o el derecho."</string>
    <string name="legacy_navigation_title" msgid="7877402855994423727">"Navegación con 3 botones"</string>
    <string name="legacy_navigation_summary" msgid="5905301067778326433">"Ve atrás o a la pantalla principal y cambia de app con los botones de la parte inferior de la pantalla."</string>
    <string name="keywords_system_navigation" msgid="3131782378486554934">"navegación del sistema, navegación con 2 botones, navegación con 3 botones, navegación por gestos, deslizar"</string>
    <string name="assistant_gesture_category_title" msgid="2478251256585807920">"Asistente digital"</string>
    <string name="assistant_corner_gesture_title" msgid="1895061522687002106">"Desliza el dedo para invocar al asistente"</string>
    <string name="assistant_corner_gesture_summary" msgid="7279576276455168075">"Desliza el dedo hacia arriba desde una de las esquinas inferiores para invocar a la app de asistente digital."</string>
    <string name="assistant_long_press_home_gesture_title" msgid="4865972278738178753">"Mantén presionado Inicio para usar Asistente"</string>
    <string name="assistant_long_press_home_gesture_summary" msgid="592882226105081447">"Mantén presionado el botón de inicio para abrir la app de asistente digital."</string>
    <string name="low_label" msgid="6525629096999711220">"Baja"</string>
    <string name="high_label" msgid="357503396626018487">"Alta"</string>
    <string name="left_edge" msgid="1513576842959071849">"Borde izquierdo"</string>
    <string name="right_edge" msgid="1505309103265829121">"Borde derecho"</string>
    <string name="back_sensitivity_dialog_message" msgid="6638367716784103306">"La sensibilidad alta puede entrar en conflicto con los gestos de la app que se hagan en los bordes de la pantalla."</string>
    <string name="back_sensitivity_dialog_title" msgid="6153608904168908264">"Sensibilidad posterior"</string>
    <string name="gesture_settings_activity_title" msgid="2025828425762595733">"Sensibilidad de la navegación por gestos"</string>
    <string name="button_navigation_settings_activity_title" msgid="7335636045504461813">"Botón de navegación"</string>
    <string name="keywords_gesture_navigation_settings" msgid="667561222717238931">"navegación por gestos, sensibilidad posterior, gesto de retroceso"</string>
    <string name="keywords_button_navigation_settings" msgid="7888812253110553920">"navegación, botón de inicio"</string>
    <string name="one_handed_title" msgid="2584414010282746195">"Modo de una mano"</string>
    <string name="one_handed_mode_enabled" msgid="3396864848786359651">"Usar el modo de una mano"</string>
    <string name="one_handed_mode_shortcut_title" msgid="1847871530184067369">"Acceso directo al modo de una mano"</string>
    <string name="keywords_one_handed" msgid="969440592493034101">"accesibilidad"</string>
    <string name="one_handed_mode_swipe_down_category" msgid="110178629274462484">"Deslizar hacia abajo para"</string>
    <string name="one_handed_mode_use_shortcut_category" msgid="1414714099339147711">"Usa la combinación de teclas para"</string>
    <string name="one_handed_mode_intro_text" msgid="7921988617828924342">"Baja la mitad superior de tu pantalla para que sea más fácil alcanzarla con una mano"</string>
    <string name="one_handed_mode_footer_text" msgid="6336209800330679840">" "<b>"Cómo usar el Modo de una mano"</b>\n" • Asegúrate de que esté seleccionada la navegación por gestos en la configuración correspondiente del sistema\n • Desliza un dedo hacia abajo, cerca del borde inferior de la pantalla"</string>
    <string name="one_handed_action_pull_down_screen_title" msgid="9187194533815438150">"Acercar la pantalla al alcance"</string>
    <string name="one_handed_action_pull_down_screen_summary" msgid="7582432473450036628">"Se moverá la parte superior de la pantalla para que llegues con el pulgar."</string>
    <string name="one_handed_action_show_notification_title" msgid="8789305491485437130">"Mostrar notificaciones"</string>
    <string name="one_handed_action_show_notification_summary" msgid="8281689861222000436">"Se mostrarán las notificaciones y la configuración."</string>
    <string name="ambient_display_summary" msgid="2650326740502690434">"Para consultar la hora, las notificaciones y otra información, presiona dos veces la pantalla."</string>
    <string name="ambient_display_wake_screen_title" msgid="7637678749035378085">"Activar pantalla"</string>
    <string name="ambient_display_tap_screen_summary" msgid="4480489179996521405">"Para consultar la hora, las notificaciones y otra información, presiona la pantalla."</string>
    <string name="emergency_gesture_screen_title" msgid="3280543310204360902">"Emergencia SOS"</string>
    <string name="emergency_gesture_switchbar_title" msgid="7421353963329899514">"Usar Emergencia SOS"</string>
    <string name="emergency_gesture_screen_summary" msgid="6640521030845132507">"Presiona rápidamente 5 veces o más el botón de encendido para comenzar las acciones que se describen más abajo"</string>
    <string name="emergency_gesture_sound_setting_title" msgid="7153948164862156536">"Reproducir alarma de cuenta regresiva"</string>
    <string name="emergency_gesture_sound_setting_summary" msgid="6573377104470235173">"Reproducir un sonido fuerte cuando comienza Emergencia SOS"</string>
    <string name="emergency_gesture_category_call_for_help_title" msgid="1680040129478289510">"Notificar para obtener ayuda"</string>
    <string name="emergency_gesture_call_for_help_title" msgid="4969340870836239982">"Llamar para obtener ayuda"</string>
    <string name="emergency_gesture_call_for_help_dialog_title" msgid="8901271205171421201">"Número al que llamar para pedir ayuda"</string>
    <string name="emergency_gesture_call_for_help_summary" msgid="6552830427932669221">"<xliff:g id="PHONE_NUMBER">%1$s</xliff:g>; presiona para cambiar"</string>
    <string name="emergency_gesture_number_override_notes" msgid="233018570696200402">"Si ingresas un número que no es de emergencia:\n • Tu dispositivo debe estar desbloqueado para usar Emergencia SOS\n • Es posible que no se responda tu llamada"</string>
    <string name="fingerprint_swipe_for_notifications_title" msgid="2271217256447175017">"Deslizar tu huella para ver notificaciones"</string>
    <string name="fingerprint_gesture_screen_title" msgid="9086261338232806522">"Deslizar huella dactilar"</string>
    <string name="fingerprint_swipe_for_notifications_suggestion_title" msgid="2956636269742745449">"Consulta tus notificaciones rápidamente"</string>
    <string name="gesture_setting_on" msgid="3223448394997988591">"Activado"</string>
    <string name="gesture_setting_off" msgid="3444029475726294919">"Desactivado"</string>
    <string name="oem_unlock_enable_disabled_summary_bootloader_unlocked" msgid="65713754674288193">"El bootloader está desbloqueado"</string>
    <string name="oem_unlock_enable_disabled_summary_connectivity_or_locked" msgid="7425519481227423860">"Conéctate a Internet o comunícate con tu proveedor"</string>
    <string name="oem_unlock_enable_disabled_summary_sim_locked_device" msgid="168124660162907358">"No disponible en dispositivos bloqueados por el proveedor"</string>
    <string name="oem_lock_info_message" msgid="8843145669619429197">"Reinicia el dispositivo para habilitar la función de protección correspondiente."</string>
    <string name="automatic_storage_manager_freed_bytes" msgid="706230592123831676">"Espacio que se liberó: <xliff:g id="SIZE">%1$s</xliff:g>\n\nÚltima vez que se ejecutó: <xliff:g id="DATE">%2$s</xliff:g>"</string>
    <string name="web_action_enable_title" msgid="6654581786741216382">"Apps instantáneas"</string>
    <string name="web_action_enable_summary" msgid="2658930257777545990">"Abre vínculos en apps, incluso aunque no estén instaladas"</string>
    <string name="web_action_section_title" msgid="994717569424234098">"Apps instantáneas"</string>
    <string name="instant_apps_settings" msgid="4280942494969957858">"Preferencias de las Apps instantáneas"</string>
    <string name="domain_url_section_title" msgid="9028890472923474958">"Apps instaladas"</string>
    <string name="automatic_storage_manager_activation_warning" msgid="170508173207142665">"Tu almacenamiento ahora está a cargo del administrador de almacenamiento"</string>
    <string name="account_for_section_header" msgid="7466759342105251096">"Cuentas de <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="auto_sync_account_title" msgid="1070908045600374254">"Sincronizar datos de apps automáticamente"</string>
    <string name="auto_sync_account_summary" msgid="7580352130028957346">"Permitir que las apps actualicen datos automáticamente"</string>
    <string name="account_sync_title" msgid="7036067017433297574">"Sincronización de la cuenta"</string>
    <string name="account_sync_summary_some_on" msgid="911460286297968724">"Sincronización activada para <xliff:g id="ID_1">%1$d</xliff:g> de <xliff:g id="ID_2">%2$d</xliff:g> elementos"</string>
    <string name="account_sync_summary_all_on" msgid="2953682111836599841">"Sincronización activada para todos los elementos"</string>
    <string name="account_sync_summary_all_off" msgid="6378301874540507884">"Sincronización desactivada para todos los elementos"</string>
    <string name="enterprise_privacy_settings" msgid="786350385374794180">"Información del dispositivo administrado"</string>
    <string name="enterprise_privacy_settings_summary_generic" msgid="5471858290610344646">"Cambios y opciones de configuración que administra tu organización"</string>
    <string name="enterprise_privacy_settings_summary_with_name" msgid="1315413275836515937">"Cambios y opciones de configuración que administra <xliff:g id="ORGANIZATION_NAME">%s</xliff:g>"</string>
    <string name="enterprise_privacy_header" msgid="4626225398848641603">"Para brindar acceso a los datos de trabajo, es posible que tu organización instale programas y cambie la configuración en tu dispositivo.\n\nPara obtener más información, comunícate con el administrador de tu organización."</string>
    <string name="enterprise_privacy_exposure_category" msgid="2507761423540037308">"Tipos de información que tu organización puede ver"</string>
    <string name="enterprise_privacy_exposure_changes_category" msgid="5459989751333816587">"Cambios que realizó el administrador de tu organización"</string>
    <string name="enterprise_privacy_device_access_category" msgid="140157499478630004">"Tu acceso a este dispositivo"</string>
    <string name="enterprise_privacy_enterprise_data" msgid="3963070078195245028">"Datos asociados a tu cuenta de trabajo, como el correo electrónico y el calendario"</string>
    <string name="enterprise_privacy_installed_packages" msgid="6707006112254572820">"Lista de apps en tu dispositivo"</string>
    <string name="enterprise_privacy_usage_stats" msgid="6328506963853465534">"Consumo de tiempo y datos de cada app"</string>
    <string name="enterprise_privacy_network_logs" msgid="3081744541193695887">"Registro de tráfico de red más reciente"</string>
    <string name="enterprise_privacy_bug_reports" msgid="2635897583413134123">"Informe de errores más reciente"</string>
    <string name="enterprise_privacy_security_logs" msgid="8494681624247959075">"Registro de seguridad más reciente"</string>
    <string name="enterprise_privacy_none" msgid="6026527690979756431">"Ninguno"</string>
    <string name="enterprise_privacy_enterprise_installed_packages" msgid="9114143640515900082">"Apps instaladas"</string>
    <string name="enterprise_privacy_apps_count_estimation_info" msgid="7959907857710107792">"La cantidad de apps es aproximada. Es posible que no se cuenten las apps que no hayas instalado desde Play Store."</string>
    <string name="enterprise_privacy_number_packages_lower_bound" msgid="5317634640873658149">"{count,plural, =1{Al menos # app}other{Al menos # apps}}"</string>
    <string name="enterprise_privacy_location_access" msgid="8023838718108456971">"Permisos de ubicación"</string>
    <string name="enterprise_privacy_microphone_access" msgid="7242958026470143653">"Permisos de micrófono"</string>
    <string name="enterprise_privacy_camera_access" msgid="7685460535880069016">"Permisos de cámara"</string>
    <string name="enterprise_privacy_enterprise_set_default_apps" msgid="7498546659083996300">"Apps predeterminadas"</string>
    <string name="enterprise_privacy_number_packages" msgid="5294444005035188274">"{count,plural, =1{# app}other{# apps}}"</string>
    <string name="enterprise_privacy_input_method" msgid="3278314982700662246">"Teclado predeterminado"</string>
    <string name="enterprise_privacy_input_method_name" msgid="2974859490559054584">"Se configuró en <xliff:g id="APP_LABEL">%s</xliff:g>"</string>
    <string name="enterprise_privacy_always_on_vpn_device" msgid="1735829327405126695">"Se activó la función \"VPN siempre activada\""</string>
    <string name="enterprise_privacy_always_on_vpn_personal" msgid="8395903360175064841">"Se activó la función \"VPN siempre activada\" en tu perfil personal"</string>
    <string name="enterprise_privacy_always_on_vpn_work" msgid="2496961514592522377">"Se activó la función \"VPN siempre activada\" en tu perfil de trabajo"</string>
    <string name="enterprise_privacy_global_http_proxy" msgid="4350347418068037051">"Se estableció el proxy HTTP global"</string>
    <string name="enterprise_privacy_ca_certs_device" msgid="1816495877258727663">"Credenciales de confianza"</string>
    <string name="enterprise_privacy_ca_certs_personal" msgid="1516422660828485795">"Credenciales de confianza en tu perfil personal"</string>
    <string name="enterprise_privacy_ca_certs_work" msgid="4318941788592655561">"Credenciales de confianza en tu perfil de trabajo"</string>
    <string name="enterprise_privacy_number_ca_certs" msgid="4540897122831942658">"{count,plural, =1{Al menos # certificado de la AC}other{Al menos # certificados de la AC}}"</string>
    <string name="enterprise_privacy_lock_device" msgid="464054894363899866">"El administrador puede bloquear el dispositivo y reestablecer la contraseña"</string>
    <string name="enterprise_privacy_wipe_device" msgid="869589182352244591">"El administrador puede borrar todos los datos del dispositivo"</string>
    <string name="enterprise_privacy_failed_password_wipe_device" msgid="7045164901334821226">"Intentos fallidos para ingresar la contraseña antes de borrar los datos del dispositivo"</string>
    <string name="enterprise_privacy_failed_password_wipe_work" msgid="2537582942554484170">"Intentos fallidos para ingresar la contraseña antes de borrar los datos del perfil de trabajo"</string>
    <string name="enterprise_privacy_number_failed_password_wipe" msgid="2695842143305867642">"{count,plural, =1{# intento}other{# intentos}}"</string>
    <string name="do_disclosure_generic" msgid="3067459392402324538">"Tu organización administra este dispositivo."</string>
    <string name="do_disclosure_with_name" msgid="867544298924410766">"<xliff:g id="ORGANIZATION_NAME">%s</xliff:g> administra este dispositivo."</string>
    <string name="do_disclosure_learn_more_separator" msgid="5714364437437041671">" "</string>
    <string name="learn_more" msgid="3534519107947510952">"Más información"</string>
    <string name="blocked_by_restricted_settings_title" msgid="7334715011474037399">"Configuración restringida"</string>
    <string name="toast_allows_restricted_settings_successfully" msgid="1219116121291466102">"Se permite la configuración restringida para <xliff:g id="APP_NAME">%s</xliff:g>"</string>
    <string name="blocked_by_restricted_settings_content" msgid="3628660029601161080">"Por seguridad, esta configuración no está disponible actualmente."</string>
    <string name="financed_privacy_settings" msgid="2575114436197204145">"Información del dispositivo financiado"</string>
    <string name="financed_privacy_intro" msgid="7836497475568741579">"Tu proveedor de crédito puede cambiar los parámetros de configuración y, además, instalar software en este dispositivo durante la configuración.\n\nSi no realizas un pago, el proveedor de crédito puede bloquear el dispositivo y cambiar su configuración.\n\nPara obtener más información, comunícate con el proveedor."</string>
    <string name="financed_privacy_restrictions_category" msgid="2472659467919651602">"Si el dispositivo es financiado, no podrás hacer esto:"</string>
    <string name="financed_privacy_install_apps" msgid="7381718005710210851">"Instalar apps por fuera de Play Store"</string>
    <string name="financed_privacy_safe_mode" msgid="5362149445732602578">"Reiniciar el dispositivo de modo seguro"</string>
    <string name="financed_privacy_multi_users" msgid="1727194928477613081">"Agregar varios usuarios al dispositivo"</string>
    <string name="financed_privacy_config_date_time" msgid="8567370445374984365">"Cambiar las zonas horarias, la fecha y la hora"</string>
    <string name="financed_privacy_developer_options" msgid="7602001474669831672">"Usar opciones para desarrolladores"</string>
    <string name="financed_privacy_credit_provider_capabilities_category" msgid="8737902277892987998">"El proveedor de crédito puede:"</string>
    <string name="financed_privacy_IMEI" msgid="1852413860963824799">"Acceder a tu número de IMEI"</string>
    <string name="financed_privacy_factory_reset" msgid="5505016667590160732">"Restablecer la configuración de fábrica del dispositivo si hay algún problema"</string>
    <string name="financed_privacy_locked_mode_category" msgid="3708288398912647751">"Si se bloquea el dispositivo, podrás usarlo solo para lo siguiente:"</string>
    <string name="financed_privacy_emergency_calls" msgid="1108183987142736497">"Realizar llamadas de emergencia"</string>
    <string name="financed_privacy_system_info" msgid="4158031444108708927">"Ver información del sistema, como la fecha, la hora, el estado de la red y la batería"</string>
    <string name="financed_privacy_turn_on_off_device" msgid="3331566753152790571">"Apagar o encender el dispositivo"</string>
    <string name="financed_privacy_notifications" msgid="5932303271274089968">"Ver notificaciones y mensajes de texto"</string>
    <string name="financed_privacy_allowlisted_apps" msgid="8333040812194879963">"Acceder a las apps permitidas por el proveedor de crédito"</string>
    <string name="financed_privacy_fully_paid_category" msgid="9221763928564246923">"Cuando pagues el monto completo, podrás hacer lo siguiente:"</string>
    <string name="financed_privacy_restrictions_removed" msgid="3182636815294595072">"Se quitan todas las restricciones del dispositivo"</string>
    <string name="financed_privacy_uninstall_creditor_app" msgid="6339004120497310705">"Puedes desinstalar la app del acreedor"</string>
    <string name="default_camera_app_title" msgid="6546248868519965998">"{count,plural, =1{App de cámara}other{Apps de cámara}}"</string>
    <string name="default_calendar_app_title" msgid="1870095225089706093">"App de calendario"</string>
    <string name="default_contacts_app_title" msgid="7740028900741944569">"App de contactos"</string>
    <string name="default_email_app_title" msgid="5411280873093244250">"{count,plural, =1{App de cliente de correo electrónico}other{Apps de cliente de correo electrónico}}"</string>
    <string name="default_map_app_title" msgid="7569231732944853320">"App de mapas"</string>
    <string name="default_phone_app_title" msgid="795025972645464135">"{count,plural, =1{App de Teléfono}other{Apps de Teléfono}}"</string>
    <string name="app_names_concatenation_template_2" msgid="8320181646458855457">"<xliff:g id="FIRST_APP_NAME">%1$s</xliff:g>, <xliff:g id="SECOND_APP_NAME">%2$s</xliff:g>"</string>
    <string name="app_names_concatenation_template_3" msgid="7019703249717854148">"<xliff:g id="FIRST_APP_NAME">%1$s</xliff:g>, <xliff:g id="SECOND_APP_NAME">%2$s</xliff:g>, <xliff:g id="THIRD_APP_NAME">%3$s</xliff:g>"</string>
    <string name="storage_default_internal_storage" msgid="4055660218818688131">"Este dispositivo"</string>
    <string name="storage_games" msgid="1176568610086802469">"Juegos"</string>
    <string name="storage_files" msgid="7968460921272772299">"Archivos"</string>
    <string name="storage_images" msgid="2055893015567979387">"Imágenes"</string>
    <string name="storage_videos" msgid="6117698226447251033">"Videos"</string>
    <string name="storage_audio" msgid="5994664984472140386">"Audio"</string>
    <string name="storage_apps" msgid="3564291603258795216">"Apps"</string>
    <string name="storage_documents_and_other" msgid="3293689243732236480">"Documentos y otros"</string>
    <string name="storage_system" msgid="8472410119822911844">"Sistema"</string>
    <string name="storage_trash" msgid="2807138998886084856">"Papelera"</string>
    <string name="storage_trash_dialog_title" msgid="2296169576049935200">"¿Quieres vaciar la papelera?"</string>
    <string name="storage_trash_dialog_ask_message" msgid="8982602137242358798">"Hay <xliff:g id="TOTAL">%1$s</xliff:g> de archivos en la papelera. Todos los elementos se borrarán definitivamente y no podrás restablecerlos."</string>
    <string name="storage_trash_dialog_empty_message" msgid="7334670765528691400">"La papelera está vacía"</string>
    <string name="storage_trash_dialog_confirm" msgid="1707723334982760436">"Vaciar la papelera"</string>
    <string name="storage_usage_summary" msgid="4591121727356723463">"<xliff:g id="NUMBER">%1$s</xliff:g> <xliff:g id="UNIT">%2$s</xliff:g> en uso"</string>
    <string name="storage_total_summary" msgid="7163360249534964272">"Total: <xliff:g id="NUMBER">%1$s</xliff:g> <xliff:g id="UNIT">%2$s</xliff:g>"</string>
    <string name="clear_instant_app_data" msgid="5951258323364386357">"Borrar app"</string>
    <string name="clear_instant_app_confirmation" msgid="3964731334459209482">"¿Quieres quitar esta app instantánea?"</string>
    <string name="launch_instant_app" msgid="8503927414339606561">"Abrir"</string>
    <string name="game_storage_settings" msgid="2521393115726178837">"Juegos"</string>
    <string name="app_info_storage_title" msgid="4076977173803093808">"Espacio en uso"</string>
    <string name="webview_uninstalled_for_user" msgid="627352948986275488">"(se desinstaló para <xliff:g id="USER">%s</xliff:g>)"</string>
    <string name="webview_disabled_for_user" msgid="5809886172032644498">"(se inhabilitó para <xliff:g id="USER">%s</xliff:g>)"</string>
    <string name="autofill_app" msgid="7595308061826307921">"Servicio Autocompletar"</string>
    <string name="default_autofill_app" msgid="372234803718251606">"Servicio de autocompletado predeterminado"</string>
    <string name="autofill_passwords" msgid="6708057251459761083">"Contraseñas"</string>
    <string name="credman_credentials" msgid="7413302794874989255">"Servicios de contraseñas, llaves de acceso y datos"</string>
    <string name="autofill_passwords_count" msgid="6359289285822955973">"{count,plural, =1{# contraseña}other{# contraseñas}}"</string>
    <string name="autofill_keywords" msgid="8598763328489346438">"automático, completar, autocompletar, contraseña"</string>
    <string name="credman_keywords" msgid="8305600680836806170">"datos, llave de acceso, contraseña"</string>
    <string name="autofill_confirmation_message" msgid="4888767934273494272">"&lt;b&gt;Asegúrate de que esta app sea confiable&lt;/b&gt; &lt;br/&gt; &lt;br/&gt; &lt;xliff:g id=app_name example=Google Autofill&gt;%1$s&lt;/xliff:g&gt; usa el contenido de tu pantalla para determinar qué se puede autocompletar."</string>
    <string name="credman_confirmation_message_title" msgid="8847900085593880729">"¿Quieres desactivar %1$s?"</string>
    <string name="credman_confirmation_message" msgid="3499478570809427026">"La información guardada, como direcciones y formas de pago, no se rellenará al acceder. Para que la información guardada quede rellenada, habilita un servicio de contraseña, llave de acceso o datos."</string>
    <string name="credman_enable_confirmation_message_title" msgid="3722566298090698004">"¿Quieres activar %1$s?"</string>
    <string name="credman_enable_confirmation_message" msgid="4466773747277583461">"Información guardada, como direcciones o métodos de pago que se compartirán con este proveedor."</string>
    <string name="credman_enable_confirmation_message_positive_button" msgid="3479082692924433102">"Activar"</string>
    <string name="credman_error_message_title" msgid="4741457523969373713">"Límite de servicios de contraseñas, llaves de acceso y datos"</string>
    <string name="credman_error_message" msgid="6793314648458925172">"Puedes tener hasta 5 servicios de contraseñas, llaves de acceso y datos activos al mismo tiempo. Desactiva un servicio para agregar otros."</string>
    <string name="credman_confirmation_message_positive_button" msgid="2812613187691345361">"Desactivar"</string>
    <string name="debug_autofill_category" msgid="5998163555428196185">"Autocompletar"</string>
    <string name="autofill_logging_level_title" msgid="3733958845861098307">"Nivel de registro"</string>
    <string name="autofill_max_partitions" msgid="7342195529574406366">"Número máximo de solicitudes por sesión"</string>
    <string name="autofill_max_visible_datasets" msgid="4970201981694392229">"Máximo de conjuntos de datos visibles"</string>
    <string name="autofill_reset_developer_options" msgid="6425613608979498608">"Restablecer valores predeterminados"</string>
    <string name="autofill_reset_developer_options_complete" msgid="1276741935956594965">"Se restablecieron las opciones de autocompletar para desarrolladores"</string>
    <string name="location_category" msgid="3496759112306219062">"Ubicación"</string>
    <string name="location_indicator_settings_title" msgid="6655916258720093451">"Indicador de ubicación de la barra de estado"</string>
    <string name="location_indicator_settings_description" msgid="2888022085372804021">"Mostrar para todas las ubicaciones, incluidas la red y la conectividad"</string>
    <string name="enable_gnss_raw_meas_full_tracking" msgid="1206679951510243341">"Forzar dimensiones GNSS completas"</string>
    <string name="enable_gnss_raw_meas_full_tracking_summary" msgid="3841463141138247167">"Seguir todas las frecuencias y constelaciones de GNSS sin ciclo de funciones"</string>
    <string name="input_method_category" msgid="2252659253631639005">"Método de entrada"</string>
    <string name="stylus_handwriting" msgid="2154591374132794563">"Escritura a mano con stylus"</string>
    <string name="stylus_handwriting_summary" msgid="6333425895172696950">"Cuando se activa, el método de entrada actual recibe el MotionEvent de la pluma stylus si un editor está enfocado."</string>
    <string name="device_theme" msgid="5027604586494772471">"Tema del dispositivo"</string>
    <string name="default_theme" msgid="4815428567082263639">"Predeterminado"</string>
    <string name="show_operator_name_title" msgid="3355910331531144028">"Nombre de la red"</string>
    <string name="show_operator_name_summary" msgid="5352696579216501773">"Mostrar el nombre de la red en la barra de estado"</string>
    <string name="install_type_instant" msgid="7685381859060486009">"App instantánea"</string>
    <string name="automatic_storage_manager_deactivation_warning" msgid="4905106133215702099">"¿Deseas desactivar el administrador de almacenamiento?"</string>
    <string name="zen_suggestion_title" msgid="4555260320474465668">"Actualizar el modo No interrumpir"</string>
    <string name="zen_suggestion_summary" msgid="1984990920503217">"Pausa las notificaciones para concentrarte"</string>
    <string name="disabled_feature" msgid="7151433782819744211">"Función no disponible"</string>
    <string name="disabled_feature_reason_slow_down_phone" msgid="5743569256308510404">"Se desactivó esta función porque ralentiza el teléfono"</string>
    <string name="show_first_crash_dialog" msgid="1696584857732637389">"Mostrar siempre el cuadro de diálogo de fallas"</string>
    <string name="show_first_crash_dialog_summary" msgid="4692334286984681111">"Mostrar el cuadro de diálogo cada vez que falle una app"</string>
    <string name="angle_enabled_app" msgid="6044941043384239076">"Seleccionar app compatible con ANGLE"</string>
    <string name="angle_enabled_app_not_set" msgid="4472572224881726067">"No se estableció ninguna app compatible con ANGLE"</string>
    <string name="angle_enabled_app_set" msgid="7811829383833353021">"App compatible con ANGLE: <xliff:g id="APP_NAME">%1$s</xliff:g>"</string>
    <string name="graphics_driver_dashboard_title" msgid="5661084817492587796">"Preferencias del controlador gráfico"</string>
    <string name="graphics_driver_dashboard_summary" msgid="6348759885315793654">"Modificar configuración del controlador gráfico"</string>
    <string name="graphics_driver_footer_text" msgid="5123754522284046790">"Cuando hay varios controladores gráficos, puedes elegir usar el que esté actualizado para las apps instaladas en el dispositivo."</string>
    <string name="graphics_driver_all_apps_preference_title" msgid="1343065382898127360">"Habilitar para todas las apps"</string>
    <string name="graphics_driver_app_preference_title" msgid="3133255818657706857">"Seleccionar controlador gráfico"</string>
    <string name="graphics_driver_app_preference_default" msgid="764432460281859855">"Predeterminado"</string>
    <string name="graphics_driver_app_preference_production_driver" msgid="1515874802568434915">"Controlador de juegos"</string>
    <string name="graphics_driver_app_preference_prerelease_driver" msgid="7355929161805829480">"Controlador para desarrolladores"</string>
    <string name="graphics_driver_app_preference_system" msgid="3754748149113184126">"Controlador gráfico del sistema"</string>
    <!-- no translation found for graphics_driver_all_apps_preference_values:0 (8039644515855740879) -->
    <!-- no translation found for graphics_driver_all_apps_preference_values:1 (157748136905839375) -->
    <!-- no translation found for graphics_driver_all_apps_preference_values:2 (8104576549429294026) -->
    <!-- no translation found for graphics_driver_app_preference_values:0 (6403705826179314116) -->
    <!-- no translation found for graphics_driver_app_preference_values:1 (485288770206606512) -->
    <!-- no translation found for graphics_driver_app_preference_values:2 (5391218026495225599) -->
    <!-- no translation found for graphics_driver_app_preference_values:3 (2586045835780389650) -->
    <string name="platform_compat_dashboard_title" msgid="1323980546791790236">"Cambios en la compatibilidad de la app"</string>
    <string name="platform_compat_dashboard_summary" msgid="4036546607938791337">"Activar o desactivar los cambios de compatibilidad de la app"</string>
    <string name="platform_compat_default_enabled_title" msgid="8973137337738388024">"Cambios habilitados de manera predeterminada"</string>
    <string name="platform_compat_default_disabled_title" msgid="3975847180953793602">"Cambios inhabilitados de manera predeterminada"</string>
    <string name="platform_compat_dialog_title_no_apps" msgid="4387656000745989506">"No hay apps disponibles"</string>
    <string name="platform_compat_dialog_text_no_apps" msgid="5715226015751055812">"Solo se pueden implementar cambios de compatibilidad para las apps depurables. Instala una app depurable y vuelve a intentarlo."</string>
    <string name="disabled_dependent_setting_summary" msgid="4508635725315852504">"Depende de otra opción de configuración"</string>
    <string name="my_device_info_account_preference_title" msgid="9197139254007133175">"Cuenta"</string>
    <string name="my_device_info_device_name_preference_title" msgid="8053298498727237971">"Nombre del dispositivo"</string>
    <string name="my_device_info_basic_info_category_title" msgid="381963187269356548">"Información básica"</string>
    <string name="my_device_info_legal_category_title" msgid="7732792841537995127">"Información reglamentaria y legal"</string>
    <string name="my_device_info_device_details_category_title" msgid="4848438695638348680">"Detalles del dispositivo"</string>
    <string name="my_device_info_device_identifiers_category_title" msgid="2197063484127704153">"Identificadores del dispositivo"</string>
    <string name="change_wifi_state_title" msgid="5629648102837821525">"Control de Wi-Fi"</string>
    <string name="change_wifi_state_app_detail_switch" msgid="1385358508267180745">"Permitir que la app controle Wi-Fi"</string>
    <string name="change_wifi_state_app_detail_summary" msgid="8230854855584217111">"Permite que esta app active o desactive la conexión Wi-Fi, busque y se conecte a redes Wi-Fi, agregue o quite redes, o inicie un hotspot de acceso local exclusivo."</string>
    <string name="change_nfc_tag_apps_title" msgid="91514009058149617">"Iniciar mediante NFC"</string>
    <string name="change_nfc_tag_apps_detail_switch" msgid="240286205725043561">"Permitir inicio del escáner de NFC"</string>
    <string name="change_nfc_tag_apps_detail_summary" msgid="7083666814715607078">"Permite que se inicie esta app cuando se escanee una etiqueta NFC.\nSi este permiso se activa, la app estará disponible como opción siempre que se detecte una etiqueta."</string>
    <string name="media_output_title" msgid="8283629315159510680">"Reproducir contenido multimedia en"</string>
    <string name="media_output_label_title" msgid="4139048973886819148">"Reproduce <xliff:g id="LABEL">%s</xliff:g> en"</string>
    <string name="media_output_default_summary" msgid="4200343059396412376">"este dispositivo"</string>
    <string name="media_out_summary_ongoing_call_state" msgid="475188726850090363">"No disponible durante llamadas"</string>
    <string name="take_call_on_title" msgid="1159417893879946757">"Atender llamada en"</string>
    <string name="cannot_change_apn_toast" msgid="296540724089240405">"No se puede cambiar este APN."</string>
    <string name="gesture_prevent_ringing_screen_title" msgid="8293094715267769349">"Evitar sonido de llamadas"</string>
    <string name="gesture_prevent_ringing_title" msgid="5978577898997523581">"Presiona el botón de encendido y el botón para subir el volumen al mismo tiempo para"</string>
    <string name="gesture_prevent_ringing_sound_title" msgid="4529077822282099235">"Acceso directo para silenciar"</string>
    <string name="prevent_ringing_option_vibrate" msgid="5456962289649581737">"Vibrar"</string>
    <string name="prevent_ringing_option_mute" msgid="7446121133560945051">"Silenciar"</string>
    <string name="prevent_ringing_option_vibrate_summary" msgid="3435299885425754304">"Vibrar"</string>
    <string name="prevent_ringing_option_mute_summary" msgid="3939350522269337013">"Silenciar"</string>
    <string name="prevent_ringing_option_unavailable_lpp_summary" msgid="8070356204398144241">"A fin de habilitar la función, cambia \"Mantener presionado el botón de encendido\" para acceder al menú de encendido."</string>
    <string name="pref_title_network_details" msgid="7329759534269363308">"Detalles de la red"</string>
    <string name="about_phone_device_name_warning" msgid="1938930553285875166">"El nombre de tu dispositivo es visible para las apps del teléfono. Es posible que también lo vean otras personas cuando te conectes a dispositivos Bluetooth o a una red Wi-Fi, o cuando configures un hotspot de Wi-Fi."</string>
    <string name="devices_title" msgid="649715719278562515">"Dispositivos"</string>
    <string name="choose_network_title" msgid="5355609223363859430">"Elegir una red"</string>
    <string name="network_disconnected" msgid="8281188173486212661">"Desconectado"</string>
    <string name="network_connected" msgid="7637745547242487795">"Conectado"</string>
    <string name="network_connecting" msgid="6856124847029124041">"Conectando…"</string>
    <string name="network_could_not_connect" msgid="676574629319069922">"No se pudo establecer conexión"</string>
    <string name="empty_networks_list" msgid="6519489879480673428">"No se encontraron redes."</string>
    <string name="network_query_error" msgid="6406348372070035274">"No se encontraron redes. Vuelve a intentarlo."</string>
    <string name="forbidden_network" msgid="7404863971282262991">"(prohibida)"</string>
    <string name="sim_card" msgid="6381158752066377709">"SIM"</string>
    <string name="wifi_no_sim_card" msgid="7144290066491585672">"No hay ninguna tarjeta SIM"</string>
    <string name="wifi_no_related_sim_card" msgid="3568255415415630510">"No hay información"</string>
    <string name="wifi_require_sim_card_to_connect" msgid="1524984445750423666">"Se requiere una tarjeta SIM para conectarse"</string>
    <string name="wifi_require_specific_sim_card_to_connect" msgid="8136020469861668506">"Se requiere una tarjeta SIM <xliff:g id="WIRELESS_CARRIER">%s</xliff:g> para conectarse"</string>
    <string name="preferred_network_mode_wcdma_perf_summary" msgid="230527592752934655">"Modo de red preferido: WCDMA preferido"</string>
    <string name="preferred_network_mode_gsm_only_summary" msgid="2936969642076535162">"Modo de red preferido: solo GSM"</string>
    <string name="preferred_network_mode_wcdma_only_summary" msgid="632816273979433076">"Modo de red preferido: solo WCDMA"</string>
    <string name="preferred_network_mode_gsm_wcdma_summary" msgid="6419309630040697488">"Modo de red preferido: GSM/WCDMA"</string>
    <string name="preferred_network_mode_cdma_summary" msgid="5735467143380764681">"Modo de red preferido: CDMA"</string>
    <string name="preferred_network_mode_cdma_evdo_summary" msgid="1667358006735235626">"Modo de red preferido: CDMA/EvDo"</string>
    <string name="preferred_network_mode_cdma_only_summary" msgid="6305930965673800101">"Modo de red preferido: solo CDMA"</string>
    <string name="preferred_network_mode_evdo_only_summary" msgid="613903666107299289">"Modo de red preferido: solo EvDo"</string>
    <string name="preferred_network_mode_cdma_evdo_gsm_wcdma_summary" msgid="5643603478619124717">"Modo de red preferido: CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_lte_summary" msgid="4236015557975544307">"Modo de red preferido: LTE"</string>
    <string name="preferred_network_mode_lte_gsm_wcdma_summary" msgid="1377100995001285751">"Modo de red preferido: GSM/WCDMA/LTE"</string>
    <string name="preferred_network_mode_lte_cdma_evdo_summary" msgid="1221806410911793222">"Modo de red preferido: CDMA+LTE/EVDO"</string>
    <string name="preferred_network_mode_lte_cdma_evdo_gsm_wcdma_summary" msgid="8974263692041299883">"Modo de red preferido: LTE/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_global_summary" msgid="817118763629102239">"Modo de red preferido: Global"</string>
    <string name="preferred_network_mode_lte_wcdma_summary" msgid="7326137039981934928">"Modo de red preferido: LTE/WCDMA"</string>
    <string name="preferred_network_mode_lte_gsm_umts_summary" msgid="5105989927899481131">"Modo de red preferido: LTE/GSM/UMTS"</string>
    <string name="preferred_network_mode_lte_cdma_summary" msgid="2364210682008525703">"Modo de red preferido: LTE/CDMA"</string>
    <string name="preferred_network_mode_tdscdma_summary" msgid="796303916110624922">"Modo de red preferido: TDSCDMA"</string>
    <string name="preferred_network_mode_tdscdma_wcdma_summary" msgid="1465990745594594173">"Modo de red preferido: TDSCDMA/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_summary" msgid="3771917510642642724">"Modo de red preferido: LTE/TDSCDMA"</string>
    <string name="preferred_network_mode_tdscdma_gsm_summary" msgid="8906951876805688851">"Modo de red preferido: TDSCDMA/GSM"</string>
    <string name="preferred_network_mode_lte_tdscdma_gsm_summary" msgid="2264537129425897267">"Modo de red preferido: LTE/GSM/TDSCDMA"</string>
    <string name="preferred_network_mode_tdscdma_gsm_wcdma_summary" msgid="2469046704847661521">"Modo de red preferido: TDSCDMA/GSM/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_wcdma_summary" msgid="2276439307637315057">"Modo de red preferido: LTE/TDSCDMA/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_gsm_wcdma_summary" msgid="1640309016390119366">"Modo de red preferido: LTE/TDSCDMA/GSM/WCDMA"</string>
    <string name="preferred_network_mode_tdscdma_cdma_evdo_gsm_wcdma_summary" msgid="8918066490624875671">"Modo de red preferido: TDSCDMA/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_cdma_evdo_gsm_wcdma_summary" msgid="1059705864131001171">"Modo de red preferido: LTE/TDSCDMA/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_nr_only_summary" msgid="9153575102136218656">"Modo de red preferido: solo NR"</string>
    <string name="preferred_network_mode_nr_lte_summary" msgid="4326679533556458480">"Modo de red preferido: NR/LTE"</string>
    <string name="preferred_network_mode_nr_lte_cdma_evdo_summary" msgid="4030662583832600005">"Modo de red preferido: NR/LTE/CDMA/EvDo"</string>
    <string name="preferred_network_mode_nr_lte_gsm_wcdma_summary" msgid="8327982533965785835">"Modo de red preferido: NR/LTE/GSM/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_cdma_evdo_gsm_wcdma_summary" msgid="7892233480076496041">"Modo de red preferido: NR/LTE/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_wcdma_summary" msgid="5762334298562095421">"Modo de red preferido: NR/LTE/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_summary" msgid="2356681171665091175">"Modo de red preferido: NR/LTE/TDSCDMA"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_gsm_summary" msgid="8889597344872814893">"Modo de red preferido: NR/LTE/TDSCDMA/GSM"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_wcdma_summary" msgid="506057560516483258">"Modo de red preferido: NR/LTE/TDSCDMA/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_gsm_wcdma_summary" msgid="4337061745216872524">"Modo de red preferido: NR/LTE/TDSCDMA/GSM/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_cdma_evdo_gsm_wcdma_summary" msgid="3396717432149544381">"Modo de red preferido: NR/LTE/TDSCDMA/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="network_5G_recommended" msgid="4769018972369031538">"5G (recomendado)"</string>
    <string name="network_lte" msgid="2449425437381668780">"LTE (recomendado)"</string>
    <string name="network_4G" msgid="9018841362928321047">"4G (recomendado)"</string>
    <string name="select_automatically" msgid="2419752566747259155">"Seleccionar red de forma automática"</string>
    <string name="carrier_settings_title" msgid="6959295328730560529">"Config. del proveedor"</string>
    <string name="cdma_lte_data_service" msgid="6937443423651347345">"Configurar servicio de datos"</string>
    <string name="mobile_data_settings_title" msgid="3927524078598009792">"Datos móviles"</string>
    <string name="mobile_data_settings_summary" msgid="7323978798199919063">"Acceder a los datos usando la red móvil"</string>
    <string name="mobile_data_settings_summary_auto_switch" msgid="7851549787645698945">"El teléfono cambiará a este proveedor automáticamente en cuanto esté dentro del rango"</string>
    <string name="mobile_data_settings_summary_unavailable" msgid="9176513507571883986">"No hay ninguna SIM disponible"</string>
    <string name="calls_preference" msgid="2166481296066890129">"Preferencia de llamadas"</string>
    <string name="sms_preference" msgid="7742964962568219351">"Preferencia de SMS"</string>
    <string name="calls_and_sms_ask_every_time" msgid="3178743088737726677">"Preguntar siempre"</string>
    <string name="mobile_network_summary_add_a_network" msgid="9079866102827526779">"Agregar una red"</string>
    <string name="default_for_calls" msgid="2788950217176988034">"Predeterminada para llamadas"</string>
    <string name="default_for_sms" msgid="1316988329407434771">"Predeterminada para SMS"</string>
    <string name="default_for_calls_and_sms" msgid="8223971369339958151">"Predeterminada para llamadas y SMS"</string>
    <string name="default_for_mobile_data" msgid="3725773640392315626">"Predeterminada para datos móviles"</string>
    <string name="mobile_data_active" msgid="8683694456401350210">"Datos móviles activados"</string>
    <string name="mobile_data_off" msgid="2702029611959308269">"Datos móviles desactivados"</string>
    <string name="subscription_available" msgid="2659722770210403365">"Disponible"</string>
    <string name="mobile_network_list_add_more" msgid="5076722903436552813">"Insertar una tarjeta SIM"</string>
    <string name="mobile_network_active_sim" msgid="6397581267971410039">"Activa / SIM"</string>
    <string name="mobile_network_inactive_sim" msgid="5829757490580409899">"Inactiva / SIM"</string>
    <string name="mobile_network_active_esim" msgid="3984452275968408382">"Activo/eSIM"</string>
    <string name="mobile_network_inactive_esim" msgid="8777415108263057939">"Inactivo/eSIM"</string>
    <string name="mobile_network_sim_name" msgid="3187192894150386537">"Nombre y color de la SIM"</string>
    <string name="mobile_network_sim_name_label" msgid="1452440641628369625">"Nombre"</string>
    <string name="mobile_network_sim_color_label" msgid="5293944087609632340">"Color (utilizado por apps compatibles)"</string>
    <string name="mobile_network_sim_name_rename" msgid="5967588549571582924">"Guardar"</string>
    <string name="mobile_network_use_sim_on" msgid="7298332437547707908">"Usar SIM"</string>
    <string name="mobile_network_use_sim_off" msgid="6303281166199670639">"Desactivado"</string>
    <string name="mobile_network_disable_sim_explanation" msgid="2851862257846773796">"Para inhabilitar esta tarjeta SIM, quítala"</string>
    <string name="mobile_network_tap_to_activate" msgid="4139979375717958102">"Presiona para activar <xliff:g id="CARRIER">%1$s</xliff:g>"</string>
    <string name="mobile_network_erase_sim" msgid="4629071168032714930">"Borrar tarjeta SIM"</string>
    <string name="preferred_network_mode_title" msgid="3083431168988535628">"Tipo de red preferido"</string>
    <string name="preferred_network_mode_summary" msgid="537577807865497546">"Cambiar el modo operativo de la red"</string>
    <string name="preferred_network_mode_dialogtitle" msgid="4179420486180351631">"Tipo de red preferido"</string>
    <string name="carrier_settings_version" msgid="3364919669057317776">"Versión de la configuración del proveedor"</string>
    <string name="call_category" msgid="641461844504128789">"Llamadas"</string>
    <string name="video_calling_settings_title" msgid="5490466306783552190">"Videollamada con el proveedor"</string>
    <string name="cdma_system_select_title" msgid="8261408056382123386">"Sistema seleccionado"</string>
    <string name="cdma_system_select_summary" msgid="384128007068464145">"Cambiar el modo de roaming de CDMA"</string>
    <string name="cdma_system_select_dialogtitle" msgid="6143586810486936984">"Sistema seleccionado"</string>
    <string name="network_operator_category" msgid="5309383730335681395">"Red"</string>
    <string name="cdma_subscription_title" msgid="3107207913315872336">"Suscripción CDMA"</string>
    <string name="cdma_subscription_summary" msgid="7134032708555561334">"Cambiar entre RUIM/SIM y NV"</string>
    <string name="cdma_subscription_dialogtitle" msgid="555971296756231647">"suscripción"</string>
    <string name="register_automatically" msgid="5208258089316657167">"Registro automático…"</string>
    <string name="roaming_alert_title" msgid="9052791521868787985">"¿Permitir el roaming de datos?"</string>
    <string name="roaming_check_price_warning" msgid="5876977438036791361">"Para saber los precios, consulta con tu proveedor de red."</string>
    <string name="mobile_data_usage_title" msgid="2047864499317759728">"Uso de datos de las apps"</string>
    <string name="mobile_network_mode_error" msgid="9222056129897416074">"El modo de red no es válido: <xliff:g id="NETWORKMODEID">%1$d</xliff:g>. Ignorar."</string>
    <string name="mobile_network_apn_title" msgid="5582995550142073054">"Nombres de puntos de acceso"</string>
    <string name="keywords_access_point_names" msgid="8174967126858505945">"apn"</string>
    <string name="manual_mode_disallowed_summary" msgid="4243142645520152175">"No está disponible cuando estás conectado a <xliff:g id="CARRIER">%1$s</xliff:g>"</string>
    <string name="see_more" msgid="7499355691042812723">"Ver más"</string>
    <string name="sim_action_enable_sub_dialog_title" msgid="4003377033815971802">"¿Quieres activar <xliff:g id="CARRIER_NAME">%1$s</xliff:g>?"</string>
    <string name="sim_action_enable_sub_dialog_title_without_carrier_name" msgid="4842051610633654278">"¿Quieres activar la SIM?"</string>
    <string name="sim_action_switch_sub_dialog_title" msgid="9180969453358718635">"¿Quieres cambiar a <xliff:g id="CARRIER_NAME">%1$s</xliff:g>?"</string>
    <string name="sim_action_switch_psim_dialog_title" msgid="5613177333235213024">"¿Cambiar a uso de tarjeta SIM?"</string>
    <string name="sim_action_switch_sub_dialog_mep_title" msgid="933856847099933004">"¿Quieres usar <xliff:g id="CARRIER_NAME">%1$s</xliff:g>?"</string>
    <string name="sim_action_switch_sub_dialog_text" msgid="2091834911153293004">"Solo se puede activar una tarjeta SIM a la vez.\n\nSi cambias a <xliff:g id="TO_CARRIER_NAME">%1$s</xliff:g>, no se cancelará el servicio de <xliff:g id="FROM_CARRIER_NAME">%2$s</xliff:g>."</string>
    <string name="sim_action_switch_sub_dialog_text_downloaded" msgid="8977951796005849471">"Solo puede estar activa una sola eSIM a la vez.\n\nSin embargo, si cambias a <xliff:g id="TO_CARRIER_NAME">%1$s</xliff:g>, no se cancelará tu servicio de <xliff:g id="FROM_CARRIER_NAME">%2$s</xliff:g>."</string>
    <string name="sim_action_switch_sub_dialog_text_single_sim" msgid="6188750682431170845">"Solo se puede activar una tarjeta SIM a la vez.\n\nSi cambias, no se cancelará el servicio de <xliff:g id="TO_CARRIER_NAME">%1$s</xliff:g>."</string>
    <string name="sim_action_switch_sub_dialog_mep_text" msgid="8348764755143679582">"Puedes usar 2 SIM a la vez. Para utilizar <xliff:g id="CARRIER_NAME">%1$s</xliff:g>, desactiva otra SIM."</string>
    <string name="sim_action_switch_sub_dialog_confirm" msgid="1901181581944638961">"Cambiar a <xliff:g id="CARRIER_NAME">%1$s</xliff:g>"</string>
    <string name="sim_action_switch_sub_dialog_carrier_list_item_for_turning_off" msgid="5392037608705799522">"Desactivar <xliff:g id="CARRIER_NAME">%1$s</xliff:g>"</string>
    <string name="sim_action_switch_sub_dialog_info_outline_for_turning_off" msgid="1617619100229136888">"Desactivar una SIM no cancelará tu servicio"</string>
    <string name="sim_action_enabling_sim_without_carrier_name" msgid="2706862823501979981">"Estableciendo conexión con la red…"</string>
    <string name="sim_action_switch_sub_dialog_progress" msgid="4718412054243793310">"Cambiando a <xliff:g id="CARRIER_NAME">%1$s</xliff:g> para llamadas y mensajes…"</string>
    <string name="sim_action_enable_sim_fail_title" msgid="1765646238941015899">"No se puede cambiar de proveedor"</string>
    <string name="sim_action_enable_sim_fail_text" msgid="4781863235721417544">"No se puede cambiar de proveedor debido a un error."</string>
    <string name="privileged_action_disable_sub_dialog_title" msgid="3298942357601334418">"¿Quieres desactivar <xliff:g id="CARRIER_NAME">%1$s</xliff:g>?"</string>
    <string name="privileged_action_disable_sub_dialog_title_without_carrier" msgid="6518373229436331608">"¿Quieres desactivar la tarjeta SIM?"</string>
    <string name="privileged_action_disable_sub_dialog_progress" msgid="5900243067681478102">"Desactivando SIM<xliff:g id="ELLIPSIS">…</xliff:g>"</string>
    <string name="privileged_action_disable_fail_title" msgid="6689494935697043555">"No se puede inhabilitar el proveedor"</string>
    <string name="privileged_action_disable_fail_text" msgid="8404023523406091819">"Se produjo un error y no se pudo inhabilitar tu proveedor."</string>
    <string name="sim_action_enable_dsds_title" msgid="226508711751577169">"¿Quieres usar 2 tarjetas SIM?"</string>
    <string name="sim_action_enable_dsds_text" msgid="970986559326263949">"Este dispositivo puede tener 2 tarjetas SIM activas al mismo tiempo. Para seguir usando una sola, presiona \"No, gracias\"."</string>
    <string name="sim_action_restart_title" msgid="7054617569121993825">"¿Quieres reiniciar el dispositivo?"</string>
    <string name="sim_action_yes" msgid="8076556020131395515">"Sí"</string>
    <string name="sim_action_reboot" msgid="3508948833333441538">"Reiniciar"</string>
    <string name="sim_action_no_thanks" msgid="435717748384544195">"No, gracias"</string>
    <string name="sim_action_cancel" msgid="2668099867029610910">"Cancelar"</string>
    <string name="sim_switch_button" msgid="1405772571706095387">"Cambiar"</string>
    <string name="dsds_activation_failure_title" msgid="4467364110584914794">"No se puede activar la SIM"</string>
    <string name="dsds_activation_failure_body_msg2" msgid="73044349546544410">"Vuelve a activar la SIM. Si el problema persiste, reinicia el dispositivo."</string>
    <string name="sim_setup_channel_id" msgid="8797972565087458515">"Activación de red"</string>
    <string name="sim_switch_channel_id" msgid="4927038626791837861">"Cambio de proveedor"</string>
    <string name="post_dsds_reboot_notification_title_with_carrier" msgid="3308827462185135307">"<xliff:g id="CARRIER_NAME">%1$s</xliff:g> está activo"</string>
    <string name="post_dsds_reboot_notification_text" msgid="7533428378211541410">"Presiona para actualizar la configuración de la tarjeta SIM"</string>
    <string name="switch_to_removable_notification" msgid="7640342063449806296">"Se cambió a <xliff:g id="CARRIER_NAME">%1$s</xliff:g>"</string>
    <string name="switch_to_removable_notification_no_carrier_name" msgid="7384856964036215338">"Se cambió a otro proveedor"</string>
    <string name="network_changed_notification_text" msgid="2407908598496951243">"Se modificó la red móvil"</string>
    <string name="dsds_notification_after_suw_title" msgid="3738898232310273982">"Configura la otra SIM"</string>
    <string name="dsds_notification_after_suw_text" msgid="1287357774676361084">"Elige tu SIM activa o usa 2 al mismo tiempo"</string>
    <string name="choose_sim_title" msgid="4804689675237716286">"Elige el número que quieras usar"</string>
    <string name="choose_sim_text" msgid="4356662002583501647">"{count,plural, =1{Hay 1 número disponible en este dispositivo, pero solo se puede usar uno a la vez}=2{Hay 2 números disponibles en este dispositivo, pero solo se puede usar uno a la vez}other{Hay # números disponibles en este dispositivo, pero solo se puede usar uno a la vez}}"</string>
    <string name="choose_sim_activating" msgid="9035902671985449448">"Activando<xliff:g id="ELLIPSIS">…</xliff:g>"</string>
    <string name="choose_sim_could_not_activate" msgid="2154564459842291617">"No se puede activar en este momento"</string>
    <string name="switch_sim_dialog_title" msgid="5407316878973237773">"¿Deseas usar <xliff:g id="CARRIER_NAME">%1$s</xliff:g>?"</string>
    <string name="switch_sim_dialog_text" msgid="7530186862171635464">"Se usará <xliff:g id="CARRIER_NAME">%1$s</xliff:g> para datos móviles, llamadas y SMS."</string>
    <string name="switch_sim_dialog_no_switch_title" msgid="809763410787744247">"No hay tarjetas SIM activas disponibles"</string>
    <string name="switch_sim_dialog_no_switch_text" msgid="7053939850026876088">"Para usar datos móviles, funciones de llamada y SMS en otro momento, ve a la configuración de red"</string>
    <string name="sim_card_label" msgid="6263064316075963775">"SIM"</string>
    <string name="erase_sim_dialog_title" msgid="4742077437653028326">"¿Quieres borrar esta eSIM?"</string>
    <string name="erase_sim_dialog_text" msgid="753031064269699885">"Si borras esta tarjeta SIM, se quitará el servicio de <xliff:g id="CARRIER_NAME_A">%1$s</xliff:g> de este dispositivo.\n\nSin embargo, no se cancelará el servicio de <xliff:g id="CARRIER_NAME_B">%1$s</xliff:g>."</string>
    <string name="erase_sim_confirm_button" msgid="8309115684335320541">"Borrar"</string>
    <string name="erasing_sim" msgid="7877703231075699139">"Borrando tarjeta SIM…"</string>
    <string name="erase_sim_fail_title" msgid="2024446702985862427">"No se puede borrar la tarjeta SIM"</string>
    <string name="erase_sim_fail_text" msgid="7870804401227483131">"No es posible borrar esta tarjeta SIM porque se produjo un error.\n\nReinicia el dispositivo y vuelve a intentarlo."</string>
    <string name="network_connection_request_dialog_title" msgid="1896186380874289434">"Conectar al dispositivo"</string>
    <string name="network_connection_request_dialog_summary" msgid="7693038309792726170">"La app de <xliff:g id="APPNAME">%1$s</xliff:g> quiere usar una red Wi-Fi temporal para conectarse a tu dispositivo"</string>
    <string name="network_connection_timeout_dialog_message" msgid="598509083077743772">"No se encontraron dispositivos. Asegúrate de que los dispositivos estén encendidos y puedan conectarse."</string>
    <string name="network_connection_timeout_dialog_ok" msgid="6022675321823723755">"Volver a intentarlo"</string>
    <string name="network_connection_errorstate_dialog_message" msgid="3360714322047603239">"Se produjo un error. La aplicación canceló la solicitud para elegir un dispositivo."</string>
    <string name="network_connection_connect_successful" msgid="2587314077675642476">"Conexión exitosa"</string>
    <string name="network_connection_connect_failure" msgid="6803313816657494319">"Error de conexión"</string>
    <string name="network_connection_request_dialog_showall" msgid="6392059758456994944">"Mostrar todo"</string>
    <string name="network_connection_searching_message" msgid="8521819623516926482">"Buscando dispositivo…"</string>
    <string name="network_connection_connecting_message" msgid="433189540877274889">"Estableciendo conexión con dispositivo…"</string>
    <string name="bluetooth_left_name" msgid="7440064067910080502">"Izquierdo"</string>
    <string name="bluetooth_right_name" msgid="7588088072444124949">"Derecho"</string>
    <string name="bluetooth_middle_name" msgid="3909371955137442319">"Funda"</string>
    <string name="settings_panel_title" msgid="346363079938069215">"Panel de Configuración"</string>
    <string name="force_desktop_mode" msgid="1336913605091334238">"Forzar modo de escritorio"</string>
    <string name="force_desktop_mode_summary" msgid="4587416867846930479">"Forzar el modo de escritorio experimental en pantallas secundarias"</string>
    <string name="enable_non_resizable_multi_window" msgid="6832903754625404477">"Habilitar apps que no cambian de tamaño en Multiventana"</string>
    <string name="enable_non_resizable_multi_window_summary" msgid="3275763753261901999">"Permitir que las apps que no cambian de tamaño aparezcan en Multiventana"</string>
    <string name="hwui_force_dark_title" msgid="4256904905631994219">"Anular forzar el modo oscuro"</string>
    <string name="hwui_force_dark_summary" msgid="6515748781487952769">"Anula la función forzar el modo oscuro para que esté siempre activo"</string>
    <string name="privacy_dashboard_title" msgid="6845403825611829558">"Privacidad"</string>
    <string name="privacy_dashboard_summary" msgid="5775090172422786808">"Permisos, actividad de la cuenta, datos personales"</string>
    <string name="privacy_controls_title" msgid="1383047169455206604">"Controles"</string>
    <string name="contextual_card_dismiss_remove" msgid="8636557343011606722">"Quitar"</string>
    <string name="contextual_card_dismiss_keep" msgid="440516181066490747">"Guardar"</string>
    <string name="contextual_card_dismiss_confirm_message" msgid="6434344989238055188">"¿Quieres quitar esta sugerencia?"</string>
    <string name="low_storage_summary" msgid="1979492757417779718">"Queda poco espacio de almacenamiento (en uso: <xliff:g id="PERCENTAGE">%1$s</xliff:g>; libre: <xliff:g id="FREE_SPACE">%2$s</xliff:g>)"</string>
    <string name="contextual_card_feedback_send" msgid="7409408664417908922">"Enviar comentarios"</string>
    <string name="contextual_card_feedback_confirm_message" msgid="3186334562157665381">"¿Te gustaría compartir tus comentarios sobre esta sugerencia?"</string>
    <string name="copyable_slice_toast" msgid="1008251852798990606">"Se copió <xliff:g id="COPY_CONTENT">%1$s</xliff:g> en el portapapeles."</string>
    <string name="search_bar_account_avatar_content_description" msgid="880523277036898350"></string>
    <string name="accessibility_usage_title" msgid="9190967143518779145">"Uso de accesibilidad"</string>
    <string name="accessibility_usage_summary" msgid="4348285359995227813">"{count,plural, =1{1 app tiene acceso completo al dispositivo}other{# apps tienen acceso completo al dispositivo}}"</string>
    <string name="wfc_disclaimer_title_text" msgid="4617195934203523503">"Información importante"</string>
    <string name="wfc_disclaimer_agree_button_text" msgid="4082872292910770344">"CONTINUAR"</string>
    <string name="wfc_disclaimer_disagree_text" msgid="8424457394700137703">"NO, GRACIAS"</string>
    <string name="wfc_disclaimer_location_title_text" msgid="7913919887475418423">"Ubicación"</string>
    <string name="wfc_disclaimer_location_desc_text" msgid="1417004513415772582">"Es posible que tu proveedor obtenga tu ubicación cuando uses este servicio para llamadas de emergencia.\n\nConsulta la Política de Privacidad de tu proveedor para obtener más detalles."</string>
    <string name="forget_passpoint_dialog_message" msgid="2433875063907365760">"Es posible que pierdas acceso a los datos o al tiempo restantes. Consúltalo con tu proveedor antes de quitarlo."</string>
    <string name="content_capture" msgid="868372905432812238">"Contenido de la app"</string>
    <string name="content_capture_summary" msgid="49720773699715531">"Permite que las apps envíen contenido al sistema Android"</string>
    <string name="capture_system_heap_dump_title" msgid="9210974110606886455">"Capturar volcado de pila del sistema"</string>
    <string name="development_memtag_page_title" msgid="3546667618748029188">"Extensión de etiquetado de mem."</string>
    <string name="development_memtag_intro" msgid="8032596625527637164">"La extensión de etiquetado de memoria (MTE) facilita la detección de problemas de seguridad de memoria en tu aplicación y hace que su código nativo sea más seguro."</string>
    <string name="development_memtag_footer" msgid="5681925148773626562">"Activar MTE puede reducir el rendimiento del dispositivo."</string>
    <string name="development_memtag_learn_more" msgid="8961984806973926704">"Más información sobre MTE"</string>
    <string name="development_memtag_toggle" msgid="2474420239518386894">"Habilita la MTE hasta que la desactives"</string>
    <string name="development_memtag_reboot_message_on" msgid="8100075676107327847">"Tendrás que reiniciar el dispositivo para activar la MTE."</string>
    <string name="development_memtag_reboot_message_off" msgid="3703925647922079456">"Tendrás que reiniciar el dispositivo para desactivar la MTE."</string>
    <string name="reboot_with_mte_title" msgid="2320125810211279">"Habilitar la MTE para una única sesión"</string>
    <string name="reboot_with_mte_message" msgid="1232881567956207641">"Se reiniciará el sistema y se permitirán los experimentos con la extensión de etiquetado de memoria (MTE). Es posible que esto afecte negativamente el rendimiento y la estabilidad. Se restablecerá en el reinicio subsiguiente."</string>
    <string name="reboot_with_mte_summary" msgid="3896537791216432882">"Reiniciar para una única sesión con MTE habilitada"</string>
    <string name="reboot_with_mte_already_enabled" msgid="4439168867613407167">"La MTE ya está habilitada"</string>
    <string name="capturing_system_heap_dump_message" msgid="8410503247477360622">"Capturando volcado del montón del sistema"</string>
    <string name="error_capturing_system_heap_dump_message" msgid="2352983250048200052">"No se pudo capturar el volcado de pila del sistema"</string>
    <string name="automatic_system_heap_dump_title" msgid="4093306504711109479">"Capturar automáticamente volcados de pila del sistema"</string>
    <string name="automatic_system_heap_dump_summary" msgid="4060846186592886986">"Capturar automáticamente un volcado de pila para el sistema Android cuando usa demasiada memoria"</string>
    <string name="wifi_disconnect_button_text" msgid="5698154296678571998">"Desconectar"</string>
    <string name="wfc_disclaimer_emergency_limitation_title_text" msgid="8276287227589397162">"Llamadas de emergencia"</string>
    <string name="wfc_disclaimer_emergency_limitation_desc_text" msgid="5503902001191552196">"Tu proveedor no admite llamadas de emergencia mediante la función Llamada por Wi-Fi.\nEl dispositivo cambia automáticamente a una red móvil para hacer una llamada de emergencia.\nEste tipo de llamadas solo se pueden realizar en áreas con cobertura móvil."</string>
    <string name="wifi_calling_summary" msgid="8566648389959032967">"Usar Wi‑Fi para mejorar la calidad de las llamadas"</string>
    <string name="backup_calling_settings_title" msgid="519714752900364326">"Llamada de copia de seguridad"</string>
    <string name="backup_calling_setting_summary" msgid="599493254305348733">"Si <xliff:g id="BACKUP_CALLING_OPERATOR_TEXT">%1$s</xliff:g> no está disponible o usas roaming, usa los datos móviles de tu SIM para las llamadas de <xliff:g id="BACKUP_CALLING_CARRIER_TEXT">%1$s</xliff:g>."</string>
    <string name="keywords_backup_calling" msgid="8592800915478816800">"llamada de copia de seguridad"</string>
    <string name="enable_receiving_mms_notification_title" msgid="6465218559386990248">"Mensaje MMS entrante"</string>
    <string name="enable_sending_mms_notification_title" msgid="7120641300854953375">"No se puede enviar el mensaje MMS"</string>
    <string name="enable_mms_notification_summary" msgid="6432752438276672500">"Presiona para permitir los mensajes MMS en <xliff:g id="OPERATOR_NAME">%1$s</xliff:g> cuando los datos móviles estén desactivados"</string>
    <string name="enable_mms_notification_channel_title" msgid="1798206332620642108">"Mensaje MMS"</string>
    <string name="sim_combination_warning_notification_title" msgid="1365401631492986487">"Problema con la combinación de SIM"</string>
    <string name="dual_cdma_sim_warning_notification_summary" msgid="2826474790710586487">"Si usas <xliff:g id="OPERATOR_NAMES">%1$s</xliff:g>, podría limitarse la funcionalidad. Presiona para obtener más información."</string>
    <string name="dual_cdma_sim_warning_notification_channel_title" msgid="1049161096896074364">"Combinación de SIM"</string>
    <string name="work_policy_privacy_settings" msgid="2702644843505242596">"Información sobre la política de tu trabajo"</string>
    <string name="work_policy_privacy_settings_summary" msgid="690118670737638405">"Configuración gestionada por tu administrador de TI"</string>
    <string name="track_frame_time_keywords" msgid="7885340257945922239">"GPU"</string>
    <string name="bug_report_handler_title" msgid="713439959113250125">"Controlador de informes de errores"</string>
    <string name="bug_report_handler_picker_footer_text" msgid="4935758328366585673">"Determina qué app controla el acceso directo a los informes de errores en el dispositivo."</string>
    <string name="personal_profile_app_subtext" msgid="5586060806997067676">"Personal"</string>
    <string name="work_profile_app_subtext" msgid="5043419461440127879">"Trabajo"</string>
    <string name="system_default_app_subtext" msgid="5212055189703164839">"Predeterminada del sistema"</string>
    <string name="default_app_none" msgid="5420632042222036264">"Ninguna"</string>
    <string name="select_invalid_bug_report_handler_toast_text" msgid="8857326334015386692">"Esta opción ya no es válida. Vuelve a intentarlo."</string>
    <string name="power_menu_setting_name" msgid="2394440932633137229">"Mantener presionado el botón de encendido"</string>
    <string name="power_menu_long_press_category_title" msgid="1051146091093775002">"Mantener presionado el botón de encendido para acceder al:"</string>
    <string name="power_menu_long_press_for_power_menu_title" msgid="477584639843663599">"Menú de encendido"</string>
    <string name="power_menu_long_press_for_assistant_title" msgid="6557738348262616455">"Asistente digital"</string>
    <string name="power_menu_summary_long_press_for_assistant" msgid="32706459458422952">"Acceso al asistente digital"</string>
    <string name="power_menu_summary_long_press_for_power_menu" msgid="7617247135239683710">"Acceso al menú de encendido"</string>
    <string name="lockscreen_privacy_not_secure" msgid="3251276389681975912">"Para usarlo, debes establecer un bloqueo de pantalla"</string>
    <string name="power_menu_power_volume_up_hint" msgid="5619917593676125759">"Menú de encendido:\nPresiona el botón de encendido y el botón de subir volumen al mismo tiempo"</string>
    <string name="power_menu_power_prevent_ringing_hint" msgid="1169955014711158873">"Silenciar sonidos:\nPresiona un botón de volumen para usar la combinación de teclas"</string>
    <string name="power_menu_long_press_for_assist_sensitivity_title" msgid="1626808509158422185">"Duración de presión"</string>
    <string name="power_menu_long_press_for_assist_sensitivity_summary" msgid="7550610071666801935">"Elige durante cuánto tiempo quieres mantener presionado el botón de encendido para ajustar la sensibilidad"</string>
    <string name="power_menu_long_press_for_assist_sensitivity_low_label" msgid="3430099983480845635">"Corta"</string>
    <string name="power_menu_long_press_for_assist_sensitivity_high_label" msgid="2059686170350829156">"Larga"</string>
    <string name="lockscreen_privacy_wallet_setting_toggle" msgid="4188327143734192000">"Mostrar billetera"</string>
    <string name="lockscreen_privacy_wallet_summary" msgid="3984851951621168573">"Permite el acceso a la billetera desde la pantalla de bloqueo"</string>
    <string name="lockscreen_privacy_qr_code_scanner_setting_toggle" msgid="1856477548806618829">"Mostrar escáner de código QR"</string>
    <string name="lockscreen_privacy_qr_code_scanner_summary" msgid="4577409244972250235">"Permitir el acceso al escáner de código QR desde la pantalla de bloqueo"</string>
    <string name="lockscreen_privacy_controls_setting_toggle" msgid="7445725343949588613">"Mostrar controles del dispositivo"</string>
    <string name="lockscreen_privacy_controls_summary" msgid="2769166101644452893">"Muestra los controles para dispositivos externos desde la pantalla de bloqueo"</string>
    <string name="lockscreen_trivial_controls_setting_toggle" msgid="8211063535536295676">"Controlar con el dispositivo bloqueado"</string>
    <string name="lockscreen_trivial_controls_summary" msgid="680581904143387225">"Si la app de controles de dispositivos lo permite, puedes controlar dispositivos externos sin desbloquear el teléfono o la tablet."</string>
    <string name="lockscreen_trivial_disabled_controls_summary" msgid="7593626010580689155">"Para usar, primero activa \"Mostrar controles del dispositivo\""</string>
    <string name="lockscreen_double_line_clock_summary" msgid="2916159550425093703">"Mostrar el reloj de dos líneas cuando esté disponible"</string>
    <string name="lockscreen_double_line_clock_setting_toggle" msgid="3408639316001688529">"Reloj de dos líneas"</string>
    <string name="lockscreen_quick_affordances_title" msgid="8615741551327565793">"Accesos directos"</string>
    <plurals name="lockscreen_quick_affordances_summary" formatted="false" msgid="4225396036524703997">
      <item quantity="other"><xliff:g id="FIRST_1">%1$s</xliff:g>, <xliff:g id="SECOND">%2$s</xliff:g></item>
      <item quantity="one"><xliff:g id="FIRST_0">%1$s</xliff:g></item>
    </plurals>
    <string name="rtt_settings_title" msgid="7049259598645966354"></string>
    <string name="rtt_settings_no_visible" msgid="7440356831140948382"></string>
    <string name="rtt_settings_visible_during_call" msgid="7866181103286073700"></string>
    <string name="rtt_settings_always_visible" msgid="2364173070088756238"></string>
    <string name="volte_5G_limited_title" msgid="5908052268836750629">"¿Deseas desactivar VoLTE?"</string>
    <string name="volte_5G_limited_text" msgid="7150583768725182345">"También se desactivará tu conexión 5G.\nDurante una llamada de voz, no puedes usar Internet y es posible que algunas apps no funcionen."</string>
    <string name="cached_apps_freezer" msgid="1057519579761550350">"Suspender la ejecución de apps almacenadas en caché"</string>
    <string name="blob_never_expires_text" msgid="7293376386620106623">"Nunca vence."</string>
    <string name="accessor_never_expires_text" msgid="4647624492147788340">"La asignación de tiempo nunca vence."</string>
    <string name="overlay_settings_title" msgid="1032863083496396365">"Permitir pantallas superpuestas en Configuración"</string>
    <string name="overlay_settings_summary" msgid="2745336273786148166">"Permite que las apps que pueden mostrar contenido sobre otras se superpongan a las pantallas de Configuración"</string>
    <string name="allow_mock_modem" msgid="3832264806530479214">"Permite módem de prueba"</string>
    <string name="allow_mock_modem_summary" msgid="9097416612748005374">"Permite que este dispositivo ejecute un servicio de módem de prueba para realizar una prueba de instrumentación. No habilites esta opción durante el uso normal del teléfono."</string>
    <string name="media_controls_title" msgid="403271085636252597">"Contenido multimedia"</string>
    <string name="media_controls_resume_title" msgid="855076860336652370">"Fijar reproductor multimedia"</string>
    <string name="media_controls_resume_description" msgid="3163482266454802097">"Para reanudar rápidamente la reproducción, el reproductor multimedia permanece abierto en Configuración rápida"</string>
    <string name="media_controls_lockscreen_title" msgid="2188311721857512510">"Mostrar contenido multimedia en la pantalla de bloqueo"</string>
    <string name="media_controls_lockscreen_description" msgid="3320333660404439510">"Para reanudar rápidamente la reproducción, el reproductor multimedia permanece abierto en la pantalla de bloqueo"</string>
    <string name="media_controls_recommendations_title" msgid="184225835236807677">"Mostrar recomendaciones multimedia"</string>
    <string name="media_controls_recommendations_description" msgid="7596498733126824030">"Según tu actividad"</string>
    <string name="media_controls_hide_player" msgid="2751439192580884015">"Ocultar reproductor"</string>
    <string name="media_controls_show_player" msgid="8504571042365814021">"Mostrar reproductor"</string>
    <string name="keywords_media_controls" msgid="8345490568291778638">"contenido multimedia"</string>
    <string name="connected_device_see_all_summary" msgid="2056010318537268108">"Se activará el Bluetooth"</string>
    <string name="provider_internet_settings" msgid="3831259474776313323">"Internet"</string>
    <string name="provider_network_settings_title" msgid="2624756136016346774">"SIM"</string>
    <string name="calls_and_sms" msgid="1931855083959003306">"Llamadas y SMS"</string>
    <string name="calls_and_sms_category" msgid="3788238090898237767">"Llamada por Wi‑Fi"</string>
    <string name="calls_sms_wfc_summary" msgid="3940529919408667336">"Hacer y recibir llamadas a través de Wi-Fi"</string>
    <string name="calls_preference_title" msgid="7536882032182563800">"Llamadas"</string>
    <string name="sms_preference_title" msgid="8392745501754864395">"SMS"</string>
    <string name="calls_sms_preferred" msgid="6016477652522583496">"preferida"</string>
    <string name="calls_sms_calls_preferred" msgid="9004261125829377885">"preferido para llamadas"</string>
    <string name="calls_sms_sms_preferred" msgid="3855778890660922711">"preferido para SMS"</string>
    <string name="calls_sms_unavailable" msgid="4055729705246556529">"no disponible"</string>
    <string name="calls_sms_temp_unavailable" msgid="8602291749338757424">"No disponible por el momento"</string>
    <string name="calls_sms_no_sim" msgid="2336377399761819718">"No hay ninguna tarjeta SIM"</string>
    <string name="network_and_internet_preferences_title" msgid="8635896466814033405">"Preferencias de red"</string>
    <string name="keywords_internet" msgid="7674082764898690310">"conexión de red, internet, inalámbrico, datos, wifi, wi-fi, wi fi, datos móviles, móvil, proveedor de telefonía, 4g, 3g, 2g, lte"</string>
    <string name="reset_your_internet_title" msgid="4856899004343241310">"¿Deseas restablecer la conexión a Internet?"</string>
    <string name="resetting_internet_text" msgid="6696779371800051806">"Restableciendo conexión a Internet…"</string>
    <string name="fix_connectivity" msgid="2781433603228089501">"Corregir conectividad"</string>
    <string name="networks_available" msgid="3299512933684383474">"Redes disponibles"</string>
    <string name="to_switch_networks_disconnect_ethernet" msgid="6615374552827587197">"Para cambiar de red, desconéctate de Ethernet"</string>
    <string name="carrier_wifi_offload_title" msgid="7263365988016247722">"Conexiones W+"</string>
    <string name="carrier_wifi_offload_summary" msgid="2980563718888371142">"Permite que Google Fi use redes W+ para mejorar la velocidad y cobertura"</string>
    <string name="carrier_wifi_network_title" msgid="5461382943873831770">"Red W+"</string>
    <string name="sim_category_title" msgid="2341314000964710495">"SIM"</string>
    <string name="downloaded_sim_category_title" msgid="2876988650413179752">"eSIM"</string>
    <string name="downloaded_sims_category_title" msgid="487799905978489922">"eSIMs"</string>
    <string name="sim_category_active_sim" msgid="1503823567818544012">"Activa"</string>
    <string name="sim_category_inactive_sim" msgid="4068899490133820881">"Inactiva"</string>
    <string name="sim_category_default_active_sim" msgid="1208194173387987231">" / Configuración predeterminada para <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="default_active_sim_calls" msgid="2390973682556353558">"llamadas"</string>
    <string name="default_active_sim_sms" msgid="8041498593025994921">"SMS"</string>
    <string name="default_active_sim_mobile_data" msgid="6798083892814045301">"datos móviles"</string>
    <string name="wifi_scan_notify_message" msgid="1331238142061476869">"Para mejorar la experiencia con el dispositivo, las apps y los servicios pueden seguir buscando 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. Puedes cambiar este parámetro en la configuración de búsqueda de Wi-Fi."</string>
    <string name="wifi_scan_change" msgid="8438320311511852918">"Cambiar"</string>
    <string name="preference_summary_default_combination" msgid="4643585915107796253">"<xliff:g id="STATE">%1$s</xliff:g>/<xliff:g id="NETWORKMODE">%2$s</xliff:g>"</string>
    <string name="mobile_data_connection_active" msgid="2422223108911581552">"Conexión establecida"</string>
    <string name="mobile_data_temp_connection_active" msgid="3430470299756236413">"Conectado temporalmente"</string>
    <string name="mobile_data_temp_using" msgid="5211002380149434155">"<xliff:g id="SUBNAME">%1$s</xliff:g> en uso temporalmente"</string>
    <string name="mobile_data_no_connection" msgid="905897142426974030">"Sin conexión"</string>
    <string name="mobile_data_off_summary" msgid="1884248776904165539">"No se conectarán automáticamente los datos móviles"</string>
    <string name="mobile_data_disable_title" msgid="8438714772256088913">"¿Quieres desactivar los datos móviles?"</string>
    <string name="mobile_data_disable_message" msgid="7829414836454769970">"No tendrás acceso a datos móviles ni a Internet a través de <xliff:g id="CARRIER">%s</xliff:g>. Solo podrás conectarte a Internet mediante Wi‑Fi."</string>
    <string name="mobile_data_disable_message_default_carrier" msgid="4449469407705838612">"tu proveedor"</string>
    <string name="not_allowed_by_ent" msgid="1958611623122304411">"Tu organización no lo permite"</string>
    <string name="aware_summary_when_bedtime_on" msgid="2063856008597376344">"No disponible cuando el modo hora de dormir está activado"</string>
    <string name="reset_importance_completed" msgid="3595536767426097205">"Se restableció la prioridad de notificaciones."</string>
    <string name="apps_dashboard_title" msgid="3269953499954393706">"Apps"</string>
    <string name="bluetooth_message_access_notification_content" msgid="5111712860712823893">"Un dispositivo quiere acceder a tus mensajes. Presiona para ver más detalles"</string>
    <string name="bluetooth_message_access_dialog_title" msgid="9009836130395061579">"¿Quieres permitir el acceso a los mensajes?"</string>
    <string name="bluetooth_message_access_dialog_content" msgid="7186694737578788487">"Un dispositivo Bluetooth, <xliff:g id="DEVICE_NAME_0">%1$s</xliff:g>, quiere acceder a tus mensajes.\n\nNunca antes te habías conectado a <xliff:g id="DEVICE_NAME_1">%2$s</xliff:g>."</string>
    <string name="bluetooth_phonebook_access_notification_content" msgid="9175220052703433637">"Un dispositivo quiere acceder a tus contactos y al registro de llamadas. Presiona para ver más detalles"</string>
    <string name="bluetooth_phonebook_access_dialog_title" msgid="7624607995928968721">"¿Quieres permitir el acceso a los contactos y al registro de llamadas?"</string>
    <string name="bluetooth_phonebook_access_dialog_content" msgid="959658135522249170">"Un dispositivo Bluetooth, <xliff:g id="DEVICE_NAME_0">%1$s</xliff:g>, quiere acceder a tus contactos y al registro de llamadas. Esto incluye datos sobre llamadas entrantes y salientes.\n\nNunca antes te habías conectado a <xliff:g id="DEVICE_NAME_1">%2$s</xliff:g>."</string>
    <string name="category_name_brightness" msgid="8520372392029305084">"Brillo"</string>
    <string name="category_name_lock_display" msgid="8310402558217129670">"Pantalla de bloqueo"</string>
    <string name="category_name_appearance" msgid="8287486771764166805">"Aspecto"</string>
    <string name="category_name_color" msgid="937514550918977151">"Color"</string>
    <string name="category_name_display_controls" msgid="7046581691184725216">"Otros controles de pantalla"</string>
    <string name="category_name_general" msgid="7737273712848115886">"General"</string>
    <string name="dark_theme_main_switch_title" msgid="4045147031947562280">"Usar Tema oscuro"</string>
    <string name="bluetooth_main_switch_title" msgid="8409835540311309632">"Usar Bluetooth"</string>
    <string name="prevent_ringing_main_switch_title" msgid="4726252811262086643">"Usar Silenciar sonidos"</string>
    <string name="use_wifi_hotsopt_main_switch_title" msgid="3909731167290690539">"Usar hotspot de Wi-Fi"</string>
    <string name="app_pinning_main_switch_title" msgid="5465506660064032876">"Usar fijación de apps"</string>
    <string name="developer_options_main_switch_title" msgid="1720074589554152501">"Usar opciones para desarrolladores"</string>
    <string name="default_print_service_main_switch_title" msgid="4697133737128324036">"Usar servicio de impresión"</string>
    <string name="multiple_users_main_switch_title" msgid="6686858308083037810">"Permitir varios usuarios"</string>
    <string name="multiple_users_main_switch_keywords" msgid="4845954458094134356">"permitir, varios, usuarios, habilitar, muchos"</string>
    <string name="wireless_debugging_main_switch_title" msgid="8463499572781441719">"Usar depuración inalámbrica"</string>
    <string name="graphics_driver_main_switch_title" msgid="6125172901855813790">"Usar las preferencias del controlador gráfico"</string>
    <string name="night_light_main_switch_title" msgid="3428298022467805219">"Usar Luz nocturna"</string>
    <string name="nfc_main_switch_title" msgid="6295839988954817432">"Usar NFC"</string>
    <string name="adaptive_brightness_main_switch_title" msgid="2681666805191642737">"Usar brillo automático"</string>
    <string name="wifi_calling_main_switch_title" msgid="4070224008346815634">"Usar llamadas por Wi-Fi"</string>
    <string name="default_see_all_apps_title" msgid="7481113230662612178">"Ver todas las apps"</string>
    <string name="smart_forwarding_title" msgid="8368634861971949799">"Desvío inteligente"</string>
    <string name="smart_forwarding_summary_enabled" msgid="3341062878373185604">"Se habilitó el Desvío inteligente"</string>
    <string name="smart_forwarding_summary_disabled" msgid="5033880700091914809">"Se inhabilitó el Desvío inteligente"</string>
    <string name="smart_forwarding_ongoing_title" msgid="962226849074401228">"Configuración de llamada"</string>
    <string name="smart_forwarding_ongoing_text" msgid="2189209372407117114">"Actualizando la configuración…"</string>
    <string name="smart_forwarding_failed_title" msgid="1859891191023516080">"Error de configuración de llamadas"</string>
    <string name="smart_forwarding_failed_text" msgid="8682640643264071789">"Error en la red o en la SIM."</string>
    <string name="smart_forwarding_failed_not_activated_text" msgid="997396203001257904">"No se activó la SIM."</string>
    <string name="smart_forwarding_input_mdn_title" msgid="5105463748849841763">"Ingresa los números de teléfono"</string>
    <string name="smart_forwarding_input_mdn_dialog_title" msgid="7542216086697868415">"Ingresa el número de teléfono"</string>
    <string name="smart_forwarding_missing_mdn_text" msgid="2907314684242542226">"Falta el número de teléfono."</string>
    <string name="smart_forwarding_missing_alert_dialog_text" msgid="7870419247987316112">"Aceptar"</string>
    <string name="enable_2g_title" msgid="8184757884636162942">"Permitir 2G"</string>
    <string name="enable_2g_summary" msgid="2794534052372565914">"2G es menos seguro, pero podría mejorar tu conexión en algunas ubicaciones. Para llamadas de emergencia, siempre se permite 2G."</string>
    <string name="enable_2g_summary_disabled_carrier" msgid="8141118453219482762">"<xliff:g id="CARRIER_NAME_2G">%1$s</xliff:g> requiere 2G para brindar servicio"</string>
    <string name="require_cellular_encryption_title" msgid="7516008146269371585">"Solicitar encriptación"</string>
    <string name="require_cellular_encryption_summary" msgid="4813823321032908641">"La encriptación es más segura, pero es posible que no puedas establecer conexión en algunas ubicaciones. No es necesaria la encriptación para realizar llamadas de emergencia."</string>
    <string name="app_info_all_services_label" msgid="1487070364839071105">"Todos los servicios"</string>
    <string name="show_clip_access_notification" msgid="7782300987639778542">"Mostrar acceso a portapapeles"</string>
    <string name="show_clip_access_notification_summary" msgid="474090757777203207">"Mostrar un mensaje cuando las apps accedan a textos, imágenes y otro contenido que hayas copiado"</string>
    <string name="all_apps" msgid="3054120149509114789">"Todas las apps"</string>
    <string name="request_manage_bluetooth_permission_dont_allow" msgid="8798061333407581300">"No permitir"</string>
    <string name="uwb_settings_title" msgid="8578498712312002231">"Ultra Wideband (UWB)"</string>
    <string name="uwb_settings_summary" msgid="3074271396764672268">"Ayuda a identificar la posición relativa de dispositivos cercanos que cuentan con UWB"</string>
    <string name="uwb_settings_summary_airplane_mode" msgid="1328864888135086484">"Desactiva el modo de avión para usar UWB"</string>
    <string name="camera_toggle_title" msgid="8952668677727244992">"Acceso a la cámara"</string>
    <string name="mic_toggle_title" msgid="265145278323852547">"Acceso al micrófono"</string>
    <string name="perm_toggle_description" msgid="5754629581767319022">"Para apps y servicios"</string>
    <string name="mic_toggle_description" msgid="484139688645092237">"Para apps y servicios. Aunque se desactive este parámetro de configuración, es posible que se sigan compartiendo los datos del micrófono cuando llames a un número de emergencia."</string>
    <string name="previous_page_content_description" msgid="6438292457923282991">"Anterior"</string>
    <string name="next_page_content_description" msgid="1641835099813416294">"Siguiente"</string>
    <string name="colors_viewpager_content_description" msgid="2591751086138259565">"Vista previa de color"</string>
    <string name="bluetooth_sim_card_access_notification_title" msgid="7351015416346359536">"Solicitud de acceso a SIM"</string>
    <string name="bluetooth_sim_card_access_notification_content" msgid="8685623260103018309">"Un dispositivo quiere acceder a tu SIM. Presiona para ver más detalles."</string>
    <string name="bluetooth_sim_card_access_dialog_title" msgid="5616323725563125179">"¿Permites el acceso a la SIM?"</string>
    <string name="bluetooth_sim_card_access_dialog_content" msgid="6281997628405909566">"Un dispositivo Bluetooth, <xliff:g id="DEVICE_NAME_0">%1$s</xliff:g>, quiere acceder a los datos de tu SIM. Eso incluye tus contactos.\n\nMientras esté conectado, <xliff:g id="DEVICE_NAME_1">%2$s</xliff:g> recibirá todas las llamadas que se realicen a <xliff:g id="PHONE_NUMBER">%3$s</xliff:g>."</string>
    <string name="bluetooth_connect_access_notification_title" msgid="2573547043170883947">"Dispositivo Bluetooth disponible"</string>
    <string name="bluetooth_connect_access_notification_content" msgid="1328465545685433304">"Un dispositivo quiere conectarse. Presiona para ver más detalles."</string>
    <string name="bluetooth_connect_access_dialog_title" msgid="1948056782712451381">"¿Conectar al dispositivo Bluetooth?"</string>
    <string name="bluetooth_connect_access_dialog_content" msgid="4336436466468405850">"<xliff:g id="DEVICE_NAME_0">%1$s</xliff:g> quiere conectarse a este teléfono.\n\nNo te conectaste a <xliff:g id="DEVICE_NAME_1">%2$s</xliff:g> antes."</string>
    <string name="bluetooth_connect_access_dialog_negative" msgid="4944672755226375059">"No conectar"</string>
    <string name="bluetooth_connect_access_dialog_positive" msgid="3630561675207269710">"Conectar"</string>
    <string name="tare_settings" msgid="3788654800004869077">"Configuración de TARE"</string>
    <string name="tare_on" msgid="2386073225978684535">"Sí"</string>
    <string name="tare_off" msgid="6305694402929756726">"No"</string>
    <string name="tare_revert" msgid="3855325741125236638">"Restablecer configuración predeterminada"</string>
    <string name="tare_settings_reverted_toast" msgid="8189887409285176731">"Config. predeterminada restablecida."</string>
    <string name="tare_max_satiated_balance" msgid="3914973999573150340">"Saldo máx. cuando el disp. está cargado"</string>
    <string name="tare_balances" msgid="731881382594747961">"Saldos"</string>
    <string name="tare_consumption_limits" msgid="3230949387874396382">"Límites de consumo"</string>
    <string name="tare_initial_consumption_limit" msgid="2921646306374048384">"Límite de consumo inicial"</string>
    <string name="tare_min_consumption_limit" msgid="3293145670921755789">"Límite de consumo mínimo"</string>
    <string name="tare_max_consumption_limit" msgid="8335700580111808823">"Límite de consumo máximo"</string>
    <string name="tare_modifiers" msgid="8919975635360280820">"Modificadores"</string>
    <string name="tare_actions_ctp" msgid="5110104015354916401">"Acciones (costo de producción)"</string>
    <string name="tare_actions_base_price" msgid="3300967942666376589">"Acciones (precio base)"</string>
    <string name="tare_rewards_instantaneous" msgid="8358683519945340874">"Recompensas por cada evento"</string>
    <string name="tare_rewards_ongoing" msgid="7657030286658143416">"Recompensas por segundo de duración"</string>
    <string name="tare_rewards_max" msgid="5283055625642837010">"Máximo de recompensas por día"</string>
    <string name="tare_app_install" msgid="7955806910408116882">"Instalar app"</string>
    <string name="tare_top_activity" msgid="7266560655483385757">"Actividad principal"</string>
    <string name="tare_notification_seen" msgid="7829963536020087742">"Notificación vista"</string>
    <string name="tare_notification_seen_15_min" msgid="832174185809497764">"Notificación vista dentro de los 15 min."</string>
    <string name="tare_notification_interaction" msgid="3806204222322830129">"Interacción de notificaciones"</string>
    <string name="tare_widget_interaction" msgid="2260701564089214184">"Interacción con el widget"</string>
    <string name="tare_other_interaction" msgid="8069163421115212751">"Otra interacción del usuario"</string>
    <string name="tare_job_max_start" msgid="1586399578665940836">"Inicio de trabajo de máxima prioridad"</string>
    <string name="tare_job_max_running" msgid="2897217372986518495">"Trabajo de máxima prioridad en ejecución"</string>
    <string name="tare_job_high_start" msgid="7464143754932031022">"Inicio de trabajo de alta prioridad"</string>
    <string name="tare_job_high_running" msgid="6541171046405088669">"Trabajo de alta prioridad en ejecución"</string>
    <string name="tare_job_default_start" msgid="6744427210148953151">"Inicio de trabajo predeterminado"</string>
    <string name="tare_job_default_running" msgid="8429081804128945217">"Trabajo predeterminado en ejecución"</string>
    <string name="tare_job_low_start" msgid="4605440035856891746">"Inicio de trabajo de baja prioridad"</string>
    <string name="tare_job_low_running" msgid="831668616902849604">"Trabajo de baja prioridad en ejecución"</string>
    <string name="tare_job_min_start" msgid="6508233901992538188">"Inicio de trabajo de mínima prioridad"</string>
    <string name="tare_job_min_running" msgid="6167128996320622604">"Trabajo de mínima prioridad en ejecución"</string>
    <string name="tare_job_timeout_penalty" msgid="7644332836795492506">"Sanción: exc. tiempo de espera trabajo"</string>
    <string name="tare_min_balance_exempted" msgid="6693710075762973485">"Saldo máximo cuando el dispositivo está cargado (exención)"</string>
    <string name="tare_min_balance_headless_app" msgid="6906353766678577244">"Saldo mín. cuando el disp. está cargado (App con sistema sin interfaz gráfica)"</string>
    <string name="tare_min_balance_other_app" msgid="3404774196832506476">"Saldo mínimo cuando el dispositivo está cargado (Apps restantes)"</string>
    <string name="tare_min_balance_addition_app_updater" msgid="5391956072471201269">"Adición de saldo mínimo con carga completa (actualizadores de apps)"</string>
  <string-array name="tare_modifiers_subfactors">
    <item msgid="3325940509857535498">"Cargando"</item>
    <item msgid="658627268149681677">"Descanso"</item>
    <item msgid="1599558140284643834">"Modo de ahorro de energía"</item>
    <item msgid="588427840913221601">"Estado del proceso"</item>
  </string-array>
    <string name="tare_dialog_confirm_button_title" msgid="9179397559760203348">"Confirmar"</string>
    <string name="dream_preview_button_title" msgid="6637456541851795952">"Vista previa"</string>
    <string name="dream_picker_category" msgid="7726447836872744867">"Selecciona un protector de pantalla"</string>
    <string name="dream_complications_toggle_title" msgid="4273232303027449163">"Mostrar información adicional"</string>
    <string name="dream_complications_toggle_summary" msgid="8088911054987524904">"Mostrar datos como la hora, el clima o demás información en el protector de pantalla"</string>
    <string name="dream_home_controls_toggle_title" msgid="706799741564479248">"Mostrar controles de la casa"</string>
    <string name="dream_home_controls_toggle_summary" msgid="4102519907917430579">"Muestra el botón de controles de la casa desde el protector de pantalla"</string>
    <string name="dream_more_settings_category" msgid="3119192146760773748">"Más parámetros de configuración"</string>
    <string name="dream_setup_title" msgid="2458303874255396142">"Elige tu protector de pantalla"</string>
    <string name="dream_setup_description" msgid="7508547154038580296">"Elige lo que quieres ver en la pantalla cuando la tablet no está conectada. Es posible que el dispositivo use más energía cuando se utiliza el protector de pantalla."</string>
    <string name="customize_button_title" msgid="1110284655990203359">"Personalizar"</string>
    <string name="customize_button_description" msgid="7440248477266126231">"Personalizar <xliff:g id="SCREENSAVER_NAME">%1$s</xliff:g>"</string>
    <string name="reboot_dialog_enable_freeform_support" msgid="6412591361284929149">"Se debe reiniciar para habilitar la asistencia de formato libre."</string>
    <string name="reboot_dialog_force_desktop_mode" msgid="2021839270403432948">"Se debe reiniciar para forzar el modo de computadora en las pantallas secundarias."</string>
    <string name="reboot_dialog_reboot_now" msgid="235616015988522355">"Reiniciar ahora"</string>
    <string name="reboot_dialog_reboot_later" msgid="4261717094186904568">"Reiniciar más adelante"</string>
    <string name="bluetooth_details_spatial_audio_title" msgid="1368071116994002707">"Audio espacial"</string>
    <string name="bluetooth_details_spatial_audio_summary" msgid="5026859623681482668">"El audio de contenido multimedia compatible se hace más envolvente"</string>
    <string name="bluetooth_details_head_tracking_title" msgid="5416972521040337799">"Seguimiento de cabeza"</string>
    <string name="bluetooth_details_head_tracking_summary" msgid="3942238746595985395">"El audio cambia a medida que mueves la cabeza para sonar más natural"</string>
    <string name="ingress_rate_limit_title" msgid="2106694002836274350">"Límite de tasa de descarga de la red"</string>
    <string name="ingress_rate_limit_summary" msgid="1097811019742438371">"Configura el límite de tasa de entrada de ancho de banda de la red, que se aplica a todas las redes que brindan conexión a Internet."</string>
    <string name="ingress_rate_limit_dialog_title" msgid="5359461052422633789">"Configura el límite de tasa de descarga de la red"</string>
    <string name="ingress_rate_limit_no_limit_entry" msgid="8741098826008012163">"Sin límite"</string>
    <string name="disable_phantom_process_monitor_title" msgid="8348108346706188771">"Inhabilita restricciones de procesos secundarios"</string>
    <string name="disable_phantom_process_monitor_summary" msgid="3044464635550256985">"Inhabilita las restricciones del uso de recursos del sistema para los procesos de la app secundaria"</string>
    <string name="bluetooth_broadcast_dialog_title" msgid="9172775308463135884">"Transmisión"</string>
    <string name="bluetooth_broadcast_dialog_broadcast_app" msgid="1016617579194329005">"Transmitir <xliff:g id="CURRENTAPP">%1$s</xliff:g>"</string>
    <string name="bluetooth_broadcast_dialog_find_message" msgid="6621660851669953883">"Escucha las transmisiones que se están reproduciendo cerca de ti"</string>
    <string name="bluetooth_broadcast_dialog_broadcast_message" msgid="6198264676009094495">"Transmite contenido multimedia a dispositivos cercanos, o bien escucha la transmisión de alguien más"</string>
    <string name="bluetooth_find_broadcast_title" msgid="5385985218699831970">"Transmisiones"</string>
    <string name="bluetooth_find_broadcast_summary" msgid="3907899428626210673">"Escuchando"</string>
    <string name="bluetooth_find_broadcast" msgid="1768337775649457586">"Buscar transmisiones"</string>
    <string name="bluetooth_find_broadcast_button_leave" msgid="7881206581147104908">"Abandonar transmisión"</string>
    <string name="bluetooth_find_broadcast_button_scan" msgid="3995664694641895189">"Escanear código QR"</string>
    <string name="find_broadcast_password_dialog_title" msgid="3176988702535737484">"Ingresar contraseña"</string>
    <string name="find_broadcast_password_dialog_connection_error" msgid="47873617983439400">"No se puede establecer conexión. Vuelve a intentarlo."</string>
    <string name="find_broadcast_password_dialog_password_error" msgid="243855327674765">"Contraseña incorrecta"</string>
    <string name="find_broadcast_join_broadcast_error" msgid="5486980388774711346">"No se pudo unir a la transmisión"</string>
    <string name="bt_le_audio_scan_qr_code_scanner" msgid="7614569515419813053">"Para comenzar a escuchar, centra el código QR a continuación"</string>
    <string name="bt_le_audio_qr_code_is_not_valid_format" msgid="7821837654128137901">"El código QR no es un formato válido"</string>
    <string name="convert_to_esim_title" msgid="71037864129009206">"Convertir a eSIM"</string>
    <string name="transfer_esim_to_another_device_title" msgid="5286117866086383192">"Transferir la tarjeta eSIM a otro dispositivo"</string>
    <string name="background_install_preference_summary" msgid="3065219346519340364">"{count,plural, =1{# app}other{# apps}}"</string>
    <string name="background_install_title" msgid="607913515188276168">"Apps instaladas en segundo plano"</string>
    <string name="background_install_summary" msgid="3890296129543309666">"El fabricante del dispositivo puede instalar apps en segundo plano, o bien permitir que tu operador y otros socios lo hagan.\n\nLas apps que aparecen en esta lista no son necesarias para que el dispositivo funcione con normalidad. Puedes desinstalar las que no quieras."</string>
    <string name="background_install_feature_list_no_entry" msgid="2071343281272266154">"No hay apps instaladas en segundo plano"</string>
    <string name="background_install_uninstall_button_description" msgid="1189649052911501249">"Desinstalar app"</string>
    <string name="background_install_before" msgid="8608614957688912715">"{count,plural, =1{Apps instaladas en el último # mes}other{Apps instaladas en los últimos # meses}}"</string>
    <string name="background_install_after" msgid="7983488897570908149">"{count,plural, =1{Apps instaladas hace más de # mes}other{Apps instaladas hace más de # meses}}"</string>
    <string name="accessibility_fingerprint_label" msgid="5017431423168191733">"Sensor de huellas dactilares"</string>
    <string name="flash_notifications_title" msgid="4490438861180492311">"Notificaciones con flash"</string>
    <string name="flash_notifications_about_title" msgid="9004351252928121214">"Info. sobre notificaciones con flash"</string>
    <string name="flash_notifications_summary_off" msgid="6056282996770691461">"Desactivado"</string>
    <string name="flash_notifications_summary_on_camera" msgid="3286405833586333730">"Activado / Flash de la cámara"</string>
    <string name="flash_notifications_summary_on_screen" msgid="9040640799633336219">"Activado / Flash de la pantalla"</string>
    <string name="flash_notifications_summary_on_camera_and_screen" msgid="2326268141063768701">"Activado / Flash de la cámara y pantalla"</string>
    <string name="flash_notifications_intro" msgid="8409873413480928249">"Ilumina la luz de la cámara o de la pantalla cuando recibes notificaciones o cuando suena una alarma"</string>
    <!-- no translation found for flash_notifications_intro_without_camera_flash (6297337174487793891) -->
    <skip />
    <string name="flash_notifications_note" msgid="2426125248448055075">"Usa las notificaciones con flash con precaución si eres sensible a la luz"</string>
    <!-- no translation found for flash_notifications_keywords (2458759275318514836) -->
    <skip />
    <string name="flash_notifications_preview" msgid="5320176885050440874">"Vista previa"</string>
    <string name="camera_flash_notification_title" msgid="2475084876382922732">"Flash de la cámara"</string>
    <string name="screen_flash_notification_title" msgid="3773100725793316708">"Flash de la pantalla"</string>
    <string name="screen_flash_notification_color_title" msgid="7213407653340970790">"Color del flash de la pantalla"</string>
    <string name="screen_flash_color_blue" msgid="3585766657607931371">"Azul"</string>
    <string name="screen_flash_color_azure" msgid="8691198532944992243">"Azul celeste"</string>
    <string name="screen_flash_color_cyan" msgid="6878780006173747267">"Cian"</string>
    <string name="screen_flash_color_spring_green" msgid="4466548514738457815">"Verde primavera"</string>
    <string name="screen_flash_color_green" msgid="8418019648507964564">"Verde"</string>
    <string name="screen_flash_color_chartreuse_green" msgid="7456381649919010366">"Verde chartreuse"</string>
    <string name="screen_flash_color_yellow" msgid="7413465411615454556">"Amarillo"</string>
    <string name="screen_flash_color_orange" msgid="979177126315557656">"Naranja"</string>
    <string name="screen_flash_color_red" msgid="8954162219886445491">"Rojo"</string>
    <string name="screen_flash_color_rose" msgid="1216848195972231251">"Rosa"</string>
    <string name="screen_flash_color_magenta" msgid="7726221666557102155">"Magenta"</string>
    <string name="screen_flash_color_violet" msgid="1279950780509029495">"Violeta"</string>
    <string name="color_selector_dialog_done" msgid="121253968943363376">"Listo"</string>
    <string name="color_selector_dialog_cancel" msgid="8667350644753900701">"Cancelar"</string>
    <string name="dock_multi_instances_not_supported_text" msgid="3513493664467667084">"Esta app solo puede estar abierta en 1 ventana"</string>
</resources>
