<?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">"Sim"</string>
    <string name="no" msgid="5541738710521607130">"Não"</string>
    <string name="create" msgid="986997212165228751">"Criar"</string>
    <string name="allow" msgid="3763244945363657722">"Permitir"</string>
    <string name="deny" msgid="7326117222944479942">"Recusar"</string>
    <string name="confirmation_turn_on" msgid="2979094011928347665">"Ativar"</string>
    <string name="device_info_default" msgid="1406619232867343310">"Desconhecido"</string>
    <string name="device_info_protected_single_press" msgid="3810785480060743677">"Toque para mostrar informações"</string>
    <string name="show_dev_countdown" msgid="2936506773086395069">"{count,plural, =1{Falta # etapa para você ativar as configurações de desenvolvimento.}one{Falta # etapa para você ativar as configurações de desenvolvimento.}other{Faltam # etapas para você ativar as configurações de desenvolvimento.}}"</string>
    <string name="show_dev_on" msgid="2840850085134853754">"Você agora é um desenvolvedor!"</string>
    <string name="show_dev_already" msgid="7041756429707644630">"Não é necessário. Você já é um desenvolvedor."</string>
    <string name="dev_settings_disabled_warning" msgid="6971867026249671244">"Primeiro, ative as opções do desenvolvedor."</string>
    <string name="dev_settings_available_to_admin_only_warning" msgid="3408243404879083111">"Apenas os usuários administradores podem acessar as configurações do desenvolvedor."</string>
    <string name="header_category_system" msgid="1665516346845259058">"Sistema"</string>
    <string name="radioInfo_service_in" msgid="9088637745836646271">"Em serviço"</string>
    <string name="radioInfo_service_out" msgid="1868347333892403287">"Fora de serviço"</string>
    <string name="radioInfo_service_off" msgid="6184928420860868571">"Rádio desativado"</string>
    <string name="radioInfo_roaming_in" msgid="8892550453644088692">"Roaming"</string>
    <string name="radioInfo_roaming_not" msgid="3137594549464975054">"Não está em 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">"Suspenso"</string>
    <string name="radioInfo_unknown" msgid="2892562356748600367">"Desconhecido"</string>
    <string name="preview_pager_content_description" msgid="3762247188224576303">"Pré-visualização"</string>
    <string name="font_size_make_smaller_desc" msgid="4978038055549590140">"Tornar menor"</string>
    <string name="font_size_make_larger_desc" msgid="5583046033381722247">"Tornar maior"</string>
    <string name="stay_awake_on_fold_title" msgid="6590454679898134221">"Sempre"</string>
    <string name="stay_awake_on_fold_summary" msgid="1939963751585954262">"O display frontal é ligado ao dobrar o dispositivo"</string>
    <string name="selective_stay_awake_title" msgid="7887645333447645168">"Apenas jogos, vídeos e mais"</string>
    <string name="selective_stay_awake_summary" msgid="9055967322921984543">"O display frontal é ativado para apps que impedem a tela de ficar inativa"</string>
    <string name="stay_awake_on_lockscreen_title" msgid="8088456642083051068">"Deslizar para cima para continuar"</string>
    <string name="stay_awake_on_lockscreen_summary" msgid="2299351813382522952">"Dobre o smartphone e deslize para cima no display frontal para continuar usando o app ou aguarde alguns segundos para que a tela seja bloqueada"</string>
    <string name="sleep_on_fold_title" msgid="7626123024330501411">"Nunca"</string>
    <string name="sleep_on_fold_summary" msgid="7737992842459588846">"O display frontal é bloqueado ao dobrar o dispositivo"</string>
    <string name="auto_rotate_settings_primary_switch_title" msgid="3440951924928594520">"Usar o giro automático"</string>
    <string name="smart_rotate_text_headline" msgid="5878008933992951904">"A detecção facial usa a câmera frontal para melhorar a precisão do giro automático. As imagens nunca são armazenadas ou enviadas ao Google."</string>
    <string name="bluetooth" msgid="8898478620943459654">"Bluetooth"</string>
    <string name="bluetooth_is_discoverable" msgid="4798961627677790935">"Visível para todos os disp. Bluetooth próx. (<xliff:g id="DISCOVERABLE_TIME_PERIOD">%1$s</xliff:g>)"</string>
    <string name="bluetooth_is_discoverable_always" msgid="8122823110652921674">"Visível para todos os dispos. Bluetooth próximos"</string>
    <string name="bluetooth_not_visible_to_other_devices" msgid="6181960579190879601">"Não visível para outros dispositivos Bluetooth"</string>
    <string name="bluetooth_only_visible_to_paired_devices" msgid="3574936359739213455">"Visível somente para dispositivos pareados"</string>
    <string name="bluetooth_devices" msgid="1063177983261608277">"Dispositivos Bluetooth"</string>
    <string name="bluetooth_device_name" msgid="1294669733490268384">"Nome do dispositivo"</string>
    <string name="bluetooth_rename_device" msgid="4219655243836021443">"Renomear o dispositivo"</string>
    <string name="bluetooth_rename_button" msgid="9162500408570289545">"Renomear"</string>
    <string name="bluetooth_disconnect_title" msgid="4581951246357823044">"Desconectar dispositivo?"</string>
    <string name="bluetooth_pairing_pref_title" msgid="3497193027590444598">"Parear novo dispositivo"</string>
    <string name="keywords_add_bt_device" msgid="4533191164203174011">"bluetooth"</string>
    <string name="bluetooth_screen_auto_on_title" msgid="8496443490064988240">"Ativar automaticamente de novo amanhã"</string>
    <string name="bluetooth_pair_right_ear_button" msgid="3979894494803078852">"Parear lado direito"</string>
    <string name="bluetooth_pair_left_ear_button" msgid="1019938875726073791">"Parear lado esquerdo"</string>
    <string name="bluetooth_pair_other_ear_dialog_title" msgid="3814943511999984012">"Pareie o outro lado"</string>
    <string name="bluetooth_pair_other_ear_dialog_left_ear_message" msgid="5711642363615781647">"Seu aparelho auditivo do lado esquerdo está conectado.\n\nPara parear o direito, confira se ele está ligado e pronto para parear."</string>
    <string name="bluetooth_pair_other_ear_dialog_right_ear_message" msgid="631521133525979967">"Seu aparelho auditivo do lado direito está conectado.\n\nPara parear o esquerdo, confira se ele está ligado e pronto para parear."</string>
    <string name="bluetooth_pair_other_ear_dialog_right_ear_positive_button" msgid="533612082529204078">"Parear lado direito"</string>
    <string name="bluetooth_pair_other_ear_dialog_left_ear_positive_button" msgid="6500192653171220257">"Parear lado esquerdo"</string>
    <string name="bluetooth_device_controls_general" msgid="1399214835599665488">"Para todos os aparelhos auditivos disponíveis"</string>
    <string name="bluetooth_device_controls_title" msgid="659009912978022189">"Mais configurações para aparelhos auditivos"</string>
    <string name="bluetooth_device_controls_summary" msgid="5387400497394163925">"Mude as configurações entre dispositivos, como atalhos e controles de telecoil"</string>
    <string name="bluetooth_device_controls_specific" msgid="7706863288754077107">"Para este aparelho"</string>
    <string name="bluetooth_audio_routing_title" msgid="5541729245424856226">"Saída de áudio"</string>
    <string name="bluetooth_audio_routing_about_title" msgid="5773336779246891954">"Sobre a saída de áudio"</string>
    <string name="bluetooth_audio_routing_summary" msgid="7180947533985969066">"Encaminhe sons para seu aparelho auditivo ou o alto-falante do smartphone"</string>
    <string name="bluetooth_screen_related" msgid="7976543255501825536">"Relacionadas"</string>
    <string name="bluetooth_ringtone_title" msgid="3177308461256892085">"Toque e alarmes"</string>
    <string name="bluetooth_call_title" msgid="6851464952021874072">"Áudio durante ligações"</string>
    <string name="bluetooth_media_title" msgid="2878373577382067290">"Sons de mídia e do sistema"</string>
    <string name="bluetooth_notification_title" msgid="8708962394926222039">"Notificações"</string>
    <string name="bluetooth_audio_routing_footer_summary" msgid="410260713589309293">"Por padrão, a saída de áudio é determinada por apps individuais"</string>
    <string name="bluetooth_device" msgid="2217973503732544291">"Dispositivo Bluetooth sem nome"</string>
    <string name="progress_scanning" msgid="2564746192843011826">"Pesquisar"</string>
    <string name="bluetooth_no_devices_found" msgid="7704539337219953182">"Nenhum dispositivo Bluetooth encontrado."</string>
    <string name="bluetooth_notif_ticker" msgid="209515545257862858">"Solicitação de pareamento Bluetooth"</string>
    <string name="bluetooth_notif_title" msgid="1196532269131348647">"Pedido de pareamento"</string>
    <string name="bluetooth_notif_message" msgid="5584717784198086653">"Toque para parear com <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="bluetooth_devices_card_off_title" msgid="1320149821945129127">"Bluetooth desativado"</string>
    <string name="bluetooth_devices_card_off_summary" msgid="2276527382891105858">"Toque para ativar"</string>
    <string name="device_picker" msgid="2427027896389445414">"Escolher dispositivo Bluetooth"</string>
    <string name="bluetooth_ask_enablement" msgid="1529030199895339199">"<xliff:g id="APP_NAME">%1$s</xliff:g> quer ativar o Bluetooth"</string>
    <string name="bluetooth_ask_disablement" msgid="1879788777942714761">"<xliff:g id="APP_NAME">%1$s</xliff:g> quer desativar o Bluetooth"</string>
    <string name="bluetooth_ask_enablement_no_name" msgid="5091401961637405417">"Um app quer ativar o Bluetooth"</string>
    <string name="bluetooth_ask_disablement_no_name" msgid="382299750909188822">"Um app quer desativar o Bluetooth"</string>
    <string name="bluetooth_turning_on" msgid="3842613808709024730">"Ativando Bluetooth..."</string>
    <string name="bluetooth_turning_off" msgid="7406309124247701148">"Desligar o Bluetooth…"</string>
    <string name="bluetooth_connection_permission_request" msgid="8793131019383198861">"Solicitação de conexão Bluetooth"</string>
    <string name="bluetooth_phonebook_request" msgid="1085102844577089889">"Solicitação de acesso à agenda telefônica"</string>
    <string name="bluetooth_map_request" msgid="8664081227240707479">"Solicitação de acesso a mensagens"</string>
    <string name="bluetooth_device_name_summary" msgid="8678342689845439583">"Visível como \"<xliff:g id="DEVICE_NAME">^1</xliff:g>\" para outros dispositivos."</string>
    <string name="bluetooth_off_footer" msgid="76578735660216295">"Ative o Bluetooth para se conectar a outros dispositivos."</string>
    <string name="bluetooth_paired_device_title" msgid="3240639218362342026">"Seus dispositivos"</string>
    <string name="bluetooth_pairing_page_title" msgid="3403981358823707692">"Parear novo dispositivo"</string>
    <string name="bluetooth_disable_a2dp_hw_offload" msgid="5942913792817797541">"Desativar descarga de hardware de Bluetooth A2DP"</string>
    <string name="bluetooth_disable_le_audio_hw_offload" msgid="4656853795514691257">"Desativar descarga de hardware de áudio Bluetooth de baixo consumo"</string>
    <string name="bluetooth_disable_hw_offload_dialog_title" msgid="6001142380445276918">"Reiniciar dispositivo?"</string>
    <string name="bluetooth_disable_hw_offload_dialog_message" msgid="1524373895333698779">"Reinicie o dispositivo para mudar essa configuração."</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>
    <string name="bluetooth_disable_leaudio" msgid="8619410595945155354">"Desativar áudio Bluetooth de baixo consumo"</string>
    <string name="bluetooth_disable_leaudio_summary" msgid="4756307633476985470">"Desativa o recurso de áudio Bluetooth de baixo consumo caso o hardware do dispositivo tenha essa opção."</string>
    <string name="bluetooth_leaudio_mode" msgid="5206961943393400814">"Áudio Bluetooth de baixo consumo"</string>
    <string name="bluetooth_show_leaudio_device_details" msgid="3306637862550475370">"Mostrar a chave do áudio Bluetooth de baixo consumo nos Detalhes do dispositivo"</string>
    <string name="bluetooth_bypass_leaudio_allowlist" msgid="7392319491894565552">"Ignorar lista de permissões do áudio Bluetooth de baixo consumo"</string>
    <string name="bluetooth_bypass_leaudio_allowlist_summary" msgid="8999245286359656738">"Usar o áudio de baixo consumo (LE Audio) por padrão, mesmo que o periférico dele não tenha sido verificado para atender aos critérios da lista de permissões."</string>
    <string name="connected_device_media_device_title" msgid="3783388247594566734">"Dispositivos portáteis de mídia"</string>
    <string name="connected_device_call_device_title" msgid="88732390601723608">"Dispositivos de chamada"</string>
    <string name="connected_device_other_device_title" msgid="4652120430615729193">"Outros dispositivos"</string>
    <string name="connected_device_saved_title" msgid="5607274378851905959">"Dispositivos salvos"</string>
    <string name="connected_device_fast_pair_device_title" msgid="543124539265592392">"Associado com a conta"</string>
    <string name="connected_device_previously_associated_fast_pair_device_title" msgid="8353405823992023457">"Usados anteriormente com a conta"</string>
    <string name="connected_device_add_device_summary" msgid="8671009879957120802">"O Bluetooth será ativado para o pareamento"</string>
    <string name="connected_device_connections_title" msgid="4164120115341579170">"Preferências de conexão"</string>
    <string name="connected_device_previously_connected_screen_title" msgid="8823331744788100605">"Conectados anteriormente"</string>
    <string name="connected_device_bluetooth_turned_on_toast" msgid="144664089794199928">"Bluetooth ativado"</string>
    <string name="previous_connected_see_all" msgid="7759413145713251328">"Ver todos"</string>
    <string name="connected_device_fast_pair_device_see_all" msgid="4898279230458128620">"Mostrar tudo"</string>
    <string name="stylus_device_details_title" msgid="7618295136015480864">"Stylus"</string>
    <string name="stylus_default_notes_app" msgid="4165657465911764628">"Pressionar o botão da stylus"</string>
    <string name="stylus_default_notes_summary_work" msgid="4554643411627934223">"<xliff:g id="APP_NAME">%s</xliff:g> (perfil de trabalho)"</string>
    <string name="stylus_textfield_handwriting" msgid="2363579035338976327">"Escreva nos campos de texto"</string>
    <string name="stylus_ignore_button" msgid="7734540973145241391">"Ignorar todos os pressionamentos de botão com a stylus"</string>
    <string name="stylus_connected_devices_title" msgid="2823967577941359812">"Stylus"</string>
    <string name="audio_streams_empty" msgid="8803517701437394982">"Nenhum stream de áudio por perto foi encontrado."</string>
    <string name="date_and_time" msgid="1788358029823431692">"Data e hora"</string>
    <string name="proxy_settings_title" msgid="4201866858226087066">"Proxy"</string>
    <string name="proxy_clear_text" msgid="6529658759984031149">"Limpar"</string>
    <string name="proxy_port_label" msgid="4647357286461712574">"Porta do proxy"</string>
    <string name="proxy_exclusionlist_label" msgid="2598613986784917542">"Ignorar proxy para"</string>
    <string name="proxy_defaultView_text" msgid="6795150505379688451">"Restaurar padrões"</string>
    <string name="proxy_action_text" msgid="1103328484441449542">"Concluído"</string>
    <string name="proxy_hostname_label" msgid="5504327742505848063">"Nome do host do proxy"</string>
    <string name="proxy_error" msgid="3615905975598084126">"Atenção"</string>
    <string name="proxy_error_dismiss" msgid="4207430265140873078">"OK"</string>
    <string name="proxy_error_invalid_host" msgid="3814412792702059247">"O nome de host digitado não é válido."</string>
    <string name="proxy_error_invalid_exclusion_list" msgid="6096353559936226599">"A lista de exclusão digitada não está formatada corretamente. Insira uma lista dos domínios excluídos separados por vírgula."</string>
    <string name="proxy_error_empty_port" msgid="4250295137005082992">"É necessário preencher o campo da porta."</string>
    <string name="proxy_error_empty_host_set_port" msgid="8886572276450900049">"O campo da porta deverá estar vazio se o campo do host estiver vazio."</string>
    <string name="proxy_error_invalid_port" msgid="2830054691770209166">"A porta digitada não é válida."</string>
    <string name="proxy_warning_limited_support" msgid="3277104160797351942">"O proxy HTTP é usado pelo navegador, mas não pode ser usado por outros apps."</string>
    <string name="proxy_url_title" msgid="3502625766036404073">"URL do PAC: "</string>
    <string name="radio_info_ping_hostname_v4" msgid="4790577760885127088">"Aplicar ping no nome do host (www.google.com) IPv4:"</string>
    <string name="radio_info_http_client_test" msgid="5673975677271544085">"Teste do cliente HTTP:"</string>
    <string name="ping_test_label" msgid="265427033290391845">"Executar teste de ping"</string>
    <string name="skip_label" msgid="6380034601349015895">"Pular"</string>
    <string name="next_label" msgid="1248293387735652187">"Avançar"</string>
    <string name="language_picker_title" msgid="4271307478263345133">"Idiomas"</string>
    <string name="language_picker_category_title" msgid="1792199453060454565">"Ordem dos idiomas preferenciais"</string>
    <string name="desc_current_default_language" msgid="1901157141663662859">"Idioma do sistema"</string>
    <string name="locale_remove_menu" msgid="3521546263421387474">"Remover"</string>
    <string name="add_a_language" msgid="2126220398077503271">"Adicionar um idioma"</string>
    <string name="app_locale_preference_title" msgid="5513627099300360232">"Idioma"</string>
    <string name="locale_picker_category_title" msgid="6212064706962721255">"Idioma preferencial"</string>
    <string name="app_locales_picker_menu_title" msgid="7617427959223831373">"Idiomas do app"</string>
    <string name="app_locale_picker_summary" msgid="6742557329924446252">"Definir o idioma de cada app"</string>
    <string name="app_locale_picker_title" msgid="2431448962911301366">"Idioma do app"</string>
    <string name="suggested_app_locales_title" msgid="8898358282377369405">"Idiomas sugeridos"</string>
    <string name="all_supported_app_locales_title" msgid="5479289964316009026">"Todos os idiomas"</string>
    <string name="preference_of_system_locale_title" msgid="8067226276038751504">"Idioma do sistema"</string>
    <string name="preference_of_system_locale_summary" msgid="5612241394431188535">"Padrão do sistema"</string>
    <string name="desc_no_available_supported_locale" msgid="7883271726226947273">"A seleção de idioma para este app não está disponível nas configurações."</string>
    <string name="desc_app_locale_disclaimer" msgid="5295933110644789052">"O idioma pode ser diferente dos disponíveis no app. Alguns apps podem não ter suporte a essa configuração."</string>
    <string name="desc_app_locale_selection_supported" msgid="6744909281573556379">"Defina o idioma de cada app."</string>
    <string name="desc_introduction_of_language_picker" msgid="1038423471887102449">"O sistema, os apps e os sites usam o primeiro idioma disponível na sua lista."</string>
    <string name="desc_notice_of_language_picker" msgid="3449290526457925447">"Para selecionar um idioma para cada app, acesse as configurações de idioma dele."</string>
    <string name="desc_locale_helper_footer_general" msgid="6112153921151780303">"Saiba mais sobre idiomas de apps"</string>
    <string name="title_change_system_locale" msgid="8589844586256566951">"Mudar o idioma do sistema para %s?"</string>
    <string name="title_system_locale_addition" msgid="8218683660751479466">"Adicionar o %s aos idiomas favoritos?"</string>
    <string name="desc_system_locale_addition" msgid="3409917362651596070">"Isso permite que os apps e sites saibam que você prefere esse idioma."</string>
    <string name="desc_notice_device_locale_settings_change" msgid="8311132485850714160">"As configurações e as preferências regionais do seu dispositivo vão mudar."</string>
    <string name="button_label_confirmation_of_system_locale_change" msgid="5593798559604894733">"Mudar"</string>
    <string name="title_unavailable_locale" msgid="2628898110416542386">"%s indisponível"</string>
    <string name="desc_unavailable_locale" msgid="2201756477400935896">"Esse idioma não pode ser usado para o sistema, mas os apps e sites vão identificar sua preferência."</string>
    <string name="regional_preferences_title" msgid="4304567374498629528">"Preferências regionais"</string>
    <string name="regional_preferences_summary" msgid="1189876997389469650">"Definir preferências de número e unidades"</string>
    <string name="regional_preferences_main_page_sub_title" msgid="4237109940015254725">"Permita que os apps saibam suas preferências regionais para personalizar sua experiência."</string>
    <string name="regional_preferences_option_page_sub_title" msgid="8303661099255197036">"Os apps vão usar suas preferências regionais quando possível."</string>
    <string name="temperature_preferences_title" msgid="5009881556503629058">"Temperatura"</string>
    <string name="first_day_of_week_preferences_title" msgid="1971850087589599553">"Primeiro dia da semana"</string>
    <string name="numbers_preferences_title" msgid="8197418984391195446">"Preferências de números"</string>
    <string name="default_string_of_regional_preference" msgid="3428899072914884203">"Usar padrão"</string>
    <string name="celsius_temperature_unit" msgid="8896459071273084507">"Celsius (°C)"</string>
    <string name="fahrenheit_temperature_unit" msgid="1118677820614569801">"Fahrenheit (°F)"</string>
    <string name="sunday_first_day_of_week" msgid="7644548348295686051">"Domingo"</string>
    <string name="monday_first_day_of_week" msgid="7244698610476506771">"Segunda-feira"</string>
    <string name="tuesday_first_day_of_week" msgid="5085370946936582391">"Terça-feira"</string>
    <string name="wednesday_first_day_of_week" msgid="6544537589727042869">"Quarta-feira"</string>
    <string name="thursday_first_day_of_week" msgid="3035885630945594833">"Quinta-feira"</string>
    <string name="friday_first_day_of_week" msgid="7074795061812083541">"Sexta-feira"</string>
    <string name="saturday_first_day_of_week" msgid="3702282590450322727">"Sábado"</string>
    <string name="title_regional_pref_footer" msgid="7450438024324794380">"Se um app não oferecer suporte a preferências regionais, ele usará as configurações padrão de localidade."</string>
    <string name="desc_regional_pref_footer_learn_more" msgid="4401708653329230081">"Saiba mais sobre as preferências de idioma."</string>
    <string name="category_title_terms_of_address" msgid="4309422700380895278">"Preferências adicionais"</string>
    <string name="terms_of_address_title" msgid="4064593634733842458">"Termos de tratamento"</string>
    <string name="terms_of_address_summary" msgid="6136134336560679144">"Definir como quer que o app se dirija a você"</string>
    <string name="terms_of_address_intro_title" msgid="6149691509414243483">"Os apps podem usar termos de tratamento para personalizar a forma como se dirigem a você."</string>
    <string name="terms_of_address_not_specified" msgid="4439257779351251973">"Não especificado"</string>
    <string name="terms_of_address_feminine" msgid="1743479869695539283">"Feminino"</string>
    <string name="terms_of_address_masculine" msgid="983106046135098856">"Masculino"</string>
    <string name="terms_of_address_neutral" msgid="5475414185543112478">"Neutro"</string>
    <string name="dlg_remove_locales_title" msgid="3170501604483612114">"{count,plural, =1{Remover idioma selecionado?}one{Remover idioma selecionado?}other{Remover idiomas selecionados?}}"</string>
    <string name="dlg_remove_locales_message" msgid="8110560091134252067">"O texto será exibido em outro idioma."</string>
    <string name="dlg_remove_locales_error_title" msgid="5875503658221562572">"Não é possível remover todos os idiomas"</string>
    <string name="dlg_remove_locales_error_message" msgid="6504279959974675302">"Mantenha pelo menos um idioma preferencial"</string>
    <string name="locale_not_translated" msgid="3071618135527110152">"Não disponível como idioma do sistema"</string>
    <string name="action_drag_label_move_up" msgid="3392196942330705015">"Mover para cima"</string>
    <string name="action_drag_label_move_down" msgid="9069518740553953426">"Mover para o fim"</string>
    <string name="action_drag_label_move_top" msgid="2430471023612171619">"Mover para o início"</string>
    <string name="action_drag_label_move_bottom" msgid="6266165197792827003">"Mover para o fim"</string>
    <string name="action_drag_label_remove" msgid="1034900377796780568">"Remover idioma"</string>
    <string name="activity_picker_label" msgid="351250401590691126">"Selecione a atividade"</string>
    <string name="cancel" msgid="5780102414089664898">"Cancelar"</string>
    <string name="okay" msgid="4827099303045669054">"Ok"</string>
    <string name="forget" msgid="3754013654135912783">"Esquecer"</string>
    <string name="save" msgid="3125033126936493822">"Salvar"</string>
    <string name="done" msgid="7497982645646431310">"Concluído"</string>
    <string name="apply" msgid="7834684883190163536">"Aplicar"</string>
    <string name="share" msgid="8502235338607613795">"Compartilhar"</string>
    <string name="add" msgid="8335206931421683426">"Adicionar"</string>
    <string name="remove" msgid="1028414219245072102">"Remover"</string>
    <string name="settings_label" msgid="943294133671632976">"Configurações"</string>
    <string name="settings_label_launcher" msgid="820982375501978609">"Configurações"</string>
    <string name="settings_shortcut" msgid="8548239727871847171">"Atalho para as configurações"</string>
    <string name="airplane_mode" msgid="3196085857882526817">"Modo avião"</string>
    <string name="wireless_networks_settings_title" msgid="8557542379234105369">"Redes sem fio e outras"</string>
    <string name="roaming" msgid="3055365654530847985">"Roaming"</string>
    <string name="roaming_enable" msgid="7845716016861535340">"Conectar aos serviços de dados quando estiver em roaming"</string>
    <string name="roaming_disable" msgid="729512894708689604">"Conectar aos serviços de dados quando estiver em roaming"</string>
    <string name="roaming_warning" msgid="7703647889040229013">"Sujeito a cobrança por uso de roaming."</string>
    <string name="date_time_auto" msgid="4239202185055225869">"Definir hora automaticamente"</string>
    <string name="zone_auto_title" msgid="5141692422373097957">"Definir automaticamente"</string>
    <string name="auto_zone_requires_location_summary" msgid="4831038184260596735">"A localização vai ser usada para definir o fuso horário quando esta opção estiver ativada"</string>
    <string name="date_time_24hour_auto" msgid="6583078135067804252">"Usar o padrão do local"</string>
    <string name="date_time_24hour" msgid="286679379105653406">"Usar formato de 24 horas"</string>
    <string name="date_time_set_time_title" msgid="2870083415922991906">"Horário"</string>
    <string name="time_format_category_title" msgid="7108616745509689991">"Formato de hora"</string>
    <string name="date_time_set_timezone_title" msgid="790404320569600222">"Fuso horário"</string>
    <string name="date_time_set_timezone" msgid="2915125337941495746">"Selecionar fuso horário"</string>
    <string name="date_time_set_date_title" msgid="7624166157167528407">"Data"</string>
    <string name="date_time_search_region" msgid="1364133854952610919">"Região de pesquisa"</string>
    <string name="date_time_select_region" msgid="5449345333305056072">"Região"</string>
    <string name="date_time_select_fixed_offset_time_zones" msgid="594848300882055361">"Selecionar compensação 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">"O <xliff:g id="DST_TIME_TYPE">%1$s</xliff:g> começa em <xliff:g id="TRANSITION_DATE">%2$s</xliff:g>."</string>
    <string name="zone_info_footer_no_dst" msgid="8399585343328811158">"Usa <xliff:g id="OFFSET_AND_NAME">%1$s</xliff:g>. Sem horário de verão."</string>
    <string name="zone_time_type_dst" msgid="9189689342265305808">"Horário de verão"</string>
    <string name="zone_time_type_standard" msgid="6865420715430680352">"Horário padrão"</string>
    <string name="zone_menu_by_region" msgid="2963565278710225652">"Selecionar por região"</string>
    <string name="zone_menu_by_offset" msgid="1257702747474426745">"Selecionar UTC com compensação"</string>
    <string name="lock_after_timeout" msgid="8682769000437403444">"Bloquear depois do tempo limite da tela"</string>
    <string name="lock_after_timeout_summary" msgid="4869265514658147304">"<xliff:g id="TIMEOUT_STRING">%1$s</xliff:g> depois do tempo limite"</string>
    <string name="lock_immediately_summary_with_exception" msgid="40819611828339044">"Imediatamente após o tempo limite, exceto quando estiver desbloqueado por <xliff:g id="TRUST_AGENT_NAME">%1$s</xliff:g>"</string>
    <string name="lock_after_timeout_summary_with_exception" msgid="3441806647509073124">"<xliff:g id="TIMEOUT_STRING">%1$s</xliff:g> após o tempo limite, exceto quando estiver desbloqueado por <xliff:g id="TRUST_AGENT_NAME">%2$s</xliff:g>"</string>
    <string name="owner_info_settings_title" msgid="3555626140700093017">"Adicionar texto na tela de bloqueio"</string>
    <string name="owner_info_settings_summary" msgid="347238313388083297">"Nenhum"</string>
    <string name="owner_info_settings_edit_text_hint" msgid="841926875876050274">"por exemplo, Android do João."</string>
    <string name="location_settings_title" msgid="8375074508036087178">"Localização"</string>
    <string name="location_settings_primary_switch_title" msgid="8849081766644685127">"Usar localização"</string>
    <string name="location_settings_summary_location_off" msgid="4797932754681162262">"Configuração desativada"</string>
    <string name="location_settings_summary_location_on" msgid="4273299717586679786">"{count,plural, =1{Ativada / # app tem acesso à localização}one{Ativada / # app tem acesso à localização}other{Ativada / # apps têm acesso à localização}}"</string>
    <string name="location_settings_loading_app_permission_stats" msgid="6054103701535557342">"Carregando…"</string>
    <string name="location_settings_footer_general" msgid="1040507068701188821">"Apps com permissão para encontrar dispositivos por perto podem determinar a posição relativa dos dispositivos conectados."</string>
    <string name="location_settings_footer_location_off" msgid="8568995909147566720">"O acesso à localização está desativado para apps e serviços. A localização do dispositivo ainda poderá ser enviada a socorristas quando você ligar ou enviar uma mensagem de texto para um número de emergência."</string>
    <string name="location_settings_footer_learn_more_content_description" msgid="349380666660145540">"Saiba mais sobre as configurações de localização"</string>
    <string name="location_settings_tooltip_text_for_chrome" msgid="3574930966097093550">"Mude o acesso à localização em \"Configurações &gt; Segurança e privacidade &gt; Controles de privacidade\""</string>
    <string name="account_settings_title" msgid="9138880127246241885">"Contas"</string>
    <string name="security_settings_title" msgid="6710768415432791970">"Segurança"</string>
    <string name="encryption_and_credential_settings_title" msgid="5856216318961482983">"Criptografia e credenciais"</string>
    <string name="lockscreen_settings_title" msgid="4086121748092341549">"Tela de bloqueio"</string>
    <string name="lockscreen_settings_what_to_show_category" msgid="9205490627927741254">"O que mostrar"</string>
    <string name="disabled_by_administrator_summary" msgid="5424846182313851124">"Indisponível"</string>
    <string name="security_status_title" msgid="6958004275337618656">"Status da segurança"</string>
    <string name="security_dashboard_summary" msgid="7571035662779425918">"Bloqueio de tela, Encontre Meu Dispositivo, Segurança dos apps"</string>
    <string name="safety_center_title" msgid="7732397372178774777">"Segurança e privacidade"</string>
    <string name="safety_center_summary" msgid="3554867379951053869">"Segurança dos apps, bloqueio do dispositivo, permissões"</string>
    <string name="security_settings_face_preference_summary" msgid="6675126437396914838">"Rosto adicionado"</string>
    <string name="security_settings_face_preference_summary_none" msgid="523320857738436024">"Configuração necessária"</string>
    <string name="security_settings_face_preference_title" msgid="2126625155005348417">"Desbloqueio facial"</string>
    <string name="security_settings_face_profile_preference_title" msgid="7519527436266375005">"Desbloqueio facial para trabalho"</string>
    <string name="security_settings_face_enroll_education_title" msgid="6448806884597691208">"Como configurar o Desbloqueio facial"</string>
    <string name="security_settings_face_enroll_education_title_accessibility" msgid="3701874093226957891">"Configurar o Desbloqueio facial"</string>
    <string name="security_settings_face_enroll_education_title_unlock_disabled" msgid="8810954233979716906">"Usar seu rosto para autenticar"</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">"Se o Desbloqueio facial de acessibilidade estiver desativado, algumas etapas da configuração poderão não funcionar com o TalkBack."</string>
    <string name="security_settings_face_enroll_education_accessibility_dialog_negative" msgid="7872647360361245461">"Voltar"</string>
    <string name="security_settings_face_enroll_education_accessibility_dialog_positive" msgid="3148077647572203458">"Continuar config."</string>
    <string name="security_settings_face_enroll_introduction_accessibility" msgid="5748221179069430975">"Usar config. de Acessibilidade"</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">"Agora não"</string>
    <string name="security_settings_face_enroll_introduction_agree" msgid="6319476573697497750">"Aceito"</string>
    <string name="security_settings_face_enroll_introduction_more" msgid="1970820298889710532">"Mais"</string>
    <string name="security_settings_face_enroll_introduction_title" msgid="7061610077237098046">"Desbloquear com seu rosto"</string>
    <string name="security_settings_face_enroll_consent_introduction_title" msgid="3942331854413767814">"Permitir Desbloqueio facial"</string>
    <string name="security_settings_face_enroll_introduction_title_unlock_disabled" msgid="5903924766168353113">"Usar seu rosto para autenticar"</string>
    <string name="security_settings_face_enroll_introduction_message_unlock_disabled" msgid="5841976283789481311">"Use seu rosto para desbloquear o smartphone ou aprovar compras.\n\nObservação: não é possível usar seu rosto para desbloquear este dispositivo. Para mais informações, entre em contato com o administrador da organização."</string>
    <string name="security_settings_face_enroll_introduction_message_setup" msgid="765965418187421753">"Use seu rosto para desbloquear o smartphone, autorizar compras ou fazer login em 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">"Centralize seu rosto dentro do círculo"</string>
    <string name="security_settings_face_enroll_enrolling_skip" msgid="5568617401632528567">"Pular"</string>
    <string name="face_intro_error_max" msgid="2474735057709291626">"Você adicionou o número máximo de rostos"</string>
    <string name="face_intro_error_unknown" msgid="1626057493054989995">"Não é possível adicionar mais rostos"</string>
    <string name="security_settings_face_enroll_error_dialog_title" msgid="2460820099922775936">"O registro não foi concluído"</string>
    <string name="security_settings_face_enroll_dialog_ok" msgid="1674650455786434426">"Ok"</string>
    <string name="security_settings_face_enroll_error_timeout_dialog_message" msgid="7768349698547951750">"Tempo máximo para registro de rostos atingido. Tente novamente."</string>
    <string name="security_settings_face_enroll_error_generic_dialog_message" msgid="3186810411630091490">"O registro do rosto não funcionou."</string>
    <string name="security_settings_face_enroll_finish_title" msgid="5882322568359775393">"Tudo pronto. E bonito."</string>
    <string name="security_settings_face_enroll_done" msgid="3048687969498187442">"Concluído"</string>
    <string name="security_settings_face_enroll_should_re_enroll_title" msgid="6835778900387289683">"Melhorar o desempenho do Desbloqueio facial"</string>
    <string name="security_settings_face_enroll_should_re_enroll_subtitle" msgid="7055780282999744813">"Configurar o Desbloqueio facial de novo"</string>
    <string name="security_settings_face_enroll_must_re_enroll_title" msgid="4421818770682557621">"Configurar o Desbloqueio facial de novo"</string>
    <string name="security_settings_face_enroll_must_re_enroll_subtitle" msgid="3584740139535177961">"Melhorar a segurança e o desempenho"</string>
    <string name="security_settings_face_enroll_improve_face_alert_title" msgid="6194184776580066012">"Configurar o Desbloqueio facial"</string>
    <string name="security_settings_face_enroll_improve_face_alert_body" msgid="2670118180411127323">"Exclua o modelo de rosto atual para configurar o Desbloqueio facial novamente.\n\nO modelo de rosto que foi usado será excluído de maneira permanente e segura.\n\nApós a remoção, você precisará do PIN, padrão ou senha para desbloquear o smartphone ou autenticar apps."</string>
    <string name="security_settings_face_enroll_improve_face_alert_body_fingerprint" msgid="2469599074650327489">"Exclua o modelo de rosto atual para configurar o Desbloqueio facial novamente.\n\nO modelo de rosto que foi usado será excluído de maneira permanente e segura.\n\nApós a remoção, você precisará da impressão digital, do PIN, padrão ou senha para desbloquear o smartphone ou autenticar apps."</string>
    <string name="security_settings_face_settings_use_face_category" msgid="1638314154119800188">"Usar desbloqueio facial para"</string>
    <string name="security_settings_face_settings_preferences_category" msgid="7628929873407280453">"Ao usar o Desbloqueio facial"</string>
    <string name="security_settings_face_settings_require_attention" msgid="4395309855914391104">"Exigir olhos abertos"</string>
    <string name="security_settings_face_settings_require_attention_details" msgid="2546230511769544074">"Para desbloquear o smartphone, os olhos precisam estar abertos"</string>
    <string name="security_settings_face_settings_require_confirmation" msgid="6603039421004198334">"Sempre exigir confirmação"</string>
    <string name="security_settings_face_settings_require_confirmation_details" msgid="3498729789625461914">"Sempre exigir etapa de confirmação ao usar Desbloqueio facial em apps"</string>
    <string name="security_settings_face_settings_remove_face_model" msgid="812920481303980846">"Excluir modelo de rosto"</string>
    <string name="security_settings_face_settings_enroll" msgid="3726313826693825029">"Configurar o Desbloqueio facial"</string>
    <string name="security_settings_face_settings_remove_dialog_title" msgid="2899669764446232715">"Excluir modelo de rosto?"</string>
    <string name="security_settings_face_settings_remove_dialog_details" msgid="916131485988121592">"Seu modelo de rosto será excluído de maneira permanente e segura.\n\nApós a exclusão, você precisará usar a impressão digital, o PIN, o padrão ou a senha para desbloquear o smartphone ou fazer a autenticação em apps."</string>
    <string name="security_settings_face_settings_remove_dialog_details_convenience" msgid="475568135197468990">"Seu modelo de rosto será excluído de maneira permanente e segura.\n\nApós a exclusão, você precisará usar a impressão digital, o PIN, o padrão ou a senha para desbloquear o smartphone."</string>
    <string name="security_settings_face_remove_dialog_details_fingerprint" msgid="7609582230650860974">"Seu modelo de rosto será excluído de maneira permanente e segura.\n\nApós a exclusão, você precisará usar a impressão digital, o PIN, o padrão ou a senha para desbloquear o smartphone ou fazer a autenticação em apps."</string>
    <string name="security_settings_face_remove_dialog_details_fingerprint_conv" msgid="2627374706274503259">"Seu modelo de rosto será excluído de maneira permanente e segura.\n\nApós a exclusão, você precisará usar a impressão digital, o PIN, o padrão ou a senha para desbloquear o smartphone"</string>
    <string name="security_settings_face_settings_context_subtitle" msgid="8284262560781442403">"Usar o Desbloqueio facial para acessar o smartphone"</string>
    <string name="security_settings_fingerprint" msgid="6387775386189204201">"Impressão digital"</string>
    <string name="security_settings_fingerprint_preference_title" msgid="2484965173528415458">"Impressão digital"</string>
    <string name="security_settings_fingerprint_settings_preferences_category" msgid="8975029409126780752">"Quando o Desbloqueio por impressão digital estiver sendo usado"</string>
    <string name="security_settings_work_fingerprint_preference_title" msgid="2076006873519745979">"Impressão digital do trabalho"</string>
    <string name="fingerprint_add_title" msgid="1837610443487902050">"Adicionar impressão digital"</string>
    <string name="security_settings_fingerprint_preference_summary" msgid="8486134175759676037">"{count,plural, =1{Impressão digital registrada}one{# impressão digital registrada}other{# impressões digitais registradas}}"</string>
    <string name="security_settings_fingerprint_preference_summary_none" msgid="1146977379031250790">"Configuração necessária"</string>
    <string name="security_settings_fingerprint_enroll_introduction_title" msgid="7931650601996313070">"Configurar impressão digital"</string>
    <string name="security_settings_fingerprint_enroll_consent_introduction_title" msgid="2278592030102282364">"Permitir Desbloqueio por impressão digital"</string>
    <string name="security_settings_fingerprint_enroll_introduction_title_unlock_disabled" msgid="1911710308293783998">"Usar a impressão digital"</string>
    <string name="security_settings_fingerprint_settings_footer_learn_more" msgid="2508322993726483601">"Saiba mais sobre o Desbloqueio por impressão digital"</string>
    <string name="security_settings_fingerprint_enroll_introduction_footer_title_1" msgid="6808124116419325722">"Você no controle"</string>
    <string name="security_settings_fingerprint_enroll_introduction_footer_title_consent_1" msgid="1122676690472680734">"Você e a criança estão no controle"</string>
    <string name="security_settings_fingerprint_enroll_introduction_footer_title_2" msgid="5663733424583416266">"Não esqueça"</string>
    <string name="security_settings_fingerprint_enroll_introduction_message_unlock_disabled" msgid="8957789840251747092">"Use sua impressão digital para desbloquear o smartphone ou aprovar compras.\n\nNota: não é possível usar sua impressão digital para desbloquear este dispositivo. Para mais informações, entre em contato com o administrador da organização."</string>
    <string name="security_settings_fingerprint_enroll_introduction_cancel" msgid="6086532316718920562">"Cancelar"</string>
    <string name="security_settings_fingerprint_enroll_introduction_no_thanks" msgid="6104718999323591180">"Agora não"</string>
    <string name="security_settings_fingerprint_enroll_introduction_agree" msgid="4068276083536421828">"Aceito"</string>
    <string name="setup_fingerprint_enroll_skip_title" msgid="2473807887676247264">"Pular impressão digital?"</string>
    <string name="setup_fingerprint_enroll_skip_after_adding_lock_text" msgid="2412645723804450304">"A configuração da impressão digital leva apenas um ou dois minutos. Se você pular esta etapa, poderá adicionar sua digital mais tarde nas configurações."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_message_setup" msgid="6255210343107484206">"Ao ver esse ícone, use sua impressão digital para fazer a autenticação, da mesma forma que você faz em logins e aprovações de compras"</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_title_1" msgid="4360262371633254407">"Não esqueça"</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_title_2" msgid="2580899232734177771">"Como funciona"</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_message_2" msgid="5909924864816776516">"O Desbloqueio por impressão digital cria um modelo único da sua digital para confirmar sua identidade. Para isso, é necessário capturar imagens do seu dedo em várias posições."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_message_consent_2" msgid="3493356605815124807">"O Desbloqueio por impressão digital cria um modelo único da impressão digital da criança para confirmar a identidade dela. Para criar esse modelo durante a configuração, é necessário que ela capture imagens da própria impressão em várias posições."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_message_6" msgid="5314031490467481499">"Para conseguir melhores resultados, use uma película com certificação Made For Google. Sua impressão digital pode não funcionar com outras películas."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_footer_message_consent_6" msgid="3563942520716110478">"Para conseguir melhores resultados, use uma película com certificação Made For Google. A impressão digital da criança pode não funcionar com outras películas."</string>
    <string name="security_settings_fingerprint_v2_enroll_introduction_message_learn_more" msgid="5856010507790137793"></string>
    <string name="security_settings_activeunlock_preference_title" msgid="4257580421087062228">"Desbloqueio do relógio"</string>
    <string name="biometric_settings_intro_with_activeunlock" msgid="5032953826653108646">"Quando o Desbloqueio facial e por impressão digital forem configurados, a impressão será solicitada para desbloquear o smartphone sempre que você estiver em uma área escura ou usando uma máscara.\n\nO Desbloqueio do relógio é outra maneira conveniente de desbloquear o smartphone, por exemplo, quando seus dedos estiverem molhados ou seu rosto não for reconhecido."</string>
    <string name="biometric_settings_intro_with_fingerprint" msgid="5881355884547769337">"O Desbloqueio do relógio é outra maneira conveniente de desbloquear o smartphone, por exemplo, quando sua impressão digital não for reconhecida."</string>
    <string name="biometric_settings_intro_with_face" msgid="7671919122230588521">"O Desbloqueio do relógio é outra maneira conveniente de desbloquear o smartphone, por exemplo, quando seu rosto não for reconhecido."</string>
    <string name="biometric_settings_use_fingerprint_or_watch_for" msgid="1160830065613858095">"Use a impressão digital ou o relógio para"</string>
    <string name="biometric_settings_use_face_or_watch_for" msgid="1507077107150278532">"Use o rosto ou o relógio para"</string>
    <string name="biometric_settings_use_face_fingerprint_or_watch_for" msgid="7495835723072020641">"Use o rosto, a impressão digital ou o relógio para"</string>
    <string name="biometric_settings_use_watch_for" msgid="5454545622244040110">"Use o relógio para"</string>
    <string name="biometric_settings_use_face_or_watch_preference_summary" msgid="4969685200340861744">"Usando o rosto ou o relógio"</string>
    <string name="biometric_settings_use_fingerprint_or_watch_preference_summary" msgid="2425628094194828407">"Usando a impressão digital ou o relógio"</string>
    <string name="biometric_settings_use_face_fingerprint_or_watch_preference_summary" msgid="188805113048792007">"Usando o rosto, a impressão digital ou o relógio"</string>
    <string name="biometric_settings_use_watch_preference_summary" msgid="2311453276747908475">"Usando o relógio"</string>
    <string name="security_settings_activeunlock_require_face_fingerprint_setup_title" msgid="8776904312629209685">"Configurar o Desbloqueio facial ou por impressão digital primeiro"</string>
    <string name="security_settings_activeunlock_require_face_fingerprint_setup_message" msgid="1669326067732567911">"Você pode desbloquear o smartphone com o relógio quando sua impressão digital ou seu rosto não forem reconhecidos"</string>
    <string name="security_settings_activeunlock_require_fingerprint_setup_title" msgid="6703703635881050623">"Configurar o Desbloqueio por impressão digital primeiro"</string>
    <string name="security_settings_activeunlock_require_fingerprint_setup_message" msgid="4966813766409918392">"Você pode desbloquear o smartphone com o relógio quando sua impressão digital não é reconhecida"</string>
    <string name="security_settings_activeunlock_require_face_setup_title" msgid="1428795376597739880">"Configurar o Desbloqueio facial primeiro"</string>
    <string name="security_settings_activeunlock_require_face_setup_message" msgid="8904070645721933399">"Você pode desbloquear o smartphone com o relógio quando seu rosto não é reconhecido"</string>
    <string name="security_settings_activeunlock_biometric_setup" msgid="8876454457817955475">"Configurar"</string>
    <string name="security_settings_fingerprint_single_watch_preference_summary" msgid="6464470096384164369">"Impressão digital e <xliff:g id="WATCH">%s</xliff:g> adicionados"</string>
    <string name="security_settings_fingerprint_multiple_watch_preference_summary" msgid="2259261786932097004">"Impressões digitais e <xliff:g id="WATCH">%s</xliff:g> adicionados"</string>
    <string name="security_settings_face_watch_preference_summary" msgid="5817376447253802793">"Rosto e <xliff:g id="WATCH">%s</xliff:g> adicionados"</string>
    <string name="security_settings_fingerprint_single_face_watch_preference_summary" msgid="764951912234638192">"Rosto, impressão digital e <xliff:g id="WATCH">%s</xliff:g> adicionados"</string>
    <string name="security_settings_fingerprint_multiple_face_watch_preference_summary" msgid="3935500711366489380">"Rosto, impressões digitais e <xliff:g id="WATCH">%s</xliff:g> adicionados"</string>
    <string name="security_settings_remoteauth_preference_title" msgid="8319680328086089533">"Desbloqueio do Remote Authenticator"</string>
    <string name="security_settings_remoteauth_preference_summary" msgid="1507004469316635196">"Relógio adicionado"</string>
    <string name="security_settings_remoteauth_enroll_introduction_title" msgid="2151004795778999671">"Configurar o relógio"</string>
    <string name="security_settings_remoteauth_enroll_introduction_message" msgid="8737276885766036074">"O \"Desbloqueio do relógio\" é outra maneira conveniente de desbloquear o smartphone, por exemplo, quando os dedos estiverem molhados ou o rosto não for reconhecido.\n\nVocê pode usar o relógio para desbloquear o smartphone quando:"</string>
    <string name="security_settings_remoteauth_enroll_introduction_disagree" msgid="7639258097401796028">"Agora não"</string>
    <string name="security_settings_remoteauth_enroll_introduction_agree" msgid="5271119227172049339">"Continuar"</string>
    <string name="security_settings_remoteauth_enroll_introduction_more" msgid="1644105894631257595">"Mais"</string>
    <string name="security_settings_remoteauth_enroll_introduction_how_title" msgid="6604152528267830349">"Como funciona"</string>
    <string name="security_settings_remoteauth_enroll_introduction_info_lock_open" msgid="8570511335628725116">"O relógio precisa estar desbloqueado, no pulso e perto do smartphone. Não é necessário desbloquear o relógio novamente enquanto ele está no seu pulso."</string>
    <string name="security_settings_remoteauth_enroll_introduction_info_notifications" msgid="4298855831154039694">"Quando este smartphone for desbloqueado, você vai receber uma notificação no relógio. Se ele foi desbloqueado sem querer, toque na notificação para bloquear o dispositivo de novo."</string>
    <string name="security_settings_remoteauth_enroll_introduction_youre_in_control_title" msgid="7974976673323638524">"Você no controle"</string>
    <string name="security_settings_remoteauth_enroll_introduction_info_remove_watch" msgid="1888318677088986801">"Você pode remover seu relógio do recurso \"Desbloqueio do relógio\" a qualquer momento nas Configurações."</string>
    <string name="security_settings_remoteauth_enroll_introduction_animation_tap_notification" msgid="1597397399097952974">"Toque em uma notificação"</string>
    <string name="security_settings_remoteauth_enroll_introduction_animation_swipe_up" msgid="2129230804324634653">"Deslize para cima na tela de bloqueio"</string>
    <string name="security_settings_remoteauth_enroll_enrolling_title" msgid="313016997943607675">"Escolha seu relógio"</string>
    <string name="security_settings_remoteauth_enroll_enrolling_list_heading" msgid="8227585438932911013">"Relógios disponíveis"</string>
    <string name="security_settings_remoteauth_enroll_enrolling_disagree" msgid="1670201454188049863">"Cancelar"</string>
    <string name="security_settings_remoteauth_enroll_enrolling_agree" msgid="7048336252635730908">"Confirmar"</string>
    <string name="security_settings_remoteauth_enroll_finish_title" msgid="3807372930755413112">"Está tudo pronto!"</string>
    <string name="security_settings_remoteauth_enroll_finish_description" msgid="4876209907275244653">"Agora, você pode usar o relógio para desbloquear o smartphone ao deslizar para cima na tela de bloqueio ou tocar em uma notificação."</string>
    <string name="security_settings_remoteauth_enroll_finish_btn_next" msgid="8072138423143889592">"Concluído"</string>
    <string name="security_settings_remoteauth_settings_title" msgid="1564912618737165129">"Desbloqueio do relógio"</string>
    <string name="security_settings_remoteauth_settings_description" msgid="2758239650119457964">"Você pode usar o relógio para desbloquear o smartphone ao deslizar para cima na tela de bloqueio ou tocar em uma notificação."</string>
    <string name="security_settings_remoteauth_settings_info_footer" msgid="795894033901478120">"Para usar o \"Desbloqueio do relógio\", é necessário que o relógio esteja desbloqueado, no pulso, perto de você e conectado a este smartphone. Se a conexão for interrompida, você precisará desbloquear o smartphone antes de usar o recurso.\n\nNão se esqueça:\nSó é possível configurar um relógio por vez. Para adicionar outro, remova o atual."</string>
    <string name="security_settings_remoteauth_settings_learn_more" msgid="5653556124819260050">"Saiba mais sobre o \"Desbloqueio do relógio\""</string>
    <string name="security_settings_remoteauth_settings_register_new_authenticator" msgid="9191331738306527887">"Adicionar relógio"</string>
    <string name="security_settings_remoteauth_settings_remove_device" msgid="2436226120578851282">"Remover relógio"</string>
    <string name="security_settings_biometric_preference_title" msgid="5012627247749093938">"Impressão digital e Desbloqueio facial"</string>
    <string name="security_settings_work_biometric_preference_title" msgid="3121755615533533585">"Desbloqueio facial e por impressão digital para o trabalho"</string>
    <string name="security_settings_biometric_preference_summary_none_enrolled" msgid="213377753727694575">"Configuração necessária"</string>
    <string name="security_settings_biometric_preference_summary_both_fp_multiple" msgid="4821859306609955966">"Rosto e impressões digitais adicionados"</string>
    <string name="security_settings_biometric_preference_summary_both_fp_single" msgid="684409535278676426">"Rosto e impressão digital registrados"</string>
    <string name="biometric_settings_intro" msgid="4263069383955676756">"Se os métodos de desbloqueio facial e por impressão digital estiverem ativos, a impressão digital será usada para desbloquear o smartphone quando você estiver em um ambiente escuro ou usando uma máscara"</string>
    <string name="biometric_settings_category_ways_to_unlock" msgid="3384767901580915266">"Formas de desbloquear a tela"</string>
    <string name="biometric_settings_category_use_face_fingerprint" msgid="4377659744376863913">"Usar o rosto ou a impressão digital para"</string>
    <string name="biometric_settings_use_biometric_unlock_phone" msgid="8180914579885804358">"Desbloquear seu smartphone"</string>
    <string name="biometric_settings_use_biometric_for_apps" msgid="6201168728906364189">"Confirmar sua identidade em apps"</string>
    <string name="biometric_settings_use_face_preference_summary" msgid="1821648836899408477">"Usando seu rosto"</string>
    <string name="biometric_settings_use_fingerprint_preference_summary" msgid="6077762097826050165">"Usando sua impressão digital"</string>
    <string name="biometric_settings_use_face_or_fingerprint_preference_summary" msgid="3029102492674234728">"Usando seu rosto ou sua impressão digital"</string>
    <string name="biometric_settings_hand_back_to_guardian_ok" msgid="1763788801883247426">"OK"</string>
    <string name="biometric_settings_add_face_in_split_mode_title" msgid="6041232223862753222">"Não é possível configurar o Desbloqueio facial"</string>
    <string name="biometric_settings_add_face_in_split_mode_message" msgid="1904738532939614456">"Saia da tela dividida para configurar o Desbloqueio facial"</string>
    <string name="biometric_settings_add_fingerprint_in_split_mode_title" msgid="9194670722730454903">"Falha ao configurar a impressão digital"</string>
    <string name="biometric_settings_add_fingerprint_in_split_mode_message" msgid="6960548382076629454">"Saia da tela dividida para configurar o Desbloqueio por impressão digital"</string>
    <string name="biometric_settings_add_biometrics_in_split_mode_ok" msgid="564103789097253645">"OK"</string>
    <string name="lock_screen_intro_skip_title" msgid="342553937472568925">"Pular bloqueio de tela?"</string>
    <string name="skip_anyway_button_label" msgid="3442274117023270068">"Pular"</string>
    <string name="go_back_button_label" msgid="6139455414099035594">"Voltar"</string>
    <string name="skip_lock_screen_dialog_button_label" msgid="641984698150020591">"Pular"</string>
    <string name="cancel_lock_screen_dialog_button_label" msgid="1801132985957491690">"Cancelar"</string>
    <string name="security_settings_fingerprint_enroll_find_sensor_title" msgid="886085239313346000">"Toque no sensor"</string>
    <string name="security_settings_sfps_enroll_find_sensor_title" msgid="8327884364635804363">"Toque no botão liga/desliga sem pressionar"</string>
    <string name="security_settings_udfps_enroll_find_sensor_title" msgid="8077484429913330179">"Como configurar sua impressão digital"</string>
    <string name="security_settings_fingerprint_enroll_find_sensor_message" msgid="6160543980992596286">"Ele fica na parte traseira do seu smartphone. Use o dedo indicador."</string>
    <string name="security_settings_udfps_enroll_find_sensor_message" msgid="8383106460819519961">"O sensor de impressão digital está na sua tela. A captura será feita na próxima etapa."</string>
    <string name="security_settings_udfps_enroll_find_sensor_start_button" msgid="3172268783620336357">"Iniciar"</string>
    <string name="security_settings_udfps_enroll_a11y" msgid="1899453114050362235">"Mova o dedo pela tela para encontrá-lo. Toque no sensor de impressão digital e o pressione."</string>
    <string name="security_settings_fingerprint_enroll_find_sensor_content_description" msgid="3065850549419750523">"Ilustração mostrando a localização do sensor de impressão digital no dispositivo"</string>
    <string name="security_settings_fingerprint_enroll_dialog_name_label" msgid="7298812463228440333">"Nome"</string>
    <string name="security_settings_fingerprint_enroll_dialog_ok" msgid="4074335979239208021">"Ok"</string>
    <string name="security_settings_fingerprint_enroll_dialog_try_again" msgid="8117874972945407006">"Tentar novamente"</string>
    <string name="security_settings_fingerprint_enroll_dialog_delete" msgid="6027141901007342389">"Excluir"</string>
    <string name="security_settings_fingerprint_enroll_start_title" msgid="7391368057800077604">"Toque no sensor"</string>
    <string name="security_settings_fingerprint_enroll_start_message" msgid="5010227772754175346">"Encoste o dedo no sensor e, após sentir uma vibração, tire o dedo"</string>
    <string name="security_settings_udfps_enroll_start_message" msgid="5032954588171487566">"Mantenha a digital no sensor até sentir uma vibração."</string>
    <string name="security_settings_sfps_enroll_start_message" msgid="9054672627477685212">"Sem pressionar o botão, mantenha a digital no sensor até sentir uma vibração.\n\nMova o dedo ligeiramente sempre que o dispositivo vibrar. Isso ajuda na captura da sua impressão digital."</string>
    <string name="security_settings_fingerprint_enroll_udfps_title" msgid="6665610134560896895">"Toque e pressione o sensor de impressão digital"</string>
    <string name="security_settings_fingerprint_enroll_repeat_title" msgid="9172202128243545021">"Tire o dedo e toque novamente"</string>
    <string name="security_settings_udfps_enroll_title_one_more_time" msgid="424937043843482410">"Mais uma vez"</string>
    <string name="security_settings_udfps_enroll_repeat_title_touch_icon" msgid="4096344864386190335">"Siga o ícone de impressão digital"</string>
    <string name="security_settings_fingerprint_enroll_repeat_message" msgid="5382958363770893577">"Repita o processo de tocar e levantar o dedo para registrar todas as partes da sua impressão digital"</string>
    <string name="security_settings_udfps_enroll_repeat_message" msgid="2213106975297867798">"Toque na tela e a mantenha pressionada sempre que o ícone de impressão digital se mover. Isso ajuda na captura da sua impressão digital."</string>
    <string name="security_settings_udfps_enroll_fingertip_title" msgid="4123142574168831116">"Coloque a ponta do dedo no sensor"</string>
    <string name="security_settings_udfps_enroll_left_edge_title" msgid="1944076382202470458">"Coloque a lateral esquerda do dedo"</string>
    <string name="security_settings_udfps_enroll_right_edge_title" msgid="9036744264606447490">"Coloque a lateral direita do dedo"</string>
    <string name="security_settings_sfps_enroll_finger_center_title" msgid="1320688855767675739">"Coloque o dedo centralizado no sensor"</string>
    <string name="security_settings_sfps_enroll_fingertip_title" msgid="2737520837684516446">"Coloque a ponta do dedo no sensor"</string>
    <string name="security_settings_sfps_enroll_left_edge_title" msgid="9022963735924413343">"Coloque a lateral esquerda do dedo no sensor"</string>
    <string name="security_settings_sfps_enroll_right_edge_title" msgid="823106857743394392">"Por fim, coloque a lateral direita do dedo no sensor"</string>
    <string name="security_settings_udfps_enroll_edge_message" msgid="4455253923746607702">"Coloque a lateral da sua impressão digital no sensor e mantenha o dedo parado por alguns instantes. Depois, mude para o outro lado"</string>
    <string name="security_settings_udfps_enroll_repeat_a11y_message" msgid="2785464357615568197">"Isso ajuda na captura da sua impressão digital"</string>
    <string name="security_settings_sfps_enroll_progress_a11y_message" msgid="6450772721691523736">"Cadastro de impressão digital em <xliff:g id="PERCENTAGE">%d</xliff:g>%%"</string>
    <string name="security_settings_sfps_animation_a11y_label" msgid="8808819903730940446">"Registro em <xliff:g id="PERCENTAGE">%d</xliff:g>%%"</string>
    <string name="security_settings_udfps_enroll_progress_a11y_message" msgid="6183535114682369699">"Cadastro de impressão digital em <xliff:g id="PERCENTAGE">%d</xliff:g>%%"</string>
    <string name="security_settings_fingerprint_enroll_finish_title" msgid="3606325177406951457">"Impressão digital registrada"</string>
    <string name="security_settings_require_screen_on_to_auth_title" msgid="1641621458536715518">"Toque para desbloquear a qualquer momento"</string>
    <string name="security_settings_require_screen_on_to_auth_description" msgid="4158414711168345398">"Toque no sensor para desbloquear, mesmo quando a tela estiver desligada. Isso aumenta as chances de desbloqueio acidental."</string>
    <string name="security_settings_require_screen_on_to_auth_keywords" msgid="5557869560397089603">"Tela, Desbloqueio"</string>
    <string name="security_settings_fingerprint_enroll_enrolling_skip" msgid="3004786457919122854">"Fazer isso depois"</string>
    <string name="security_settings_udfps_tip_fingerprint_help" msgid="7580784640741217494">"Tire o dedo e toque novamente"</string>
    <string name="security_settings_udfps_side_fingerprint_help" msgid="2567232481013195191">"Coloque a lateral da sua impressão digital no sensor e mantenha o dedo parado por alguns instantes. Depois, mude para o outro lado"</string>
    <string name="setup_fingerprint_enroll_enrolling_skip_title" msgid="352947044008973812">"Pular configuração da impressão digital?"</string>
    <string name="setup_fingerprint_enroll_enrolling_skip_message" msgid="4876965433600560365">"Você optou por usar a impressão digital como uma maneira de desbloquear seu smartphone. Se você pular agora, precisará fazer essa configuração mais tarde. A configuração demora aproximadamente um minuto."</string>
    <string name="lock_screen_skip_setup_title" msgid="6979006375138175111">"Pular a configuração de <xliff:g id="OPTIONS">%s</xliff:g>?"</string>
    <string name="lock_screen_pin_skip_title" msgid="6853866579893458111">"Pular configuração do PIN?"</string>
    <string name="lock_screen_pin_skip_face_title" msgid="8810770395309512358">"Pular configuração de PIN e rosto?"</string>
    <string name="lock_screen_pin_skip_fingerprint_title" msgid="371214283158750976">"Pular configuração de PIN e impressão digital?"</string>
    <string name="lock_screen_pin_skip_biometrics_title" msgid="1082066572914073311">"Pular configuração de PIN, rosto e impressão digital?"</string>
    <string name="lock_screen_password_skip_title" msgid="8891463713793185768">"Pular configuração de senha?"</string>
    <string name="lock_screen_password_skip_face_title" msgid="8166210519462164998">"Pular configuração de senha e rosto?"</string>
    <string name="lock_screen_password_skip_fingerprint_title" msgid="2506392546016772170">"Pular configuração de senha e impressão digital?"</string>
    <string name="lock_screen_password_skip_biometrics_title" msgid="900281322095862009">"Pular configuração de senha, rosto e digital?"</string>
    <string name="lock_screen_pattern_skip_title" msgid="7214938393640060932">"Pular configuração de padrão?"</string>
    <string name="lock_screen_pattern_skip_face_title" msgid="145100333454316334">"Pular configuração de padrão e rosto?"</string>
    <string name="lock_screen_pattern_skip_fingerprint_title" msgid="2513110208722100495">"Pular config. de padrão e impressão digital?"</string>
    <string name="lock_screen_pattern_skip_biometrics_title" msgid="2434258106825380187">"Pular configuração de padrão, rosto e digital?"</string>
    <string name="security_settings_fingerprint_enroll_setup_screen_lock" msgid="3538784524778508018">"Configurar bloqueio de tela"</string>
    <string name="security_settings_fingerprint_enroll_done" msgid="9198775984215057337">"Concluído"</string>
    <string name="security_settings_fingerprint_enroll_touch_dialog_title" msgid="5742429501012827526">"Opa, este não é o sensor"</string>
    <string name="security_settings_fingerprint_enroll_touch_dialog_message" msgid="7172969336386036998">"Toque no sensor na parte traseira do smartphone. Use o dedo indicador."</string>
    <string name="security_settings_fingerprint_enroll_error_unable_to_process_dialog_title" msgid="6305457126747942642">"Falha na configuração de impressão digital"</string>
    <string name="security_settings_fingerprint_enroll_error_unable_to_process_message_setup" msgid="2735739618722623980">"Tente de novo ou configure a impressão digital mais tarde nas Configurações"</string>
    <string name="security_settings_fingerprint_enroll_error_unable_to_process_message" msgid="5858386244898601003">"Tente de novo ou configure a impressão digital mais tarde."</string>
    <string name="security_settings_fingerprint_enroll_error_dialog_title" msgid="8582267776559099046">"Tempo de configuração esgotado"</string>
    <string name="security_settings_fingerprint_enroll_error_timeout_dialog_message_setup" msgid="8521566666541069383">"Você pode configurar sua impressão digital mais tarde nas Configurações."</string>
    <string name="security_settings_fingerprint_enroll_error_generic_dialog_message_setup" msgid="8140162986046783546">"Algo deu errado. Você pode configurar sua impressão digital mais tarde nas Configurações."</string>
    <string name="security_settings_fingerprint_enroll_error_timeout_dialog_message" msgid="3534341971920335247">"Você pode configurar sua impressão digital mais tarde."</string>
    <string name="security_settings_fingerprint_enroll_error_generic_dialog_message" msgid="4344665784935791640">"Algo deu errado. Você pode configurar sua impressão digital mais tarde."</string>
    <string name="fingerprint_enroll_button_add" msgid="6652490687672815760">"Adicionar outra"</string>
    <string name="fingerprint_enroll_button_next" msgid="1034110123277869532">"Próxima"</string>
    <string name="security_fingerprint_disclaimer_lockscreen_disabled_1" msgid="294529888220959309">"A opção de bloqueio de tela está desativada. Para saber mais, entre em contato com o administrador da sua organização."</string>
    <string name="security_fingerprint_disclaimer_lockscreen_disabled_2" msgid="8070829069640846543">"Ainda será possível usar sua impressão digital para autorizar compras e o acesso a apps."</string>
    <string name="security_settings_fingerprint_enroll_lift_touch_again" msgid="2590665137265458789">"Levante o dedo e depois toque no sensor novamente"</string>
    <string name="security_settings_fingerprint_bad_calibration_title" msgid="3073145395701953620">"Não foi possível usar o sensor de impressão digital"</string>
    <string name="security_settings_fingerprint_bad_calibration" msgid="304585658839584958">"Entre em contato com uma assistência técnica."</string>
    <string name="security_advanced_settings" msgid="6260756619837834042">"Mais configurações de segurança"</string>
    <string name="security_advanced_settings_work_profile_settings_summary" msgid="7295451997961973175">"Bloqueio do perfil de trabalho, criptografia e muito mais"</string>
    <string name="security_advanced_settings_no_work_profile_settings_summary" msgid="345336447137417638">"Criptografia, credenciais e muito mais"</string>
    <string name="security_advanced_settings_keywords" msgid="5294945170370974974">"segurança, mais configurações de segurança, mais configurações, configurações avançadas de segurança"</string>
    <string name="privacy_advanced_settings" msgid="8828215456566937719">"Mais configurações de privacidade"</string>
    <string name="more_security_privacy_settings" msgid="123465614090328851">"Mais segurança e privacidade"</string>
    <string name="security_header" msgid="961514795852103424">"Segurança"</string>
    <string name="privacy_header" msgid="5526002421324257007">"Privacidade"</string>
    <string name="work_profile_category_header" msgid="85707750968948517">"Perfil de trabalho"</string>
    <string name="private_space_title" msgid="1752064212078238723">"Espaço privado"</string>
    <string name="private_space_summary" msgid="2274405892301976238">"Mantenha apps particulares bloqueados e ocultos"</string>
    <string name="private_space_description" msgid="4059594203775816136">"Mantenha a privacidade de apps em um espaço separado que você pode ocultar ou bloquear"</string>
    <string name="private_space_lock_title" msgid="7230836881433350526">"Bloqueio do espaço privado"</string>
    <string name="private_space_one_lock_summary" msgid="2106513606571219068">"Você pode desbloquear seu Espaço privado da mesma maneira que desbloqueia seu dispositivo ou escolher um bloqueio diferente"</string>
    <string name="private_space_screen_lock_title" msgid="8679383894967823163">"Usar o bloqueio de tela do dispositivo"</string>
    <string name="private_space_biometric_title" msgid="3934339826674553174">"Desbloqueio facial e por impressão digital"</string>
    <string name="private_space_fingerprint_title" msgid="5989254643211889931">"Desbloqueio por impressão digital"</string>
    <string name="private_space_face_title" msgid="3290402865367663079">"Desbloqueio facial"</string>
    <string name="private_space_biometric_summary" msgid="4403837276018724581">"Toque para configurar"</string>
    <string name="private_space_fingerprint_unlock_title" msgid="3614016453395789051">"Desbloqueio por impressão digital para o espaço privado"</string>
    <string name="private_space_face_unlock_title" msgid="462248384776453613">"Desbloqueio facial para o espaço privado"</string>
    <string name="private_space_category_ways_to_unlock" msgid="4356631225316950046">"Formas de desbloquear a tela"</string>
    <string name="private_space_screen_lock_summary" msgid="394837965365561070">"Igual ao bloqueio de tela do dispositivo"</string>
    <string name="private_space_new_lock_title" msgid="9056139964133004094">"Escolher outro bloqueio para o espaço privado?"</string>
    <string name="private_space_auto_lock_title" msgid="8663409382910601261">"Bloquear o espaço privado automaticamente"</string>
    <string name="private_space_auto_lock_page_summary" msgid="8679844515655838654">"Você poderá bloquear seu espaço privado automaticamente se não usar o dispositivo por um período de tempo"</string>
    <string name="private_space_auto_lock_every_time" msgid="1215061855836002830">"Sempre que o dispositivo for bloqueado"</string>
    <string name="private_space_auto_lock_after_inactivity" msgid="1748673030841528649">"Depois de cinco minutos de inatividade"</string>
    <string name="private_space_auto_lock_never" msgid="595014527119778873">"Nunca"</string>
    <string name="private_space_hide_title" msgid="8687034008994037610">"Ocultar quando bloqueado"</string>
    <string name="privatespace_hide_page_title" msgid="8417507414027827566">"Ocultar o espaço privado quando bloqueado"</string>
    <string name="privatespace_hide_page_summary" msgid="5525422595477989312">"Oculte o espaço privado na sua lista de apps para que outras pessoas não saibam que ele está no dispositivo"</string>
    <string name="privatespace_access_header" msgid="6066826215718835041">"Acessar o espaço privado quando oculto"</string>
    <string name="privatespace_search_description" msgid="3121043205513022357">"Na lista de apps, digite \"espaço privado\" na barra de pesquisa"</string>
    <string name="privatespace_tap_tile_description" msgid="8346440188590931635">"Toque no bloco do espaço privado"</string>
    <string name="privatespace_unlock_description" msgid="3177710543121916413">"Desbloqueie seu espaço privado"</string>
    <string name="privatespace_hide_off_summary" msgid="7227778747159633671">"Desativado"</string>
    <string name="privatespace_hide_on_summary" msgid="6136704537527640183">"Ativado"</string>
    <string name="private_space_category_system" msgid="1286843321867285700">"Sistema"</string>
    <string name="private_space_delete_title" msgid="636873505724100006">"Excluir espaço privado"</string>
    <string name="private_space_delete_header" msgid="4594429153176776184">"Excluir espaço privado?"</string>
    <string name="private_space_delete_summary" msgid="3344372988408565545">"Seu espaço privado será removido do seu dispositivo. Todos os apps e dados particulares serão excluídos. Não é possível desfazer essa ação."</string>
    <string name="private_space_accounts" msgid="1078277762792056395">"Estas contas serão removidas do seu espaço privado:"</string>
    <string name="private_space_delete_button_label" msgid="1256981385318225002">"Excluir"</string>
    <string name="private_space_confirm_deletion_header" msgid="3468651585498942977">"Excluindo espaço privado…"</string>
    <string name="private_space_confirm_deletion_summary" msgid="342544588554284686">"Isso vai levar alguns instantes"</string>
    <string name="private_space_deleted" msgid="7692240901492540053">"Espaço privado excluído"</string>
    <string name="private_space_delete_failed" msgid="7705795653796174741">"Não foi possível excluir o espaço privado"</string>
    <string name="private_space_unlocked" msgid="9091600948712932046">"Espaço privado desbloqueado"</string>
    <string name="no_device_lock_title" msgid="1078223464721029954">"Defina um bloqueio de tela"</string>
    <string name="no_device_lock_summary" msgid="7436025227616244687">"Para usar o Espaço particular, defina um bloqueio de tela neste dispositivo."</string>
    <string name="no_device_lock_action_label" msgid="2640487005629001288">"Definir bloqueio de tela"</string>
    <string name="no_device_lock_cancel" msgid="4412602160321228863">"Cancelar"</string>
    <string name="private_space_cancel_label" msgid="379259667396956886">"Cancelar"</string>
    <string name="private_space_setup_button_label" msgid="2094882154623560585">"Configurar"</string>
    <string name="private_space_setup_title" msgid="2272968244329821450">"Espaço privado"</string>
    <string name="private_space_hide_apps_summary" msgid="4418722947376042418">"Oculte ou bloqueie espaços privados em um espaço separado. Use uma Conta do Google dedicada para ter mais segurança."</string>
    <string name="private_space_setup_sub_header" msgid="5454598292017819146">"Configurar um espaço privado"</string>
    <string name="private_space_separate_account_text" msgid="4492251315012955548"><b>"Escolha uma Conta do Google para o espaço"</b>\n"Usar uma conta dedicada ajuda a impedir que arquivos, fotos e e-mails sincronizados apareçam fora do seu espaço"</string>
    <string name="private_space_protected_lock_text" msgid="9123250938334372735"><b>"Defina um bloqueio"</b>\n"Bloqueie o espaço para impedir que outras pessoas o abram"</string>
    <string name="private_space_install_apps_text" msgid="5693139160766464498"><b>"Instale apps"</b>\n"Seu espaço privado tem a própria Play Store para que você possa instalar apps com facilidade."</string>
    <string name="private_space_apps_permission_text" msgid="7030946025253366172">"Os apps do seu Espaço privado não aparecem na gestão de permissões, no painel de privacidade e em outras configurações quando esse espaço está bloqueado.\n\nSeu Espaço privado não pode ser movido para um novo dispositivo. Você precisará configurar outro Espaço privado se quiser usá-lo em outro dispositivo.\n\nQualquer usuário que conectar seu dispositivo a um computador ou instalar apps perigosos no dispositivo conseguirá acessar seu Espaço privado."</string>
    <string name="private_space_setting_up_text" msgid="8458035555212009528">"Configurando o espaço privado…"</string>
    <string name="private_space_notifications_hidden_title" msgid="2009112565217540581">"Notificações de apps no espaço privado ficam ocultas quando ele está bloqueado"</string>
    <string name="private_space_explore_settings_title" msgid="1448128245941571654">"Consulte as configurações do espaço privado para ocultá-lo e configurar o bloqueio automático"</string>
    <string name="private_space_apps_installed_title" msgid="4781838023423527730">"Os apps necessários já estão instalados no seu espaço privado"</string>
    <string name="private_space_error_screen_title" msgid="739381738044418346">"Não foi possível configurar um espaço privado"</string>
    <string name="private_space_tryagain_label" msgid="8305362615231738367">"Tentar de novo"</string>
    <string name="private_space_lockscreen_title" msgid="6034864097861137509">"Usar o bloq. de tela p/ abrir o Espaço privado?"</string>
    <string name="private_space_lockscreen_summary" msgid="430569465080645805">"Você pode desbloquear seu Espaço privado da mesma maneira que desbloqueia seu dispositivo ou escolher um bloqueio diferente"</string>
    <string name="private_space_use_screenlock_label" msgid="9182153443192032782">"Usar o bloqueio de tela"</string>
    <string name="private_space_set_lock_label" msgid="1790408277477408475">"Escolher novo bloqueio"</string>
    <string name="private_space_success_title" msgid="4351904015352046118">"Tudo pronto!"</string>
    <string name="private_space_access_text" msgid="4433988836344567888">"Para encontrar o espaço privado, abra sua lista de apps e role até a parte de baixo dela"</string>
    <string name="private_space_done_label" msgid="1020482651595246071">"Concluído"</string>
    <string name="private_space_scrolldown_to_access" msgid="4820954877349434545">"Role a tela para baixo para encontrar o Espaço privado"</string>
    <string name="private_space_retry_signin_title" msgid="8090276618867918844">"Login"</string>
    <string name="private_space_retry_summary" msgid="1920444015972648774">"Faça login em uma conta para usar com seu espaço privado"</string>
    <string name="private_space_skip_login_label" msgid="7078019409056628192">"Agora não"</string>
    <string name="private_space_continue_login_label" msgid="7779965766333065391">"Continuar"</string>
    <string name="private_space_lock_setup_title" msgid="6541564212199510787">"Escolher um bloqueio para seu Espaço privado"</string>
    <string name="private_space_lock_setup_description" msgid="423405593476300918">"É possível desbloquear seu espaço particular com sua impressão digital. Por motivos de segurança, essa opção exige um bloqueio de backup."</string>
    <string name="private_space_choose_your_pin_header" msgid="4560802934975898265">"Defina um PIN para seu espaço privado"</string>
    <string name="private_space_choose_your_password_header" msgid="7660259341095044434">"Defina uma senha para seu espaço privado"</string>
    <string name="private_space_choose_your_pattern_header" msgid="2165607102459936724">"Defina um padrão para seu espaço privado"</string>
    <string name="private_space_apps_and_notifications_header" msgid="7493922100321972687">"Apps e notificações"</string>
    <string name="private_space_notifications_title" msgid="3456249671149740404">"Notificações sensíveis na tela de bloqueio"</string>
    <string name="private_space_sensitive_notifications_description" msgid="1466031201599700985">"Mostrar conteúdo sensível quando o espaço privado estiver desbloqueado"</string>
    <string name="private_space_gaia_education_title" msgid="3787414895669666563">"Crie uma Conta do Google para ajudar a manter a privacidade dos seus dados"</string>
    <string name="private_space_gaia_education_description" msgid="1592753570023264559">"Na próxima tela, você pode fazer login em uma conta para usar com seu espaço privado"</string>
    <string name="private_space_gaia_education_header" msgid="7835879839637613495"><b>"Crie uma conta dedicada para ajudar a impedir que os dados apareçam fora do espaço privado, como:"</b></string>
    <string name="private_space_gaia_education_bullet1" msgid="641701340908301992">"Fotos, arquivos, e-mails, contatos, eventos da agenda e outros dados sincronizados"</string>
    <string name="private_space_gaia_education_bullet2" msgid="3679859681253672976">"Histórico e recomendações de download de apps"</string>
    <string name="private_space_gaia_education_bullet3" msgid="1703614225321289717">"Histórico de navegação, favoritos e senhas salvas"</string>
    <string name="private_space_gaia_education_bullet4" msgid="515761604505366164">"Conteúdo sugerido relacionado à sua atividade em apps do espaço privado"</string>
    <string name="private_space_gaia_education_got_it" msgid="7824029819615566806">"Entendi"</string>
    <string name="fingerprint_add_max" msgid="8639321019299347447">"É possível adicionar até <xliff:g id="COUNT">%d</xliff:g> digitais"</string>
    <string name="fingerprint_intro_error_max" msgid="4431784409732135610">"Você adicionou o número máximo de impressões digitais"</string>
    <string name="fingerprint_intro_error_unknown" msgid="877005321503793963">"Não é possível adicionar mais impressões digitais"</string>
    <string name="fingerprint_delete_title" msgid="5412123164503407098">"Excluir \"<xliff:g id="FINGERPRINT_ID">%1$s</xliff:g>\""</string>
    <string name="fingerprint_last_delete_message_profile_challenge" msgid="4104208067277655068">"Não será possível usar a impressão digital para desbloquear seu perfil de trabalho, autorizar compras ou fazer login em apps de trabalho."</string>
    <string name="encryption_settings_title" msgid="2848716008695618360">"Criptografia"</string>
    <string name="encrypted_summary" msgid="545623487587251207">"Criptografado"</string>
    <string name="no_screen_lock_issue_title" msgid="1814109590692792891">"Defina um bloqueio de tela"</string>
    <string name="no_screen_lock_issue_summary" msgid="2383217853510608406">"Para aumentar a segurança, defina um PIN, um padrão ou uma senha para este dispositivo."</string>
    <string name="no_screen_lock_issue_action_label" msgid="2691229130486382863">"Definir bloqueio de tela"</string>
    <string name="no_screen_lock_issue_notification_title" msgid="1214876733592830628">"Defina um bloqueio de tela"</string>
    <string name="no_screen_lock_issue_notification_text" msgid="8696194459170873345">"Para aumentar a segurança, defina um PIN, um padrão ou uma senha para este dispositivo."</string>
    <string name="suggested_lock_settings_title" msgid="7836065447159730217">"Proteger seu smartphone"</string>
    <string name="suggested_fingerprint_lock_settings_title" msgid="3140266181874137984">"Adicionar impressão digital para desbloqueio"</string>
    <string name="lock_settings_picker_title" msgid="9219376327364915334">"Escolher bloqueio de tela"</string>
    <string name="lock_settings_picker_new_lock_title" msgid="3113042086804290919">"Escolha um bloqueio de tela"</string>
    <string name="lock_settings_picker_update_lock_title" msgid="536853138943415927">"Escolha um novo bloqueio de tela"</string>
    <string name="lock_settings_picker_new_profile_lock_title" msgid="2270462215256413800">"Escolha um bloqueio para apps de trabalho"</string>
    <string name="lock_settings_picker_update_profile_lock_title" msgid="5929068163516308927">"Escolha um novo bloqueio de trabalho"</string>
    <string name="lock_settings_picker_biometrics_added_security_message" msgid="1105247657304421299">"Para aumentar a segurança, defina um bloqueio de tela alternativo"</string>
    <string name="lock_settings_picker_biometric_message" msgid="2609666443527262781">"Escolha seu método de bloqueio de tela alternativo"</string>
    <string name="lock_settings_picker_admin_restricted_personal_message" msgid="3532653662159888328">"Se o bloqueio de tela for esquecido, ele não poderá ser redefinido pelo administrador de TI."</string>
    <string name="lock_settings_picker_admin_restricted_personal_message_action" msgid="5956615234246626264">"Defina um bloqueio diferente para o trabalho"</string>
    <string name="lock_settings_picker_profile_message" msgid="9142379549980873478">"Se você se esquecer, peça ao administrador de TI para redefinir o bloqueio"</string>
    <string name="setup_lock_settings_options_button_label" msgid="6098297461618298505">"Opções de bloqueio de tela"</string>
    <string name="setup_lock_settings_options_dialog_title" msgid="7985107300517468569">"Opções de bloqueio de tela"</string>
    <string name="lock_screen_auto_pin_confirm_title" msgid="3012128112186088375">"Desbloqueio com confirmação automática"</string>
    <string name="lock_screen_auto_pin_confirm_summary" msgid="9050818870806580819">"Desbloqueia automaticamente se você inserir um PIN correto de seis ou mais dígitos. É uma forma um pouco menos segura do que confirmar tocando em Enter."</string>
    <string name="auto_pin_confirm_user_message" msgid="6194556173488939314">"Confirmar PIN correto automaticamente"</string>
    <string name="auto_pin_confirm_opt_in_security_message" msgid="580773976736184893">"Confirmar o PIN tocando em Enter é mais seguro do que usar a confirmação automática"</string>
    <string name="auto_confirm_on_pin_verify_description" msgid="2052240431173223502">"Insira o PIN do dispositivo para ativar a confirmação automática"</string>
    <string name="auto_confirm_off_pin_verify_description" msgid="4256219155659760047">"Insira o PIN do dispositivo para desativar a confirmação automática"</string>
    <string name="unlock_set_unlock_launch_picker_title" msgid="4981063601772605609">"Bloqueio de tela"</string>
    <string name="unlock_set_unlock_launch_picker_title_profile" msgid="7631371082326055429">"Bloqueio do perfil de trabalho"</string>
    <string name="unlock_set_unlock_off_title" msgid="2831957685685921667">"Nenhum"</string>
    <string name="unlock_set_unlock_none_title" msgid="2844029875174409728">"Deslizar"</string>
    <string name="unlock_set_unlock_pattern_title" msgid="8224895208452995332">"Padrão"</string>
    <string name="unlock_set_unlock_pin_title" msgid="5283636759362880407">"PIN"</string>
    <string name="unlock_set_unlock_password_title" msgid="2559842616268607041">"Senha"</string>
    <string name="unlock_set_do_later_title" msgid="6565575303676064364">"Agora não"</string>
    <string name="current_screen_lock" msgid="1367883977261098017">"Bloqueio de tela atual"</string>
    <string name="fingerprint_unlock_set_unlock_pattern" msgid="2229689425933043901">"Padrão • Impressão digital"</string>
    <string name="fingerprint_unlock_set_unlock_pin" msgid="7979848492740627674">"PIN • Impressão digital"</string>
    <string name="fingerprint_unlock_set_unlock_password" msgid="6207676267295036963">"Senha • Impressão digital"</string>
    <string name="fingerprint_unlock_skip_fingerprint" msgid="7631242444064287891">"Continuar sem impressão digital"</string>
    <string name="face_unlock_set_unlock_pattern" msgid="4206669838203096608">"Padrão • Rosto"</string>
    <string name="face_unlock_set_unlock_pin" msgid="9034912683791069602">"PIN • Rosto"</string>
    <string name="face_unlock_set_unlock_password" msgid="5874950853246424756">"Senha • Rosto"</string>
    <string name="face_unlock_skip_face" msgid="189695556498300008">"Continuar sem o Desbloqueio facial"</string>
    <string name="biometrics_unlock_skip_biometrics" msgid="7399882488272450182">"Continuar sem configurar a impressão digital ou o rosto"</string>
    <string name="unlock_set_unlock_mode_off" msgid="4632139864722236359">"Nenhum"</string>
    <string name="unlock_set_unlock_mode_none" msgid="5596049938457028214">"Deslizar"</string>
    <string name="unlock_set_unlock_mode_pattern" msgid="1926480143883094896">"Padrão"</string>
    <string name="unlock_set_unlock_mode_pin" msgid="9028659554829888373">"PIN"</string>
    <string name="unlock_set_unlock_mode_password" msgid="8810609692771987513">"Senha"</string>
    <string name="unlock_disable_frp_warning_title" msgid="2545569051372893686">"Remover todos os tipos de desbloqueio de dispositivo?"</string>
    <string name="unlock_disable_frp_warning_title_profile" msgid="1005284289723910461">"Remover proteção de perfil?"</string>
    <string name="unlock_disable_frp_warning_content_pattern" msgid="6246242612158828147">"Um padrão protege o smartphone em casos de roubo ou perda"</string>
    <string name="unlock_disable_frp_warning_content_pattern_fingerprint" msgid="2259825377085781801">"Um padrão protege o smartphone em casos de roubo ou perda.<xliff:g id="EMPTY_LINE">

</xliff:g>O modelo de impressão digital armazenado no dispositivo também será excluído. Você não poderá usar sua impressão digital para fazer a autenticação em apps."</string>
    <string name="unlock_disable_frp_warning_content_pattern_face" msgid="4699508435412336378">"Um padrão protege o smartphone em casos de roubo ou perda.<xliff:g id="EMPTY_LINE">

</xliff:g>Seu modelo de rosto também será excluído de maneira permanente e segura. Você não poderá usar seu rosto para fazer a autenticação em apps."</string>
    <string name="unlock_disable_frp_warning_content_pattern_face_fingerprint" msgid="7049706229344804972">"Um padrão protege o smartphone em casos de roubo ou perda.<xliff:g id="EMPTY_LINE">

</xliff:g>O modelo de impressão digital armazenado no dispositivo será excluído. Seu modelo de rosto também será excluído de maneira permanente e segura. Você não poderá usar seu rosto ou impressão digital para fazer a autenticação em apps."</string>
    <string name="unlock_disable_frp_warning_content_pin" msgid="122154942944422284">"Um PIN protege o smartphone em casos de roubo ou perda"</string>
    <string name="unlock_disable_frp_warning_content_pin_authbound_keys" msgid="6497861740382402784">"Você vai perder dados salvos, como o PIN.<xliff:g id="EMPTY_LINE_0">

</xliff:g>Cards configurados para pagamento por aproximação serão removidos.<xliff:g id="EMPTY_LINE_1">

</xliff:g>Carteiras e outros apps que exigem o desbloqueio do dispositivo podem não funcionar corretamente."</string>
    <string name="unlock_disable_frp_warning_content_pin_fingerprint" msgid="983373874470746066">"Um PIN protege o smartphone em casos de roubo ou perda.<xliff:g id="EMPTY_LINE">

</xliff:g>O modelo de impressão digital armazenado no dispositivo também será excluído. Você não poderá usar sua impressão digital para fazer a autenticação em apps."</string>
    <string name="unlock_disable_frp_warning_content_pin_fingerprint_authbound_keys" msgid="8930057076658360799">"Você vai perder dados salvos, como o PIN e o modelo de impressão digital.<xliff:g id="EMPTY_LINE_0">

</xliff:g>Cards configurados para pagamento por aproximação serão removidos.<xliff:g id="EMPTY_LINE_1">

</xliff:g>Carteiras e outros apps que exigem o desbloqueio do dispositivo podem não funcionar corretamente."</string>
    <string name="unlock_disable_frp_warning_content_pin_face" msgid="5607150515413131761">"Um PIN protege o smartphone em casos de roubo ou perda.<xliff:g id="EMPTY_LINE">

</xliff:g>Seu modelo de rosto também será excluído de maneira permanente e segura. Você não poderá usar seu rosto para fazer a autenticação em apps."</string>
    <string name="unlock_disable_frp_warning_content_pin_face_authbound_keys" msgid="979399855891561038">"Você vai perder dados salvos, como o PIN e o modelo de rosto.<xliff:g id="EMPTY_LINE_0">

</xliff:g>Cards configurados para pagamento por aproximação serão removidos.<xliff:g id="EMPTY_LINE_1">

</xliff:g>Carteiras e outros apps que exigem o desbloqueio do dispositivo podem não funcionar corretamente."</string>
    <string name="unlock_disable_frp_warning_content_pin_face_fingerprint" msgid="1821792325159866312">"Um PIN protege o smartphone em casos de roubo ou perda.<xliff:g id="EMPTY_LINE">

</xliff:g>O modelo de impressão digital armazenado no dispositivo será excluído. Seu modelo de rosto também será excluído de maneira permanente e segura. Você não poderá usar seu rosto ou impressão digital para fazer a autenticação em apps."</string>
    <string name="unlock_disable_frp_warning_content_pin_face_fingerprint_authbound_keys" msgid="7019955731206729909">"Você vai perder dados salvos, como o PIN e os modelos de rosto e impressão digital.<xliff:g id="EMPTY_LINE_0">

</xliff:g>Cards configurados para pagamento por aproximação serão removidos.<xliff:g id="EMPTY_LINE_1">

</xliff:g>Carteiras e outros apps que exigem o desbloqueio do dispositivo podem não funcionar corretamente."</string>
    <string name="unlock_disable_frp_warning_content_password" msgid="6422723907917376210">"Uma senha protege o smartphone em casos de roubo ou perda"</string>
    <string name="unlock_disable_frp_warning_content_password_fingerprint" msgid="8899452884016354856">"Uma senha protege o smartphone em casos de roubo ou perda.<xliff:g id="EMPTY_LINE">

</xliff:g>O modelo de impressão digital armazenado no dispositivo também será excluído. Você não poderá usar sua impressão digital para fazer a autenticação em apps."</string>
    <string name="unlock_disable_frp_warning_content_password_face" msgid="1811067332335964495">"Uma senha protege o smartphone em casos de roubo ou perda.<xliff:g id="EMPTY_LINE">

</xliff:g>Seu modelo de rosto também será excluído de maneira permanente e segura. Você não poderá usar seu rosto para fazer a autenticação em apps."</string>
    <string name="unlock_disable_frp_warning_content_password_face_fingerprint" msgid="7063649456205159491">"Uma senha protege o smartphone em casos de roubo ou perda.<xliff:g id="EMPTY_LINE">

</xliff:g>O modelo de impressão digital armazenado no dispositivo será excluído. Seu modelo de rosto também será excluído de maneira permanente e segura. Você não poderá usar seu rosto ou impressão digital para fazer a autenticação em apps."</string>
    <string name="unlock_disable_frp_warning_content_unknown" msgid="8903568674104115231">"Os recursos de proteção do dispositivo não funcionarão sem seu bloqueio de tela."</string>
    <string name="unlock_disable_frp_warning_content_unknown_fingerprint" msgid="6542744110902941189">"Os recursos de proteção do dispositivo não funcionarão sem o bloqueio de tela.<xliff:g id="EMPTY_LINE">

</xliff:g>O modelo de impressão digital armazenado no dispositivo também será excluído. Você não poderá usar sua impressão digital para fazer a autenticação em apps."</string>
    <string name="unlock_disable_frp_warning_content_unknown_face" msgid="4559917661432267841">"Os recursos de proteção do dispositivo não funcionarão sem o bloqueio de tela.<xliff:g id="EMPTY_LINE">

</xliff:g>Seu modelo de rosto também será excluído de maneira permanente e segura. Você não poderá usar seu rosto para fazer a autenticação em apps."</string>
    <string name="unlock_disable_frp_warning_content_unknown_face_fingerprint" msgid="3779582301453677644">"Os recursos de proteção do dispositivo não funcionarão sem o bloqueio de tela.<xliff:g id="EMPTY_LINE">

</xliff:g>O modelo de impressão digital armazenado no dispositivo será excluído. Seu modelo de rosto também será excluído de maneira permanente e segura. Você não poderá usar seu rosto ou impressão digital para fazer a autenticação em apps."</string>
    <string name="unlock_disable_frp_warning_ok" msgid="6173427638951230842">"Excluir"</string>
    <string name="unlock_footer_high_complexity_requested" msgid="4471274783909915352">"Há uma recomendação de um PIN ou uma senha forte pelo app <xliff:g id="APP_NAME">%1$s</xliff:g>. Ele pode não funcionar adequadamente sem essa configuração."</string>
    <string name="unlock_footer_medium_complexity_requested" msgid="5515870066751600640">"Há uma recomendação de novo PIN ou senha pelo app <xliff:g id="APP_NAME">%1$s</xliff:g>. Ele pode não funcionar adequadamente sem essa configuração."</string>
    <string name="unlock_footer_low_complexity_requested" msgid="2517656037576567971">"Há uma recomendação de novo padrão, PIN ou senha pelo app <xliff:g id="APP_NAME">%1$s</xliff:g>. Ele pode não funcionar adequadamente sem essa configuração."</string>
    <string name="unlock_footer_none_complexity_requested" msgid="8534900170428140529">"Recomendação de um novo bloqueio de tela pelo app <xliff:g id="APP_NAME">%1$s</xliff:g>"</string>
    <string name="lock_failed_attempts_before_wipe" msgid="6874652886647631418">"Tente novamente. Tentativa <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">"Seus dados serão excluídos"</string>
    <string name="lock_last_pattern_attempt_before_wipe_device" msgid="5816668400104558952">"Se você informar um padrão incorreto na próxima tentativa, os dados deste dispositivo serão excluídos"</string>
    <string name="lock_last_pin_attempt_before_wipe_device" msgid="2815681042623708775">"Se você informar um PIN incorreto na próxima tentativa, os dados deste dispositivo serão excluídos"</string>
    <string name="lock_last_password_attempt_before_wipe_device" msgid="985126164175708507">"Se você informar uma senha incorreta na próxima tentativa, os dados deste dispositivo serão excluídos"</string>
    <string name="lock_last_pattern_attempt_before_wipe_user" msgid="8283944727199433440">"Se você informar um padrão incorreto na próxima tentativa, este usuário será excluído"</string>
    <string name="lock_last_pin_attempt_before_wipe_user" msgid="972834567684477451">"Se você informar um PIN incorreto na próxima tentativa, este usuário será excluído"</string>
    <string name="lock_last_password_attempt_before_wipe_user" msgid="3797239847079686727">"Se você informar uma senha incorreta na próxima tentativa, este usuário será excluído"</string>
    <string name="lock_last_pattern_attempt_before_wipe_profile" msgid="2479195488386373253">"Se você informar um padrão incorreto na próxima tentativa, seu perfil de trabalho e os dados correspondentes serão excluídos"</string>
    <string name="lock_last_pin_attempt_before_wipe_profile" msgid="7086428013814722436">"Se você digitar um PIN incorreto na próxima tentativa, seu perfil de trabalho e os dados correspondentes serão excluídos"</string>
    <string name="lock_last_password_attempt_before_wipe_profile" msgid="253673907244112643">"Se você digitar uma senha incorreta na próxima tentativa, seu perfil de trabalho e os dados correspondentes serão excluídos"</string>
    <string name="lockpassword_password_too_short" msgid="1938086368137797700">"{count,plural, =1{Precisa ter pelo menos # caractere}one{Precisa ter pelo menos # caractere}other{Precisa ter pelo menos # caracteres}}"</string>
    <string name="lockpassword_password_too_short_all_numeric" msgid="4301294924022401502">"{count,plural, =1{Caso use apenas números, a senha precisa ter pelo menos 1 dígito}one{Caso use apenas números, a senha precisa ter pelo menos # dígito}other{Caso use apenas números, a senha precisa ter pelo menos # dígitos}}"</string>
    <string name="lockpassword_pin_too_short" msgid="8910105226463085689">"{count,plural, =1{O PIN precisa ter pelo menos # dígito}one{O PIN precisa ter pelo menos # dígito}other{O PIN precisa ter pelo menos # dígitos}}"</string>
    <string name="lockpassword_pin_too_short_autoConfirm_extra_message" msgid="3271351502900762571">"{count,plural, =1{O PIN precisa ter pelo menos # dígito, mas recomendamos {minAutoConfirmLen} dígitos para maior segurança.}one{O PIN precisa ter pelo menos # dígito, mas recomendamos {minAutoConfirmLen} dígitos para maior segurança.}other{O PIN precisa ter pelo menos # dígitos, mas recomendamos {minAutoConfirmLen} dígitos para maior segurança.}}"</string>
    <string name="lockpassword_password_too_long" msgid="1940345313260498308">"{count,plural, =1{Precisa ter menos de # caractere}one{Precisa ter menos de # caractere}other{Precisa ter menos de # caracteres}}"</string>
    <string name="lockpassword_pin_too_long" msgid="1678212054564388576">"{count,plural, =1{Precisa ter menos de # dígito}one{Precisa ter menos de # dígito}other{Precisa ter menos de # dígitos}}"</string>
    <string name="lockpassword_pin_recently_used" msgid="6650277060998923465">"O administrador do dispositivo não permite o uso de um PIN recente"</string>
    <string name="lockpassword_illegal_character" msgid="3434031212215886433">"Não pode incluir um caractere inválido"</string>
    <string name="lockpassword_password_requires_letters" msgid="7058340182953750553">"{count,plural, =1{Precisa ter pelo menos 1 letra}one{Precisa ter pelo menos # letra}other{Precisa ter pelo menos # letras}}"</string>
    <string name="lockpassword_password_requires_lowercase" msgid="3286121470522077547">"{count,plural, =1{Precisa ter pelo menos 1 letra minúscula}one{Precisa ter pelo menos # letra minúscula}other{Precisa ter pelo menos # letras minúsculas}}"</string>
    <string name="lockpassword_password_requires_uppercase" msgid="720312543910397772">"{count,plural, =1{Precisa ter pelo menos 1 letra maiúscula}one{Precisa ter pelo menos # letra maiúscula}other{Precisa ter pelo menos # letras maiúsculas}}"</string>
    <string name="lockpassword_password_requires_numeric" msgid="3886918493600507548">"{count,plural, =1{Precisa ter pelo menos 1 dígito numérico}one{Precisa ter pelo menos # dígito numérico}other{Precisa ter pelo menos # dígitos numéricos}}"</string>
    <string name="lockpassword_password_requires_symbols" msgid="2904870551002210131">"{count,plural, =1{Precisa ter pelo menos 1 caractere especial}one{Precisa ter pelo menos # caractere especial}other{Precisa ter pelo menos # caracteres especiais}}"</string>
    <string name="lockpassword_password_requires_nonletter" msgid="1185342065898300006">"{count,plural, =1{Precisa ter pelo menos 1 caractere que não seja letra}one{Precisa ter pelo menos # caractere que não seja letra}other{Precisa ter pelo menos # caracteres que não sejam letras}}"</string>
    <string name="lockpassword_password_requires_nonnumerical" msgid="389687423482993365">"{count,plural, =1{Precisa ter pelo menos 1 caractere não numérico}one{Precisa ter pelo menos # caractere não numérico}other{Precisa ter pelo menos # caracteres não numéricos}}"</string>
    <string name="lockpassword_password_recently_used" msgid="5341218079730167191">"O administrador do dispositivo não permite usar uma senha recente"</string>
    <string name="lockpassword_pin_no_sequential_digits" msgid="5843639256988031272">"Não é permitido usar uma sequência de dígitos em ordem crescente, decrescente ou repetidos"</string>
    <string name="lockpassword_confirm_label" msgid="560897521093566777">"Confirmar"</string>
    <string name="lockpassword_clear_label" msgid="311359833434539894">"Limpar"</string>
    <string name="lockpassword_credential_changed" msgid="5934778179732392028">"O bloqueio de tela já foi alterado. Tente novamente usando o novo bloqueio de tela."</string>
    <string name="lockpattern_tutorial_cancel_label" msgid="775215267818384016">"Cancelar"</string>
    <string name="lockpattern_tutorial_continue_label" msgid="1329049481210689408">"Avançar"</string>
    <string name="manage_device_admin" msgid="1044620606203916275">"Apps do administrador do dispositivo"</string>
    <string name="number_of_device_admins_none" msgid="152926922020437312">"Nenhum app ativo"</string>
    <string name="number_of_device_admins" msgid="3402909995362162876">"{count,plural, =1{# app ativo}one{# app ativo}other{# apps ativos}}"</string>
    <string name="manage_trust_agents" msgid="6410149930029992356">"Agentes de confiança"</string>
    <string name="disabled_because_no_backup_security" msgid="4998095356607488854">"Para usar, primeiro defina um bloqueio de tela"</string>
    <string name="manage_trust_agents_summary" msgid="6423843123607674286">"Nenhum"</string>
    <string name="manage_trust_agents_summary_on" msgid="3302574418419446146">"{count,plural, =1{1 agente de confiança ativo}one{# agente de confiança ativo}other{# agentes de confiança ativos}}"</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">"Parear com <xliff:g id="DEVICE_NAME">%1$s</xliff:g>?"</string>
    <string name="bluetooth_pairing_group_late_bonding" msgid="3047893658902159692">"Confirme para adicionar a segunda peça do seu dispositivo de áudio"</string>
    <string name="bluetooth_pairing_key_msg" msgid="1329835708475701761">"Código de pareamento Bluetooth"</string>
    <string name="bluetooth_enter_passkey_msg" msgid="5806420933599368592">"Digite o código de pareamento e pressione \"Return\" ou \"Enter\""</string>
    <string name="bluetooth_enable_alphanumeric_pin" msgid="7256286571636950635">"O PIN contém letras ou símbolos"</string>
    <string name="bluetooth_pin_values_hint" msgid="2753202519050044670">"Geralmente, 0000 ou 1234"</string>
    <string name="bluetooth_pin_values_hint_16_digits" msgid="5603928271430883558">"São necessários 16 dígitos"</string>
    <string name="bluetooth_enter_pin_other_device" msgid="6737778699899780717">"Talvez seja necessário digitar este PIN no outro dispositivo."</string>
    <string name="bluetooth_enter_passkey_other_device" msgid="8270426446247344709">"Talvez seja necessário digitar esta senha no outro dispositivo."</string>
    <string name="bluetooth_paring_group_msg" msgid="2455293929036668131">"Confirme para parear com o dispositivo de áudio"</string>
    <string name="bluetooth_pairing_shares_phonebook" msgid="4329325125260724843">"Permitir o acesso aos seus contatos e seu histórico de ligações"</string>
    <string name="bluetooth_pairing_phonebook_toggle_text" msgid="2474015367387690034">"Permitir o acesso a contatos e ao histórico de ligações também"</string>
    <string name="bluetooth_pairing_phonebook_toggle_details" msgid="1367197978487212581">"As informações serão usadas para fazer o anúncio de ligações e muito mais"</string>
    <string name="bluetooth_error_title" msgid="2284738188253690278"></string>
    <string name="bluetooth_connecting_error_message" msgid="3941893154784152112">"Não foi possível conectar ao <xliff:g id="DEVICE_NAME">%1$s</xliff:g>."</string>
    <string name="bluetooth_preference_found_media_devices" msgid="830061195998352840">"Dispositivos encontrados"</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">"Parear e conectar"</string>
    <string name="bluetooth_empty_list_bluetooth_off" msgid="7326727272747345476">"Com o Bluetooth ativado, o dispositivo pode se comunicar com dispositivos próximos"</string>
    <string name="bluetooth_empty_list_bluetooth_off_auto_on_available" msgid="5833847615853525971">"Com o Bluetooth ativado, o dispositivo pode se comunicar com dispositivos próximos. Recursos como o Quick Share, o Encontre Meu Dispositivo e a localização do dispositivo usam o Bluetooth."</string>
    <string name="bluetooth_scanning_on_info_message" msgid="786648535600075223">"Quando o Bluetooth está ativado, seu dispositivo pode se comunicar com outros dispositivos Bluetooth por perto.\n\nPara melhorar a experiência, os apps e serviços ainda podem procurar dispositivos por perto a qualquer momento, mesmo com o Bluetooth desativado. Isso pode ser usado, por exemplo, para aprimorar serviços e recursos baseados na localização. Mude essa opção nas configurações de busca por Bluetooth."</string>
    <string name="bluetooth_scanning_on_info_message_auto_on_available" msgid="5047787966768730069">"Com o Bluetooth ativado, o dispositivo pode se comunicar com dispositivos próximos. Recursos como Quick Share, Encontre Meu Dispositivo e localização do dispositivo usam o Bluetooth.\n\nApps e serviços ainda podem procurar dispositivos por perto a qualquer momento, mesmo quando o Bluetooth está desativado. Isso pode ser usado, por exemplo, para melhorar recursos e serviços com base na localização. Você pode mudar essa opção nas configurações da busca por Bluetooth."</string>
    <string name="bluetooth_scan_change" msgid="1744636222637390367">"Mudar"</string>
    <string name="device_details_title" msgid="1155622417516195481">"Detalhes do dispositivo"</string>
    <string name="bluetooth_device_keyboard_settings_preference_title" msgid="3411693160917620519">"Configurações de teclado"</string>
    <string name="bluetooth_device_mac_address" msgid="4873325074786732703">"Endereço Bluetooth do dispositivo: <xliff:g id="ADDRESS">%1$s</xliff:g>"</string>
    <string name="bluetooth_multuple_devices_mac_address" msgid="4974301550897923376">"Endereço Bluetooth do dispositivo:\n<xliff:g id="ADDRESS">%1$s</xliff:g>"</string>
    <string name="bluetooth_unpair_dialog_title" msgid="6943633443716052995">"Esquecer dispositivo?"</string>
    <string name="remove_association_button" msgid="5004208145998061135">"Remover associação"</string>
    <string name="bluetooth_companion_app_remove_association_dialog_title" msgid="1344518601377991897">"Desconectar o app?"</string>
    <string name="bluetooth_companion_app_body" msgid="8442643629075687761">"O app <xliff:g id="APP_NAME">%1$s</xliff:g> não se conectará mais ao seu <xliff:g id="DEVICE_NAME">%2$s</xliff:g>"</string>
    <string name="device_details_leaudio_toggle_summary" msgid="7684848254433230809">"Experimental. Melhora a qualidade do som."</string>
    <string name="bluetooth_unpair_dialog_forget_confirm_button" msgid="9184489424930549015">"Esquecer 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">"Número máximo de dispositivos de áudio Bluetooth conectados"</string>
    <string name="bluetooth_max_connected_audio_devices_dialog_title" msgid="4056811727247312473">"Selecione o número máximo de dispositivos de áudio Bluetooth conectados"</string>
    <string name="nfc_stack_debuglog_title" msgid="2926748386805740609">"Registro de depuração da pilha NFC"</string>
    <string name="nfc_stack_debuglog_summary" msgid="7333205107551132121">"Aumentar o nível de registros da pilha NFC"</string>
    <string name="nfc_verbose_vendor_log_title" msgid="5554505631122964628">"Registro detalhado de depuração NFC do fornecedor"</string>
    <string name="nfc_verbose_vendor_log_summary" msgid="3049128322855928507">"Incluir mais registros de fornecedores específicos do dispositivo em relatórios de bugs, que podem conter informações particulares."</string>
    <string name="nfc_snoop_log_title" msgid="1576197495976952388">"Registro NCI NFC sem filtro"</string>
    <string name="nfc_snoop_log_summary" msgid="3988383328800163180">"Capturar detalhes de pacotes NFC, que podem conter informações particulares."</string>
    <string name="nfc_reboot_dialog_title" msgid="2033983438635768169">"Reiniciar o dispositivo?"</string>
    <string name="nfc_reboot_dialog_message" msgid="4929353168157966992">"O registro detalhado de NFC é destinado apenas a fins de desenvolvimento. Dados NFC extras estão incluídos em relatórios de bugs, que podem conter informações particulares. Reinicie o dispositivo para mudar essa configuração."</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">"espelho"</string>
    <string name="wifi_display_enable_menu_item" msgid="7391841780777318134">"Ativar tela sem fio"</string>
    <string name="wifi_display_no_devices_found" msgid="7904877793677102805">"Nenhum dispositivo encontrado por perto."</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">"Em uso"</string>
    <string name="wifi_display_status_not_available" msgid="8463750208946968594">"Indisponível"</string>
    <string name="wifi_display_options_title" msgid="7584326966240865043">"Opções de Display sem fio"</string>
    <string name="wifi_display_options_forget" msgid="3140558691112356024">"Esquecer"</string>
    <string name="wifi_display_options_done" msgid="7608851767701954020">"Concluído"</string>
    <string name="wifi_display_options_name" msgid="8181334945680312228">"Nome"</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">"Fazer login"</string>
    <string name="wifi_venue_website_button_text" msgid="7749360432667175030">"Abrir site"</string>
    <string name="wifi_time_remaining" msgid="8503606272869846170">"Tempo restante: <xliff:g id="REMAINING_TIME">%1$s</xliff:g>"</string>
    <string name="wifi_expiry_time" msgid="5419758551129267624">"Expira em <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> quer ativar o Wi-Fi"</string>
    <string name="wifi_ask_disable" msgid="1663208096020309639">"<xliff:g id="REQUESTER">%s</xliff:g> quer desativar o Wi-Fi"</string>
    <string name="art_verifier_for_debuggable_title" msgid="1926445785190030479">"Verificar bytecode de apps depuráveis"</string>
    <string name="art_verifier_for_debuggable_summary" msgid="4802875841862652879">"Permitir que o ART verifique o bytecode de apps depuráveis"</string>
    <string name="show_refresh_rate" msgid="5742688821872354973">"Mostrar taxa de atualização"</string>
    <string name="show_refresh_rate_summary" msgid="3558118122374609663">"Mostrar a taxa de atualização de tela atual"</string>
    <string name="show_hdr_sdr_ratio" msgid="4188007289024955585">"Mostrar a proporção HDR/SDR"</string>
    <string name="show_hdr_sdr_ratio_summary" msgid="986292785096013733">"Mostrar a proporção HDR/SDR atual"</string>
    <string name="nfc_quick_toggle_title" msgid="3607620705230351666">"NFC"</string>
    <string name="nfc_secure_settings_title" msgid="4906958426927741485">"Exigir desbloqueio de dispositivo para usar a NFC"</string>
    <string name="android_beam_settings_title" msgid="2797963824490671295">"Android Beam"</string>
    <string name="android_beam_on_summary" msgid="6067720758437490896">"Pronto para transmitir conteúdo de apps via NFC"</string>
    <string name="android_beam_off_summary" msgid="5693961375631325042">"Desativado"</string>
    <string name="nfc_disabled_summary" msgid="8737797364522502351">"Indisponível porque a NFC está desativada"</string>
    <string name="android_beam_explained" msgid="5684416131846701256">"Quando este recurso está ativado, é possível enviar o conteúdo do app para outro dispositivo compatível com NFC, mantendo os dispositivos próximos. Por exemplo, é possível enviar páginas da Web, vídeos do YouTube, contatos e muito mais.\n\nBasta aproximar os dispositivos (normalmente de costas um para o outro) e tocar na tela. O app determina o que é enviado."</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">"Configurações de Wi-Fi"</string>
    <string name="wifi_select_network" msgid="6692897876718813259">"Selecionar Wi-Fi"</string>
    <string name="wifi_starting" msgid="6147022683967506341">"Ativando Wi-Fi..."</string>
    <string name="wifi_stopping" msgid="4471699665741299711">"Desativando Wi-Fi..."</string>
    <string name="wifi_error" msgid="4903954145386086899">"Erro"</string>
    <string name="wifi_sap_no_channel_error" msgid="2126487622024749402">"Banda de 5 GHz não está disponível neste país"</string>
    <string name="wifi_in_airplane_mode" msgid="1235412508135267981">"No modo avião"</string>
    <string name="wifi_notify_open_networks" msgid="2610323626246818961">"Notificar quando houver redes públicas"</string>
    <string name="wifi_notify_open_networks_summary" msgid="191058832201741013">"Notificar quando uma rede pública de alta qualidade estiver disponível."</string>
    <string name="wifi_allow_wep_networks" msgid="8772342993235292010">"Permitir redes WEP"</string>
    <string name="wifi_allow_wep_networks_summary" msgid="3033397893296724615">"WEP é um protocolo de segurança mais antigo que oferece menos proteção"</string>
    <string name="wifi_allow_wep_networks_summary_carrier_not_allow" msgid="6298103289728210026">"Sua operadora não permite redes WEP porque elas são menos seguras"</string>
    <string name="wifi_wakeup" msgid="3834327315861781611">"Ativar o Wi‑Fi automaticamente"</string>
    <string name="wifi_wakeup_summary" msgid="5778059083790221465">"Reativar o Wi‑Fi automaticamente perto de redes salvas de alta qualidade, como sua rede doméstica."</string>
    <string name="wifi_wakeup_summary_no_location" msgid="681323616606485096">"Indisponível porque a localização está desativada. Ative a "<annotation id="link">"localização"</annotation>"."</string>
    <string name="wifi_install_credentials" msgid="5192903644606839972">"Instalar certificados"</string>
    <string name="wifi_scan_notify_text" msgid="7163137260385995873">"Para melhorar a precisão do local, os apps e serviços ainda podem procurar redes Wi-Fi a qualquer momento, mesmo quando o Wi-Fi está desativado. Isso pode ser usado, por exemplo, para melhorar recursos e serviços baseados na localização. Você pode mudar essa opção nas <xliff:g id="LINK_BEGIN_0">LINK_BEGIN</xliff:g>configurações de busca por Wi-Fi<xliff:g id="LINK_END_1">LINK_END</xliff:g>."</string>
    <string name="wifi_scan_notify_text_scanning_off" msgid="7439201783168213149">"Para melhorar a precisão do local, ative a busca por Wi-Fi nas <xliff:g id="LINK_BEGIN_0">LINK_BEGIN</xliff:g>configurações desse recurso<xliff:g id="LINK_END_1">LINK_END</xliff:g>."</string>
    <string name="wifi_cellular_data_fallback_title" msgid="2844653839490977040">"Mudar para dados móveis automaticamente"</string>
    <string name="wifi_cellular_data_fallback_summary" msgid="7039944853033554386">"Usar dados móveis quando o Wi-Fi perder o acesso à Internet. Cobranças de dados podem ser aplicadas."</string>
    <string name="wifi_add_network" msgid="4178564862173751181">"Adicionar rede"</string>
    <string name="wifi_configure_settings_preference_title" msgid="2536725796700696566">"Preferências de Wi‑Fi"</string>
    <string name="wifi_configure_settings_preference_summary_wakeup_on" msgid="7822368955551467382">"O Wi‑Fi é reativado automaticamente"</string>
    <string name="wifi_configure_settings_preference_summary_wakeup_off" msgid="5710203586018223864">"O Wi‑Fi não é reativado automaticamente"</string>
    <string name="wifi_menu_p2p" msgid="5234165837732940385">"Wi-Fi Direct"</string>
    <string name="wifi_empty_list_wifi_off" msgid="7697422506708419298">"Para acessar as redes disponíveis, ative o Wi-Fi."</string>
    <string name="wifi_empty_list_wifi_on" msgid="2448010040478321376">"Procurando redes…"</string>
    <string name="wifi_empty_list_user_restricted" msgid="454861411536708709">"Você não tem permissão para alterar a rede Wi-Fi."</string>
    <string name="wifi_settings_scanning_required_title" msgid="1088663325396007484">"Ativar a busca por Wi‑Fi?"</string>
    <string name="wifi_settings_scanning_required_summary" msgid="4770243653675416569">"Para ativar o Wi‑Fi automaticamente, primeiro você precisa ativar a busca por Wi‑Fi."</string>
    <string name="wifi_settings_scanning_required_info" msgid="1473411566072565789">"A busca por Wi-Fi permite que apps e serviços procurem redes Wi‑Fi a qualquer momento, mesmo quando o Wi‑Fi está desativado. Essa configuração pode ser usada, por exemplo, para melhorar recursos e serviços baseados na localização."</string>
    <string name="wifi_settings_scanning_required_turn_on" msgid="1112223196123955447">"Ativar"</string>
    <string name="wifi_settings_scanning_required_enabled" msgid="4721729158927146365">"Busca por Wi‑Fi ativada"</string>
    <string name="wifi_settings_warning_wep_network" msgid="2655077013800385646">"Esta rede usa um protocolo de segurança mais antigo e menos seguro"</string>
    <string name="wifi_settings_wep_networks_blocked_title" msgid="8337700496544833669">"A rede <xliff:g id="NAME">%1$s</xliff:g> foi bloqueada"</string>
    <string name="wifi_settings_wep_networks_summary_toggle_off" msgid="1113138364046142949">"Esta rede usa um protocolo de segurança mais antigo chamado WEP, que é menos seguro. Para se conectar mesmo assim, permita a conexão em redes WEP."</string>
    <string name="wifi_settings_wep_networks_summary_blocked_by_carrier" msgid="6085673947156094523">"Sua operadora não permite que você se conecte a esta rede porque ela usa um protocolo de segurança mais antigo e menos seguro"</string>
    <string name="wifi_settings_wep_networks_button_allow" msgid="2807926329019873706">"Permitir WEP"</string>
    <string name="wifi_settings_ssid_block_button_close" msgid="3013886895576949908">"Fechar"</string>
    <string name="wifi_settings_wep_networks_disconnect_title" msgid="2158070405309246888">"Desconectar de <xliff:g id="NAME">%1$s</xliff:g>?"</string>
    <string name="wifi_settings_wep_networks_disconnect_summary" msgid="643132352152685538">"Você se conectou a uma rede WEP. Se bloquear essas redes, a conexão será perdida."</string>
    <string name="wifi_show_advanced" msgid="2969378109942071741">"Opções avançadas"</string>
    <string name="wifi_advanced_toggle_description" msgid="7299179796727934885">"Lista suspensa \"Opções avançadas\""</string>
    <string name="wifi_advanced_toggle_description_collapsed" msgid="3615140699129928913">"abrir"</string>
    <string name="wifi_ssid" msgid="2713062130735103151">"Nome da rede"</string>
    <string name="wifi_ssid_hint" msgid="1940577553241083524">"Digite o SSID"</string>
    <string name="wifi_security" msgid="9095934643631406913">"Segurança"</string>
    <string name="wifi_hidden_network" msgid="6466834025375485596">"Rede oculta"</string>
    <string name="wifi_hidden_network_warning" msgid="3937433813754746158">"Se seu roteador não estiver transmitindo o ID da rede, mas você quiser se conectar a ela no futuro, configure a rede como oculta.\n\nIsso pode gerar um risco à segurança, porque seu smartphone transmitirá regularmente o próprio sinal para encontrar a rede.\n\nA configuração da rede como oculta não altera as configurações do seu roteador."</string>
    <string name="wifi_signal" msgid="4442182285304271424">"Potência do sinal"</string>
    <string name="wifi_status" msgid="5349199188871002778">"Status"</string>
    <string name="tx_wifi_speed" msgid="2368986629172050673">"Velocidade do link de transmissão"</string>
    <string name="rx_wifi_speed" msgid="5167966079215111232">"Velocidade do link de recepção"</string>
    <string name="wifi_speed" msgid="6562147734565434513">"Velocidade do link"</string>
    <string name="wifi_frequency" msgid="3120998420184702834">"Frequência"</string>
    <string name="wifi_ip_address" msgid="8903577251845268209">"Endereço IP"</string>
    <string name="passpoint_label" msgid="6513669696739302866">"Salvo via"</string>
    <string name="passpoint_content" msgid="5219226173518418335">"Credenciais 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">"Autenticação da Fase 2"</string>
    <string name="wifi_eap_ca_cert" msgid="8033404008276298886">"Certificado de CA"</string>
    <string name="wifi_eap_min_tls_ver" msgid="174023604103299457">"Versão mínima de TLS"</string>
    <string name="wifi_eap_ocsp" msgid="8713933962516871238">"Status de certificado on-line"</string>
    <string name="wifi_eap_domain" msgid="8304301470752333203">"Domínio"</string>
    <string name="wifi_eap_user_cert" msgid="3569182430929173220">"Certificado do usuário"</string>
    <string name="wifi_eap_identity" msgid="3629406902174137028">"Identidade"</string>
    <string name="wifi_eap_anonymous" msgid="8630332141751267000">"Identidade anônima"</string>
    <string name="wifi_password" msgid="1458802324849513755">"Senha"</string>
    <string name="wifi_show_password" msgid="6865993988238157923">"Mostrar senha"</string>
    <string name="wifi_ap_choose_2G" msgid="1436802195991542016">"Banda de 2,4 GHz"</string>
    <string name="wifi_ap_prefer_5G" msgid="2520628479818369902">"Banda de 5 GHz preferencial"</string>
    <string name="wifi_ip_settings" msgid="6420498748726599133">"Configuração do IP"</string>
    <string name="wifi_privacy_settings" msgid="3283946009000725698">"Privacidade"</string>
    <string name="wifi_privacy_mac_settings" msgid="3188060664478313363">"MAC"</string>
    <string name="wifi_privacy_device_name_settings" msgid="3699130177041345275">"Nome do dispositivo"</string>
    <string name="wifi_privacy_send_device_name_toggle_title" msgid="1228107313152880073">"Enviar nome do dispositivo"</string>
    <string name="wifi_privacy_send_device_name_toggle_summary" msgid="5995365836332817655">"Compartilhe o nome deste dispositivo com a rede"</string>
    <string name="wifi_subscription" msgid="4432423938285430113">"Inscrição"</string>
    <string name="wifi_subscription_summary" msgid="18802471063384598">"Ver ou mudar inscrição"</string>
    <string name="wifi_privacy_settings_ephemeral_summary" msgid="8502084692297249372">"MAC aleatório"</string>
    <string name="wifi_dpp_add_device_to_network" msgid="6141246783457722976">"Adicionar um dispositivo"</string>
    <string name="wifi_dpp_center_qr_code" msgid="5270782275746178104">"Centralize o QR code abaixo para adicionar o dispositivo a “<xliff:g id="SSID">%1$s</xliff:g>”"</string>
    <string name="wifi_dpp_scan_qr_code" msgid="3543923817779444434">"Ler QR code"</string>
    <string name="wifi_dpp_scan_qr_code_join_network" msgid="969985020363459133">"Centralize o QR code abaixo para conectar a “<xliff:g id="SSID">%1$s</xliff:g>”"</string>
    <string name="wifi_dpp_scan_qr_code_join_unknown_network" msgid="3180020429793614145">"Para acessar a rede Wi-Fi, leia o QR code"</string>
    <string name="wifi_dpp_share_wifi" msgid="2431744447544057866">"Compartilhar Wi‑Fi"</string>
    <string name="wifi_dpp_scan_qr_code_with_another_device" msgid="6967364080214325016">"Faça a leitura deste QR code com outro dispositivo para entrar na rede “<xliff:g id="SSID">%1$s</xliff:g>”"</string>
    <string name="wifi_dpp_scan_open_network_qr_code_with_another_device" msgid="5398619697898444311">"Faça a leitura deste QR code para conectar-se a “<xliff:g id="SSID">%1$s</xliff:g>”"</string>
    <string name="wifi_dpp_failure_authentication_or_configuration" msgid="847551626830740204">"Tente novamente. Se o problema persistir, entre em contato com o fabricante do dispositivo"</string>
    <string name="wifi_dpp_failure_not_compatible" msgid="4453775826337805825">"Algo deu errado"</string>
    <string name="wifi_dpp_failure_timeout" msgid="7902971341771145564">"Verifique se o dispositivo está conectado, carregado e ligado"</string>
    <string name="wifi_dpp_failure_generic" msgid="6559442892600448442">"Verifique se o dispositivo está conectado, carregado e ligado. Se o problema persistir, entre em contato com o fabricante do dispositivo"</string>
    <string name="wifi_dpp_failure_not_supported" msgid="2908961523550486480">"Não há compatibilidade com a adição de “<xliff:g id="SSID">%1$s</xliff:g>” neste dispositivo"</string>
    <string name="wifi_dpp_failure_cannot_find_network" msgid="8519567801353014036">"Tente aproximar o dispositivo do ponto de acesso/roteador Wi-Fi"</string>
    <string name="wifi_dpp_failure_enrollee_authentication" msgid="7008840843663520852">"Verifique a senha e tente novamente"</string>
    <string name="wifi_dpp_failure_enrollee_rejected_configuration" msgid="982310033782652478">"Entre em contato com o fabricante do dispositivo"</string>
    <string name="wifi_dpp_check_connection_try_again" msgid="6118892932595974823">"Verifique a conexão e tente novamente"</string>
    <string name="wifi_dpp_choose_network" msgid="3987007684129341427">"Escolher rede"</string>
    <string name="wifi_dpp_choose_network_to_connect_device" msgid="4321618376432197593">"Para conectar seu dispositivo, escolha uma rede"</string>
    <string name="wifi_dpp_add_device_to_wifi" msgid="5170095438763569255">"Adicionar este dispositivo a “<xliff:g id="SSID">%1$s</xliff:g>”?"</string>
    <string name="wifi_dpp_wifi_shared_with_device" msgid="4484366631307204949">"Wi‑Fi compartilhado com o dispositivo"</string>
    <string name="wifi_dpp_add_another_device" msgid="3307575293580739604">"Adicionar outro dispositivo"</string>
    <string name="wifi_dpp_choose_different_network" msgid="8963625819804792157">"Escolher uma rede diferente"</string>
    <string name="wifi_dpp_could_not_add_device" msgid="6865710911186601933">"Não foi possível adicionar o dispositivo"</string>
    <string name="wifi_dpp_device_found" msgid="633646744759830603">"Dispositivo encontrado"</string>
    <string name="wifi_dpp_sharing_wifi_with_this_device" msgid="7250369936882080107">"Compartilhando o Wi‑Fi com este dispositivo…"</string>
    <string name="wifi_dpp_connecting" msgid="2312769193202897589">"Conectando…"</string>
    <string name="wifi_dpp_share_hotspot" msgid="6186452780604755316">"Compartilhar ponto de acesso"</string>
    <string name="wifi_dpp_lockscreen_title" msgid="5246641326066972419">"Confirme sua identidade"</string>
    <string name="wifi_dpp_wifi_password" msgid="4992986319806934381">"Senha do Wi-Fi: <xliff:g id="PASSWORD">%1$s</xliff:g>"</string>
    <string name="wifi_dpp_hotspot_password" msgid="688464342650820420">"Senha do ponto de acesso: <xliff:g id="PASSWORD">%1$s</xliff:g>"</string>
    <string name="wifi_auto_connect_title" msgid="1890342051674657892">"Conexão automática"</string>
    <string name="wifi_auto_connect_summary" msgid="1707702705345670370">"Permitir conexão com esta rede quando ela estiver ao alcance"</string>
    <string name="wifi_dpp_add_device" msgid="8695656122114721335">"Adicionar dispositivo"</string>
    <string name="wifi_dpp_connect_network_using_qr_code" msgid="6975258007798254937">"Use um QR code para adicionar um dispositivo a esta rede"</string>
    <string name="wifi_dpp_qr_code_is_not_valid_format" msgid="5190689503019328279">"O QR code não está em um formato válido"</string>
    <string name="retry" msgid="7542103800274026915">"Repetir"</string>
    <string name="wifi_shared" msgid="8850748923537589782">"Compartilhar com outros usuários do dispositivo"</string>
    <string name="wifi_unchanged" msgid="8026045290856150191">"(sem alteração)"</string>
    <string name="wifi_unspecified" msgid="4561964943472312208">"Selecionar"</string>
    <string name="wifi_multiple_cert_added" msgid="2151019652853383776">"Vários certificados adicionados"</string>
    <string name="wifi_use_system_certs" msgid="5587866698144996931">"Usar certificados do sistema"</string>
    <string name="wifi_do_not_provide_eap_user_cert" msgid="6336636553673065145">"Não fornecer"</string>
    <string name="wifi_trust_on_first_use" msgid="7488431582505858774">"Confiar no primeiro uso"</string>
    <string name="wifi_ssid_too_long" msgid="5961719058705013875">"O nome da rede é muito longo."</string>
    <string name="wifi_no_domain_warning" msgid="1452133316532366772">"É necessário especificar um domínio."</string>
    <string name="wifi_no_user_cert_warning" msgid="8466376918835248956">"Certificado obrigatório."</string>
    <string name="wifi_scan_always_turnon_message" msgid="2165909441512029921">"Para melhorar a precisão de local e outras finalidades, <xliff:g id="APP_NAME">%1$s</xliff:g> quer ativar a verificação de rede, mesmo que o Wi-Fi esteja desligado.\n\nPermitir isto para todos os apps que quiserem verificar?"</string>
    <string name="wifi_scan_always_turn_on_message_unknown" msgid="4903345360745717385">"Para melhorar a precisão de local e para outras finalidades, um app desconhecido quer ativar a procura de redes, mesmo com o Wi-Fi desligado.\n\nPermitir isso para todos os apps que quiserem procurar?"</string>
    <string name="wifi_scan_always_confirm_allow" msgid="4154200627800959777">"Permitir"</string>
    <string name="wifi_scan_always_confirm_deny" msgid="6997087934558839256">"Negar"</string>
    <string name="no_internet_access_text" msgid="3611993143350310936">"Esta rede não tem acesso à Internet. Permanecer conectado?"</string>
    <string name="partial_connectivity_text" msgid="8874614799723694554">"Alguns apps e serviços podem não funcionar devido à conectividade limitada. Usar mesmo assim?"</string>
    <string name="no_internet_access_remember" msgid="5113610157731269258">"Não perguntar novamente para esta rede"</string>
    <string name="lost_internet_access_title" msgid="9032463989950384698">"O Wi‑Fi não está conectado à Internet"</string>
    <string name="lost_internet_access_text" msgid="1535911323549496789">"Alterne para a rede móvel sempre que o Wi-Fi tiver uma conexão ruim. Cobranças de dados podem ser aplicadas."</string>
    <string name="lost_internet_access_switch" msgid="7935665847081706202">"Mudar para rede móvel"</string>
    <string name="lost_internet_access_cancel" msgid="1981171269794585284">"Continuar no Wi‑Fi"</string>
    <string name="lost_internet_access_persist" msgid="6813604557672782197">"Não mostrar de novo"</string>
    <string name="wifi_connect" msgid="2481467560349907397">"Conectar"</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" msgid="7450277833386859724">"Conectando…"</string>
    <string name="wifi_failed_connect_message" msgid="8538000546604347894">"Falha ao conectar à rede"</string>
    <string name="wifi_not_in_range_message" msgid="3885327464037574739">"Rede fora do alcance"</string>
    <string name="wifi_forget" msgid="3485573280364015620">"Esquecer"</string>
    <string name="wifi_modify" msgid="5127926476383659412">"Modificar"</string>
    <string name="wifi_save" msgid="2312643132472226807">"Salvar"</string>
    <string name="wifi_failed_save_message" msgid="1830279872341387120">"Falha ao salvar a rede"</string>
    <string name="wifi_cancel" msgid="6698897376888935410">"Cancelar"</string>
    <string name="wifi_forget_dialog_title" msgid="4363829200968563164">"Esquecer a rede?"</string>
    <string name="wifi_saved_access_points_summary" msgid="6637163320524940353">"{count,plural, =1{1 rede}one{# rede}other{# redes}}"</string>
    <string name="wifi_saved_passpoint_access_points_summary" msgid="8939933724918673785">"{count,plural, =1{1 assinatura}one{# assinatura}other{# assinaturas}}"</string>
    <string name="wifi_saved_all_access_points_summary" msgid="2335870101156113858">"{count,plural, =1{1 rede e assinatura}one{# rede e assinatura}other{# redes e assinaturas}}"</string>
    <string name="wifi_advanced_ssid_title" msgid="1561437650193980185">"SSID"</string>
    <string name="wifi_advanced_device_mac_address_title" msgid="6155800851233164411">"Endereço MAC do dispositivo"</string>
    <string name="wifi_advanced_randomized_mac_address_title" msgid="3930671320234553088">"Endereço MAC randomizado"</string>
    <string name="wifi_advanced_randomized_mac_address_disconnected_title" msgid="2755843130417523727">"Endereço MAC randomizado (último uso)"</string>
    <string name="wifi_details_title" msgid="222735438574597493">"Detalhes da rede"</string>
    <string name="wifi_details_subnet_mask" msgid="1619151769276260512">"Máscara de sub-rede"</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">"Endereços IPv6"</string>
    <string name="hotspot_device_details_category" msgid="3110651914598697220">"Detalhes do dispositivo de ponto de acesso"</string>
    <string name="hotspot_device_details_internet_source" msgid="1563266599673281875">"Fonte de Internet"</string>
    <string name="internet_source_wifi" msgid="6952593095166435179">"Wi-Fi"</string>
    <string name="internet_source_mobile_data" msgid="877403889449201789">"Dados móveis"</string>
    <string name="internet_source_ethernet" msgid="8338472576454100966">"Ethernet"</string>
    <string name="hotspot_battery_charging_summary" msgid="6690892148553288457">"<xliff:g id="BATTERY_PERCENTAGE">%1$s</xliff:g> ‑ Carregando"</string>
    <string name="hotspot_connection_category" msgid="4320380513982923556">"Conexão de ponto de acesso"</string>
    <string name="hotspot_connection_strength" msgid="87359986943768421">"Potência da conexão"</string>
    <string name="wifi_saved_access_points_label" msgid="5691340724310548151">"Redes salvas"</string>
    <string name="wifi_subscribed_access_points_tab" msgid="7224061396195667208">"Assinaturas"</string>
    <string name="wifi_saved_other_networks_tab" msgid="7942647415716557293">"Outras redes"</string>
    <string name="wifi_ip_settings_invalid_ip_address" msgid="3622891107865052307">"Digite um endereço IP válido."</string>
    <string name="wifi_ip_settings_invalid_gateway" msgid="1174931247370931239">"Digite um endereço de gateway válido."</string>
    <string name="wifi_ip_settings_invalid_dns" msgid="1757402215999845975">"Digite um endereço de DNS válido."</string>
    <string name="wifi_ip_settings_invalid_network_prefix_length" msgid="5980808986926987299">"Digite um tamanho do prefixo de rede entre 0 e 32."</string>
    <string name="wifi_dns1" msgid="6764769531843748514">"DNS 1 (a menos que substituído por um DNS particular)"</string>
    <string name="wifi_dns2" msgid="7273133202625326148">"DNS 2 (a menos que substituído por um DNS particular)"</string>
    <string name="wifi_gateway" msgid="3699227808616416759">"Gateway"</string>
    <string name="wifi_network_prefix_length" msgid="1003365439352276622">"Tamanho do prefixo de rede"</string>
    <string name="wifi_p2p_settings_title" msgid="1689918226469221870">"Wi-Fi Direct"</string>
    <string name="wifi_p2p_menu_search" msgid="8383306178784876840">"Pesquisar dispositivos"</string>
    <string name="wifi_p2p_menu_searching" msgid="3428767661028761100">"Pesquisando…"</string>
    <string name="wifi_p2p_menu_rename" msgid="7059994112737743336">"Renomear dispositivo"</string>
    <string name="wifi_p2p_peer_devices" msgid="5158559154640283546">"Dispositivos pareados"</string>
    <string name="wifi_p2p_remembered_groups" msgid="5497007770930525695">"Grupos lembrados"</string>
    <string name="wifi_p2p_failed_connect_message" msgid="6767831720507440027">"Não foi possível conectar."</string>
    <string name="wifi_p2p_failed_rename_message" msgid="1317434386267376606">"Falha ao renomear dispositivo."</string>
    <string name="wifi_p2p_disconnect_title" msgid="96361896458072463">"Desconectar?"</string>
    <string name="wifi_p2p_disconnect_message" msgid="1208761239498807208">"Se você desconectar, sua conexão com <xliff:g id="PEER_NAME">%1$s</xliff:g> será encerrada."</string>
    <string name="wifi_p2p_disconnect_multiple_message" msgid="4490648217799144078">"Se você se desconectar, sua conexão com <xliff:g id="PEER_NAME">%1$s</xliff:g> e <xliff:g id="PEER_COUNT">%2$s</xliff:g> outros dispositivos serão encerrados."</string>
    <string name="wifi_p2p_cancel_connect_title" msgid="8476985132989357041">"Cancelar convite?"</string>
    <string name="wifi_p2p_cancel_connect_message" msgid="2409074184473879809">"Quer cancelar o convite para se conectar com <xliff:g id="PEER_NAME">%1$s</xliff:g>?"</string>
    <string name="wifi_p2p_delete_group_message" msgid="4880242270742385699">"Esquecer este grupo?"</string>
    <string name="wifi_hotspot_checkbox_text" msgid="1549663436920597006">"Ponto de acesso Wi-Fi"</string>
    <string name="wifi_hotspot_off_subtext" msgid="2751383134504362078">"Não está compartilhando a Internet ou conteúdo com outros dispositivos"</string>
    <string name="wifi_hotspot_no_password_subtext" msgid="3685689196772398783">"Nenhuma senha definida"</string>
    <string name="wifi_hotspot_name_title" msgid="6633480190014369846">"Nome do ponto de acesso"</string>
    <string name="wifi_hotspot_password_title" msgid="9096340919454296786">"Senha do ponto de acesso"</string>
    <string name="wifi_hotspot_auto_off_title" msgid="8855711787485504882">"Desativar ponto de acesso automaticamente"</string>
    <string name="wifi_hotspot_auto_off_summary" msgid="8283656069997871354">"Quando nenhum dispositivo estiver conectado"</string>
    <string name="wifi_hotspot_maximize_compatibility" msgid="6494125684420024058">"Aumentar compatibilidade"</string>
    <string name="wifi_hotspot_maximize_compatibility_single_ap_summary" msgid="383355687431591441">"Ajuda outros dispositivos a encontrarem esse ponto de acesso. A velocidade da conexão do ponto de acesso é reduzida."</string>
    <string name="wifi_hotspot_maximize_compatibility_dual_ap_summary" msgid="3579549223159056533">"Ajuda outros dispositivos a encontrarem esse ponto de acesso. Maior uso da bateria."</string>
    <string name="wifi_hotspot_speed_title" msgid="8629448084180512685">"Velocidade e compatibilidade"</string>
    <string name="wifi_hotspot_speed_summary_2g" msgid="5063438001736234858">"2,4 GHz / Compatível com a maioria dos dispositivos"</string>
    <string name="wifi_hotspot_speed_summary_5g" msgid="6221158936983135040">"5 GHz / Compatível com muitos dispositivos"</string>
    <string name="wifi_hotspot_speed_summary_6g" msgid="8863992901226595544">"6 GHz / Compatível com poucos dispositivos"</string>
    <string name="wifi_hotspot_speed_summary_2g_and_5g" msgid="5931052946168943750">"2,4 e 5 GHz / Compatível com a maioria dos dispositivos"</string>
    <string name="wifi_hotspot_speed_intro" msgid="6973482196363758925">"Escolha uma frequência para o ponto de acesso. A frequência afeta a velocidade da conexão e o tipo de dispositivo que pode encontrar seu ponto de acesso."</string>
    <string name="wifi_hotspot_speed_category" msgid="5265655850463630286">"Frequência preferida"</string>
    <string name="wifi_hotspot_speed_2g" msgid="3400600834257664480">"2,4 GHz"</string>
    <string name="wifi_hotspot_speed_2g_summary" msgid="6930273933810520155">"Velocidades mais baixas. Compatível com a maioria dos dispositivos."</string>
    <string name="wifi_hotspot_speed_5g" msgid="4058116867148848395">"5 GHz"</string>
    <string name="wifi_hotspot_speed_5g_summary" msgid="562987935924535694">"Altas velocidades. Compatível com muitos dispositivos."</string>
    <string name="wifi_hotspot_speed_2g_5g" msgid="9192756255938408285">"2,4 e 5 GHz"</string>
    <string name="wifi_hotspot_speed_2g_5g_summary" msgid="8104575293617700173">"Altas velocidades. O ponto de acesso de banda dupla é compatível com a maioria dos dispositivos"</string>
    <string name="wifi_hotspot_speed_6g" msgid="3787697484862730500">"6 GHz"</string>
    <string name="wifi_hotspot_speed_6g_summary" msgid="8675262219242174548">"Velocidades mais altas. Compatível com poucos dispositivos."</string>
    <string name="wifi_hotspot_speed_summary_unavailable" msgid="7276080644693388756">"Não está disponível no seu país ou região"</string>
    <string name="wifi_hotspot_speed_footer" msgid="8846939503916795002">"Caso sua frequência preferida não esteja disponível, o ponto de acesso pode usar outra. As configurações de segurança do ponto de acesso poderão mudar se você modificar a frequência."</string>
    <string name="wifi_hotspot_security_summary_unavailable" msgid="117582979310345853">"Indisponível com 6 GHz"</string>
    <string name="wifi_hotspot_security_footer" msgid="4608329688744949796">"As configurações de segurança poderão mudar se você modificar a frequência do ponto de acesso"</string>
    <string name="wifi_hotspot_instant_title" msgid="7052526695338853703">"Ponto de acesso instantâneo"</string>
    <string name="wifi_hotspot_instant_summary_on" msgid="3142749148673081288">"Ativado"</string>
    <string name="wifi_hotspot_instant_summary_off" msgid="8594065628453795615">"Desativado"</string>
    <string name="wifi_tether_starting" msgid="8879874184033857814">"Ativando o ponto de acesso..."</string>
    <string name="wifi_tether_stopping" msgid="4416492968019409188">"Desativando o ponto de acesso..."</string>
    <string name="wifi_tether_carrier_unsupport_dialog_title" msgid="3089432578433978073">"Tethering indisponível"</string>
    <string name="wifi_tether_carrier_unsupport_dialog_content" msgid="5920421547607921112">"Entre em contato com sua operadora para saber mais"</string>
    <string name="wifi_tether_enabled_subtext" msgid="5085002421099821056">"A rede <xliff:g id="NETWORK_SSID">%1$s</xliff:g> está ativa"</string>
    <string name="wifi_tether_configure_ssid_default" msgid="1709397571393179300">"Ponto de acesso Android"</string>
    <string name="wifi_add_app_single_network_title" msgid="8911612806204065225">"Salvar rede?"</string>
    <string name="wifi_add_app_single_network_saving_summary" msgid="7366337245410388895">"Salvando…"</string>
    <string name="wifi_add_app_single_network_saved_summary" msgid="7135016314713158289">"Salva"</string>
    <string name="wifi_add_app_network_save_failed_summary" msgid="7223817782309294652">"Não é possível salvar. Tente novamente."</string>
    <string name="wifi_add_app_networks_title" msgid="4384594865433042851">"Salvar redes?"</string>
    <string name="wifi_add_app_networks_saving_summary" msgid="577680250954742033">"Salvando <xliff:g id="NUMBER">%d</xliff:g> redes…"</string>
    <string name="wifi_add_app_networks_saved_summary" msgid="1648417628665152905">"Redes salvas"</string>
    <string name="wifi_calling_settings_title" msgid="264665264535884440">"Chamadas por Wi-Fi"</string>
    <string name="wifi_calling_suggestion_title" msgid="4791435106729906727">"Aumentar as chamadas com Wi‑Fi"</string>
    <string name="wifi_calling_suggestion_summary" msgid="5413024679599742858">"Ativar a chamada no Wi‑Fi para aumentar a cobertura"</string>
    <string name="wifi_calling_mode_title" msgid="5145896168360825619">"Preferência de chamadas"</string>
    <string name="wifi_calling_mode_dialog_title" msgid="944146521898592440">"Preferência de chamadas"</string>
    <string name="wifi_calling_roaming_mode_title" msgid="7703305991991520773">"Preferências de roaming"</string>
    <!-- no translation found for wifi_calling_roaming_mode_summary (6061631305384464179) -->
    <skip />
    <string name="wifi_calling_roaming_mode_dialog_title" msgid="5382466713784067077">"Preferências de roaming"</string>
  <string-array name="wifi_calling_mode_choices_v2">
    <item msgid="6052353275413974742">"Wi-Fi"</item>
    <item msgid="8622872038388687383">"Celular"</item>
    <item msgid="3027927219952052398">"Somente 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">"Celular"</item>
  </string-array>
    <string name="wifi_calling_mode_wifi_preferred_summary" msgid="3240387177966098351">"Se o Wi‑Fi estiver indisponível, use a rede móvel"</string>
    <string name="wifi_calling_mode_cellular_preferred_summary" msgid="3746914244902314059">"Se a rede móvel estiver indisponível, use Wi‑Fi"</string>
    <string name="wifi_calling_mode_wifi_only_summary" msgid="3155660680014892641">"Chamar via Wi-Fi. Sem sinal do Wi‑Fi, a chamada será encerrada."</string>
    <string name="wifi_calling_off_explanation" msgid="6295526820826322895">"Quando a \"chamada no Wi-Fi\" estiver ativada, seu smartphone poderá encaminhar chamadas por redes Wi-Fi ou pela rede da sua operadora, dependendo da sua preferência e de qual sinal estiver mais forte. Antes de ativar esse recurso, verifique as taxas e outros detalhes com sua operadora.<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">"Endereço de emergência"</string>
    <string name="emergency_address_summary" msgid="3022628750270626473">"Usado como seu local quando você faz uma chamada de emergência usando o Wi‑Fi"</string>
    <string name="private_dns_help_message" msgid="851221502063782306"><annotation id="url">"Saiba mais"</annotation>" sobre recursos de DNS particular"</string>
    <string name="private_dns_mode_on" msgid="8878679071975375696">"Ativado"</string>
    <string name="wifi_calling_settings_activation_instructions" msgid="3936067355828542266">"Ativar chamada no Wi-Fi"</string>
    <string name="wifi_calling_turn_on" msgid="7687886259199428823">"Ativar chamada no 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">"Som e vibração"</string>
    <string name="account_settings" msgid="255404935489127404">"Contas"</string>
    <string name="accessibility_category_work" msgid="5133894487353964944">"Contas do perfil de trabalho - <xliff:g id="MANAGED_BY">%s</xliff:g>"</string>
    <string name="accessibility_category_personal" msgid="2228088849803484780">"Contas do perfil pessoal"</string>
    <string name="accessibility_category_clone" msgid="7893383448944567885">"Contas de perfil clonadas"</string>
    <string name="accessibility_work_account_title" msgid="7622485151217943839">"Conta de trabalho - <xliff:g id="MANAGED_BY">%s</xliff:g>"</string>
    <string name="accessibility_personal_account_title" msgid="8535265881509557013">"Conta pessoal - <xliff:g id="MANAGED_BY">%s</xliff:g>"</string>
    <string name="search_settings" msgid="7573686516434589771">"Pesquisar"</string>
    <string name="display_settings" msgid="7197750639709493852">"Tela"</string>
    <string name="accelerometer_title" msgid="7745991950833748909">"Giro automático da tela"</string>
    <string name="auto_rotate_option_off" msgid="2788096269396290731">"Desativado"</string>
    <string name="auto_rotate_option_on" msgid="5776678230808498171">"Ativado"</string>
    <string name="auto_rotate_option_face_based" msgid="3438645484087953174">"Ativ. - Reconhecimento facial"</string>
    <string name="auto_rotate_switch_face_based" msgid="9116123744601564320">"Detecção facial"</string>
    <string name="auto_rotate_link_a11y" msgid="5146188567212233286">"Saiba mais sobre o giro automático"</string>
    <string name="screen_resolution_title" msgid="2690518693139811486">"Resolução da tela"</string>
    <string name="screen_resolution_option_high" msgid="2617496842852992853">"Alta resolução"</string>
    <string name="screen_resolution_option_full" msgid="2694003735219114186">"Resolução máxima"</string>
    <string name="screen_resolution_footer" msgid="6772341522952795647">"A resolução máxima consome mais bateria. A troca de resolução pode fazer com que alguns apps sejam reiniciados."</string>
    <string name="screen_resolution_selected_a11y" msgid="6158451180032224977">"Selecionada"</string>
    <string name="color_mode_title" msgid="8666690832113906028">"Cores"</string>
    <string name="color_mode_option_natural" msgid="6192875655101283303">"Naturais"</string>
    <string name="color_mode_option_boosted" msgid="4698797857766774289">"Realçadas"</string>
    <string name="color_mode_option_saturated" msgid="3413853820158447300">"Saturadas"</string>
    <string name="color_mode_option_automatic" msgid="2281217686509980870">"Adaptáveis"</string>
    <string name="brightness" msgid="6216871641021779698">"Nível de brilho"</string>
    <string name="auto_brightness_title" msgid="4239324728760986697">"Brilho adaptável"</string>
    <string name="auto_brightness_description" msgid="6807117118142381193">"O brilho da tela será ajustado automaticamente ao seu ambiente e às suas atividades. Mova o controle deslizante para ajudar o brilho adaptável a memorizar suas preferências."</string>
    <string name="auto_brightness_summary_on" msgid="2748088951224387004">"Ativado"</string>
    <string name="auto_brightness_summary_off" msgid="8077066192887677956">"Desativado"</string>
    <string name="display_white_balance_title" msgid="2624544323029364713">"Balanço de branco da tela"</string>
    <string name="display_white_balance_summary" msgid="7625456704950209050"></string>
    <string name="fold_lock_behavior_title" msgid="786228803694268449">"Continuar usando apps com a tela dobrada"</string>
    <string name="disable_game_default_frame_rate_title" msgid="3712908601744143753">"Desativar o frame rate padrão para jogos"</string>
    <string name="disable_game_default_frame_rate_summary" msgid="4436762704707434225">"Desativar o limite máximo de frame rate para jogos em <xliff:g id="FRAME_RATE">%1$d</xliff:g> Hz."</string>
    <string name="peak_refresh_rate_title" msgid="2056355754210341011">"Smooth Display"</string>
    <string name="peak_refresh_rate_summary" msgid="3212309985294885790">"Aumenta automaticamente a taxa de atualização para <xliff:g id="ID_1">%1$d</xliff:g> Hz para alguns conteúdos. Maior uso da bateria."</string>
    <string name="force_high_refresh_rate_toggle" msgid="3325789621928312050">"Forçar taxa de atualização máxima"</string>
    <string name="force_high_refresh_rate_desc" msgid="7794566420873814875">"Maior taxa de atualização para melhoria na resposta tátil e na qualidade das animações. Maior uso da bateria."</string>
    <string name="adaptive_sleep_title" msgid="2987961991423539233">"Reconhecimento de tela em uso"</string>
    <string name="adaptive_sleep_title_no_permission" msgid="1719759921214237016">"Acesso à câmera necessário"</string>
    <string name="adaptive_sleep_summary_no_permission" msgid="5822591289468803691">"O acesso à câmera é necessário para o reconhecimento de tela em uso. Toque para gerenciar as permissões dos Serviços de personalização do dispositivo"</string>
    <string name="adaptive_sleep_manage_permission_button" msgid="1404510197847664846">"Gerenciar permissões"</string>
    <string name="adaptive_sleep_description" msgid="1835321775327187860">"Evita que a tela seja desativada se você estiver olhando para ela"</string>
    <string name="adaptive_sleep_privacy" msgid="7664570136417980556">"Usando a câmera frontal, o \"Reconhecimento de tela em uso\" detecta se alguém está olhando para a tela. Ele funciona no dispositivo, e as imagens nunca são armazenadas nem enviadas ao Google."</string>
    <string name="adaptive_sleep_contextual_slice_title" msgid="7467588613212629758">"Ativar o \"reconhecimento de tela em uso\""</string>
    <string name="adaptive_sleep_contextual_slice_summary" msgid="2993867044745446094">"Mantenha a tela ligada enquanto estiver olhando para ela"</string>
    <string name="power_consumption_footer_summary" msgid="4901490700555257237">"Um tempo limite da tela mais longo vai consumir a bateria mais rapidamente."</string>
    <string name="auto_rotate_camera_lock_title" msgid="5369003176695105872">"A câmera está bloqueada"</string>
    <string name="auto_rotate_camera_lock_summary" msgid="5699491516271544672">"Desbloqueie a câmera para usar a detecção facial"</string>
    <string name="adaptive_sleep_camera_lock_summary" msgid="8417541183603618098">"A câmera precisa ser desbloqueada para usar o reconhecimento de tela em uso"</string>
    <string name="auto_rotate_summary_no_permission" msgid="1025061139746254554">"A detecção facial precisa de acesso a câmera. Toque para gerenciar as permissões dos Serviços de personalização do dispositivo"</string>
    <string name="auto_rotate_manage_permission_button" msgid="2591146085906382385">"Gerenciar permissões"</string>
    <string name="night_display_title" msgid="8532432776487216581">"Modo noturno"</string>
    <string name="night_display_text" msgid="4789324042428095383">"O Modo noturno deixa sua tela na cor âmbar. Isso facilita olhar para a tela ou ler com pouca luz, ajudando você a adormecer com mais facilidade."</string>
    <string name="night_display_auto_mode_title" msgid="5869128421470824381">"Programação"</string>
    <string name="night_display_auto_mode_never" msgid="2721729920187175239">"Nenhuma"</string>
    <string name="night_display_auto_mode_custom" msgid="3938791496034086916">"Nos horários definidos"</string>
    <string name="night_display_auto_mode_twilight" msgid="4291855156158833997">"Do anoitecer ao amanhecer"</string>
    <string name="night_display_start_time_title" msgid="2611541851596977786">"Horário de início"</string>
    <string name="night_display_end_time_title" msgid="5243112480391192111">"Horário de término"</string>
    <string name="night_display_temperature_title" msgid="857248782470764263">"Intensidade"</string>
    <string name="night_display_summary_off_auto_mode_never" msgid="7406899634169354142">"Nunca será ativado automaticamente"</string>
    <string name="night_display_summary_off_auto_mode_custom" msgid="6667008039080687931">"Será ativada automaticamente às <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="night_display_summary_off_auto_mode_twilight" msgid="3669132200611324994">"Será ativado automaticamente ao anoitecer"</string>
    <string name="night_display_summary_on_auto_mode_never" msgid="832333009202889350">"Nunca será desativado automaticamente"</string>
    <string name="night_display_summary_on_auto_mode_custom" msgid="2096677025343425755">"Será desativado automaticamente às <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="night_display_summary_on_auto_mode_twilight" msgid="8070517472000680361">"Será desativado automaticamente ao amanhecer"</string>
    <string name="night_display_not_currently_on" msgid="6600205753103093827">"O Modo noturno está desativado"</string>
    <string name="twilight_mode_location_off_dialog_message" msgid="4559150893687124801">"A localização do dispositivo é necessária para determinar as horas de nascer e pôr do sol."</string>
    <string name="twilight_mode_launch_location" msgid="7799112373591153956">"Configurações de localização"</string>
    <string name="dark_ui_activation_on_manual" msgid="1541006734577325234">"Ativar agora"</string>
    <string name="dark_ui_activation_off_manual" msgid="2395333709291250065">"Desativar agora"</string>
    <string name="dark_ui_activation_on_auto" msgid="4824339634784765049">"Ativar até o amanhecer"</string>
    <string name="dark_ui_activation_off_auto" msgid="9136717444658505208">"Desativar até anoitecer"</string>
    <string name="dark_ui_title" msgid="3373976268671557416">"Modo escuro"</string>
    <string name="dark_ui_auto_mode_title" msgid="9027528859262295099">"Programação"</string>
    <string name="dark_ui_auto_mode_never" msgid="3980412582267787662">"Nenhuma"</string>
    <string name="dark_ui_auto_mode_auto" msgid="6658909029498623375">"Do anoitecer ao amanhecer"</string>
    <string name="dark_ui_auto_mode_custom" msgid="3800138185265182170">"Nos horários definidos"</string>
    <string name="dark_ui_auto_mode_custom_bedtime" msgid="8465023741946439266">"Na hora de dormir"</string>
    <string name="dark_ui_status_title" msgid="3505119141437774329">"Status"</string>
    <string name="dark_ui_summary_off_auto_mode_never" msgid="5828281549475697398">"Nunca será ativado automaticamente"</string>
    <string name="dark_ui_summary_off_auto_mode_auto" msgid="6766831395970887213">"Será ativado automaticamente ao anoitecer"</string>
    <string name="dark_ui_summary_off_auto_mode_custom" msgid="1345906088326708376">"Será ativado automaticamente: <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="dark_ui_summary_off_auto_mode_custom_bedtime" msgid="7759826673214624622">"Será ativado automaticamente na hora de dormir"</string>
    <string name="dark_ui_summary_on_auto_mode_never" msgid="2468597062391435521">"Nunca será desativado automaticamente"</string>
    <string name="dark_ui_summary_on_auto_mode_auto" msgid="5553376115092648636">"Será desativado automaticamente ao amanhecer"</string>
    <string name="dark_ui_summary_on_auto_mode_custom" msgid="2526935680241734784">"Será desativado automaticamente: <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="dark_ui_summary_on_auto_mode_custom_bedtime" msgid="1976993025762551246">"Será desativado automaticamente após a hora de dormir"</string>
    <string name="dark_ui_text" msgid="4392646155331126666">"O tema escuro usa um plano de fundo preto para aumentar a duração da bateria em algumas telas. Ele é ativado apenas depois que a tela for desligada."</string>
    <string name="dark_ui_bedtime_footer_summary" msgid="5576501833145170581">"O tema escuro está seguindo sua programação do Modo hora de dormir"</string>
    <string name="dark_ui_bedtime_footer_action" msgid="1493095487994054339">"Configurações do Modo hora de dormir"</string>
    <string name="even_dimmer_display_title" msgid="8589063452814896327">"Ainda mais escuro"</string>
    <string name="even_dimmer_display_summary" msgid="120301078873242172">"Permitir que o dispositivo fique mais escuro do que o normal"</string>
    <string name="screen_timeout" msgid="7709947617767439410">"Tempo limite da tela"</string>
    <string name="screen_timeout_summary" msgid="5558778019594643427">"Depois de <xliff:g id="TIMEOUT_DESCRIPTION">%1$s</xliff:g> de inatividade"</string>
    <string name="screen_timeout_summary_not_set" msgid="5107680774964178875">"Sem definição"</string>
    <string name="wallpaper_settings_title" msgid="5635129851136006383">"Plano de fundo"</string>
    <string name="style_and_wallpaper_settings_title" msgid="2232042809407308946">"Plano de fundo e estilo"</string>
    <string name="wallpaper_dashboard_summary" msgid="2324472863981057118">"Tela inicial, tela de bloqueio"</string>
    <string name="wallpaper_suggestion_title" msgid="3812842717939877330">"Alterar plano de fundo"</string>
    <string name="wallpaper_suggestion_summary" msgid="9077061486716754784">"Personalizar sua tela"</string>
    <string name="wallpaper_settings_fragment_title" msgid="8445963841717633149">"Selecionar de..."</string>
    <string name="style_suggestion_title" msgid="1213747484782364775">"Personalizar seu smartphone"</string>
    <string name="style_suggestion_summary" msgid="4271131877800968159">"Use diferentes estilos, planos de fundo e muito mais"</string>
    <string name="screensaver_settings_title" msgid="3588535639672365395">"Protetor de tela"</string>
    <string name="keywords_screensaver" msgid="7249337959432229172">"protetor de tela"</string>
    <string name="screensaver_settings_when_to_dream_bedtime" msgid="3279310576803094771">"Indisponível durante o Modo hora de dormir"</string>
    <string name="screensaver_settings_toggle_title" msgid="6194634226897244374">"Usar o protetor de tela"</string>
    <string name="screensaver_settings_summary_either_long" msgid="371949139331896271">"Ao carregar ou quando encaixado na base"</string>
    <string name="screensaver_settings_summary_dock_and_charging" msgid="8485905100159376156">"Na base e carregando"</string>
    <string name="screensaver_settings_summary_sleep" msgid="6555922932643037432">"Ao carregar"</string>
    <string name="screensaver_settings_summary_dock" msgid="6997766385189369733">"Encaixado na base"</string>
    <string name="screensaver_settings_summary_never" msgid="4988141393040918450">"Nunca"</string>
    <string name="screensaver_settings_summary_on" msgid="4210827304351483645">"Ativado / <xliff:g id="SCREEN_SAVER">%1$s</xliff:g>"</string>
    <string name="screensaver_settings_summary_off" msgid="8720357504939106923">"Desativada"</string>
    <string name="screensaver_settings_when_to_dream" msgid="8145025742428940520">"Quando começar"</string>
    <string name="lift_to_wake_title" msgid="8994218158737714046">"Levantar para ativar"</string>
    <string name="ambient_display_screen_title" msgid="8615947016991429325">"Tela ambiente"</string>
    <string name="ambient_display_category_triggers" msgid="1216640141609270011">"Quando mostrar"</string>
    <string name="doze_title" msgid="1523090408230862316">"Ativar tela para notificações"</string>
    <string name="doze_summary" msgid="8252867381522942804">"Quando a tela está escura, ela é ativada quando chegam notificações"</string>
    <string name="doze_always_on_title" msgid="7326245192352868477">"Sempre mostrar hora e informações"</string>
    <string name="doze_always_on_summary" msgid="509097829739647852">"Maior uso da bateria"</string>
    <string name="force_bold_text" msgid="4620929631102086716">"Negrito"</string>
    <string name="title_font_size" msgid="570613010306330622">"Tamanho da fonte"</string>
    <string name="short_summary_font_size" msgid="8444689613442419978">"Aumente ou diminua o texto"</string>
    <string name="sim_lock_settings" msgid="7331982427303002613">"Configurações de bloqueio do chip"</string>
    <string name="sim_lock_settings_category" msgid="6475255139493877786">"Bloqueio do chip"</string>
    <string name="sim_pin_toggle" msgid="6814489621760857328">"Bloquear chip"</string>
    <string name="sim_pin_change" msgid="5978881209990507379">"Alterar PIN do chip"</string>
    <string name="sim_enter_pin" msgid="8235202785516053253">"PIN do chip"</string>
    <string name="sim_enable_sim_lock" msgid="6486354334679225748">"Bloquear chip"</string>
    <string name="sim_disable_sim_lock" msgid="6939439812841857306">"Desbloquear chip"</string>
    <string name="sim_enter_old" msgid="6882545610939674813">"PIN do chip antigo"</string>
    <string name="sim_enter_new" msgid="9010947802784561582">"Novo PIN do chip"</string>
    <string name="sim_reenter_new" msgid="6131418271490374263">"Digitar novo PIN novamente"</string>
    <string name="sim_change_pin" msgid="1104103818545005448">"PIN do chip"</string>
    <string name="sim_invalid_pin_hint" msgid="3376397829969578877">"Digite um PIN com 4 a 8 números"</string>
    <string name="sim_pins_dont_match" msgid="1540348773896609260">"PIN diferente do anterior"</string>
    <string name="sim_change_succeeded" msgid="3516905528149069739">"PIN do chip alterado"</string>
    <string name="sim_pin_disable_failed" msgid="8719890393181032837">"Não é possível desativar o PIN."</string>
    <string name="sim_pin_enable_failed" msgid="5156513975085380284">"Não é possível ativar o PIN."</string>
    <string name="sim_enter_ok" msgid="3401715290135787531">"OK"</string>
    <string name="sim_enter_cancel" msgid="2001859323724961490">"Cancelar"</string>
    <string name="sim_change_data_title" msgid="4663239438584588847">"Usar <xliff:g id="CARRIER">%1$s</xliff:g> para dados móveis?"</string>
    <string name="sim_change_data_message" msgid="3046178883369645132">"Você está usando <xliff:g id="CARRIER2_0">%2$s</xliff:g> para dados móveis. Se alterar para <xliff:g id="CARRIER1">%1$s</xliff:g>, <xliff:g id="CARRIER2_1">%2$s</xliff:g> não será mais usada para dados móveis."</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">"Atualizar chip preferido?"</string>
    <string name="sim_preferred_message" msgid="6004009449266648351">"O <xliff:g id="NEW_SIM">%1$s</xliff:g> é o único chip no seu dispositivo. Quer usá-lo para dados móveis, chamadas e mensagens SMS?"</string>
    <string name="enable_auto_data_switch_dialog_title" msgid="3563043560556718994">"Melhorar a cobertura de dados móveis?"</string>
    <string name="enable_auto_data_switch_dialog_message" msgid="5777287241521946883">"Permita que o dispositivo mude automaticamente para a operadora <xliff:g id="BACKUP_CARRIER">%1$s</xliff:g> e use os dados móveis quando a disponibilidade melhorar."</string>
    <string name="auto_data_switch_dialog_managed_profile_warning" msgid="6839438290079866605">\n\n"Ligações, mensagens e tráfego de rede podem estar visíveis para sua organização."</string>
    <string name="wrong_pin_code_pukked" msgid="3414172752791445033">"Código PIN do chip incorreto. Entre em contato com a operadora para desbloquear o dispositivo."</string>
    <string name="wrong_pin_code" msgid="8124222991071607958">"{count,plural, =1{Código PIN do chip incorreto. Você tem # tentativa restante. Se o código correto não for digitado, vai ser necessário entrar em contato com a operadora para desbloquear o dispositivo.}one{Código PIN do chip incorreto. Você tem # tentativa restante.}other{Código PIN do chip incorreto. Você tem # tentativas restantes.}}"</string>
    <string name="wrong_pin_code_one" msgid="6924852214263071441">"Código PIN do chip incorreto. Tentativas restantes: 1. Caso o código correto não seja digitado, será necessário entrar em contato com a operadora para desbloquear o dispositivo."</string>
    <string name="pin_failed" msgid="3726505565797352255">"Falha na operação de PIN do chip."</string>
    <string name="system_update_settings_list_item_title" msgid="3398346836439366350">"Atualizações do sistema"</string>
    <string name="system_update_settings_list_item_summary" msgid="6703752298349642101"></string>
    <string name="firmware_version" msgid="1606901586501447275">"Versão do Android"</string>
    <string name="security_patch" msgid="4071756145347865382">"Atualização de segurança do Android"</string>
    <string name="model_info" msgid="8997566254717810904">"Modelo"</string>
    <string name="hardware_revision" msgid="3454709180861965025">"Versão do hardware"</string>
    <string name="manufactured_year" msgid="3401517138700926475">"Ano da fabricação"</string>
    <string name="fcc_equipment_id" msgid="6596668314025646129">"ID do equipamento"</string>
    <string name="baseband_version" msgid="2600182227599835857">"Versão da banda de base"</string>
    <string name="kernel_version" msgid="3513538109381366881">"Versão do kernel"</string>
    <string name="build_number" msgid="9009733242117579826">"Número da versão"</string>
    <string name="module_version" msgid="1787518340082046658">"Atualização do sistema do Google Play"</string>
    <string name="battery_info" msgid="7873528123969546728">"Informações da bateria"</string>
    <string name="device_info_not_available" msgid="4804474466616712326">"Não disponível"</string>
    <string name="storage_settings" msgid="7472188817781592677">"Armazenamento"</string>
    <string name="storage_settings_for_app" msgid="229425418984637483">"Armazenamento e cache"</string>
    <string name="storage_settings_title" msgid="486118156723194815">"Configurações de armazenamento"</string>
    <string name="status_eid" msgid="7532406028683438634">"EID"</string>
    <string name="eid_multi_sim" msgid="9087924808336397804">"EID (slot do chip <xliff:g id="EID_SLOT_ID">%1$d</xliff:g>)"</string>
    <string name="imei_multi_sim" msgid="9001570420423929507">"IMEI (slot para chip <xliff:g id="IMEI_SLOT_ID">%1$d</xliff:g>)"</string>
    <string name="imei_multi_sim_primary" msgid="7914653040843734282">"IMEI (slot para chip <xliff:g id="IMEI_SLOT_ID_PRIMARY">%1$d</xliff:g>, principal)"</string>
    <string name="view_saved_network" msgid="1232387673095080910">"Selecione uma rede salva para ver"</string>
    <string name="status_imei" msgid="5719752369250485007">"IMEI"</string>
    <string name="status_imei_sv" msgid="6908985558726440951">"IMEI SV"</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">"Versão do PRL"</string>
    <string name="meid_multi_sim" msgid="1460689549266621286">"MEID (slot para chip <xliff:g id="MEID_SLOT_ID">%1$d</xliff:g>)"</string>
    <string name="meid_multi_sim_primary" msgid="8921262417580407201">"MEID (slot para chip <xliff:g id="MEID_SLOT_ID_PRIMARY">%1$d</xliff:g>, principal)"</string>
    <string name="scanning_status_text_on" msgid="3846571210578042940">"Ativada"</string>
    <string name="scanning_status_text_off" msgid="4002352668313705132">"Desativada"</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 rede de dados móveis"</string>
    <string name="status_voice_network_type" msgid="8700356693062562884">"Tipo de rede de voz móvel"</string>
    <string name="status_latest_area_info" msgid="8288488664620741734">"Informações da operadora"</string>
    <string name="status_data_state" msgid="525196229491743487">"Estado da rede móvel"</string>
    <string name="status_esim_id" msgid="5158916796362809133">"EID"</string>
    <string name="status_service_state" msgid="1693424422121058791">"Status do serviço"</string>
    <string name="status_signal_strength" msgid="7644525712554444359">"Potência do sinal"</string>
    <string name="status_roaming" msgid="1253597174715663778">"Roaming"</string>
    <string name="status_operator" msgid="4335640583552058491">"Rede"</string>
    <string name="status_wifi_mac_address" msgid="4447611754614388914">"Endereço MAC da rede Wi-Fi"</string>
    <string name="status_device_wifi_mac_address" msgid="1896121694334176494">"Endereço MAC do Wi-Fi do dispositivo"</string>
    <string name="status_bt_address" msgid="6919660304578476547">"Endereço Bluetooth"</string>
    <string name="status_serial_number" msgid="9060064164331466789">"Número de série"</string>
    <string name="status_up_time" msgid="1274778533719495438">"Tempo em atividade"</string>
    <string name="battery_manufacture_date" msgid="7139426520156833987">"Data de fabricação"</string>
    <string name="battery_first_use_date" msgid="3157207331722711317">"Data do primeiro uso"</string>
    <string name="battery_cycle_count" msgid="2912949283386571900">"Contagem de ciclos"</string>
    <string name="battery_cycle_count_not_available" msgid="2426584515665184664">"Indisponível"</string>
    <string name="memory_calculating_size" msgid="3898240439798661242">"Calculando..."</string>
    <string name="storage_menu_rename" msgid="8549835371429159336">"Renomear"</string>
    <string name="storage_menu_mount" msgid="4760531872302820569">"Montar"</string>
    <string name="storage_menu_unmount" msgid="8171552487742912282">"Ejetar"</string>
    <string name="storage_menu_format" msgid="8903698999905354146">"Formatar o cartão SD"</string>
    <string name="storage_menu_format_button" msgid="7623565190643699626">"Formatar o cartão"</string>
    <string name="storage_menu_format_public" msgid="5567214442727034630">"Formatar como portátil"</string>
    <string name="storage_menu_format_option" msgid="4886059624052908432">"Formatar"</string>
    <string name="storage_menu_migrate" msgid="2196088149560070193">"Migrar dados"</string>
    <string name="storage_menu_forget" msgid="5154017890033638936">"Esquecer"</string>
    <string name="storage_menu_set_up" msgid="4401074025612064744">"Configurar"</string>
    <string name="storage_menu_free" msgid="616100170298501673">"Liberar espaço"</string>
    <string name="storage_menu_manage" msgid="7465522758801346408">"Gerenciar armazenamento"</string>
    <string name="storage_free_up_space_title" msgid="281047807372131975">"Liberar espaço"</string>
    <string name="storage_free_up_space_summary" msgid="6650027929735481350">"Acesse o app Files para gerenciar e liberar espaço"</string>
    <string name="storage_other_users" msgid="7017206190449510992">"Outros usuários"</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">"Ativação de <xliff:g id="NAME">%1$s</xliff:g> concluída"</string>
    <string name="storage_mount_failure" msgid="3667915814876418011">"Falha ao montar <xliff:g id="NAME">%1$s</xliff:g>"</string>
    <string name="storage_unmount_success" msgid="6406298575402936148">"<xliff:g id="NAME">%1$s</xliff:g> ejetado com segurança"</string>
    <string name="storage_unmount_failure" msgid="3796912279003790607">"Não foi possível ejetar <xliff:g id="NAME">%1$s</xliff:g> com segurança"</string>
    <string name="storage_rename_title" msgid="5911285992205282312">"Renomear armazenamento"</string>
    <string name="storage_dialog_unmountable" msgid="1761107904296941687">"Esse <xliff:g id="NAME_0">^1</xliff:g> está corrompido. \n\nPara utilizar o <xliff:g id="NAME_1">^1</xliff:g>, é necessário configurá-lo primeiro."</string>
    <string name="storage_internal_format_details" msgid="2399034372813686846">"Você pode formatar esse cartão SD para armazenar fotos, vídeos, músicas etc. e acessar esses itens em outros dispositivos. \n\n"<b>"Todos os dados no cartão SD vão ser apagados."</b>" \n\n"<b>"Antes de formatar"</b>" \n\n"<b>"Faça backup de fotos e de outras mídias"</b>" \nTransfira os arquivos de mídia para outro local de armazenamento neste dispositivo ou para um computador usando um cabo USB. \n\n"<b>"Faça backup de apps"</b>" \nTodos os apps armazenados neste <xliff:g id="NAME">^1</xliff:g> vão ser desinstalados, e os dados deles serão apagados. Se quiser manter esses apps, eles precisam ser transferidos para outro local de armazenamento neste dispositivo."</string>
    <string name="storage_internal_unmount_details" msgid="487689543322907311"><b>"Quando você ejetar este <xliff:g id="NAME_0">^1</xliff:g>, os apps armazenados nele deixarão de funcionar, e os arquivos de mídia não ficarão disponíveis até que ele seja inserido novamente."</b>" \n\nEste <xliff:g id="NAME_1">^1</xliff:g> é formatado para funcionar apenas neste dispositivo. Não funcionará em nenhum outro."</string>
    <string name="storage_internal_forget_details" msgid="5606507270046186691">"Para usar os apps, fotos ou dados que este <xliff:g id="NAME">^1</xliff:g> contém, insira-o novamente. \n\nVocê também pode esquecer esse armazenamento se o dispositivo não estiver disponível. \n\nSe você optar por esquecê-lo, todos os dados do dispositivo serão perdidos para sempre. \n\nÉ possível reinstalar os apps mais tarde, mas os dados armazenados neste dispositivo serão perdidos."</string>
    <string name="storage_internal_forget_confirm_title" msgid="379238668153099015">"Esquecer <xliff:g id="NAME">^1</xliff:g>?"</string>
    <string name="storage_internal_forget_confirm" msgid="5752634604952674123">"Todos os apps, fotos e dados armazenados nesse <xliff:g id="NAME">^1</xliff:g> serão perdidos permanentemente."</string>
    <string name="storage_detail_dialog_system" msgid="7461009051858709479">"O sistema inclui arquivos usados para executar a versão <xliff:g id="VERSION">%s</xliff:g> do Android"</string>
    <string name="storage_wizard_guest" msgid="5813419895687733649">"Usuários convidados não podem formatar cartões SD"</string>
    <string name="storage_wizard_format_progress_title" msgid="9170393018855949774">"Formatando <xliff:g id="NAME">^1</xliff:g>…"</string>
    <string name="storage_wizard_format_progress_body" msgid="1044024044955390417">"Não remova o <xliff:g id="NAME">^1</xliff:g> enquanto ele estiver sendo formatado."</string>
    <string name="storage_wizard_ready_title" msgid="3631022511474086605">"<xliff:g id="NAME">^1</xliff:g> formatado"</string>
    <string name="storage_wizard_move_confirm_title" msgid="6812469630804101590">"Mover <xliff:g id="APP">^1</xliff:g>"</string>
    <string name="storage_wizard_move_confirm_body" msgid="1713022828842263574">"A transferência de <xliff:g id="APP">^1</xliff:g> e seus dados para <xliff:g id="NAME_0">^2</xliff:g> levará apenas alguns momentos. Você não conseguirá usar o app até que a transferência seja concluída. \n\nNão remova o <xliff:g id="NAME_1">^2</xliff:g> durante a transferência."</string>
    <string name="storage_wizard_move_unlock" msgid="14651384927767749">"Para mover os dados é necessário desbloquear o usuário <xliff:g id="APP">^1</xliff:g>."</string>
    <string name="storage_wizard_move_progress_title" msgid="3912406225614672391">"Movendo <xliff:g id="APP">^1</xliff:g>…"</string>
    <string name="storage_wizard_move_progress_body" msgid="2396714553394935094">"Não remova o <xliff:g id="NAME">^1</xliff:g> durante a transferência. \n\nO app <xliff:g id="APP">^2</xliff:g> deste dispositivo não ficará disponível até a conclusão da transferência."</string>
    <string name="storage_wizard_init_v2_title" msgid="2538630338392381113">"Como você usará este <xliff:g id="NAME">^1</xliff:g>?"</string>
    <string name="storage_wizard_init_v2_or" msgid="5558706089661158026">"Ou"</string>
    <string name="storage_wizard_init_v2_external_title" msgid="2786416384217054112">"Formatar o cartão SD para armazenamento portátil"</string>
    <string name="storage_wizard_init_v2_external_summary" msgid="2002761631147966185">"Armazene fotos, vídeos, músicas e muito mais e acesse esses itens em outros dispositivos. &lt;a href=https://support.google.com/android/answer/12153449&gt;Saiba mais sobre como configurar um cartão SD&lt;/a&gt;."</string>
    <string name="storage_wizard_init_v2_external_action" msgid="6140058734875839081">"Formatar"</string>
    <string name="storage_wizard_init_v2_later" msgid="5366815913892609285">"Configurar mais tarde"</string>
    <string name="storage_wizard_format_confirm_v2_title" msgid="6294104100437326067">"Formatar este <xliff:g id="NAME">^1</xliff:g>?"</string>
    <string name="storage_wizard_format_confirm_v2_body" msgid="635958708974709506">"Este <xliff:g id="NAME_0">^1</xliff:g> precisa ser formatado para armazenar apps, arquivos e mídia. \n\nA formatação limpará todo o conteúdo do <xliff:g id="NAME_1">^2</xliff:g>. Faça backup em outro <xliff:g id="NAME_2">^3</xliff:g> ou dispositivo para evitar que o conteúdo seja perdido."</string>
    <string name="storage_wizard_format_confirm_v2_body_external" msgid="5810296966099830035">"Este <xliff:g id="NAME_0">^1</xliff:g> precisa ser formatado para armazenar fotos, vídeos, músicas e muito mais. \n\nA formatação vai apagar o conteúdo do <xliff:g id="NAME_1">^2</xliff:g>. Para evitar a perda de conteúdo, faça backup em outro <xliff:g id="NAME_2">^3</xliff:g> ou dispositivo."</string>
    <string name="storage_wizard_format_confirm_v2_action" msgid="5718254101386377126">"Formatar <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_migrate_v2_title" msgid="3471564531564756698">"Mover conteúdo para o <xliff:g id="NAME">^1</xliff:g>?"</string>
    <string name="storage_wizard_migrate_v2_checklist" msgid="2618258869444553060">"Durante a transferência:"</string>
    <string name="storage_wizard_migrate_v2_checklist_media" msgid="5867134681730723744">"não remova o <xliff:g id="NAME">^1</xliff:g>."</string>
    <string name="storage_wizard_migrate_v2_checklist_apps" msgid="1882077445750580783">"alguns apps não funcionarão;"</string>
    <string name="storage_wizard_migrate_v2_now" msgid="3341460117088026966">"Mover conteúdo"</string>
    <string name="storage_wizard_migrate_v2_later" msgid="6067756122853315642">"Mover conteúdo mais tarde"</string>
    <string name="storage_wizard_migrate_progress_v2_title" msgid="8791318509516968103">"Movendo conteúdo…"</string>
    <string name="storage_wizard_slow_v2_title" msgid="3760766921170980221">"<xliff:g id="NAME">^1</xliff:g> lento"</string>
    <string name="storage_wizard_slow_v2_body" msgid="7604252106419016929">"Você ainda pode usar o <xliff:g id="NAME_0">^1</xliff:g>, mas ele pode ficar lento. \n\nÉ possível que os apps armazenados no <xliff:g id="NAME_1">^2</xliff:g> não funcionem corretamente e que as transferências de conteúdo sejam mais demoradas. \n\nTente usar um <xliff:g id="NAME_2">^3</xliff:g> mais rápido ou use esse <xliff:g id="NAME_3">^4</xliff:g> apenas como armazenamento portátil."</string>
    <string name="storage_wizard_slow_v2_start_over" msgid="1806852287668077536">"Recomeçar"</string>
    <string name="storage_wizard_slow_v2_continue" msgid="7469713755893007901">"Continuar"</string>
    <string name="storage_wizard_ready_v2_external_body" msgid="7688457485389886923">"Você já pode usar o <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_ready_v2_internal_body" msgid="3520269956641115883">"Você já pode usar o <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="storage_wizard_ready_v2_internal_moved_body" msgid="1163588718127651062">"Você já pode usar o <xliff:g id="NAME">^1</xliff:g>"</string>
    <string name="battery_status_title" msgid="4661768220545945771">"Status da bateria"</string>
    <string name="battery_level_title" msgid="1371765298786083448">"Nível da bateria"</string>
    <string name="communal_settings_title" msgid="2845678473945902115">"Compartilhadas"</string>
    <string name="communal_settings_summary" msgid="4923914136953940317">"Configurações compartilhadas"</string>
    <string name="satellite_setting" msgid="706846910912477125">"Mensagem via satélite"</string>
    <string name="apn_settings" msgid="4295467389400441299">"APNs"</string>
    <string name="apn_edit" msgid="2003683641840248741">"Editar ponto de acesso"</string>
    <string name="apn_add" msgid="9069613192201630934">"Adicionar ponto de acesso"</string>
    <string name="apn_not_set" msgid="8246646433109750293">"Sem definição"</string>
    <string name="apn_not_set_for_mvno" msgid="1141490067313964640">"Não definido"</string>
    <string name="apn_name" msgid="6677695784108157953">"Nome"</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">"Porta"</string>
    <string name="apn_user" msgid="5831763936428279228">"Nome de usuário"</string>
    <string name="apn_password" msgid="7435086635953953029">"Senha"</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 MMS"</string>
    <string name="apn_mms_port" msgid="6500563737462966663">"Porta 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 autenticação"</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 roaming do APN"</string>
    <string name="carrier_enabled" msgid="664074151573150130">"Ativar/Desativar APN"</string>
    <string name="carrier_enabled_summaryOn" msgid="5212067975273903381">"APN ativado"</string>
    <string name="carrier_enabled_summaryOff" msgid="8541959867953738521">"APN desativado"</string>
    <string name="bearer" msgid="3231443241639159358">"Portador"</string>
    <string name="network_type" msgid="748590707422733595">"Tipo de rede"</string>
    <string name="network_type_unspecified" msgid="7756349656194518725">"Não especificado"</string>
    <string name="mvno_type" msgid="4734654257494971247">"Tipo de MVNO"</string>
    <string name="mvno_match_data" msgid="5213193073684321156">"Valor de MVNO"</string>
    <string name="menu_delete" msgid="9199740901584348273">"Excluir APN"</string>
    <string name="menu_new" msgid="6571230342655509006">"Novo APN"</string>
    <string name="menu_save" msgid="6611465355127483100">"Salvar"</string>
    <string name="menu_cancel" msgid="1197826697950745335">"Cancelar"</string>
    <string name="error_title" msgid="7158648377702417716"></string>
    <string name="error_duplicate_apn_entry" msgid="7792928408935276618">"Entrada APN duplicada."</string>
    <string name="error_name_empty" msgid="1258275899283079142">"O campo Nome não pode ficar vazio."</string>
    <string name="error_apn_empty" msgid="7657491065443746915">"O APN não pode estar vazio."</string>
    <string name="error_mcc_not3" msgid="883659545640179094">"O campo MCC deve ter 3 dígitos."</string>
    <string name="error_mnc_not23" msgid="7642478711158474918">"O campo MNC deve ter 2 ou 3 dígitos."</string>
    <string name="error_adding_apn_type" msgid="1324263534991467943">"A operadora não permite adicionar APNs do tipo %s."</string>
    <string name="error_mmsc_valid" msgid="8380951905485647380">"O campo MMSC não é válido."</string>
    <string name="restore_default_apn" msgid="6596048535642130689">"Restaurando as configurações APN padrão."</string>
    <string name="menu_restore" msgid="4310539620115151551">"Redefinir para o padrão"</string>
    <string name="restore_default_apn_completed" msgid="5167505087078340256">"Redefinição das configurações padrão do APN concluída."</string>
    <string name="reset_dashboard_title" msgid="7423200250697886918">"Redefinir opções"</string>
    <string name="reset_mobile_network_settings_title" msgid="5616713931258506842">"Redefinir configurações de rede móvel"</string>
    <string name="reset_mobile_network_settings_desc" msgid="7292636387692165727">"Essa ação redefine todas as configurações de rede móvel"</string>
    <string name="reset_mobile_network_settings_confirm_title" msgid="7510965634669511241">"Redefinir conf. de rede móvel?"</string>
    <string name="reset_bluetooth_wifi_title" msgid="4113071322344697317">"Redefinir Bluetooth e Wi-Fi"</string>
    <string name="reset_bluetooth_wifi_desc" msgid="4030295669083059711">"Todas as configurações de Wi-Fi e Bluetooth serão redefinidas. Não é possível desfazer essa ação."</string>
    <string name="reset_bluetooth_wifi_button_text" msgid="3974098137045963639">"Reiniciar"</string>
    <string name="reset_bluetooth_wifi_complete_toast" msgid="5893439291030574365">"O Bluetooth e o Wi-Fi foram redefinidos"</string>
    <string name="reset_esim_title" msgid="4194570573425902754">"Limpar eSIMs"</string>
    <string name="reset_esim_desc" msgid="6125192435907740751">"Essa ação não cancela seu plano de serviço móvel. Para um chip de substituição, entre em contato com a operadora."</string>
    <string name="reset_network_button_text" msgid="2281476496459610071">"Redefinir configurações"</string>
    <string name="reset_network_final_desc" msgid="5304365082065278425">"Redefinir todas as configurações de rede? Não é possível desfazer essa ação."</string>
    <string name="reset_network_final_desc_esim" msgid="1129251284212847939">"Você quer mesmo redefinir todas as configurações de rede e apagar os eSIMs salvos? Não é possível desfazer essa ação."</string>
    <string name="reset_network_final_button_text" msgid="2433867118414000462">"Redefinir configurações"</string>
    <string name="reset_network_confirm_title" msgid="913014422184481270">"Redefinir?"</string>
    <string name="network_reset_not_available" msgid="1966334631394607829">"A redefinição da rede não está disponível para esse usuário"</string>
    <string name="reset_network_complete_toast" msgid="1367872474130621115">"As configurações de rede foram redefinidas"</string>
    <string name="reset_esim_error_title" msgid="6516110227665862295">"Não é possível apagar os eSIMs"</string>
    <string name="reset_esim_error_msg" msgid="8459527827897797168">"Ocorreu um erro e os eSIMs não foram apagados.\n\nReinicie o dispositivo e tente de novo."</string>
    <string name="main_clear_title" msgid="277664302144837723">"Limpar todos os dados (redefinir para a configuração original)"</string>
    <string name="main_clear_short_title" msgid="4752094765533020696">"Limpar todos os dados"</string>
    <string name="main_clear_desc_also_erases_external" msgid="3687911419628956693"><li>"Músicas"</li>\n<li>"Fotos"</li>\n<li>"Outros dados do usuário"</li></string>
    <string name="main_clear_desc_also_erases_esim" msgid="4553469876411831729"><li>"eSIMs"</li></string>
    <string name="main_clear_desc_no_cancel_mobile_plan" msgid="369883568059127035">\n\n"Essa ação não cancelará seu plano de serviços móveis."</string>
    <string name="main_clear_final_desc" msgid="5800877928569039580">"Todas as informações pessoais e os apps baixados serão excluídos. Não é possível desfazer essa ação."</string>
    <string name="main_clear_final_desc_esim" msgid="6592404057237813989">"Todas as suas informações pessoais, inclusive apps e eSIMs baixados, serão excluídas. Não é possível desfazer essa ação."</string>
    <string name="main_clear_confirm_title" msgid="6577071819657853713">"Limpar todos os dados?"</string>
    <string name="main_clear_not_available" msgid="3433795327146684827">"A redefinição para a configuração original não está disponível para este usuário"</string>
    <string name="main_clear_progress_title" msgid="7239741132015617719">"Limpando"</string>
    <string name="main_clear_progress_text" msgid="4636695115176327972">"Aguarde…"</string>
    <string name="call_settings_title" msgid="2531072044177194164">"Conf. de chamada"</string>
    <string name="call_settings_summary" msgid="8244293779053318053">"Configurar correio voz, encaminhamento, espera etc."</string>
    <string name="tether_settings_title_usb" msgid="5926474044238409099">"Tethering USB"</string>
    <string name="tether_settings_title_wifi" msgid="4327056146425282159">"Ponto de acesso portátil"</string>
    <string name="tether_settings_title_bluetooth" msgid="8878813702520141084">"Tethering Bluetooth"</string>
    <string name="tether_settings_title_usb_bluetooth" msgid="4437274151658505496">"Tethering"</string>
    <string name="tether_settings_title_all" msgid="6807525590937697228">"Ponto de acesso e tethering"</string>
    <string name="tether_settings_summary_hotspot_on_tether_on" msgid="6110241048260139633">"Ponto de acesso e tethering ativados"</string>
    <string name="tether_settings_summary_hotspot_on_tether_off" msgid="5057598961245943644">"Ponto de acesso ativado"</string>
    <string name="tether_settings_summary_hotspot_off_tether_on" msgid="7181518138494995888">"Tethering ativado"</string>
    <string name="tether_settings_disabled_on_data_saver" msgid="9054069463426952689">"Não é possível vincular ou usar pontos de acesso portáteis enquanto a Economia de dados está ativada"</string>
    <string name="tether_settings_summary_hotspot_only" msgid="8529008147731140279">"Somente ponto de acesso"</string>
    <string name="tether_settings_summary_usb_tethering_only" msgid="6351624505239356221">"Somente USB"</string>
    <string name="tether_settings_summary_bluetooth_tethering_only" msgid="1451008625343274930">"Somente Bluetooth"</string>
    <string name="tether_settings_summary_ethernet_tethering_only" msgid="3582266687537419309">"Apenas Ethernet"</string>
    <string name="tether_settings_summary_hotspot_and_usb" msgid="5999349643653265016">"Ponto de acesso, USB"</string>
    <string name="tether_settings_summary_hotspot_and_bluetooth" msgid="810514646401708557">"Ponto de acesso, Bluetooth"</string>
    <string name="tether_settings_summary_hotspot_and_ethernet" msgid="5489192670354277152">"Ponto de acesso, Ethernet"</string>
    <string name="tether_settings_summary_usb_and_bluetooth" msgid="1355680331767261967">"USB, Bluetooth"</string>
    <string name="tether_settings_summary_usb_and_ethernet" msgid="2195017679820919905">"USB, Ethernet"</string>
    <string name="tether_settings_summary_bluetooth_and_ethernet" msgid="1015253926959211012">"Bluetooth, Ethernet"</string>
    <string name="tether_settings_summary_hotspot_and_usb_and_bluetooth" msgid="2949043525073791732">"Ponto de acesso, USB, Bluetooth"</string>
    <string name="tether_settings_summary_hotspot_and_usb_and_ethernet" msgid="5178946567323581144">"Ponto de acesso, USB, Ethernet"</string>
    <string name="tether_settings_summary_hotspot_and_bluetooth_and_ethernet" msgid="4104425838594994441">"Ponto de acesso, Bluetooth, Ethernet"</string>
    <string name="tether_settings_summary_usb_and_bluetooth_and_ethernet" msgid="5880591133984166550">"USB, Bluetooth, Ethernet"</string>
    <string name="tether_settings_summary_all" msgid="7565193614882005775">"Ponto de acesso, USB, Bluetooth, Ethernet"</string>
    <string name="tether_settings_summary_off" msgid="2526164899130351968">"Não está compartilhando a Internet com outros dispositivos"</string>
    <string name="tether_preference_summary_off" msgid="6266799346319794630">"Desativados"</string>
    <string name="usb_tethering_button_text" msgid="7364633823180913777">"Tethering USB"</string>
    <string name="bluetooth_tether_checkbox_text" msgid="6108398414967813545">"Tethering Bluetooth"</string>
    <string name="ethernet_tether_checkbox_text" msgid="959743110824197356">"Tethering Ethernet"</string>
    <string name="tethering_footer_info" msgid="6782375845587483281">"Use o ponto de acesso e tethering para que outros dispositivos possam usar a Internet pela sua conexão de dados móveis. Os apps também podem criar um ponto de acesso para compartilhar conteúdo com dispositivos por perto."</string>
    <string name="tethering_footer_info_sta_ap_concurrency" msgid="2079039077487477676">"Use o ponto de acesso e tethering para que outros dispositivos possam usar a Internet pela sua conexão de dados móveis. Os apps também podem criar um ponto de acesso para compartilhar conteúdo com dispositivos por perto."</string>
    <string name="tethering_help_button_text" msgid="2823655011510912001">"Ajuda"</string>
    <string name="network_settings_title" msgid="4663717899931613176">"Rede móvel"</string>
    <string name="sms_application_title" msgid="4791107002724108809">"App de SMS"</string>
    <string name="sms_change_default_dialog_title" msgid="2343439998715457307">"Alterar app de SMS?"</string>
    <string name="sms_change_default_dialog_text" msgid="8777606240342982531">"Usar o <xliff:g id="NEW_APP">%1$s</xliff:g> em vez do <xliff:g id="CURRENT_APP">%2$s</xliff:g> como app de SMS?"</string>
    <string name="sms_change_default_no_previous_dialog_text" msgid="6215622785087181275">"Usar o <xliff:g id="NEW_APP">%s</xliff:g> como app de SMS?"</string>
    <string name="network_scorer_change_active_dialog_title" msgid="7005220310238618141">"Alterar o Assistente de Wi-Fi?"</string>
    <string name="network_scorer_change_active_dialog_text" msgid="7006057749370850706">"Usar <xliff:g id="NEW_APP">%1$s</xliff:g> em vez de <xliff:g id="CURRENT_APP">%2$s</xliff:g> para gerenciar suas conexões de rede?"</string>
    <string name="network_scorer_change_active_no_previous_dialog_text" msgid="680685773455072321">"Usar <xliff:g id="NEW_APP">%s</xliff:g> para gerenciar suas conexões de rede?"</string>
    <string name="location_category_recent_location_requests" msgid="2205900488782832082">"Solicitações recentes"</string>
    <string name="managed_profile_location_switch_title" msgid="1265007506385460066">"Local do perfil de trabalho"</string>
    <string name="location_app_level_permissions" msgid="907206607664629759">"Permissões de acesso à localização"</string>
    <string name="location_app_permission_summary_location_off" msgid="2711822936853500335">"Localização desativada"</string>
    <string name="location_app_permission_summary_location_on" msgid="7552095451731948984">"{count,plural, =1{# app de {total} tem acesso à localização}one{# app de {total} tem acesso à localização}other{# apps de {total} têm acesso à localização}}"</string>
    <string name="location_category_recent_location_access" msgid="2558063524482178146">"Acesso recente"</string>
    <string name="location_recent_location_access_see_all" msgid="4203102419355323325">"Ver tudo"</string>
    <string name="location_recent_location_access_view_details" msgid="5803264082558504544">"Mais detalhes"</string>
    <string name="location_no_recent_apps" msgid="6814206631456177033">"Nenhum app solicitou a localização recentemente"</string>
    <string name="location_no_recent_accesses" msgid="6031735777805464247">"Nenhum app acessou a localização recentemente"</string>
    <string name="location_high_battery_use" msgid="4277318891200626524">"Uso da bateria elevado"</string>
    <string name="location_low_battery_use" msgid="5218950289737996431">"Uso da bateria reduzido"</string>
    <string name="location_scanning_wifi_always_scanning_title" msgid="5004781272733434794">"Busca por Wi-Fi"</string>
    <string name="location_scanning_wifi_always_scanning_description" msgid="6236055656376931306">"Permite que apps e serviços procurem redes Wi‑Fi a qualquer momento, mesmo quando o Wi‑Fi está desativado. Essa configuração pode ser usada, por exemplo, para melhorar recursos e serviços baseados na localização."</string>
    <string name="location_scanning_bluetooth_always_scanning_title" msgid="1809309545730215891">"Busca por Bluetooth"</string>
    <string name="location_scanning_bluetooth_always_scanning_description" msgid="5362988856388462841">"Permite que apps e serviços procurem dispositivos próximos a qualquer momento, mesmo quando o Bluetooth está desativado. Essa configuração pode ser usada, por exemplo, para melhorar recursos e serviços baseados na localização."</string>
    <string name="location_services_preference_title" msgid="604317859531782159">"Serviços de localização"</string>
    <string name="location_services_screen_title" msgid="5640002489976602476">"Serviços de localização"</string>
    <string name="location_time_zone_detection_toggle_title" msgid="6478751613645015287">"Usar a localização"</string>
    <string name="location_time_zone_detection_status_title" msgid="8903495354385600423">"Não é possível definir o fuso horário automaticamente"</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">"Localização ou Serviços de localização desativados"</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">"Localização do dispositivo necessária"</string>
    <string name="location_time_zone_detection_location_is_off_dialog_message" msgid="5846316326139169523">"Para configurar o fuso horário usando seu local, ative a localização e atualize as configurações de fuso horário"</string>
    <string name="location_time_zone_detection_location_is_off_dialog_ok_button" msgid="2685647335717750297">"Configurações de localização"</string>
    <string name="location_time_zone_provider_fix_dialog_ok_button" msgid="9026666001835079126">"Corrigir"</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">"O fuso horário automático está desativado"</string>
    <string name="location_time_zone_detection_not_applicable" msgid="6757964612836952714">"A detecção de fuso horário do local está desativada"</string>
    <string name="location_time_zone_detection_not_supported" msgid="3251181656388306501">"A detecção de fuso horário do local está indisponível"</string>
    <string name="location_time_zone_detection_not_allowed" msgid="8264525161514617051">"Não são permitidas mudanças na detecção de fuso horário do local"</string>
    <string name="location_time_zone_detection_auto_is_on" msgid="8797434659844659323">"A localização pode ser usada para definir o fuso horário"</string>
    <string name="about_settings_summary" msgid="4831942939227432513">"Ver informações legais, status, versão do software"</string>
    <string name="legal_information" msgid="7509900979811934843">"Informações legais"</string>
    <string name="manual" msgid="3651593989906084868">"Manual"</string>
    <string name="regulatory_labels" msgid="5960251403367154270">"Selos de conformidade"</string>
    <string name="safety_and_regulatory_info" msgid="8285048080439298528">"Manual de segurança e regulamentação"</string>
    <string name="copyright_title" msgid="83245306827757857">"Direitos autorais"</string>
    <string name="license_title" msgid="8745742085916617540">"Licença"</string>
    <string name="module_license_title" msgid="8705484239826702828">"Licenças de atualização do sistema do Google Play"</string>
    <string name="terms_title" msgid="2071742973672326073">"Termos e Condições"</string>
    <string name="webview_license_title" msgid="5832692241345780517">"Licença do sistema Webview"</string>
    <string name="wallpaper_attributions" msgid="4323659759250650736">"Créditos do plano de fundo"</string>
    <string name="wallpaper_attributions_values" msgid="987277439026021925">"Provedores de imagens de satélite:\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">"Ocorreu um problema ao carregar o manual."</string>
    <string name="settings_license_activity_title" msgid="7832071619364734914">"Licenças de terceiros"</string>
    <string name="settings_license_activity_unavailable" msgid="9014803774391134570">"Há um problema ao carregar as licenças."</string>
    <string name="settings_license_activity_loading" msgid="1653151990366578827">"Carregando..."</string>
    <string name="settings_safetylegal_activity_loading" msgid="1757860124583063395">"Carregando..."</string>
    <string name="lockpassword_choose_your_password_header" msgid="2407205113298094824">"Defina uma senha"</string>
    <string name="lockpassword_choose_your_profile_password_header" msgid="7038997227611893312">"Defina uma senha de trabalho"</string>
    <string name="lockpassword_choose_your_pin_header" msgid="7754265746504679473">"Defina um PIN"</string>
    <string name="lockpassword_choose_your_profile_pin_header" msgid="4581749963670819048">"Defina um PIN de trabalho"</string>
    <string name="lockpassword_choose_your_pattern_header" msgid="5674909390779586252">"Defina um padrão"</string>
    <string name="lockpassword_choose_your_pattern_description" msgid="6808109256008481046">"Para aumentar a segurança, defina um padrão para desbloquear o dispositivo"</string>
    <string name="lockpassword_choose_your_profile_pattern_header" msgid="3101811498330756641">"Definir um padrão de trabalho"</string>
    <string name="lockpassword_choose_your_password_header_for_fingerprint" msgid="3167261267229254090">"Para usar a impressão digital, defina uma senha"</string>
    <string name="lockpassword_choose_your_pattern_header_for_fingerprint" msgid="4707788269512303400">"Para usar a impressão digital, defina um padrão"</string>
    <string name="lockpassword_choose_your_pin_message" msgid="7230665212172041837">"Por segurança, defina um PIN"</string>
    <string name="lockpassword_choose_your_pin_header_for_fingerprint" msgid="2783879743691792556">"Para usar a impressão digital, defina um PIN"</string>
    <string name="lockpassword_confirm_your_password_header" msgid="6132312814563023990">"Digite sua senha novamente"</string>
    <string name="lockpassword_reenter_your_profile_password_header" msgid="3812040127714827685">"Digite sua senha de trabalho novamente"</string>
    <string name="lockpassword_confirm_your_work_password_header" msgid="4647071231702288305">"Digite sua senha de trabalho"</string>
    <string name="lockpassword_confirm_your_pattern_header" msgid="4037701363240138651">"Confirme seu padrão"</string>
    <string name="lockpassword_confirm_your_work_pattern_header" msgid="2668883108969165844">"Informe seu padrão de trabalho"</string>
    <string name="lockpassword_confirm_your_pin_header" msgid="2241722970567131308">"Digite seu PIN novamente"</string>
    <string name="lockpassword_reenter_your_profile_pin_header" msgid="2890233614560435538">"Digite seu PIN de trabalho novamente"</string>
    <string name="lockpassword_confirm_your_work_pin_header" msgid="4229765521391960255">"Digite seu PIN de trabalho"</string>
    <string name="lockpassword_confirm_passwords_dont_match" msgid="2100071354970605232">"Senha diferente da anterior"</string>
    <string name="lockpassword_confirm_pins_dont_match" msgid="1103699575489401030">"PIN diferente do anterior"</string>
    <string name="lockpassword_draw_your_pattern_again_header" msgid="1045638030120803622">"Desenhe seu padrão novamente"</string>
    <string name="lockpassword_choose_lock_generic_header" msgid="5669348379247148696">"Selecionar desbloqueio"</string>
    <string name="lockpassword_password_set_toast" msgid="6615759749393973795">"A senha foi definida"</string>
    <string name="lockpassword_pin_set_toast" msgid="5415783847198570890">"O PIN foi definido"</string>
    <string name="lockpassword_pattern_set_toast" msgid="3090582314362416762">"O padrão foi definido"</string>
    <string name="lockpassword_choose_your_password_header_for_face" msgid="622276003801157839">"Definir backup do Desbloqueio facial"</string>
    <string name="lockpassword_choose_your_pattern_header_for_face" msgid="7333603579958317102">"Definir backup do Desbloqueio facial"</string>
    <string name="lockpassword_choose_your_pin_header_for_face" msgid="704061826984851309">"Definir backup do Desbloqueio facial"</string>
    <string name="lockpassword_choose_your_password_header_for_biometrics" msgid="2053366309272487015">"Defina uma senha para usar o rosto ou a impressão digital"</string>
    <string name="lockpassword_choose_your_pattern_header_for_biometrics" msgid="4038476475293734905">"Defina um padrão para usar o rosto ou a impressão digital"</string>
    <string name="lockpassword_choose_your_pin_header_for_biometrics" msgid="9086039918921009380">"Defina um PIN para usar o rosto ou a impressão digital"</string>
    <string name="lockpassword_forgot_password" msgid="5730587692489737223">"Esqueceu sua senha?"</string>
    <string name="lockpassword_forgot_pattern" msgid="1196116549051927516">"Esqueceu seu padrão?"</string>
    <string name="lockpassword_forgot_pin" msgid="7164232234705747672">"Esqueceu seu PIN?"</string>
    <string name="lockpassword_confirm_your_pattern_generic" msgid="7401165571170203743">"Desenhe seu padrão para continuar"</string>
    <string name="lockpassword_confirm_your_pin_generic" msgid="8990266101852808091">"Digite seu PIN para continuar"</string>
    <string name="lockpassword_confirm_your_password_generic" msgid="8823867445451497224">"Digite sua senha para continuar"</string>
    <string name="lockpassword_confirm_your_pattern_generic_profile" msgid="7003851856761939690">"Desenhe seu padrão de trabalho para continuar"</string>
    <string name="lockpassword_confirm_your_pin_generic_profile" msgid="6524208128570235127">"Digite seu PIN de trabalho para continuar"</string>
    <string name="lockpassword_confirm_your_password_generic_profile" msgid="5918738487760814147">"Digite sua senha de trabalho para continuar"</string>
    <string name="lockpassword_strong_auth_required_device_pattern" msgid="113817518413715557">"Para aumentar a segurança, use o padrão do dispositivo"</string>
    <string name="lockpassword_strong_auth_required_device_pin" msgid="9163822166411129815">"Para aumentar a segurança, digite o PIN do dispositivo"</string>
    <string name="lockpassword_strong_auth_required_device_password" msgid="8310047427464299337">"Para aumentar a segurança, digite a senha do dispositivo."</string>
    <string name="lockpassword_strong_auth_required_work_pattern" msgid="6803652050512161140">"Para aumentar a segurança, use o padrão de trabalho"</string>
    <string name="lockpassword_strong_auth_required_work_pin" msgid="4208510396448713500">"Para aumentar a segurança, digite o PIN de trabalho"</string>
    <string name="lockpassword_strong_auth_required_work_password" msgid="6119482061429323090">"Para aumentar a segurança, digite a senha de trabalho"</string>
    <string name="lockpassword_confirm_your_pattern_header_frp" msgid="5641858015891896427">"Verificar padrão"</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 senha"</string>
    <string name="lockpassword_remote_validation_header" msgid="4992647285784962073">"Confirme sua identidade"</string>
    <string name="lockpassword_remote_validation_pattern_details" msgid="4655537780358707983">"Para transferir Contas do Google, configurações e muito mais, insira o padrão do seu outro dispositivo. Seu padrão está criptografado."</string>
    <string name="lockpassword_remote_validation_pin_details" msgid="2373654227583206297">"Para transferir Contas do Google, configurações e muito mais, insira o PIN do seu outro dispositivo. Seu PIN está criptografado."</string>
    <string name="lockpassword_remote_validation_password_details" msgid="3482328925925888340">"Para transferir Contas do Google, configurações e muito mais, insira a senha do seu outro dispositivo. Sua senha está criptografada."</string>
    <string name="lockpassword_remote_validation_set_pattern_as_screenlock" msgid="7595104317648465901">"Também usar o padrão para o desbloqueio"</string>
    <string name="lockpassword_remote_validation_set_pin_as_screenlock" msgid="509672303005547218">"Também usar o PIN para o desbloqueio"</string>
    <string name="lockpassword_remote_validation_set_password_as_screenlock" msgid="2066701840753591922">"Também usar a senha para o desbloqueio"</string>
    <string name="lockpassword_confirm_repair_mode_pattern_header" msgid="6669435143987988314">"Verificar padrão"</string>
    <string name="lockpassword_confirm_repair_mode_pin_header" msgid="2585263648322879131">"Verificar PIN"</string>
    <string name="lockpassword_confirm_repair_mode_password_header" msgid="3064676176428495228">"Verificar senha"</string>
    <string name="lockpassword_confirm_repair_mode_pattern_details" msgid="6187536224419477465">"Use o padrão do dispositivo para continuar"</string>
    <string name="lockpassword_confirm_repair_mode_pin_details" msgid="203022189107305807">"Insira o PIN do dispositivo para continuar"</string>
    <string name="lockpassword_confirm_repair_mode_password_details" msgid="4860219600771003873">"Insira a senha do dispositivo para continuar"</string>
    <string name="lockpassword_invalid_pin" msgid="7530854476819820600">"PIN incorreto"</string>
    <string name="lockpassword_invalid_password" msgid="1588184930542221687">"Senha incorreta"</string>
    <string name="lockpattern_need_to_unlock_wrong" msgid="8109305107409924083">"Padrão incorreto"</string>
    <string name="work_challenge_emergency_button_text" msgid="5529942788380505927">"Emergência"</string>
    <string name="lock_settings_title" msgid="665707559508132349">"Segurança do dispositivo"</string>
    <string name="lockpattern_change_lock_pattern_label" msgid="5853706275279878879">"Mudar padrão de desbloqueio"</string>
    <string name="lockpattern_change_lock_pin_label" msgid="7327409886587802756">"Mudar PIN de desbloqueio"</string>
    <string name="lockpattern_recording_intro_header" msgid="8325736706877916560">"Desenhe um padrão de desbloqueio"</string>
    <string name="lockpattern_recording_intro_footer" msgid="2656868858594487197">"Pressione Menu para obter ajuda."</string>
    <string name="lockpattern_recording_inprogress" msgid="7268008332694009191">"Tire o dedo ao terminar"</string>
    <string name="lockpattern_recording_incorrect_too_short" msgid="3351522018450593723">"Conecte pelo menos <xliff:g id="NUMBER">%d</xliff:g> pontos. Tente novamente."</string>
    <string name="lockpattern_pattern_entered_header" msgid="7709618312713127249">"Padrão registrado"</string>
    <string name="lockpattern_need_to_confirm" msgid="6489499109451714360">"Desenhe o padrão de novo para confirmar"</string>
    <string name="lockpattern_pattern_confirmed_header" msgid="2969990617475456153">"Seu novo padrão de desbloqueio"</string>
    <string name="lockpattern_confirm_button_text" msgid="6122815520373044089">"Confirmar"</string>
    <string name="lockpattern_restart_button_text" msgid="255339375151895998">"Desenhar novamente"</string>
    <string name="lockpattern_retry_button_text" msgid="4229668933251849760">"Limpar"</string>
    <string name="lockpattern_continue_button_text" msgid="5253269556259503537">"Continuar"</string>
    <string name="lockpattern_settings_title" msgid="9223165804553269083">"Padrão de desbloqueio"</string>
    <string name="lockpattern_settings_enable_title" msgid="7401197111303283723">"Exigir padrão"</string>
    <string name="lockpattern_settings_enable_summary" msgid="1116467204475387886">"É necessário desenhar o padrão para desbloquear a tela"</string>
    <string name="lockpattern_settings_enable_visible_pattern_title" msgid="3340969054395584754">"Tornar o padrão visível"</string>
    <string name="lockpattern_settings_enhanced_pin_privacy_title" msgid="7172693275721931683">"Privacidade de PIN melhorada"</string>
    <string name="lockpattern_settings_enhanced_pin_privacy_summary" msgid="8639588868341114740">"Desativar animações ao inserir o PIN"</string>
    <string name="lockpattern_settings_enable_visible_pattern_title_profile" msgid="5138189101808127489">"Tornar o padrão de perfil visível"</string>
    <string name="lockpattern_settings_enable_tactile_feedback_title" msgid="2273374883831956787">"Vibrar ao tocar"</string>
    <string name="lockpattern_settings_enable_power_button_instantly_locks" msgid="1638619728773344099">"Bloquear com botão liga/desliga"</string>
    <string name="lockpattern_settings_power_button_instantly_locks_summary" msgid="2202430156268094229">"Exceto quando estiver desbloqueado por <xliff:g id="TRUST_AGENT_NAME">%1$s</xliff:g>"</string>
    <string name="lockpattern_settings_choose_lock_pattern" msgid="2193588309557281466">"Padrão de desbloqueio"</string>
    <string name="lockpattern_settings_change_lock_pattern" msgid="7614155083815661347">"Alterar padrão"</string>
    <string name="lockpattern_settings_help_how_to_record" msgid="2093801939046625774">"Como desenhar um padrão de desbloqueio"</string>
    <string name="lockpattern_too_many_failed_confirmation_attempts" msgid="7891484005551794824">"Excesso de tentativas incorretas. Tente novamente em <xliff:g id="NUMBER">%d</xliff:g> segundos."</string>
    <string name="activity_not_found" msgid="5464331414465894254">"O app não está instalado no telefone."</string>
    <string name="lock_settings_profile_title" msgid="103605580492566086">"Segurança do perfil de trabalho"</string>
    <string name="lock_settings_profile_screen_lock_title" msgid="3776275029218681815">"Bloqueio de tela do perfil de trabalho"</string>
    <string name="lock_settings_profile_unification_title" msgid="5777961097706546513">"Usar um bloqueio"</string>
    <string name="lock_settings_profile_unification_summary" msgid="1317553536289481654">"Use um bloqueio para o perfil de trabalho e para a tela do dispositivo"</string>
    <string name="lock_settings_profile_unification_dialog_title" msgid="5163178097464820825">"Usar um bloqueio?"</string>
    <string name="lock_settings_profile_unification_dialog_body" msgid="1222905637428672355">"Seu dispositivo usará o bloqueio do perfil de trabalho. As políticas de trabalho serão aplicadas aos dois bloqueios."</string>
    <string name="lock_settings_profile_unification_dialog_uncompliant_body" msgid="8844682343443755895">"O bloqueio do seu perfil de trabalho não atende aos requisitos de segurança da sua organização. Você pode usar o mesmo bloqueio para a tela do dispositivo e para o perfil de trabalho, mas todas as políticas de bloqueio de trabalho serão aplicadas."</string>
    <string name="lock_settings_profile_unification_dialog_confirm" msgid="6276915393736137843">"Usar um bloqueio"</string>
    <string name="lock_settings_profile_unification_dialog_uncompliant_confirm" msgid="8509287115116369677">"Usar um bloqueio"</string>
    <string name="lock_settings_profile_unified_summary" msgid="777095092175037385">"Igual ao bloqueio de tela do dispositivo"</string>
    <string name="manageapplications_settings_title" msgid="9198876415524237657">"Gerenciar apps"</string>
    <string name="applications_settings" msgid="1941993743933425622">"Informações do app"</string>
    <string name="applications_settings_header" msgid="3154670675856048015">"Configurações do app"</string>
    <string name="install_applications" msgid="3921609656584369901">"Fontes desconhecidas"</string>
    <string name="install_applications_title" msgid="7890233747559108106">"Permitir todas as origens"</string>
    <string name="recent_app_category_title" msgid="189758417804427533">"Apps abertos recentemente"</string>
    <string name="see_all_apps_title" msgid="1650653853942381797">"{count,plural, =1{Mostrar todos os apps}one{Mostrar # app}other{Mostrar todos os # apps}}"</string>
    <string name="forgot_password_title" msgid="3967873480875239885">"Entre em contato com o admin. de TI"</string>
    <string name="forgot_password_text" msgid="2583194470767613163">"Ele pode ajudar você a redefinir seu PIN, seu padrão ou sua senha"</string>
    <string name="advanced_settings" msgid="2368905204839169094">"Configurações avançadas"</string>
    <string name="advanced_settings_summary" msgid="1823765348195530035">"Ativa mais opções de configuração"</string>
    <string name="application_info_label" msgid="1015706497694165866">"Informações do app"</string>
    <string name="storage_label" msgid="2522307545547515733">"Armazenamento"</string>
    <string name="auto_launch_label" msgid="4069860409309364872">"Abrir por padrão"</string>
    <string name="auto_launch_label_generic" msgid="5033137408273064599">"Padrões"</string>
    <string name="screen_compatibility_label" msgid="7549658546078613431">"Compatibilidade de tela"</string>
    <string name="permissions_label" msgid="1708927634370314404">"Permissões"</string>
    <string name="cache_header_label" msgid="2441967971921741047">"Cache (memória temporária)"</string>
    <string name="clear_cache_btn_text" msgid="8597272828928143723">"Limpar cache"</string>
    <string name="cache_size_label" msgid="313456088966822757">"Cache (memória temporária)"</string>
    <string name="uri_permissions_text" msgid="8406345863117405105">"{count,plural, =1{1 item}one{# item}other{# itens}}"</string>
    <string name="clear_uri_btn_text" msgid="4828117421162495134">"Limpar acesso"</string>
    <string name="controls_label" msgid="8671492254263626383">"Controles"</string>
    <string name="force_stop" msgid="2681771622136916280">"Forçar fechamento"</string>
    <string name="archive" msgid="9074663845068632127">"Arquivar"</string>
    <string name="restore" msgid="7622486640713967157">"Restaurar"</string>
    <string name="restoring_step_one" msgid="3465050101254272874">"Restaurando"</string>
    <string name="restoring_step_two" msgid="140484846432595108">"Restaurando."</string>
    <string name="restoring_step_three" msgid="3712883580876329811">"Restaurando…"</string>
    <string name="restoring_step_four" msgid="8966846882470446209">"Restaurando…"</string>
    <string name="total_size_label" msgid="2052185048749658866">"Total"</string>
    <string name="application_size_label" msgid="6407051020651716729">"Tamanho do app"</string>
    <string name="external_code_size_label" msgid="7375146402660973743">"App de armazenamento USB"</string>
    <string name="data_size_label" msgid="7814478940141255234">"Dados do usuário"</string>
    <string name="uninstall_text" msgid="315764653029060126">"Desinstalar"</string>
    <string name="uninstall_all_users_text" msgid="5924715251087176474">"Desinstalar para todos os usuários"</string>
    <string name="install_text" msgid="4558333621516996473">"Instalar"</string>
    <string name="disable_text" msgid="5146002260857428005">"Desativar"</string>
    <string name="enable_text" msgid="8570798764647110430">"Ativar"</string>
    <string name="clear_user_data_text" msgid="6773186434260397947">"Limpar armazenamento"</string>
    <string name="app_factory_reset" msgid="8974044931667015201">"Desinstalar atualizações"</string>
    <string name="app_restricted_settings_lockscreen_title" msgid="5993061278264872648">"Permitir configurações restritas"</string>
    <string name="auto_launch_enable_text" msgid="8912714475823807798">"Algumas atividades selecionadas por você são abertas neste app por padrão."</string>
    <string name="always_allow_bind_appwidgets_text" msgid="2069415023986858324">"Você optou por permitir que este app crie widgets e acesse os dados."</string>
    <string name="auto_launch_disable_text" msgid="502648841250936209">"Nenhum padrão definido."</string>
    <string name="clear_activities" msgid="488089228657585700">"Limpar preferências padrão"</string>
    <string name="screen_compatibility_text" msgid="5915767835411020274">"Talvez este app não seja desenvolvido para sua tela. É possível controlar o ajuste da tela aqui."</string>
    <string name="ask_compatibility" msgid="8388397595148476565">"Perguntar ao iniciar"</string>
    <string name="enable_compatibility" msgid="1163387233622859712">"Dimensionar app"</string>
    <string name="unknown" msgid="8192160131923461175">"Desconhecido"</string>
    <string name="sort_order_alpha" msgid="3400680865280266582">"Ordenar por nome"</string>
    <string name="sort_order_size" msgid="7731928486199737223">"Ordenar por tamanho"</string>
    <string name="sort_order_recent_notification" msgid="1496198895330443073">"Mais recentes"</string>
    <string name="sort_order_frequent_notification" msgid="4063700985742284794">"Mais frequentes"</string>
    <string name="show_running_services" msgid="8666008279959853318">"Mostrar serviços em exec."</string>
    <string name="show_background_processes" msgid="5682856012453562151">"Mostrar processo em cache"</string>
    <string name="default_emergency_app" msgid="1929974800666613803">"App de emergência"</string>
    <string name="reset_app_preferences" msgid="8861758340732716573">"Redefinir apps"</string>
    <string name="reset_app_preferences_title" msgid="8935136792316050759">"Redefinir apps?"</string>
    <string name="reset_app_preferences_desc" msgid="8550782670650158299">"Isso vai redefinir todas as preferências para:\n\n"<li>"Apps desativados"</li>\n<li>"Notificações de apps desativados"</li>\n<li>"Apps padrão para ações"</li>\n<li>"Restrições de dados em segundo plano para apps"</li>\n<li>"Qualquer restrição de permissão"</li>\n<li>"Configurações de uso da bateria."</li>\n\n"Você não vai perder nenhum dado do app."</string>
    <string name="reset_app_preferences_button" msgid="2591318711372850058">"Redefinir apps"</string>
    <string name="filter" msgid="9039576690686251462">"Filtro"</string>
    <string name="filter_dlg_title" msgid="3086282431958601338">"Selecione as opções de filtro"</string>
    <string name="filter_apps_all" msgid="5705421199299914620">"Todos os apps"</string>
    <string name="filter_apps_disabled" msgid="5068011814871004105">"Apps desativados"</string>
    <string name="filter_apps_third_party" msgid="9049447784849114843">"Instalados"</string>
    <string name="filter_apps_running" msgid="535465683273284141">"Rodando"</string>
    <string name="not_installed" msgid="5074606858798519449">"Não instalado para o usuário"</string>
    <string name="installed" msgid="2837449358488825884">"Instalado"</string>
    <string name="no_applications" msgid="985069304755391640">"Nenhum app"</string>
    <string name="internal_storage" msgid="999496851424448809">"Espaço interno"</string>
    <string name="recompute_size" msgid="1098091228370999128">"Recalculando o tamanho…"</string>
    <string name="clear_data_dlg_title" msgid="180446967743732410">"Excluir os dados do app?"</string>
    <string name="clear_data_dlg_text" msgid="3440011276559762619">"Os dados desse app, incluindo arquivos e configurações, serão excluídos permanentemente deste dispositivo"</string>
    <string name="dlg_ok" msgid="1421350367857960997">"OK"</string>
    <string name="dlg_cancel" msgid="5164705061530774899">"Cancelar"</string>
    <string name="dlg_delete" msgid="1790919205039397659">"Excluir"</string>
    <string name="app_not_found_dlg_text" msgid="8634675268730513704">"O app não foi encontrado na lista de apps instalados."</string>
    <string name="clear_failed_dlg_text" msgid="6866741916836125732">"Não foi possível limpar o armazenamento do app."</string>
    <string name="computing_size" msgid="4915310659841174866">"Calculando…"</string>
    <string name="invalid_size_value" msgid="7017371543563259201">"Não foi possível calcular o tamanho do pacote."</string>
    <string name="version_text" msgid="7628938665256107608">"versão <xliff:g id="VERSION_NUM">%1$s</xliff:g>"</string>
    <string name="move_app" msgid="5421158479447276791">"Mover"</string>
    <string name="archiving_failed" msgid="2037798988961634978">"Falha ao arquivar"</string>
    <string name="archiving_succeeded" msgid="7891249456483297845">"<xliff:g id="PACKAGE_LABEL">%1$s</xliff:g> arquivado"</string>
    <string name="restoring_failed" msgid="3390531747355943533">"Falha na restauração"</string>
    <string name="restoring_in_progress" msgid="7787443682651146115">"Restaurando app: <xliff:g id="PACKAGE_LABEL">%1$s</xliff:g>"</string>
    <string name="another_migration_already_in_progress" msgid="6550546307856052261">"Outra migração já está em andamento."</string>
    <string name="insufficient_storage" msgid="8115088042669030558">"Não há espaço de armazenamento suficiente."</string>
    <string name="does_not_exist" msgid="6499163879348776120">"O app não existe."</string>
    <string name="invalid_location" msgid="8013853455355520557">"O local de instalação não é válido."</string>
    <string name="system_package" msgid="7559476279008519360">"As atualizações do sistema não podem ser instaladas em mídia externa."</string>
    <string name="move_error_device_admin" msgid="1561502976834303626">"Não é possível instalar o administrador do dispositivo em uma mídia externa"</string>
    <string name="force_stop_dlg_title" msgid="86745852555490146">"Forçar fechamento?"</string>
    <string name="force_stop_dlg_text" msgid="1527286468544457368">"Se você forçar o fechamento de um app, ele pode apresentar mau funcionamento."</string>
    <string name="app_disable_dlg_positive" msgid="1414218905322009505">"Desativar app"</string>
    <string name="app_disable_dlg_text" msgid="2449382902751908916">"Se você desativar este app, o Android e outros apps poderão deixar de funcionar como deveriam. Não é possível excluir esse app porque ele veio pré-instalado no seu dispositivo. Ao optar pela desativação, você desativa esse app e o oculta no dispositivo."</string>
    <string name="app_install_details_group_title" msgid="1172114479073704677">"Loja"</string>
    <string name="app_install_details_title" msgid="7783556181897142187">"Detalhes do app"</string>
    <string name="app_install_details_summary" msgid="2013043219249992373">"App instalado da <xliff:g id="APP_STORE">%1$s</xliff:g>"</string>
    <string name="instant_app_details_summary" msgid="417197491598208216">"Mais informações em <xliff:g id="APP_STORE">%1$s</xliff:g>"</string>
    <string name="app_ops_running" msgid="6127474473137428721">"Em execução"</string>
    <string name="app_ops_never_used" msgid="9038133162371204506">"(Nunca usado)"</string>
    <string name="storageuse_settings_title" msgid="3125650750657988194">"Uso do armazenamento"</string>
    <string name="service_restarting" msgid="5104563288155809226">"Reiniciando"</string>
    <string name="cached" msgid="5379485147573438201">"Processo em segundo plano em cache"</string>
    <string name="no_running_services" msgid="9079738069349859373">"Nada em execução."</string>
    <string name="service_started_by_app" msgid="6845028506417670179">"Iniciado pelo app."</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> livre"</string>
    <string name="service_foreground_processes" msgid="6380905887193621704">"<xliff:g id="MEMORY">%1$s</xliff:g> usada"</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">"Usuário: <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="running_process_item_removed_user_label" msgid="4812732296696662613">"Usuário removido"</string>
    <string name="running_processes_item_description_s_s" msgid="6835918861352501671">"<xliff:g id="NUMPROCESS">%1$d</xliff:g> processo e <xliff:g id="NUMSERVICES">%2$d</xliff:g> serviço"</string>
    <string name="running_processes_item_description_s_p" msgid="1209371773353932361">"<xliff:g id="NUMPROCESS">%1$d</xliff:g> processo e <xliff:g id="NUMSERVICES">%2$d</xliff:g> serviços"</string>
    <string name="running_processes_item_description_p_s" msgid="8957061449107822282">"<xliff:g id="NUMPROCESS">%1$d</xliff:g> processos e <xliff:g id="NUMSERVICES">%2$d</xliff:g> serviço"</string>
    <string name="running_processes_item_description_p_p" msgid="3292999232897469679">"<xliff:g id="NUMPROCESS">%1$d</xliff:g> processos e <xliff:g id="NUMSERVICES">%2$d</xliff:g> serviços"</string>
    <string name="running_processes_header_title" msgid="558961782589967366">"Memória do dispositivo"</string>
    <string name="running_processes_header_footer" msgid="2726092156680487584">"Uso de RAM por apps"</string>
    <string name="running_processes_header_system_prefix" msgid="8819527769608555124">"Sistema"</string>
    <string name="running_processes_header_apps_prefix" msgid="4151874328324238133">"Apps"</string>
    <string name="running_processes_header_free_prefix" msgid="4271100378295864738">"Livre"</string>
    <string name="running_processes_header_used_prefix" msgid="5205762402234243007">"Em uso"</string>
    <string name="running_processes_header_cached_prefix" msgid="839132595831993521">"Em cache"</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">"App em execução"</string>
    <string name="no_services" msgid="3898812785511572899">"Não ativo"</string>
    <string name="runningservicedetails_services_title" msgid="11853795112787355">"Serviços"</string>
    <string name="runningservicedetails_processes_title" msgid="5292271587797234038">"Processos"</string>
    <string name="service_stop" msgid="5712522600201308795">"Parar"</string>
    <string name="service_manage" msgid="3896322986828332075">"Configurações"</string>
    <string name="service_stop_description" msgid="6327742632400026677">"Este serviço foi iniciado pelo app correspondente. Interrompê-lo pode provocar a falha do app."</string>
    <string name="heavy_weight_stop_description" msgid="3086419998820881290">"Não é possível interromper este app com segurança. Se ele for interrompido, alguns de seus trabalhos atuais podem ser perdidos."</string>
    <string name="background_process_stop_description" msgid="4792038933517438037">"Este é um processo de app antigo que ainda está em execução caso seja necessário novamente. Geralmente, não há motivo para interrompê-lo."</string>
    <string name="service_manage_description" msgid="6615788996428486121">"<xliff:g id="CLIENT_NAME">%1$s</xliff:g>: em uso no momento. Toque em \"Config.\" para controlá-lo."</string>
    <string name="main_running_process_description" msgid="6685973937935027773">"Processo principal em uso."</string>
    <string name="process_service_in_use_description" msgid="4210957264507014878">"O serviço <xliff:g id="COMP_NAME">%1$s</xliff:g> está em uso."</string>
    <string name="process_provider_in_use_description" msgid="6730020083976048028">"O provedor <xliff:g id="COMP_NAME">%1$s</xliff:g> está em uso."</string>
    <string name="runningservicedetails_stop_dlg_title" msgid="6201041461740445113">"Interromper o serviço do sistema?"</string>
    <string name="language_input_gesture_title" msgid="3292455685728572960">"Idiomas, entrada e gestos"</string>
    <string name="language_settings" msgid="8700174277543875046">"Idiomas e entrada"</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">"Você não tem permissão para alterar o idioma do dispositivo."</string>
    <string name="language_keyboard_settings_title" msgid="7934844313233544557">"Idiomas e entrada"</string>
    <string name="input_assistance" msgid="3437568284144952104">"Ferramentas"</string>
    <string name="keyboard_settings_category" msgid="5392847229300117064">"Teclado e métodos de entrada"</string>
    <string name="system_language" msgid="1146762166579643257">"Idiomas do sistema"</string>
    <string name="phone_language" msgid="5986939176239963826">"Idiomas"</string>
    <string name="phone_language_summary" msgid="863041222809685325"></string>
    <string name="auto_replace" msgid="4830732960264447043">"Substituição automática"</string>
    <string name="auto_replace_summary" msgid="1285443414597153423">"Corrigir palavras digitadas incorretamente"</string>
    <string name="auto_caps" msgid="5573583581288305355">"Capitalização automática"</string>
    <string name="auto_caps_summary" msgid="3144141933426846665">"Escrever a primeira letra nas sentenças com letra maiúscula"</string>
    <string name="auto_punctuate" msgid="2838809477621809507">"Pontuação automática"</string>
    <string name="hardkeyboard_category" msgid="8729780593378161071">"Configurações de teclado físico"</string>
    <string name="auto_punctuate_summary" msgid="3549190848611386748">"Pressione a tecla de Espaço duas vezes para inserir \".\""</string>
    <string name="show_password" msgid="7101900779571040117">"Mostrar senhas"</string>
    <string name="show_password_summary" msgid="9025960283785111619">"Mostrar os caracteres rapidamente enquanto você digita"</string>
    <string name="spellchecker_security_warning" msgid="2016059050608271820">"Este corretor ortográfico pode coletar todo o texto que você digita, incluindo dados pessoais, como senhas e números de cartão de crédito. É um corretor do app <xliff:g id="SPELLCHECKER_APPLICATION_NAME">%1$s</xliff:g>. Utilizar este corretor ortográfico?"</string>
    <string name="spellchecker_quick_settings" msgid="6449414356743946577">"Configurações"</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 na tela"</string>
    <string name="keywords_virtual_keyboard" msgid="1494726424879503434">"Gboard"</string>
    <string name="available_virtual_keyboard_category" msgid="6930012948152749337">"Teclado na tela disponível"</string>
    <string name="add_virtual_keyboard" msgid="2515850206289352606">"Gerenciar teclados na tela"</string>
    <string name="keyboard_options_category" msgid="8040137073401152608">"Opções"</string>
    <string name="keyboard_a11y_category" msgid="8230758278046841469">"Acessibilidade"</string>
    <string name="physical_keyboard_title" msgid="3328134097512350958">"Teclado físico"</string>
    <string name="show_ime" msgid="4334255501724746849">"Usar teclado na tela"</string>
    <string name="show_ime_summary" msgid="7293345791727205975">"Manter na tela enquanto o teclado físico estiver ativo"</string>
    <string name="bounce_keys" msgid="7419450970351743904">"Teclas de filtro"</string>
    <string name="bounce_keys_summary" msgid="7347050868868080302">"O teclado ignora pressionamentos rápidos e repetidos da mesma tecla dentro de <xliff:g id="BOUNCE_KEYS_THRESHOLD">%1$d</xliff:g> ms"</string>
    <string name="slow_keys" msgid="2891452895499690837">"Teclas lentas"</string>
    <string name="slow_keys_summary" msgid="1784371292745423292">"Ajusta o tempo que leva para um pressionamento de tecla ser ativado para <xliff:g id="SLOW_KEYS_THRESHOLD">%1$d</xliff:g> ms"</string>
    <string name="sticky_keys" msgid="7317317044898161747">"Teclas de aderência"</string>
    <string name="sticky_keys_summary" msgid="1844953803625480623">"Pressione uma tecla por vez para usar atalhos em vez de manter as teclas pressionadas juntas"</string>
    <string name="keyboard_shortcuts_helper" msgid="2553221039203165344">"Atalhos do teclado"</string>
    <string name="keyboard_shortcuts_helper_summary" msgid="5979507677602559203">"Mostrar lista de atalhos"</string>
    <string name="language_and_input_for_work_category_title" msgid="2546950919124199743">"Teclados e ferramentas de perfil de trabalho"</string>
    <string name="virtual_keyboards_for_work_title" msgid="786459157034008675">"Teclado na tela para o trabalho"</string>
    <string name="keyboard_default_layout" msgid="5377811770620422301">"Padrão"</string>
    <string name="trackpad_settings" msgid="2071131324087677005">"Touchpad"</string>
    <string name="trackpad_mouse_settings" msgid="136226693583218429">"Touchpad e mouse"</string>
    <string name="trackpad_settings_summary" msgid="3369855644136760402">"Velocidade do cursor, gestos"</string>
    <string name="trackpad_tap_to_click" msgid="1938230946542070746">"Tocar para clicar"</string>
    <string name="trackpad_touchpad_gesture_title" msgid="7568052847609914436">"Gestos do touchpad"</string>
    <string name="trackpad_touchpad_gesture_summary" msgid="6256074591395359124">"Personalize gestos individuais de navegação do touchpad"</string>
    <string name="trackpad_reverse_scrolling_title" msgid="422877284529360866">"Rolagem reversa"</string>
    <string name="trackpad_reverse_scrolling_summary" msgid="6048648562887499036">"O conteúdo vai para cima quando você rola a tela para baixo"</string>
    <string name="trackpad_bottom_right_tap_title" msgid="6275428879042702880">"Toque no canto inferior direito"</string>
    <string name="trackpad_bottom_right_tap_summary" msgid="8734094086900680674">"Toque no canto inferior direito do touchpad para mais opções"</string>
    <string name="trackpad_pointer_speed" msgid="7786579408631352625">"Velocidade do cursor"</string>
    <string name="trackpad_touch_gesture" msgid="8641725062131922497">"Aprender gestos do touchpad"</string>
    <string name="keywords_touchpad" msgid="8159846254066666032">"trackpad, track pad, mouse, cursor, rolar, deslizar, clicar com o botão direito do mouse, clicar, ponteiro"</string>
    <string name="keywords_trackpad_bottom_right_tap" msgid="1285062446073929305">"clicar com o botão direito do mouse, tocar"</string>
    <string name="gesture_title_go_home" msgid="3682238648647225933">"Ir para a tela inicial"</string>
    <string name="gesture_summary_go_home" msgid="6409031586904205741">"Deslize para cima com três dedos em qualquer lugar do touchpad"</string>
    <string name="gesture_title_go_back" msgid="6619462058488419802">"Voltar"</string>
    <string name="gesture_summary_go_back" msgid="4981604277892236888">"Deslize da esquerda ou direita com três dedos"</string>
    <string name="gesture_title_recent_apps" msgid="6082688963233208761">"Conferir os apps recentes"</string>
    <string name="gesture_summary_recent_apps" msgid="6643179135202417509">"Deslize para cima com três dedos, segure e depois solte"</string>
    <string name="gesture_title_notifications" msgid="791717222472350194">"Abrir notificações e Configurações rápidas"</string>
    <string name="gesture_summary_notifications" msgid="8419514601638387255">"Deslize para baixo com três dedos na tela inicial"</string>
    <string name="gesture_title_switch_apps" msgid="5840994412037872157">"Mudar de app"</string>
    <string name="gesture_summary_switch_apps" msgid="6842648062151413042">"Deslize para a esquerda ou direita com quatro dedos"</string>
    <string name="gesture_button_skip" msgid="5174842083451193213">"Pular"</string>
    <string name="gesture_button_next" msgid="695288092704187356">"Próxima"</string>
    <string name="gesture_button_restart" msgid="1895850891992530133">"Reiniciar"</string>
    <string name="gesture_button_done" msgid="6387900351203032188">"Concluído"</string>
    <string name="trackpad_go_back_title" msgid="5312164160947491440">"Voltar"</string>
    <string name="trackpad_go_back_summary" msgid="4201901101085902768">"Deslize para a esquerda ou direita com três dedos"</string>
    <string name="trackpad_go_home_title" msgid="2146525662148291552">"Ir para a página inicial"</string>
    <string name="trackpad_go_home_summary" msgid="2222744701528360887">"Deslize para cima com três dedos"</string>
    <string name="trackpad_recent_apps_title" msgid="8195970908411585445">"Apps recentes"</string>
    <string name="trackpad_recent_apps_summary" msgid="2685092851677573794">"Deslize para cima com três dedos, sem soltar"</string>
    <string name="trackpad_notifications_title" msgid="3521663305043747880">"Notificações"</string>
    <string name="trackpad_notifications_summary" msgid="7663647367648690040">"Deslize para baixo com três dedos"</string>
    <string name="trackpad_switch_apps_title" msgid="7342032935377284039">"Mudar de app"</string>
    <string name="trackpad_switch_apps_summary" msgid="9193942041912927440">"Deslize para a esquerda ou direita com quatro dedos"</string>
    <string name="modifier_keys_settings" msgid="2537108435032034683">"Teclas modificadoras"</string>
    <string name="modifier_keys_settings_summary" msgid="6933143361657444436">"Mudar o comportamento das teclas"</string>
    <string name="modifier_keys_reset_title" msgid="948294258402761066">"Redefinir tudo"</string>
    <string name="modifier_keys_default_summary" msgid="8701640508670973258">"Padrão"</string>
    <string name="modifier_keys_reset_message" msgid="5236994817619936058">"Tem certeza de que quer redefinir todas as teclas modificadoras para o padrão?"</string>
    <string name="modifier_keys_done" msgid="8196199314913909700">"Concluído"</string>
    <string name="modifier_keys_cancel" msgid="7136520252570826772">"Cancelar"</string>
    <string name="modifier_keys_reset" msgid="551170906710422041">"Redefinir"</string>
    <string name="modifier_keys_picker_title" msgid="244545904150587851">"Escolher a tecla modificadora"</string>
    <string name="modifier_keys_picker_summary" msgid="739397232249560785">"Escolha uma nova tecla para <xliff:g id="MODIFIER_KEY_DEFAULT_NAME">%1$s</xliff:g>:"</string>
    <string name="ime_label_title" msgid="8994569521516807168">"Layout do <xliff:g id="IME_LABEL">%s</xliff:g>"</string>
    <string name="default_keyboard_layout" msgid="8690689331289452201">"Padrão"</string>
    <string name="automatic_keyboard_layout_label" msgid="9138088156046198913">"Automático: <xliff:g id="LAYOUT_LABEL">%s</xliff:g>"</string>
    <string name="user_selected_keyboard_layout_label" msgid="154742505924555156">"Usuário selecionado: <xliff:g id="LAYOUT_LABEL">%s</xliff:g>"</string>
    <string name="speech_category_title" msgid="5995161659186229742">"Fala"</string>
    <string name="pointer_speed" msgid="7398649279282675718">"Velocidade do cursor"</string>
    <string name="game_controller_settings_category" msgid="8557472715034961918">"Controlador de jogos"</string>
    <string name="vibrate_input_devices" msgid="5192591087864449142">"Redirecionar vibração"</string>
    <string name="vibrate_input_devices_summary" msgid="8791680891376689823">"Enviar vibração para o controlador de jogo quando conectado"</string>
    <string name="keyboard_layout_dialog_title" msgid="8770130364048089954">"Escolha o layout do teclado"</string>
    <string name="keyboard_layout_dialog_setup_button" msgid="6546245862744626706">"Configurar os layouts do teclado"</string>
    <string name="keyboard_layout_dialog_switch_hint" msgid="3303564123674979354">"Para alterar, pressione Ctrl+espaço"</string>
    <string name="keyboard_layout_default_label" msgid="6078569989261528039">"Padrão"</string>
    <string name="keyboard_layout_picker_title" msgid="240504762718562906">"Layouts de teclado"</string>
    <string name="keyboard_layout_picker_category_title" msgid="2369473692906329772">"Layouts de teclado físico"</string>
    <string name="user_dict_settings_title" msgid="680410651924276991">"Dicionário pessoal"</string>
    <string name="user_dict_settings_for_work_title" msgid="1245315720684961770">"Dicionário pessoal para o trabalho"</string>
    <string name="user_dict_settings_summary" msgid="4939694372338975081">"Adiciona palavras para que sejam usadas em apps como o corretor ortográfico"</string>
    <string name="user_dict_settings_add_menu_title" msgid="8046882347281382968">"Adicionar"</string>
    <string name="user_dict_settings_add_dialog_title" msgid="3485845465134083084">"Adicionar ao dicionário"</string>
    <string name="user_dict_settings_add_screen_title" msgid="1866408024073475379">"Frase"</string>
    <string name="user_dict_settings_add_dialog_more_options" msgid="2642928746425808108">"Mais opções"</string>
    <string name="user_dict_settings_add_dialog_less_options" msgid="100432503633458156">"Menos opções"</string>
    <string name="user_dict_settings_add_dialog_confirm" msgid="1866751313790655088">"OK"</string>
    <string name="user_dict_settings_add_word_option_name" msgid="2686051785623698231">"Palavra:"</string>
    <string name="user_dict_settings_add_shortcut_option_name" msgid="5722204336242646866">"Atalho:"</string>
    <string name="user_dict_settings_add_locale_option_name" msgid="2117468247460253346">"Idioma:"</string>
    <string name="user_dict_settings_add_word_hint" msgid="4560494723256242785">"Digite uma palavra"</string>
    <string name="user_dict_settings_add_shortcut_hint" msgid="6209624157217434640">"Atalho opcional"</string>
    <string name="user_dict_settings_edit_dialog_title" msgid="316493656442362284">"Editar palavra"</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">"Excluir"</string>
    <string name="user_dict_settings_empty_text" msgid="86562873609647919">"Você não tem nenhuma palavra no dicionário do usuário. Para adicionar uma palavra, toque no botão de adição (+)."</string>
    <string name="user_dict_settings_all_languages" msgid="8563387437755363526">"Para todos os idiomas"</string>
    <string name="user_dict_settings_more_languages" msgid="5378870726809672319">"Mais idiomas..."</string>
    <string name="testing" msgid="6294172343766732037">"Testando"</string>
    <string name="keyboard_settings_summary" msgid="9188442758316476986">"Teclado na tela e ferramentas"</string>
    <string name="keyboard_settings_with_physical_keyboard_summary" msgid="2240779804018260938">"Teclado na tela, teclado físico e ferramentas"</string>
    <string name="builtin_keyboard_settings_title" msgid="5096171620714179661">"Teclado físico"</string>
    <string name="enabled_locales_keyboard_layout" msgid="3939886151098958639">"Layout"</string>
    <string name="gadget_picker_title" msgid="7615902510050731400">"Escolher o gadget"</string>
    <string name="widget_picker_title" msgid="7641298325488989676">"Escolher widget"</string>
    <string name="allow_bind_app_widget_activity_allow_bind_title" msgid="3537968409832846255">"Criar widget e permitir acesso?"</string>
    <string name="allow_bind_app_widget_activity_allow_bind" msgid="5825298768068148804">"Após a criação do widget, o aplicativo poderá acessar todos os itens exibidos na tela.\n\nAplicativo: <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">"Sempre permitir que <xliff:g id="WIDGET_HOST_NAME">%1$s</xliff:g> crie widgets e acesse os dados"</string>
    <string name="testing_usage_stats" msgid="4660643799010906365">"Estatísticas de uso"</string>
    <string name="usage_stats_sort_by_usage_time" msgid="2927310334119998301">"Ordenar por tempo de uso"</string>
    <string name="usage_stats_sort_by_last_time_used" msgid="7039213339779884017">"Ordenar pelo último uso"</string>
    <string name="usage_stats_sort_by_app_name" msgid="4463833145514850478">"Ordenar por nome do app"</string>
    <string name="last_time_used_label" msgid="7589377271406011659">"Último uso"</string>
    <string name="last_time_used_never" msgid="2936073559267990034">"nunca"</string>
    <string name="usage_time_label" msgid="9105343335151559883">"Tempo de uso"</string>
    <string name="accessibility_settings" msgid="4713215774904704682">"Acessibilidade"</string>
    <string name="accessibility_settings_title" msgid="6739115703615065716">"Configurações de acessibilidade"</string>
    <string name="accessibility_settings_summary" msgid="2366627644570558503">"Exibição, interação, áudio"</string>
    <string name="vision_settings_title" msgid="8919983801864103069">"Configuração visual"</string>
    <string name="vision_settings_description" msgid="7614894785054441991">"Você pode personalizar este dispositivo do jeito que quiser. Esses recursos de acessibilidade podem ser alterados depois nas Configurações."</string>
    <string name="vision_settings_suggestion_title" msgid="4689275412658803919">"Mudar o tamanho da fonte"</string>
    <string name="screen_reader_category_title" msgid="5825700839731107803">"Leitor de tela"</string>
    <string name="keyboard_category_title" msgid="6841712758039893220">"Opções de teclado físico"</string>
    <string name="captions_category_title" msgid="574490148949400274">"Legendas"</string>
    <string name="audio_category_title" msgid="5283853679967605826">"Áudio"</string>
    <string name="general_category_title" msgid="6298579528716834157">"Geral"</string>
    <string name="display_category_title" msgid="6638191682294461408">"Exibição"</string>
    <string name="accessibility_color_and_motion_title" msgid="2323301706545305874">"Cor e movimento"</string>
    <string name="accessibility_color_contrast_title" msgid="5757724357142452378">"Contraste de cor"</string>
    <string name="accessibility_color_contrast_intro" msgid="7795090401101214930">"Um contraste mais alto faz com que o texto, os botões e os ícones se destaquem. Escolha o contraste mais adequado para você."</string>
    <string name="color_contrast_note" msgid="7592686603372566198">"É possível que alguns apps ainda não tenham suporte a todas as configurações de contraste de cor e texto"</string>
    <string name="accessibility_color_contrast_summary" msgid="7563237683500106632">"Ajuste a aparência das cores e do texto em relação à cor do plano de fundo"</string>
    <string name="color_contrast_preview" msgid="6791430227535363883">"Prévia"</string>
    <string name="color_contrast_preview_sender_name" msgid="8641943417589238147">"Helen, Adam"</string>
    <string name="color_contrast_preview_email_send_date" msgid="2108702726171600080">"há 2 dias"</string>
    <string name="color_contrast_preview_email_badge" msgid="4845484039428505392">"Acompanhar?"</string>
    <string name="color_contrast_preview_email_title" msgid="198712116139754823">"Relatório de viagem de negócios"</string>
    <string name="color_contrast_preview_email_body" msgid="4139331665325624199">"Entre em contato \ncomigo ou com a Helen para receber ajuda. Este relatório será"</string>
    <string name="color_contrast_preview_email_attachment_name" msgid="852407311884814746">"Despesas de clientes"</string>
    <string name="accessibility_turn_screen_darker_title" msgid="5986223133285858349">"Escurecer a tela"</string>
    <string name="interaction_control_category_title" msgid="2696474616743882372">"Controles de interação"</string>
    <string name="accessibility_tap_assistance_title" msgid="1058913033421048284">"Controles de marcação de tempo"</string>
    <string name="accessibility_system_controls_title" msgid="6403287349518987624">"Controles do sistema"</string>
    <string name="user_installed_services_category_title" msgid="2639470729311439731">"Apps baixados"</string>
    <string name="experimental_category_title" msgid="898904396646344152">"Experimentais"</string>
    <string name="feature_flags_dashboard_title" msgid="348990373716658289">"Sinalizações de recursos"</string>
    <string name="bt_hci_snoop_log_filters_dashboard_title" msgid="401330708633716596">"Filtro do registro de espionagem de HCI Bluetooth"</string>
    <string name="bt_hci_snoop_log_filters_dashboard_summary" msgid="1319792184194176235">"Definir filtros"</string>
    <string name="bt_hci_snoop_log_filters_dashboard_footer" msgid="4158945851818483666">"Desative e ative o Bluetooth para que as mudanças entrem em vigor"</string>
    <string name="bt_hci_snoop_log_filter_pbap_title" msgid="1735427364451634823">"Registro de espionagem de HCI Bluetooth filtrando PBAP"</string>
    <string name="bt_hci_snoop_log_filter_map_title" msgid="180092480793945544">"Registro de espionagem de HCI Bluetooth filtrando MAP"</string>
    <string name="bt_hci_snoop_log_filter_summary" msgid="7217091930762522599">"Defina o modo de filtragem. Desative e ative o Bluetooth para que as mudanças entrem em vigor"</string>
    <string name="bt_hci_snoop_log_filtered_mode_disabled_summary" msgid="8824952559433361848">"Defina o modo de registro de espionagem de HCI Bluetooth como \"Filtro ativado\" para mudar essa opção"</string>
    <string name="talkback_title" msgid="8756080454514251327">"Talkback"</string>
    <string name="talkback_summary" msgid="5820927220378864281">"Leitor de tela, usado principalmente para pessoas com deficiência visual total ou parcial"</string>
    <string name="select_to_speak_summary" msgid="1995285446766920925">"Toque nos itens da tela para ouvir a leitura em voz alta"</string>
    <string name="accessibility_captioning_title" msgid="4561871958958925225">"Preferências de legenda"</string>
    <string name="accessibility_captioning_about_title" msgid="3542171637334191563">"Sobre as preferências de legenda"</string>
    <string name="accessibility_captioning_footer_learn_more_content_description" msgid="5730040700677017706">"Saiba mais sobre as preferências de legenda"</string>
    <string name="accessibility_screen_magnification_title" msgid="1211169976144629087">"Ampliação"</string>
    <string name="accessibility_screen_magnification_shortcut_title" msgid="2387963646377987780">"Atalho para ampliação"</string>
    <string name="accessibility_screen_magnification_follow_typing_title" msgid="6379517513916651560">"Ampliar digitação"</string>
    <string name="accessibility_screen_magnification_follow_typing_summary" msgid="2882250257391761678">"A lupa acompanha o texto enquanto você digita"</string>
    <string name="accessibility_screen_magnification_always_on_title" msgid="3814297443759580936">"Manter ativada quando mudar de app"</string>
    <string name="accessibility_screen_magnification_always_on_summary" msgid="306908451430863049">"A lupa fica ativada e diminui o zoom ao trocar de app"</string>
    <string name="accessibility_screen_magnification_joystick_title" msgid="1803769708582404964">"Joystick"</string>
    <string name="accessibility_screen_magnification_joystick_summary" msgid="4640300148573982720">"Ative e mova a lupa com um joystick na tela. Toque e mantenha, depois arraste o joystick para controlar a lupa. Toque e arraste para mover o joystick."</string>
    <string name="accessibility_screen_magnification_about_title" msgid="8857919020223505415">"Sobre a ampliação"</string>
    <string name="accessibility_screen_magnification_footer_learn_more_content_description" msgid="924848332575978463">"Saiba mais sobre a ampliação"</string>
    <string name="accessibility_magnification_mode_title" msgid="8446475127807168063">"Tipo de ampliação"</string>
    <string name="accessibility_magnification_area_settings_message" msgid="8498648925928109462">"Ampliar toda a tela, uma área específica ou alternar entre as duas opções"</string>
    <string name="accessibility_magnification_area_settings_full_screen_summary" msgid="2728962784113713010">"Tela cheia"</string>
    <string name="accessibility_magnification_area_settings_window_screen_summary" msgid="9191632962955877019">"Tela parcial"</string>
    <string name="accessibility_magnification_area_settings_all_summary" msgid="8107511976748799455">"Alternar entre tela cheia e tela parcial"</string>
    <string name="accessibility_magnification_mode_dialog_title" msgid="9151027667059878578">"Escolher o tipo de ampliação"</string>
    <string name="accessibility_magnification_mode_dialog_option_full_screen" msgid="4892487869954032029">"Ampliar toda a tela"</string>
    <string name="accessibility_magnification_mode_dialog_option_window" msgid="4492443201099153362">"Ampliar parte da tela"</string>
    <string name="accessibility_magnification_mode_dialog_option_switch" msgid="561043521011229424">"Alternar entre tela cheia e tela parcial"</string>
    <string name="accessibility_magnification_area_settings_mode_switch_summary" msgid="2885238806099080966">"Toque no botão para alternar entre as duas opções"</string>
    <string name="accessibility_magnification_switch_shortcut_title" msgid="3671432048806533079">"Mudar para o botão de acessibilidade?"</string>
    <string name="accessibility_magnification_switch_shortcut_message" msgid="7718653917415163833">"O uso do toque triplo para ampliar parte da tela deixará a digitação e outras ações mais lentas.\n\nO botão de acessibilidade aparecerá na tela sobre outros apps. Toque nele para ampliar."</string>
    <string name="accessibility_magnification_switch_shortcut_positive_button" msgid="2446942190957296957">"Mudar para o botão de acessibilidade"</string>
    <string name="accessibility_magnification_switch_shortcut_negative_button" msgid="7115794462123071594">"Usar o toque triplo"</string>
    <string name="accessibility_magnification_triple_tap_warning_title" msgid="8484669851397296597">"Seu teclado pode ficar mais lento"</string>
    <string name="accessibility_magnification_triple_tap_warning_message" msgid="2008671502848936410">"Ao usar o toque triplo para ampliar parte da tela, talvez você encontre algum problema no teclado.\n\nPara evitar isso, mude o atalho de ampliação do toque triplo para outro comando.\n"<annotation id="link">"Mudar configuração"</annotation></string>
    <string name="accessibility_magnification_triple_tap_warning_positive_button" msgid="8712304035901450010">"Continuar mesmo assim"</string>
    <string name="accessibility_magnification_triple_tap_warning_negative_button" msgid="2028849736366584733">"Cancelar"</string>
    <string name="accessibility_magnification_service_settings_title" msgid="3531350704632316017">"Configurações de ampliação"</string>
    <string name="accessibility_screen_magnification_navbar_title" msgid="480853328665484528">"Ampliar com atalho"</string>
    <string name="accessibility_screen_magnification_state_navbar_gesture" msgid="8067042663897802231">"Ampliar com atalho e toque triplo"</string>
    <string name="accessibility_introduction_title" msgid="8834950581512452348">"Sobre <xliff:g id="SERVICE">%1$s</xliff:g>"</string>
    <string name="accessibility_text_reading_options_title" msgid="3224648909213325563">"Texto e tamanho de exibição"</string>
    <string name="accessibility_text_reading_options_suggestion_title" msgid="2492155642665312733">"Mudar a exibição do texto"</string>
    <string name="accessibility_text_reading_preview_mail_subject" msgid="4597374768612733616">"Assunto: Tipos de balões de ar quente"</string>
    <string name="accessibility_text_reading_preview_mail_from" msgid="1797499780365288020">"De: Bruno"</string>
    <string name="accessibility_text_reading_preview_mail_content" msgid="8078152365771951802">"Bom dia.\n\nEu só queria saber como a criação dos designs está indo. Eles vão estar prontos antes de começarmos a criar os novos balões?"</string>
    <string name="accessibility_text_reading_reset_button_title" msgid="5960753279788187669">"Redefinir configurações"</string>
    <string name="accessibility_text_reading_reset_message" msgid="824644303661026712">"As definições de tamanho e texto da tela foram redefinidas"</string>
    <string name="accessibility_text_reading_confirm_dialog_title" msgid="2865331351355690389">"Redefinir o texto e o tamanho da tela?"</string>
    <string name="accessibility_text_reading_confirm_dialog_reset_button" msgid="8215800137850243736">"Redefinir"</string>
    <string name="accessibility_text_reading_conversation_message_1" msgid="7883952203831957831">"Algum plano para o fim de semana?"</string>
    <string name="accessibility_text_reading_conversation_message_2" msgid="8112160435318635856">"Vou para a praia. Quer ir também?"</string>
    <string name="accessibility_screen_option" msgid="8465307075278878145">"Opções"</string>
    <string name="accessibility_preference_magnification_summary" msgid="2875518904115896888">"Aumentar o zoom na tela"</string>
    <string name="accessibility_screen_magnification_short_summary" msgid="2207048420669939150">"Tocar três vezes para ampliar"</string>
    <string name="accessibility_screen_magnification_navbar_short_summary" msgid="4885018322430052037">"Toque em um botão para aplicar zoom"</string>
    <string name="accessibility_screen_magnification_intro_text" msgid="3856180549393526339">"Aplique zoom rapidamente na tela para ampliar o conteúdo"</string>
    <string name="accessibility_screen_magnification_summary" msgid="8267672508057326959">"&lt;b&gt;Para aumentar o zoom, faça o seguinte:&lt;/b&gt;&lt;br/&gt; {0,number,integer}. Use o atalho para iniciar a ampliação.&lt;br/&gt; {1,number,integer}. Toque na tela.&lt;br/&gt; {2,number,integer}. Arraste dois dedos para navegar pela tela.&lt;br/&gt; {3,number,integer}. Faça um gesto de pinça com dois dedos para ajustar o zoom.&lt;br/&gt; {4,number,integer}. Use o atalho para interromper a ampliação.&lt;br/&gt;&lt;br/&gt; &lt;b&gt;Se quiser aumentar o zoom temporariamente, faça o seguinte:&lt;/b&gt;&lt;br/&gt; {0,number,integer}. Confira se o tipo de ampliação está definido como tela cheia.&lt;br/&gt; {1,number,integer}. Use o atalho para iniciar a ampliação.&lt;br/&gt; {2,number,integer}. Toque em qualquer lugar da tela e a mantenha pressionada.&lt;br/&gt; {3,number,integer}. Arraste o dedo para navegar pela tela.&lt;br/&gt; {4,number,integer}. Solte para interromper a ampliação."</string>
    <string name="accessibility_screen_magnification_navbar_summary" msgid="807985499898802296">"Quando a ampliação está ativada, você pode aumentar o zoom na tela.\n\n"<b>"Para aplicar zoom"</b>", inicie a ampliação e toque em qualquer lugar da tela.\n"<ul><li>"Arraste dois dedos ou mais para rolar a tela."</li>\n<li>"Faça um gesto de pinça com dois ou mais dedos para ajustar o zoom."</li></ul>\n\n<b>"Para aplicar zoom temporariamente"</b>", inicie a ampliação e depois toque em qualquer ponto na tela e mantenha-o pressionado.\n"<ul><li>"Arraste para mover a tela."</li>\n<li>"Levante o dedo para diminuir o zoom."</li></ul>\n\n"Não é possível aumentar o zoom no teclado e na barra de navegação."</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">"Usar o botão de acessibilidade para abrir"</string>
    <string name="accessibility_tutorial_dialog_title_volume" msgid="494810949830845234">"Mantenha as teclas de volume pressionadas para abrir"</string>
    <string name="accessibility_tutorial_dialog_title_triple" msgid="7089562919284464400">"Toque três vezes na tela para abrir"</string>
    <string name="accessibility_tutorial_dialog_title_two_finger_double" msgid="3912970760484557646">"Tocar duas vezes na tela com dois dedos para abrir"</string>
    <string name="accessibility_tutorial_dialog_title_gesture" msgid="4965810097646659332">"Usar gesto para abrir"</string>
    <string name="accessibility_tutorial_dialog_title_gesture_settings" msgid="6800684770875867559">"Usar o gesto de acessibilidade"</string>
    <string name="accessibility_tutorial_dialog_message_button" msgid="7002398857479782303">"Para usar esse recurso, toque no botão de acessibilidade <xliff:g id="ACCESSIBILITY_ICON">%s</xliff:g> na parte inferior da tela.\n\nPara alternar entre os recursos, toque no botão de acessibilidade e o pressione."</string>
    <string name="accessibility_tutorial_dialog_message_floating_button" msgid="2551777208185138391">"Para usar esse recurso, toque no botão de acessibilidade na sua tela."</string>
    <string name="accessibility_tutorial_dialog_message_volume" msgid="5033080515460519183">"Para usar esse recurso, toque nas duas teclas de volume e as mantenha pressionadas."</string>
    <string name="accessibility_tutorial_dialog_message_triple" msgid="5219991116201165146">"Para iniciar ou interromper a ampliação, toque três vezes em qualquer lugar da tela."</string>
    <string name="accessibility_tutorial_dialog_message_two_finger_triple" msgid="860548190334486449">"Para iniciar ou interromper a ampliação, toque duas vezes em qualquer lugar da tela com dois dedos."</string>
    <string name="accessibility_tutorial_dialog_message_gesture" msgid="4148062210755434854">"Para usar esse recurso, deslize de baixo para cima na tela com dois dedos.\n\nPara alternar entre os recursos, deslize de baixo para cima com dois dedos, sem soltar."</string>
    <string name="accessibility_tutorial_dialog_message_gesture_talkback" msgid="8142847782708562793">"Para usar esse recurso, deslize de baixo para cima na tela com três dedos.\n\nPara alternar entre os recursos, deslize de baixo para cima com três dedos, sem soltar."</string>
    <string name="accessibility_tutorial_dialog_message_gesture_settings" msgid="40769674586981429">"Para usar um recurso de acessibilidade, deslize de baixo para cima na tela com dois dedos.\n\nPara alternar entre recursos, deslize de baixo para cima com dois dedos, sem soltar."</string>
    <string name="accessibility_tutorial_dialog_message_gesture_settings_talkback" msgid="7292969929578621958">"Para usar um recurso de acessibilidade, deslize de baixo para cima na tela com três dedos.\n\nPara alternar entre recursos, deslize de baixo para cima com três dedos, sem soltar."</string>
    <string name="accessibility_tutorial_dialog_button" msgid="2031773187678948436">"Ok"</string>
    <string name="accessibility_tutorial_dialog_link_button" msgid="6797349445794031781">"Configurações do botão"</string>
    <string name="accessibility_shortcut_title" msgid="8125867833704517463">"Atalho para <xliff:g id="SERVICE">%1$s</xliff:g>"</string>
    <string name="accessibility_shortcut_edit_summary_software" msgid="6405629977940618205">"Botão de acessibilidade"</string>
    <string name="accessibility_shortcut_edit_summary_software_gesture" msgid="5489284264414421286">"Gesto de acessibilidade"</string>
    <string name="accessibility_shortcut_edit_dialog_title_software_gesture" msgid="8078659880723370597">"Deslizar para cima com dois dedos"</string>
    <string name="accessibility_shortcut_edit_dialog_title_software_gesture_talkback" msgid="7422753388389160524">"Deslizar para cima com três dedos"</string>
    <string name="accessibility_shortcut_edit_dialog_title_software" msgid="4796192466943479849">"Tocar no botão de acessibilidade"</string>
    <string name="accessibility_shortcut_edit_dialog_title_software_by_gesture" msgid="3981188764050497346">"Usar o gesto de acessibilidade"</string>
    <string name="accessibility_shortcut_edit_dialog_summary_software" msgid="5606196352833449600">"Toque no botão de acessibilidade <xliff:g id="ACCESSIBILITY_ICON">%s</xliff:g> na parte inferior da tela.\n\nPara alternar entre os recursos, toque no botão de acessibilidade e mantenha-o pressionado."</string>
    <string name="accessibility_shortcut_edit_dialog_summary_software_gesture" msgid="8292555254353761635">"Deslize de baixo para cima na tela com dois dedos.\n\nPara alternar entre recursos, deslize de baixo para cima na tela com dois dedos, sem soltar."</string>
    <string name="accessibility_shortcut_edit_dialog_summary_software_gesture_talkback" msgid="84483464524360845">"Deslize de baixo para cima na tela com três dedos.\n\nPara alternar entre recursos, deslize de baixo para cima na tela com três dedos, sem soltar."</string>
    <string name="accessibility_shortcut_edit_dialog_summary_software_floating" msgid="4459254227203203324"><annotation id="link">"Mais opções"</annotation></string>
    <string name="footer_learn_more_content_description" msgid="8843798273152131341">"Saiba mais sobre <xliff:g id="SERVICE">%1$s</xliff:g>"</string>
    <string name="accessibility_shortcut_edit_dialog_title_hardware" msgid="2356853121810443026">"Manter as teclas de volume pressionadas"</string>
    <string name="accessibility_shortcut_hardware_keyword" msgid="3921915304537166064">"manter as teclas de volume pressionadas"</string>
    <string name="accessibility_shortcut_edit_dialog_summary_hardware" msgid="2503134386397991634">"Toque nas duas teclas de volume e as mantenha pressionadas"</string>
    <string name="accessibility_shortcut_edit_dialog_title_two_finger_double_tap" msgid="2271778556854020996">"Tocar duas vezes na tela com dois dedos"</string>
    <string name="accessibility_shortcut_two_finger_double_tap_keyword" msgid="2971265341474137433">"tocar duas vezes na tela com dois dedos"</string>
    <string name="accessibility_shortcut_edit_dialog_summary_two_finger_double_tap" msgid="8262165091808318538">"Toque na tela {0,number,integer} vezes rapidamente com dois dedos"</string>
    <string name="accessibility_shortcut_edit_dialog_title_triple_tap" msgid="6672798007229795841">"Tocar na tela três vezes"</string>
    <string name="accessibility_shortcut_triple_tap_keyword" msgid="6863958573135995927">"tocar na tela três vezes"</string>
    <string name="accessibility_shortcut_edit_dialog_summary_triple_tap" msgid="2102327956423320536">"Toque na tela {0,number,integer} vezes rapidamente. Esse atalho pode deixar o dispositivo mais lento"</string>
    <string name="accessibility_shortcut_edit_dialog_title_advance" msgid="4567868630655591506">"Avançado"</string>
    <string name="accessibility_screen_magnification_navbar_configuration_warning" msgid="266736851606791552">"O botão Acessibilidade está definido para <xliff:g id="SERVICE">%1$s</xliff:g>. Para usar a ampliação, toque nesse botão, mantenha-o pressionado e selecione a ampliação."</string>
    <string name="accessibility_screen_magnification_gesture_navigation_warning" msgid="991017769735632046">"O gesto de acessibilidade está definido para <xliff:g id="SERVICE">%1$s</xliff:g>. Para usar a ampliação, deslize de baixo para cima com dois dedos e mantenha a tela pressionada. Em seguida, selecione \"Ampliação\"."</string>
    <string name="accessibility_global_gesture_preference_title" msgid="3713636732641882959">"Atalho do volume"</string>
    <string name="accessibility_shortcut_settings" msgid="836783442658447995">"Configurações de atalho"</string>
    <string name="accessibility_shortcut_service_on_lock_screen_title" msgid="3923122834058574478">"Atalho da tela de bloqueio"</string>
    <string name="accessibility_shortcut_description" msgid="2184693606202133549">"Permitir que o atalho do recurso seja ativado pela tela de bloqueio. Pressione as duas teclas de volume por alguns segundos."</string>
    <string name="accessibility_button_title" msgid="5251235485581552614">"Botão de acessibilidade"</string>
    <string name="accessibility_button_gesture_title" msgid="3573456209050374139">"Botão e gesto de acessibilidade"</string>
    <string name="accessibility_button_intro_text" msgid="80993874471745687">"Acesse rapidamente os recursos de acessibilidade em qualquer tela"</string>
    <string name="accessibility_button_about_title" msgid="3581116105084067926">"Sobre o botão de acessibilidade"</string>
    <string name="accessibility_button_gesture_about_title" msgid="8468987303602865536">"Sobre o botão e o gesto de acessibilidade"</string>
    <string name="accessibility_button_gesture_footer_learn_more_content_description" msgid="4144803517680297869">"Saiba mais sobre o botão e o gesto de acessibilidade"</string>
    <string name="accessibility_button_intro" msgid="2601976470525277903">"Como usar o botão de acessibilidade. O gesto não está disponível na navegação com três botões."</string>
    <string name="accessibility_button_summary" msgid="8510939012631455831">"Acessar rapidamente os recursos de acessibilidade"</string>
    <string name="accessibility_button_gesture_description" msgid="1141723096904904336">"&lt;b&gt;Para começar&lt;/b&gt;&lt;br/&gt; {0,number,integer}. Abra as configurações de acessibilidade&lt;br/&gt; {1,number,integer}. Selecione um recurso e toque no atalho&lt;br/&gt; {2,number,integer}. Escolha se quer usar um botão ou um gesto para acessar o recurso&lt;br/&gt;"</string>
    <string name="accessibility_button_description" msgid="7669538706120092399">"&lt;b&gt;Para começar&lt;/b&gt;&lt;br/&gt; {0,number,integer}. Abra as configurações de acessibilidade&lt;br/&gt; {1,number,integer}. Selecione um recurso e toque no atalho&lt;br/&gt; {2,number,integer}. Escolha o botão para acessar o recurso&lt;br/&gt;"</string>
    <string name="accessibility_button_or_gesture_title" msgid="3510075963401163529">"Usar botão ou gesto"</string>
    <string name="accessibility_button_location_title" msgid="7182107846092304942">"Localização"</string>
    <string name="accessibility_button_size_title" msgid="5785110470538960881">"Tamanho"</string>
    <string name="accessibility_button_fade_title" msgid="8081993897680588829">"Esmaecer quando não estiver em uso"</string>
    <string name="accessibility_button_fade_summary" msgid="7865950833524973709">"Esmaece depois de alguns segundos para facilitar a visualização da tela"</string>
    <string name="accessibility_button_opacity_title" msgid="4727355657530362289">"Transparência quando não estiver em uso"</string>
    <string name="accessibility_button_low_label" msgid="4193015407828927741">"Transparente"</string>
    <string name="accessibility_button_high_label" msgid="9138077512008190896">"Não transparente"</string>
    <string name="accessibility_toggle_high_text_contrast_preference_title" msgid="1830189632458752698">"Texto em alto contraste"</string>
    <string name="accessibility_toggle_high_text_contrast_preference_summary" msgid="5286411556836346180">"Mudar a cor do texto para preto ou branco. Maximiza o contraste com o plano de fundo."</string>
    <string name="accessibility_toggle_maximize_text_contrast_preference_title" msgid="8737272017343509753">"Maximize o contraste do texto"</string>
    <string name="accessibility_toggle_maximize_text_contrast_preference_summary" msgid="5493999083693403489">"Mude a cor do texto para preto ou branco para aumentar o contraste com o plano de fundo"</string>
    <string name="accessibility_toggle_screen_magnification_auto_update_preference_title" msgid="4987009529235165664">"Atual. autom. da ampliação da tela"</string>
    <string name="accessibility_toggle_screen_magnification_auto_update_preference_summary" msgid="9034532513972547720">"Atualiz. ampliação da tela em transições de aplic."</string>
    <string name="accessibility_power_button_ends_call_prerefence_title" msgid="8187306131979612144">"Botão liga/desliga encerra chamadas"</string>
    <string name="accessibility_toggle_large_pointer_icon_title" msgid="5508351959249876801">"Cursor do mouse grande"</string>
    <string name="accessibility_toggle_large_pointer_icon_summary" msgid="1480527946039237705">"Deixar o ponteiro do mouse mais perceptível"</string>
    <string name="accessibility_force_invert_title" msgid="5015366813138748407">"Forçar apps a usar o tema escuro"</string>
    <string name="accessibility_force_invert_summary" msgid="1882329675950887268">"Para apps que não tem um tema escuro. Alguns apps podem ter problemas, como cores invertidas."</string>
    <string name="accessibility_disable_animations" msgid="2993529829457179058">"Remover animações"</string>
    <string name="accessibility_disable_animations_summary" msgid="5828228669556554565">"Reduzir o movimento na tela"</string>
    <string name="accessibility_toggle_primary_mono_title" msgid="7587152099472946571">"Áudio mono"</string>
    <string name="accessibility_toggle_primary_mono_summary" msgid="1935283927319407303">"Combinar canais ao tocar áudio"</string>
    <string name="accessibility_toggle_primary_balance_title" msgid="7332275200153366714">"Balanço de áudio"</string>
    <string name="accessibility_toggle_primary_balance_left_label" msgid="6415750010517682014">"Esquerdo"</string>
    <string name="accessibility_toggle_primary_balance_right_label" msgid="2987443495390104935">"Direito"</string>
    <string name="accessibility_timeout_default" msgid="1033702739376842824">"Padrão"</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">"Tempo para agir (tempo limite de acessibilidade)"</string>
    <string name="accessibility_control_timeout_about_title" msgid="813588002683460837">"Sobre o tempo para agir (tempo limite de acessibilidade)"</string>
    <string name="accessibility_control_timeout_footer_learn_more_content_description" msgid="8118584413220542193">"Saiba mais sobre o tempo para agir (tempo limite de acessibilidade)"</string>
    <string name="accessibility_control_timeout_preference_title" msgid="1443940538597464758">"Tempo para agir"</string>
    <string name="accessibility_control_timeout_preference_summary" msgid="4037051091059316310">"Nem todos os apps têm suporte para esta preferência de marcação de tempo"</string>
    <string name="accessibility_control_timeout_preference_intro_text" msgid="1398116710556762245">"Escolha por quanto tempo mostrar mensagens temporárias que solicitam uma ação"</string>
    <string name="accessibility_long_press_timeout_preference_title" msgid="5237764682976688855">"Atraso ao tocar e pressionar"</string>
    <string name="accessibility_display_inversion_preference_title" msgid="5476133104746207952">"Inversão de cores"</string>
    <string name="accessibility_display_inversion_switch_title" msgid="7458595722552743503">"Usar inversão de cores"</string>
    <string name="accessibility_display_inversion_shortcut_title" msgid="6889624526691513462">"Atalho para inversão de cores"</string>
    <string name="accessibility_display_inversion_preference_intro_text" msgid="1159663288481145318">"A inversão de cores escurece telas claras e clareia telas escuras."</string>
    <string name="accessibility_display_inversion_preference_subtitle" msgid="4494767676482389509">"&lt;b&gt;É sempre bom lembrar:&lt;/b&gt;&lt;br/&gt; &lt;ol&gt; &lt;li&gt; As cores vão mudar em mídias e imagens.&lt;/li&gt; &lt;li&gt; A inversão de cores funciona em todos os apps.&lt;/li&gt; &lt;li&gt; Para mostrar um plano de fundo escuro, você pode usar o tema escuro.&lt;/li&gt; &lt;/ol&gt;"</string>
    <string name="accessibility_action_label_panel_slice" msgid="1313725957071602932">"acessar as configurações"</string>
    <string name="accessibility_autoclick_preference_title" msgid="2703143361605555752">"Clique automático (tempo de permanência)"</string>
    <string name="accessibility_autoclick_about_title" msgid="152923024405552594">"Sobre o clique automático (tempo de permanência)"</string>
    <string name="accessibility_autoclick_footer_learn_more_content_description" msgid="7056189627042350691">"Saiba mais sobre o clique automático (tempo de permanência)"</string>
    <string name="accessibility_autoclick_intro_text" msgid="8959680635470639347">"É possível configurar um mouse para clicar automaticamente quando o cursor parar de se mover por um determinado período."</string>
    <string name="accessibility_autoclick_description" msgid="6695732131412361101">"O clique automático pode ser útil em caso de dificuldade para clicar com o mouse"</string>
    <string name="accessibility_autoclick_default_title" msgid="2024730028293793490">"Clique automático desativado"</string>
    <string name="accessibility_autoclick_short_title" msgid="7938302504358912984">"Curto"</string>
    <string name="accessibility_autoclick_short_summary" msgid="4106953930081213514">"0,2 segundos"</string>
    <string name="accessibility_autoclick_medium_title" msgid="3134175117576834320">"Médio"</string>
    <string name="accessibility_autoclick_medium_summary" msgid="1343390686514222871">"0,6 segundos"</string>
    <string name="accessibility_autoclick_long_title" msgid="6799311820641687735">"Longo"</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">"Mais curto"</string>
    <string name="accessibility_autoclick_longer_desc" msgid="2566025502981487443">"Mais longo"</string>
    <string name="accessibility_autoclick_seekbar_desc" msgid="8363959277814621118">"Tempo do clique automático"</string>
    <string name="accessibility_vibration_settings_title" msgid="936301142478631993">"Vibração e retorno tátil"</string>
    <string name="accessibility_vibration_settings_summary" msgid="3690308537483465527">"Controle a intensidade da vibração para diferentes usos"</string>
    <string name="accessibility_vibration_settings_state_on" msgid="5566026932372832502">"Ativados"</string>
    <string name="accessibility_vibration_settings_state_off" msgid="7946588741954981703">"Desativados"</string>
    <string name="accessibility_vibration_setting_disabled_for_silent_mode_summary" msgid="3982701772953323190">"Configuração desativada porque o dispositivo está no modo silencioso"</string>
    <string name="accessibility_call_vibration_category_title" msgid="2545607568768192318">"Chamadas"</string>
    <string name="accessibility_notification_alarm_vibration_category_title" msgid="2683635252414849417">"Notificações e alarmes"</string>
    <string name="accessibility_interactive_haptics_category_title" msgid="3162855291184592021">"Retorno tátil interativo"</string>
    <string name="accessibility_vibration_primary_switch_title" msgid="6162579254864450592">"Usar vibração e retorno tátil"</string>
    <string name="accessibility_alarm_vibration_title" msgid="4661294337828522745">"Vibração do alarme"</string>
    <string name="accessibility_media_vibration_title" msgid="1372073715403945428">"Vibração de mídia"</string>
    <string name="accessibility_keyboard_vibration_title" msgid="7559967730626765441">"Vibração do teclado"</string>
    <string name="accessibility_ring_vibration_title" msgid="4689811297654320885">"Vibração do toque"</string>
    <string name="accessibility_notification_vibration_title" msgid="6205679908785776478">"Vibração das notificações"</string>
    <string name="accessibility_touch_vibration_title" msgid="533931451319110741">"Feedback por toque"</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">"O app <xliff:g id="ACCESSIBILITY_APP_NAME">%1$s</xliff:g> foi adicionado às Configurações rápidas. Deslize para baixo para ativar ou desativar a qualquer momento."</string>
    <string name="accessibility_service_qs_tooltip_content" msgid="6002493441414967868">"Também é possível adicionar o app <xliff:g id="ACCESSIBILITY_APP_NAME">%1$s</xliff:g> às Configurações rápidas na parte de cima da tela"</string>
    <string name="accessibility_color_correction_auto_added_qs_tooltip_content" msgid="9092661358437404374">"A correção de cor foi adicionada às Configurações rápidas. Deslize para baixo para ativar ou desativar a qualquer momento."</string>
    <string name="accessibility_color_correction_qs_tooltip_content" msgid="3258628434235475205">"Também é possível adicionar a correção de cor às Configurações rápidas na parte de cima da tela"</string>
    <string name="accessibility_color_inversion_auto_added_qs_tooltip_content" msgid="7267618234972101725">"A inversão de cores foi adicionada às Configurações rápidas. Deslize para baixo para ativar ou desativar a qualquer momento."</string>
    <string name="accessibility_color_inversion_qs_tooltip_content" msgid="5046332142185711869">"Também é possível adicionar a inversão de cores às Configurações rápidas na parte de cima da tela"</string>
    <string name="accessibility_reduce_bright_colors_auto_added_qs_tooltip_content" msgid="1906588335786328512">"O recurso Mais escuro foi adicionado às Configurações rápidas. Deslize para baixo para ativar ou desativar a qualquer momento."</string>
    <string name="accessibility_reduce_bright_colors_qs_tooltip_content" msgid="7522121299176176785">"Também é possível adicionar o recurso Mais escuro às Configurações rápidas na parte de cima da tela"</string>
    <string name="accessibility_one_handed_mode_auto_added_qs_tooltip_content" msgid="7914554254280416532">"O modo uma mão foi adicionado às Configurações rápidas. Deslize para baixo para ativar ou desativar a qualquer momento."</string>
    <string name="accessibility_one_handed_mode_qs_tooltip_content" msgid="2754332083184384603">"Também é possível adicionar o modo uma mão às Configurações rápidas na parte de cima da tela"</string>
    <string name="accessibility_font_scaling_auto_added_qs_tooltip_content" msgid="7229921960884718332">"Tamanho da fonte adicionado às Configurações rápidas. Mude o tamanho da fonte a qualquer momento deslizando para baixo."</string>
    <string name="accessibility_quick_settings_tooltip_dismiss" msgid="3269120277643884190">"Dispensar"</string>
    <string name="accessibility_daltonizer_primary_switch_title" msgid="32064721588910540">"Usar correção de cor"</string>
    <string name="accessibility_daltonizer_shortcut_title" msgid="7480360363995502369">"Atalho para correção de cor"</string>
    <string name="accessibility_daltonizer_about_title" msgid="6063650804116981287">"Sobre a correção de cor"</string>
    <string name="accessibility_daltonizer_footer_learn_more_content_description" msgid="2091679253892040910">"Saiba mais sobre a correção de cor"</string>
    <string name="accessibility_color_inversion_about_title" msgid="8275754480247040136">"Sobre a inversão de cores"</string>
    <string name="accessibility_color_inversion_footer_learn_more_content_description" msgid="5382579548498952445">"Saiba mais sobre a inversão de cores"</string>
    <string name="accessibility_captioning_primary_switch_title" msgid="3663677340286206100">"Mostrar legendas"</string>
    <string name="accessibility_captioning_primary_switch_summary" msgid="2544094070306830218">"Apenas para apps com suporte"</string>
    <string name="captioning_appearance_title" msgid="3128792092290011408">"Tamanho e estilo das legendas"</string>
    <string name="captioning_appearance_summary" msgid="4620682807315588019">"Tamanho do texto: <xliff:g id="ACCESSIBILITY_FONT_SIZE">%1$s</xliff:g>"</string>
    <string name="captioning_more_options_title" msgid="3484496882942539652">"Mais opções"</string>
    <string name="accessibility_captioning_preference_intro" msgid="8995427146374031134">"Personalize o tamanho e estilo da legenda para facilitar a leitura"</string>
    <string name="accessibility_captioning_preference_summary" msgid="8335768472978374255">"Nem todos os apps de mídia têm suporte a essas preferências de legenda"</string>
    <string name="accessibility_shortcut_type_software" msgid="2552732582767687515">"Botão de acessibilidade"</string>
    <string name="accessibility_shortcut_type_software_gesture" msgid="5608959693931019059">"Deslizar de baixo para cima com dois dedos"</string>
    <string name="accessibility_shortcut_type_hardware" msgid="4834144210432451916">"Mantenha as teclas de volume pressionadas"</string>
    <string name="accessibility_shortcut_type_triple_tap" msgid="7717524216825494543">"Tocar na tela três vezes"</string>
    <string name="accessibility_shortcut_edit_screen_title" msgid="4494142067760961499">"Editar atalhos de acessibilidade"</string>
    <string name="accessibility_shortcut_edit_screen_prompt" msgid="5966054283114856682">"Escolha o atalho para %1$s"</string>
    <string name="accessibility_hearingaid_instruction_continue_button" msgid="3367260988024430722">"Continuar"</string>
    <string name="accessibility_hearingaid_title" msgid="1263619711863375614">"Aparelhos auditivos"</string>
    <string name="accessibility_hearingaid_intro" msgid="6686620444104350629">"Configure e gerencie aparelhos auditivos ASHA e LE Audio, implantes cocleares e outros dispositivos de amplificação de som"</string>
    <string name="accessibility_hearingaid_not_connected_summary" msgid="7438018718889849521">"Nenhum aparelho auditivo conectado"</string>
    <string name="accessibility_hearingaid_adding_summary" msgid="999051610528600783">"Adicionar aparelhos auditivos"</string>
    <string name="accessibility_hearingaid_pair_instructions_title" msgid="2357706801112207624">"Parear aparelhos auditivos"</string>
    <string name="accessibility_hearingaid_pair_instructions_message" msgid="581652489109350119">"Na próxima tela, toque nos seus aparelhos auditivos. Talvez seja necessário parear os aparelhos esquerdo e direito separadamente.\n\nConfira se eles estão ligados e prontos para parear."</string>
    <string name="accessibility_hearingaid_active_device_summary" msgid="509703438222873967">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g> ativo"</string>
    <string name="accessibility_hearingaid_left_side_device_summary" msgid="1907302799168261001">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g>, somente o esquerdo"</string>
    <string name="accessibility_hearingaid_right_side_device_summary" msgid="148257064855054376">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g>, somente o direito"</string>
    <string name="accessibility_hearingaid_left_and_right_side_device_summary" msgid="4268221140368164452">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g>, esquerdo e direito"</string>
    <string name="accessibility_hearingaid_more_device_summary" msgid="8092641784056942546">"<xliff:g id="DEVICE_NAME">%1$s</xliff:g> e mais um"</string>
    <string name="accessibility_hearing_device_pairing_title" msgid="2701812183769537320">"Parear novo dispositivo"</string>
    <string name="accessibility_hearing_device_connected_title" msgid="3785140037249487287">"Aparelhos auditivos"</string>
    <string name="accessibility_hearing_device_saved_title" msgid="7573926212664909296">"Dispositivos salvos"</string>
    <string name="accessibility_hearing_device_control" msgid="2661965917013100611">"Controles de aparelhos auditivos"</string>
    <string name="accessibility_hearing_device_shortcut_title" msgid="7645100199603031360">"Atalho de aparelhos auditivos"</string>
    <string name="accessibility_hac_mode_title" msgid="2037950424429555652">"Compatibilidade com aparelhos auditivos"</string>
    <string name="accessibility_hac_mode_summary" msgid="5198760061256669067">"Melhora a compatibilidade com telecoils e reduz sons indesejados"</string>
    <string name="accessibility_hearing_device_about_title" msgid="7883758309646288250">"Sobre aparelhos auditivos"</string>
    <string name="accessibility_hearing_device_footer_summary" msgid="256061045064940818">"Para encontrar outros aparelhos auditivos que não têm suporte de ASHA ou LE Audio, toque em "<b>"Parear novo dispositivo"</b>" &gt; "<b>"Mais dispositivos"</b></string>
    <string name="accessibility_hearing_device_pairing_page_title" msgid="6608901091770850295">"Parear aparelho auditivo"</string>
    <string name="accessibility_hearing_device_pairing_intro" msgid="7022201665808166517">"Você pode parear aparelhos auditivos ASHA e LE Audio nesta página. Confira se o seu aparelho auditivo está ligado e pronto para parear."</string>
    <string name="accessibility_found_hearing_devices" msgid="637407580358386553">"Aparelhos auditivos disponíveis"</string>
    <string name="accessibility_found_all_devices" msgid="7817834722148556520">"Não está encontrando seu aparelho auditivo?"</string>
    <string name="accessibility_list_all_devices_title" msgid="161495343959211216">"Mais dispositivos"</string>
    <string name="accessibility_audio_adjustment_title" msgid="1332113739136802997">"Ajuste de áudio"</string>
    <string name="accessibility_toggle_audio_description_preference_title" msgid="8916473886256061220">"Audiodescrição"</string>
    <string name="accessibility_audio_description_summary" msgid="2554789094873781056">"Ouça uma descrição do que está acontecendo na tela em filmes e programas compatíveis com esse recurso"</string>
    <string name="keywords_audio_description" msgid="6202816411593281252">"descrição de áudio, áudio, descrição, baixa visão,"</string>
    <string name="accessibility_summary_shortcut_enabled" msgid="4030427268146752644">"Atalho ativado"</string>
    <string name="accessibility_summary_shortcut_disabled" msgid="564005462092499068">"Atalho desativado"</string>
    <string name="accessibility_summary_state_enabled" msgid="1065431632216039369">"Ativado"</string>
    <string name="accessibility_summary_state_disabled" msgid="9173234532752799694">"Desativado"</string>
    <string name="accessibility_summary_state_stopped" msgid="2343602489802623424">"Não está funcionando. Toque para ver informações."</string>
    <string name="accessibility_description_state_stopped" msgid="5364752492861199133">"Este serviço está com problemas."</string>
    <string name="accessibility_shortcuts_settings_title" msgid="974740249671825145">"Atalhos de acessibilidade"</string>
    <string name="enable_quick_setting" msgid="6648073323202243604">"Mostrar em \"Configurações rápidas\""</string>
    <string name="daltonizer_mode_deuteranomaly_title" msgid="4210949400493358650">"Vermelho-verde"</string>
    <string name="daltonizer_mode_protanomaly_title" msgid="6392456967103014723">"Vermelho-verde"</string>
    <string name="daltonizer_mode_tritanomaly_title" msgid="2278786218762602022">"Azul-amarelo"</string>
    <string name="daltonizer_mode_grayscale_title" msgid="152005391387952588">"Escala de cinza"</string>
    <string name="daltonizer_mode_deuteranomaly_summary" msgid="2117727423019598455">"Dificuldade com a cor verde, deuteranomalia"</string>
    <string name="daltonizer_mode_protanomaly_summary" msgid="4617032854982040748">"Dificuldade com a cor vermelha, protanomalia"</string>
    <string name="daltonizer_mode_tritanomaly_summary" msgid="2428218320118180070">"Tritanomalia"</string>
    <string name="reduce_bright_colors_preference_title" msgid="2249314004651574997">"Escurecer mais a tela"</string>
    <string name="reduce_bright_colors_switch_title" msgid="1751678397884065312">"Deixar a tela ainda mais escura"</string>
    <string name="reduce_bright_colors_shortcut_title" msgid="495648157059202745">"Atalho para escurecer ainda mais a tela"</string>
    <string name="reduce_bright_colors_about_title" msgid="503655452544934393">"Sobre o recurso Mais escuro"</string>
    <string name="reduce_bright_colors_preference_intro_text" msgid="3502290826747650566">"Diminua o brilho da tela para deixar a leitura mais confortável"</string>
    <string name="reduce_bright_colors_intensity_preference_title" msgid="7455443033955118267">"Intensidade"</string>
    <string name="reduce_bright_colors_intensity_start_label" msgid="930387498396426039">"Controle de luminosidade"</string>
    <string name="reduce_bright_colors_intensity_end_label" msgid="1422600205484299860">"Mais claro"</string>
    <string name="reduce_bright_colors_persist_preference_title" msgid="4368829654993343354">"Manter o recurso ativado após a reinicialização do dispositivo"</string>
    <string name="accessibilty_autoclick_preference_subtitle_short_delay" msgid="2981206111858937724">"{count,plural, =1{Curto ({time} segundo)}one{Curto ({time} segundo)}other{Curto ({time} segundos)}}"</string>
    <string name="accessibilty_autoclick_preference_subtitle_medium_delay" msgid="6867395206533459204">"{count,plural, =1{Médio ({time} segundo)}one{Médio ({time} segundo)}other{Médio ({time} segundos)}}"</string>
    <string name="accessibilty_autoclick_preference_subtitle_long_delay" msgid="4079139970819335593">"{count,plural, =1{Longo ({time} segundo)}one{Longo ({time} segundo)}other{Longo ({time} segundos)}}"</string>
    <string name="accessibilty_autoclick_delay_unit_second" msgid="5979297390686370567">"{count,plural, =1{{time} segundo}one{{time} segundo}other{{time} segundos}}"</string>
    <string name="accessibility_menu_item_settings" msgid="2652637954865389271">"Configurações"</string>
    <string name="accessibility_feature_state_on" msgid="1777344331063467511">"Ativada"</string>
    <string name="accessibility_feature_state_off" msgid="169119895905460512">"Desativada"</string>
    <string name="captioning_preview_title" msgid="2888561631323180535">"Visualização"</string>
    <string name="captioning_standard_options_title" msgid="5360264497750980205">"Opções padrão"</string>
    <string name="captioning_locale" msgid="5533303294290661590">"Idioma"</string>
    <string name="captioning_text_size" msgid="8039448543171463017">"Tamanho do texto"</string>
    <string name="captioning_preset" msgid="4174276086501638524">"Estilo da legenda"</string>
    <string name="captioning_custom_options_title" msgid="3858866498893566351">"Opções de personalização"</string>
    <string name="captioning_background_color" msgid="5231412761368883107">"Cor do plano de fundo"</string>
    <string name="captioning_background_opacity" msgid="6453738649182382614">"Opacidade do plano de fundo"</string>
    <string name="captioning_window_color" msgid="1406167274530183119">"Cor da janela de legendas"</string>
    <string name="captioning_window_opacity" msgid="4031752812991199525">"Opacidade da janela de legendas"</string>
    <string name="captioning_foreground_color" msgid="9057327228286129232">"Cor do texto"</string>
    <string name="captioning_foreground_opacity" msgid="1395843080697567189">"Opacidade do texto"</string>
    <string name="captioning_edge_color" msgid="6035818279902597518">"Cor da borda"</string>
    <string name="captioning_edge_type" msgid="5281259280060811506">"Tipo de borda"</string>
    <string name="captioning_typeface" msgid="285325623518361407">"Família de fontes"</string>
    <string name="captioning_preview_text" msgid="4973475065545995704">"As legendas ficarão assim"</string>
    <string name="captioning_preview_characters" msgid="7854812443613580460">"Aa"</string>
    <string name="locale_default" msgid="8948077172250925164">"Padrão"</string>
    <string name="color_title" msgid="2511586788643787427">"Cor"</string>
    <string name="color_unspecified" msgid="4102176222255378320">"Padrão"</string>
    <string name="color_none" msgid="3703632796520710651">"Nenhum"</string>
    <string name="color_white" msgid="1896703263492828323">"Branco"</string>
    <string name="color_gray" msgid="8554077329905747877">"Cinza"</string>
    <string name="color_black" msgid="9006830401670410387">"Preto"</string>
    <string name="color_red" msgid="5210756997426500693">"Vermelho"</string>
    <string name="color_green" msgid="4400462091250882271">"Verde"</string>
    <string name="color_blue" msgid="4997784644979140261">"Azul"</string>
    <string name="color_cyan" msgid="4341758639597035927">"Ciano"</string>
    <string name="color_yellow" msgid="5957551912912679058">"Amarelo"</string>
    <string name="color_magenta" msgid="8943538189219528423">"Magenta"</string>
    <string name="enable_service_title" msgid="7231533866953706788">"Permitir que o <xliff:g id="SERVICE">%1$s</xliff:g> tenha controle total do seu dispositivo?"</string>
    <string name="capabilities_list_title" msgid="1225853611983394386">"<xliff:g id="SERVICE">%1$s</xliff:g> precisa:"</string>
    <string name="touch_filtered_warning" msgid="4225815157460318241">"Como um app está ocultando uma solicitação de permissão, as configurações não podem confirmar sua resposta."</string>
    <string name="accessibility_service_warning" msgid="6779187188736432618">"<xliff:g id="SERVICE">%1$s</xliff:g> está solicitando controle total deste dispositivo. O serviço pode ler a tela e realizar ações em nome de usuários com necessidades especiais. Esse nível de controle não é adequado para a maioria dos apps."</string>
    <string name="accessibility_service_warning_description" msgid="6573203795976134751">"O controle total é adequado para apps que ajudam você com as necessidades de acessibilidade, mas não para a maioria dos apps."</string>
    <string name="accessibility_service_screen_control_title" msgid="324795030658109870">"Ver e controlar tela"</string>
    <string name="accessibility_service_screen_control_description" msgid="8431940515157990426">"Pode ler todo o conteúdo na tela e mostrar conteúdo sobreposto a outros apps."</string>
    <string name="accessibility_service_action_perform_title" msgid="1449360056585337833">"Ver e realizar ações"</string>
    <string name="accessibility_service_action_perform_description" msgid="7807832069800034738">"Pode monitorar suas interações com um app ou um sensor de hardware e interagir com apps em seu nome."</string>
    <string name="accessibility_dialog_button_allow" msgid="8274918676473216697">"Permitir"</string>
    <string name="accessibility_dialog_button_deny" msgid="2037249860078259284">"Negar"</string>
    <string name="accessibility_dialog_button_stop" msgid="7584815613743292151">"Desativar"</string>
    <string name="accessibility_dialog_button_cancel" msgid="8625997437316659966">"Manter ativado"</string>
    <string name="disable_service_title" msgid="8178020230162342801">"Desativar <xliff:g id="SERVICE">%1$s</xliff:g>?"</string>
    <string name="accessibility_no_services_installed" msgid="3725569493860028593">"Nenhum serviço foi instalado"</string>
    <string name="accessibility_no_service_selected" msgid="1310596127128379897">"Nenhum serviço selecionado"</string>
    <string name="accessibility_service_default_description" msgid="7801435825448138526">"Nenhuma descrição foi fornecida."</string>
    <string name="settings_button" msgid="2195468788019730377">"Configurações"</string>
    <string name="keywords_reduce_bright_colors" msgid="1683190961013139183">"sensibilidade à luz, fotofobia, tema escuro, enxaqueca, dor de cabeça, modo de leitura, modo noturno, reduzir brilho, ponto branco"</string>
    <string name="keywords_accessibility" msgid="8593989878379366798">"visão, audição, cego, surdo, motor, destreza, assistivo, assistência, facilidade de uso, facilidade de acesso, mão, ajuda"</string>
    <string name="keywords_magnification" msgid="3908145308269840862">"Lupa de janela, zoom, ampliação, baixa visão, ampliar, aumentar"</string>
    <string name="keywords_talkback" msgid="2816435437095102527"></string>
    <string name="keywords_live_caption" msgid="1667203998080567556">"Legendas, closed captions, CC, Transcrição instantânea, deficiência auditiva, perda auditiva, legenda ao vivo, voz em texto"</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">"tamanho da tela, tela grande"</string>
    <string name="keywords_bold_text" msgid="6257418169207099589">"Alto contraste, baixa visão, fonte em negrito"</string>
    <string name="keywords_select_to_speak" msgid="2872704811610888719"></string>
    <string name="keywords_color_correction" msgid="8540442886990423681">"ajustar cor"</string>
    <string name="keywords_color_inversion" msgid="4291058365873221962">"escurecer tela, clarear tela"</string>
    <string name="keywords_contrast" msgid="4668393735398949873">"contraste de cor"</string>
    <string name="keywords_accessibility_menu" msgid="4300579436464706608"></string>
    <string name="keywords_switch_access" msgid="5813094504384313402"></string>
    <string name="keywords_auto_click" msgid="6811744211216280998">"motor, mouse, mouse externo, mouse controlado por movimentos da cabeça, mouse adaptável, cadeira de rodas, joystick"</string>
    <string name="keywords_hearing_aids" msgid="4657889873249157071">"aparelhos auditivos, perda auditiva, implantes cocleares, dispositivos de amplificação, processadores de som, CAE"</string>
    <string name="keywords_rtt" msgid="2429130928152514402">"deficiência auditiva, perda auditiva, legendas, teletipo, TTD"</string>
    <string name="keywords_voice_access" msgid="7807335263195876454"></string>
    <string name="keywords_3_button_navigation" msgid="436361965016404218">"três botões"</string>
    <string name="keywords_touch_and_hold_delay" msgid="7854640156419599912">"destreza, motor, idoso, artrite, LER, derrame, tremor, esclerose múltipla, paralisia cerebral, tremendo, lesão por esforço repetitivo, mão"</string>
    <string name="keywords_accessibility_timeout" msgid="8903766864902000346">"atraso, destreza, idoso"</string>
    <string name="print_settings" msgid="8519810615863882491">"Impressão"</string>
    <string name="print_settings_summary_no_service" msgid="6721731154917653862">"Desativada"</string>
    <string name="print_settings_summary" msgid="1458773840720811915">"{count,plural, =1{1 serviço de impressão ativado}one{# serviço de impressão ativado}other{# serviços de impressão ativados}}"</string>
    <string name="print_jobs_summary" msgid="7040836482336577323">"{count,plural, =1{1 trabalho de impressão}one{# trabalho de impressão}other{# trabalhos de impressão}}"</string>
    <string name="print_settings_title" msgid="7680498284751129935">"Serviços de impressão"</string>
    <string name="print_no_services_installed" msgid="7554057966540602692">"Nenhum serviço instalado"</string>
    <string name="print_no_printers_found" msgid="4833082484646109486">"Nenhuma impressora encontrada"</string>
    <string name="print_menu_item_settings" msgid="8202755044784599740">"Configurações"</string>
    <string name="print_menu_item_add_printers" msgid="7958192149202584039">"Adicionar impressoras"</string>
    <string name="print_feature_state_on" msgid="7132063461008624685">"Ativada"</string>
    <string name="print_feature_state_off" msgid="1466195699995209446">"Desativado"</string>
    <string name="print_menu_item_add_service" msgid="1549091062463044676">"Adicionar serviço"</string>
    <string name="print_menu_item_add_printer" msgid="8711630848324870892">"Adicionar impressora"</string>
    <string name="print_menu_item_search" msgid="5989979785203603169">"Pesquisar"</string>
    <string name="print_searching_for_printers" msgid="5401413178028348800">"Procurando impressoras"</string>
    <string name="print_service_disabled" msgid="9185935228930987786">"Serviço desativado"</string>
    <string name="print_print_jobs" msgid="2605944855933091183">"Trabalhos de impressão"</string>
    <string name="print_print_job" msgid="8477859161886726608">"Trabalho de impressão"</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">"Imprimindo <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">"Erro ao imprimir <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_blocked_state_title_template" msgid="3134100215188411074">"A impressora bloqueou <xliff:g id="PRINT_JOB_NAME">%1$s</xliff:g>"</string>
    <string name="print_search_box_shown_utterance" msgid="6215002365360341961">"Caixa de pesquisa exibida"</string>
    <string name="print_search_box_hidden_utterance" msgid="5355387966141712567">"Caixa de pesquisa oculta"</string>
    <string name="printer_info_desc" msgid="1206872325746154206">"Mais informações sobre essa impressora"</string>
    <string name="power_usage_summary_title" msgid="4198312848584882113">"Bateria"</string>
    <string name="power_usage_summary" msgid="6857382582534984531">"O que está consumindo a bateria"</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">"<xliff:g id="REMAIN">%1$s</xliff:g> restantes"</string>
    <string name="power_charge_remaining" msgid="7046064326172265116">"<xliff:g id="UNTIL_CHARGED">%1$s</xliff:g> até carregar"</string>
    <string name="power_usage_detail_screen_time" msgid="6027274749498485283">"Tempo de tela"</string>
    <string name="power_usage_detail_background_time" msgid="3661437083554322691">"Tempo em segundo plano"</string>
    <string name="low_battery_summary" msgid="4458925347316501953">"Bateria fraca"</string>
    <string name="background_activity_summary" msgid="3817376868497046016">"Permitir que o app seja executado em segundo plano"</string>
    <string name="background_activity_warning_dialog_title" msgid="3449566823290744823">"Limitar atividade em segundo plano?"</string>
    <string name="background_activity_warning_dialog_text" msgid="8202776985767701095">"Se você limitar as atividades em segundo plano de um app, ele poderá apresentar mau funcionamento"</string>
    <string name="background_activity_disabled_dialog_text" msgid="4053170297325882494">"Como o app não está configurado para otimizar bateria, não é possível restringi-lo.\n\nPara restringir, ative a otimização."</string>
    <string name="manager_battery_usage_category_title" msgid="1493303237531629961">"Gerenciar uso da bateria"</string>
    <string name="manager_battery_usage_allow_background_usage_title" msgid="6294649996820358852">"Permitir o uso em segundo plano"</string>
    <string name="manager_battery_usage_allow_background_usage_summary" msgid="8021153755201340819">"Ative para receber atualizações em tempo real ou desative para economizar bateria"</string>
    <string name="manager_battery_usage_unrestricted_title" msgid="2426486290463258032">"Sem restrições"</string>
    <string name="manager_battery_usage_optimized_title" msgid="8080765739761921817">"Otimizado"</string>
    <string name="manager_battery_usage_restricted_title" msgid="7702863764130323118">"Restrito"</string>
    <string name="manager_battery_usage_unrestricted_summary" msgid="6819279865465667692">"Permitir o uso da bateria em segundo plano sem restrições. Pode usar mais bateria."</string>
    <string name="manager_battery_usage_optimized_summary" msgid="1332545476428039900">"Otimizar com base no seu uso. Recomendado para a maioria dos apps."</string>
    <string name="manager_battery_usage_restricted_summary" msgid="8324695640704416905">"Restringir o uso da bateria em segundo plano. O app pode não funcionar como esperado. As notificações podem demorar mais para chegar."</string>
    <string name="manager_battery_usage_footer" msgid="2635906573922553766">"Mudar a forma como um app usa sua bateria pode afetar o desempenho dele."</string>
    <string name="manager_battery_usage_footer_limited" msgid="5180776148877306780">"O app requer uso <xliff:g id="STATE">%1$s</xliff:g> da bateria."</string>
    <string name="manager_battery_usage_unrestricted_only" msgid="3646162131339418216">"irrestrito"</string>
    <string name="manager_battery_usage_optimized_only" msgid="7121785281913056432">"otimizado"</string>
    <string name="manager_battery_usage_link_a11y" msgid="374918091821438564">"Saiba mais sobre as opções de uso da bateria"</string>
    <string name="device_screen_usage" msgid="1011630249648289909">"Uso da tela desde a carga completa"</string>
    <string name="advanced_battery_title" msgid="3005993394776555079">"Uso da bateria"</string>
    <string name="history_details_title" msgid="8628584613889559355">"Detalhes do histórico"</string>
    <string name="advanced_battery_preference_title" msgid="3790901207877260883">"Uso da bateria"</string>
    <string name="advanced_battery_preference_summary_with_hours" msgid="954091349133320955">"Ver o uso nas últimas 24 horas"</string>
    <string name="advanced_battery_preference_summary" msgid="2372763700477268393">"Mostrar o uso desde a última carga total"</string>
    <string name="battery_details_title" msgid="3289680399291090588">"Uso da bateria pelo app"</string>
    <string name="details_subtitle" msgid="2550872569652785527">"Detalhes de uso"</string>
    <string name="controls_subtitle" msgid="3759606830916441564">"Ajustar uso de energia"</string>
    <string name="packages_subtitle" msgid="8687690644931499428">"Pacotes incluídos"</string>
    <string name="battery_tip_summary_title" msgid="321127485145626939">"Os apps estão funcionando normalmente"</string>
    <string name="battery_tip_low_battery_title" msgid="4155239078744100997">"Nível da bateria baixo"</string>
    <string name="battery_tip_low_battery_summary" msgid="2629633757244297436">"Ativar a Economia de bateria para prolongar a duração da carga"</string>
    <string name="battery_tip_smart_battery_title" msgid="8925025450214912325">"Melhorar a duração da bateria"</string>
    <string name="battery_tip_smart_battery_summary" msgid="3592965553502362965">"Ative o Gerenciador de bateria"</string>
    <string name="battery_tip_early_heads_up_title" msgid="4411387863476629452">"Ativar a Economia de bateria"</string>
    <string name="battery_tip_early_heads_up_summary" msgid="578523794827443977">"A bateria pode acabar antes do normal"</string>
    <string name="battery_tip_early_heads_up_done_title" msgid="7705597228709143337">"Economia de bateria ativada"</string>
    <string name="battery_saver_link_a11y" msgid="6613079613524512257">"Saiba mais sobre a Economia de bateria"</string>
    <string name="battery_tip_early_heads_up_done_summary" msgid="7858923105760361208">"Alguns recursos podem ser limitados"</string>
    <string name="battery_tip_high_usage_title" msgid="9110720762506146697">"Maior uso da bateria"</string>
    <string name="battery_tip_high_usage_summary" msgid="3938999581403084551">"Ver apps com maior uso"</string>
    <string name="battery_tip_limited_temporarily_title" msgid="6258554134146272311">"Carregamento otimizado para proteger a bateria"</string>
    <string name="battery_tip_limited_temporarily_summary" msgid="5107379280241187562">"Para ajudar a prolongar a vida útil da bateria, o carregamento foi otimizado"</string>
    <string name="battery_tip_limited_temporarily_sec_button_content_description" msgid="5648444926736883551">"Saiba mais sobre a pausa no carregamento"</string>
    <string name="battery_tip_limited_temporarily_dialog_resume_charge" msgid="2302295458913832342">"Retomar o carregamento"</string>
    <string name="battery_tip_dialog_message_footer" msgid="986542164372177504">"Inclui atividade em segundo plano com alto consumo de energia"</string>
    <string name="battery_tip_restrict_title" msgid="4537101947310626753">"{count,plural, =1{Restringir # app}one{Restringir # app}other{Restringir # apps}}"</string>
    <string name="battery_tip_restrict_handled_title" msgid="7142074986508706853">"{count,plural, =1{O app {label} foi restrito recentemente}one{# app foi restrito recentemente}other{# apps foram restritos recentemente}}"</string>
    <string name="battery_tip_restrict_summary" msgid="7539469590829235277">"{count,plural, =1{O app {label} consome muita bateria em segundo plano}one{# app consome muita bateria em segundo plano}other{# apps consomem muita bateria em segundo plano}}"</string>
    <string name="battery_tip_restrict_handled_summary" msgid="3535697154547199190">"{count,plural, =1{Não é possível executar esse app em segundo plano}one{Não é possível executar esse app em segundo plano}other{Não é possível executar esses apps em segundo plano}}"</string>
    <string name="battery_tip_restrict_app_dialog_title" msgid="1649476357343160240">"{count,plural, =1{Restringir app?}one{Restringir # app?}other{Restringir # apps?}}"</string>
    <string name="battery_tip_restrict_app_dialog_message" msgid="137856003724730751">"Para economizar bateria, não permita que o app <xliff:g id="APP">%1$s</xliff:g> use a bateria em segundo plano. Ele pode não funcionar corretamente e é possível que haja atraso nas notificações."</string>
    <string name="battery_tip_restrict_apps_less_than_5_dialog_message" msgid="5894648804112181324">"Para economizar bateria, não permita que esses apps usem a bateria em segundo plano. Os apps com restrição podem não funcionar corretamente e é possível que haja atraso nas notificações.\n\nApps:"</string>
    <string name="battery_tip_restrict_apps_more_than_5_dialog_message" msgid="4546838397423565138">"Para economizar bateria, não permita que esses apps usem a bateria em segundo plano. Os apps com restrição podem não funcionar corretamente e é possível que haja atraso nas notificações.\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">"Remover restrição?"</string>
    <string name="battery_tip_unrestrict_app_dialog_message" msgid="215449637818582819">"Esse app poderá usar a bateria em segundo plano. É possível que sua bateria acabe antes do esperado."</string>
    <string name="battery_tip_unrestrict_app_dialog_ok" msgid="7940183167721998470">"Remover"</string>
    <string name="battery_tip_unrestrict_app_dialog_cancel" msgid="4968135709160207507">"Cancelar"</string>
    <string name="battery_tip_charge_to_full_button" msgid="9172893341338732733">"Substituir"</string>
    <string name="battery_tip_incompatible_charging_title" msgid="1567827436103364999">"Verifique o acessório de carregamento"</string>
    <string name="battery_tip_incompatible_charging_content_description" msgid="355668467640367701">"Saiba mais sobre a incompatibilidade de carregamento"</string>
    <string name="smart_battery_manager_title" msgid="3677620516657920364">"Gerenciador de bateria"</string>
    <string name="smart_battery_title" msgid="9095903608520254254">"Gerenciar apps automaticamente"</string>
    <string name="smart_battery_footer" msgid="8407121907452993645">"Quando o Gerenciador de bateria detectar que apps estão descarregando a bateria, você terá a opção de restringi-los. Apps com restrição podem não funcionar corretamente e é possível que as notificações atrasem."</string>
    <string name="restricted_app_title" msgid="6585080822121007436">"Apps restritos"</string>
    <string name="restricted_app_summary" msgid="1022307922754893997">"{count,plural, =1{Limitando o uso da bateria de # app}one{Limitando o uso da bateria de # app}other{Limitando o uso da bateria de # apps}}"</string>
    <string name="restricted_app_time_summary" msgid="3097721884155913252">"Restringido <xliff:g id="TIME">%1$s</xliff:g>"</string>
    <string name="restricted_app_detail_footer" msgid="3495725286882138803">"O uso da bateria em segundo plano por esses apps é limitado. Eles podem não funcionar corretamente e é possível que haja atraso nas notificações."</string>
    <string name="battery_auto_restriction_title" msgid="827206218118093357">"Usar o Gerenciador de bateria"</string>
    <string name="battery_auto_restriction_summary" msgid="2140896101984815711">"Detectar quando apps estiverem descarregando a bateria"</string>
    <string name="battery_manager_summary" msgid="255708681438809287">"Detectar quando apps estiverem descarregando a bateria"</string>
    <string name="battery_manager_summary_unsupported" msgid="7334173707292807964">"Detectar quando apps estiverem descarregando a bateria"</string>
    <string name="battery_manager_app_restricted" msgid="2583902700677009173">"{count,plural, =1{# app restrito}one{# app restrito}other{# apps restritos}}"</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">"Erro ao ler o medidor de bateria."</string>
    <string name="battery_missing_link_message" msgid="6021565067124898074"></string>
    <string name="battery_missing_link_a11y_message" msgid="3310971406602316323">"Toque para saber mais sobre o erro"</string>
    <string name="power_screen" msgid="4596900105850963806">"Tela"</string>
    <string name="power_cpu" msgid="1820472721627148746">"CPU"</string>
    <string name="power_flashlight" msgid="8993388636332573202">"Lanterna"</string>
    <string name="power_camera" msgid="4778315081581293923">"Câmera"</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">"Rede móvel"</string>
    <string name="power_phone" msgid="2768396619208561670">"Chamadas de voz"</string>
    <string name="battery_screen_usage" msgid="90008745183187461">"Uso da tela: <xliff:g id="TIME">^1</xliff:g>"</string>
    <string name="battery_used_by" msgid="6457305178016189330">"<xliff:g id="PERCENT">%1$s</xliff:g> de uso 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> da bateria total"</string>
    <string name="battery_detail_since_full_charge" msgid="5650946565524184582">"Detalhamento desde a última carga completa"</string>
    <string name="battery_last_full_charge" msgid="8308424441475063956">"Última carga completa"</string>
    <string name="battery_full_charge_last" msgid="465146408601016923">"A carga completa dura cerca de"</string>
    <string name="battery_footer_summary" msgid="6753248007004259000">"A duração restante da bateria é aproximada e pode mudar de acordo com o uso"</string>
    <string name="battery_detail_power_usage" msgid="1492926471397355477">"Uso da bateria"</string>
    <string name="battery_not_usage" msgid="3851536644733662392">"Não houve uso desde a última carga completa"</string>
    <string name="battery_not_usage_24hr" msgid="8397519536160741248">"Sem uso nas últimas 24h"</string>
    <string name="battery_usage_without_time" msgid="1346894834339420538"></string>
    <string name="battery_usage_since_last_full_charge" msgid="3488425008925924769">"desde a última carga completa"</string>
    <string name="battery_usage_system_apps" msgid="8659537819731575299">"Apps do sistema"</string>
    <string name="battery_usage_uninstalled_apps" msgid="8170405012552803662">"Apps desinstalados"</string>
    <string name="battery_usage_others" msgid="311793281613609986">"Outros"</string>
    <string name="estimated_time_left" msgid="948717045180211777">"Tempo restante estimado"</string>
    <string name="estimated_charging_time_left" msgid="2287135413363961246">"Até a carga completa"</string>
    <string name="estimated_time_description" msgid="211058785418596009">"A estimativa pode mudar conforme o uso"</string>
    <string name="process_mediaserver_label" msgid="6135260215912215092">"Servidor de mídia"</string>
    <string name="process_dex2oat_label" msgid="1190208677726583153">"Otimização do app"</string>
    <string name="process_network_tethering" msgid="6822671758152900766">"Tethering"</string>
    <string name="process_removed_apps" msgid="6544406592678476902">"Apps removidos"</string>
    <string name="battery_saver" msgid="7737147344510595864">"Economia de bateria"</string>
    <string name="battery_saver_auto_title" msgid="6789753787070176144">"Ativar automaticamente"</string>
    <string name="battery_saver_auto_no_schedule" msgid="5123639867350138893">"Sem programação"</string>
    <string name="battery_saver_auto_routine" msgid="4656495097900848608">"Com base na sua rotina"</string>
    <string name="battery_saver_pref_auto_routine_summary" msgid="4739240095966241508">"Será ativada com base na sua rotina"</string>
    <string name="battery_saver_auto_percentage" msgid="558533724806281980">"Com base na porcentagem"</string>
    <string name="battery_saver_auto_routine_summary" msgid="3913145448299472628">"A Economia de bateria é ativada quando há possibilidade de a bateria acabar antes da próxima carga usual"</string>
    <string name="battery_saver_auto_percentage_summary" msgid="6190884450723824287">"Será ativada em <xliff:g id="PERCENT">%1$s</xliff:g>"</string>
    <string name="battery_saver_schedule_settings_title" msgid="3688019979950082237">"Definir uma programação"</string>
    <string name="battery_saver_turn_on_summary" msgid="1433919417587171160">"Prolongar a duração da bateria"</string>
    <string name="battery_saver_sticky_title_new" msgid="5942813274115684599">"Desativar após carregar"</string>
    <string name="battery_saver_sticky_title_percentage" msgid="1178162022087559148">"Desativar em <xliff:g id="BATTERY_PERCENTAGE">%1$s</xliff:g>"</string>
    <string name="battery_saver_sticky_description_new" msgid="6472610662679038342">"A Economia de bateria é desativada quando a carga atinge <xliff:g id="BATTERY_PERCENTAGE">%1$s</xliff:g>"</string>
    <!-- no translation found for battery_saver_seekbar_title (3712266470054006641) -->
    <skip />
    <string name="battery_saver_seekbar_title_placeholder" msgid="7141264642540687540">"Ativar"</string>
    <string name="battery_saver_master_switch_title" msgid="3474312070095834915">"Usar a Economia de bateria"</string>
    <string name="battery_saver_turn_on_automatically_title" msgid="7857393318205740864">"Ativar automaticamente"</string>
    <string name="battery_saver_turn_on_automatically_never" msgid="6194649389871448663">"Nunca"</string>
    <string name="battery_saver_turn_on_automatically_pct" msgid="4294335680892392449">"com <xliff:g id="PERCENT">%1$s</xliff:g> de bateria"</string>
    <string name="battery_percentage" msgid="1779934245963043490">"Porcentagem da bateria"</string>
    <string name="battery_percentage_description" msgid="2321465139126125541">"Mostrar a porcentagem da bateria na barra de status"</string>
    <string name="battery_usage_chart_graph_hint_last_full_charge" msgid="6570336408060566877">"Nível da bateria desde a última carga completa"</string>
    <string name="battery_usage_chart_graph_hint" msgid="9182079098173323005">"Nível da bateria nas últimas 24h"</string>
    <string name="battery_app_usage" msgid="8976453608783133770">"Uso de apps desde a última carga completa"</string>
    <string name="battery_app_usage_for_past_24" msgid="1234770810563940656">"Uso do app nas últimas 24h"</string>
    <string name="battery_system_usage" msgid="1395943945140097585">"Uso do sistema desde a última carga completa"</string>
    <string name="battery_system_usage_for_past_24" msgid="3341520273114616263">"Uso do sistema nas últimas 24h"</string>
    <string name="battery_system_usage_for" msgid="3248552137819897140">"Uso do sistema entre <xliff:g id="SLOT">%s</xliff:g>"</string>
    <string name="battery_app_usage_for" msgid="7309909074935858949">"Uso do app em <xliff:g id="SLOT">%s</xliff:g>"</string>
    <string name="battery_system_usage_since_last_full_charge_to" msgid="4196795733829841971">"Uso do sistema desde a última carga completa <xliff:g id="SLOT_TIMESTAMP">%s</xliff:g>"</string>
    <string name="battery_app_usage_since_last_full_charge_to" msgid="4339201995118102114">"Uso do app desde a última carga completa <xliff:g id="SLOT_TIMESTAMP">%s</xliff:g>"</string>
    <string name="battery_usage_total_less_than_one_minute" msgid="1035425863251685509">"Total: menos de um minuto"</string>
    <string name="battery_usage_background_less_than_one_minute" msgid="3957971442554437909">"Segundo plano: menos de um minuto"</string>
    <string name="battery_usage_screen_time_less_than_one_minute" msgid="2911989465891679033">"Tempo de uso: menos de um minuto"</string>
    <string name="power_usage_time_less_than_one_minute" msgid="8407404329381010144">"Menos de um 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">"Segundo plano: <xliff:g id="TIME">%s</xliff:g>"</string>
    <string name="battery_usage_screen_time" msgid="3973865893520804115">"Tempo de uso: <xliff:g id="TIME">%s</xliff:g>"</string>
    <string name="battery_usage_screen_footer_empty" msgid="3301144846133808193">"Os dados de uso da bateria ficam disponíveis algumas horas depois do carregamento total"</string>
    <string name="battery_usage_chart_label_now" msgid="4598282721949430165">"agora"</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_time_info_and_battery_level" msgid="6732629268310936155">"<xliff:g id="TIME_INFO">%1$s</xliff:g>. <xliff:g id="BATTERY_LEVEL">%2$s</xliff:g>⁠"</string>
    <string name="battery_usage_chart" msgid="4114747521432440017">"Gráfico de uso da bateria"</string>
    <string name="daily_battery_usage_chart" msgid="4176059567682992686">"Gráfico de uso diário da bateria"</string>
    <string name="hourly_battery_usage_chart" msgid="3098314511076561272">"Gráfico de uso da bateria por hora"</string>
    <string name="battery_level_percentage" msgid="1433178290838842146">"Mudança na porcentagem do nível de bateria de <xliff:g id="START_PERCENTAGE">%1$s</xliff:g> para <xliff:g id="END_PERCENTAGE">%2$s</xliff:g>"</string>
    <string name="battery_usage_breakdown_title_since_last_full_charge" msgid="435006273323199906">"Uso da bateria desde a última carga completa"</string>
    <string name="battery_usage_breakdown_title_for_slot" msgid="4823179483667671406">"Uso da bateria no período: <xliff:g id="SLOT">%s</xliff:g>"</string>
    <string name="screen_time_category_last_full_charge" msgid="8856908320256057753">"Tempo de uso desde a última carga completa"</string>
    <string name="screen_time_category_for_slot" msgid="8287722270554654959">"Tempo de uso no período: <xliff:g id="SLOT">%s</xliff:g>"</string>
    <string name="battery_usage_spinner_view_by_apps" msgid="8769276544072098082">"Visualizar por apps"</string>
    <string name="battery_usage_spinner_view_by_systems" msgid="7904104223212160541">"Visualizar por sistemas"</string>
    <string name="battery_usage_less_than_percent" msgid="5873099028895001082">"Menos de <xliff:g id="PERCENTAGE">%1$s</xliff:g>"</string>
    <string name="battery_cycle_count_footer" msgid="3642121059800373545">"Devido a inspeções de qualidade realizadas antes do envio, a contagem de ciclos pode não estar zerada no primeiro uso"</string>
    <string name="process_stats_summary_title" msgid="502683176231281732">"Estatísticas de processo"</string>
    <string name="process_stats_summary" msgid="522842188571764699">"Estatísticas detalhadas sobre os processos em execução"</string>
    <string name="app_memory_use" msgid="7559666138324410666">"Uso da memória"</string>
    <string name="process_stats_total_duration" msgid="3898635541254636618">"<xliff:g id="USEDRAM">%1$s</xliff:g> de <xliff:g id="TOTALRAM">%2$s</xliff:g> usados durante <xliff:g id="TIMEDURATION">%3$s</xliff:g>"</string>
    <string name="process_stats_total_duration_percentage" msgid="4391502694312709148">"<xliff:g id="PERCENT">%1$s</xliff:g> de RAM usado durante <xliff:g id="TIMEDURATION">%2$s</xliff:g>"</string>
    <string name="process_stats_type_background" msgid="4094034441562453522">"Segundo plano"</string>
    <string name="process_stats_type_foreground" msgid="5043049335546793803">"Primeiro plano"</string>
    <string name="process_stats_type_cached" msgid="129788969589599563">"Em cache"</string>
    <string name="process_stats_os_label" msgid="2096501347732184886">"Sistema operacional Android"</string>
    <string name="process_stats_os_native" msgid="794547105037548539">"Native"</string>
    <string name="process_stats_os_kernel" msgid="5626269994512354996">"Kernel"</string>
    <string name="process_stats_os_zram" msgid="3067278664868354143">"Z-Ram"</string>
    <string name="process_stats_os_cache" msgid="4753163023524305711">"Caches"</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 (segundo plano)"</string>
    <string name="process_stats_run_time" msgid="8631920944819076418">"Tempo de execução"</string>
    <string name="processes_subtitle" msgid="5791138718719605724">"Processos"</string>
    <string name="services_subtitle" msgid="9136741140730524046">"Serviços"</string>
    <string name="menu_proc_stats_duration" msgid="1249684566371309908">"Duração"</string>
    <string name="mem_details_title" msgid="8064756349669711949">"Detalhes da memória"</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 dia"</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 porcentagens"</string>
    <string name="menu_use_uss" msgid="1663914348353623749">"Usar Uss"</string>
    <string name="menu_proc_stats_type" msgid="5048575824389855689">"Tipo de estatísticas"</string>
    <string name="menu_proc_stats_type_background" msgid="6796434633192284607">"Segundo plano"</string>
    <string name="menu_proc_stats_type_foreground" msgid="9011432748521890803">"Primeiro plano"</string>
    <string name="menu_proc_stats_type_cached" msgid="1351321959600144622">"Em cache"</string>
    <string name="voice_input_output_settings" msgid="1055497319048272051">"Entrada e saída de voz"</string>
    <string name="voice_input_output_settings_title" msgid="6449454483955543064">"Configurações de entrada e saída de voz"</string>
    <string name="voice_search_settings_title" msgid="228743187532160069">"Pesquisa por voz"</string>
    <string name="keyboard_settings_title" msgid="2199286020368890114">"Teclado Android"</string>
    <string name="voice_input_settings" msgid="105821652985768064">"Configurações da entrada de texto por voz"</string>
    <string name="voice_input_settings_title" msgid="3708147270767296322">"Entrada de texto por voz"</string>
    <string name="voice_service_preference_section_title" msgid="4807795449147187497">"Serviços de entrada de texto por voz"</string>
    <string name="voice_interactor_preference_summary" msgid="3942881638813452880">"Hotword completa e interação"</string>
    <string name="voice_recognizer_preference_summary" msgid="9195427725367463336">"Conversão simples de fala em texto"</string>
    <string name="voice_interaction_security_warning" msgid="7962884055885987671">"Este serviço de entrada por voz poderá executar monitoramento por voz sempre ativado e apps com o recurso de comando de voz em seu nome. Ele está incluído no app <xliff:g id="VOICE_INPUT_SERVICE_APP_NAME">%s</xliff:g>. Quer ativar o uso deste serviço?"</string>
    <string name="on_device_recognition_settings" msgid="6503160369314598069">"Configurações de reconhecimento no dispositivo"</string>
    <string name="on_device_recognition_settings_title" msgid="7137599722039096545">"Reconhecimento no dispositivo"</string>
    <string name="on_device_recognition_settings_summary" msgid="3292736423223499348">"Reconhecimento de fala no dispositivo"</string>
    <string name="tts_engine_preference_title" msgid="7808775764174571132">"Mecanismo preferencial"</string>
    <string name="tts_engine_settings_title" msgid="1298093555056321577">"Configurações do mecanismo"</string>
    <string name="tts_sliders_title" msgid="6901146958648426181">"Velocidade da fala e tom de voz"</string>
    <string name="tts_engine_section_title" msgid="5115035218089228451">"Mecanismo"</string>
    <string name="tts_install_voice_title" msgid="5133545696447933812">"Vozes"</string>
    <string name="tts_spoken_language" msgid="4652894245474520872">"Idioma falado"</string>
    <string name="tts_install_voices_title" msgid="6505257816336165782">"Instalar vozes"</string>
    <string name="tts_install_voices_text" msgid="902408506519246362">"Continue no app <xliff:g id="TTS_APP_NAME">%s</xliff:g> para instalar as vozes"</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">"Redefinir"</string>
    <string name="tts_play" msgid="2945513377250757221">"Reproduzir"</string>
    <string name="vpn_settings_title" msgid="9131315656202257272">"VPN"</string>
    <string name="vpn_settings_insecure_single" msgid="9012504179995045195">"Não segura"</string>
    <string name="vpn_settings_single_insecure_multiple_total" msgid="6107225844641301139">"<xliff:g id="VPN_COUNT">%d</xliff:g> não segura"</string>
    <string name="vpn_settings_multiple_insecure_multiple_total" msgid="1706236062478680488">"<xliff:g id="VPN_COUNT">%d</xliff:g> não segura"</string>
    <string name="adaptive_connectivity_title" msgid="7464959640138428192">"Conectividade adaptável"</string>
    <string name="adaptive_connectivity_summary" msgid="3648731530666326885">"Aumenta a duração da bateria e melhora o desempenho do dispositivo ao gerenciar suas conexões de rede automaticamente"</string>
    <string name="adaptive_connectivity_switch_on" msgid="3653067561620745493">"Ativado"</string>
    <string name="adaptive_connectivity_switch_off" msgid="5076172560836115265">"Desativada"</string>
    <string name="adaptive_connectivity_main_switch_title" msgid="261045483524512420">"Usar Conectividade adaptável"</string>
    <string name="credentials_title" msgid="7535942196886123656">"Armazenamento de credenciais"</string>
    <string name="credentials_install" msgid="3933218407598415827">"Instalar um certificado"</string>
    <string name="credentials_reset" msgid="4246628389366452655">"Limpar credenciais"</string>
    <string name="credentials_reset_summary" msgid="5400585520572874255">"Remover todos os certificados"</string>
    <string name="trusted_credentials" msgid="2522784976058244683">"Credenciais confiáveis"</string>
    <string name="trusted_credentials_summary" msgid="345822338358409468">"Mostrar os certificados e as autoridades de confiança"</string>
    <string name="user_credentials" msgid="4044405430790970775">"Credenciais do usuário"</string>
    <string name="user_credentials_summary" msgid="686471637627271856">"Ver e modificar as credenciais armazenadas"</string>
    <string name="advanced_security_title" msgid="7117581975877192652">"Avançado"</string>
    <string name="credentials_settings_not_available" msgid="7433088409177429600">"As credenciais não estão disponíveis para este usuário"</string>
    <string name="credential_for_vpn_and_apps" msgid="2208229692860871136">"Instalada para VPN e apps"</string>
    <string name="credential_for_wifi" msgid="2286560570630763556">"Instalada para Wi-Fi"</string>
    <string name="credential_for_wifi_in_use" msgid="7276290656840986618">"Instalada para Wi-Fi (em uso)"</string>
    <string name="credentials_reset_hint" msgid="4054601857203464867">"Remover todo o conteúdo?"</string>
    <string name="credentials_erased" msgid="9121052044566053345">"Armazenamento de credenciais apagado."</string>
    <string name="credentials_not_erased" msgid="3611058412683184031">"Armaz. de creden. não apagado."</string>
    <string name="usage_access_title" msgid="1580006124578134850">"Apps com acesso ao uso"</string>
    <string name="ca_certificate" msgid="3076484307693855611">"Certificado de CA"</string>
    <string name="user_certificate" msgid="6897024598058566466">"Cert. do usuário do app e VPN"</string>
    <string name="wifi_certificate" msgid="8461905432409380387">"Certificado de Wi-Fi"</string>
    <string name="ca_certificate_warning_title" msgid="7951148441028692619">"Seus dados não serão particulares"</string>
    <string name="ca_certificate_warning_description" msgid="8409850109551028774">"Os certificados de CA são usados por sites, apps e VPNs para criptografia. Instale apenas os certificados de CA de organizações em que você confia. \n\nSe você instalar um certificado de CA, o proprietário dele poderá acessar seus dados, como senhas ou detalhes do cartão de crédito, nos sites visitados ou apps usados, mesmo que esses dados estejam criptografados."</string>
    <string name="certificate_warning_dont_install" msgid="3794366420884560605">"Não instalar"</string>
    <string name="certificate_warning_install_anyway" msgid="4633118283407228740">"Instalar assim mesmo"</string>
    <string name="cert_not_installed" msgid="6725137773549974522">"Certificado não instalado"</string>
    <string name="request_manage_credentials_title" msgid="596805634568013413">"Permitir que "<b>"<xliff:g id="APP_NAME">^1</xliff:g>"</b>" instale certificados neste dispositivo?"</string>
    <string name="request_manage_credentials_description" msgid="8044839857171509619">"Para confirmar sua identidade, os certificados compartilharão o ID exclusivo do seu dispositivo com os apps e URLs abaixo"</string>
    <string name="request_manage_credentials_dont_allow" msgid="3630610197644877809">"Não permitir"</string>
    <string name="request_manage_credentials_allow" msgid="4910940118408348245">"Permitir"</string>
    <string name="request_manage_credentials_more" msgid="6101210283534101582">"Mostrar mais"</string>
    <string name="certificate_management_app" msgid="8086699498358080826">"App de gerenc. de certificados"</string>
    <string name="no_certificate_management_app" msgid="3025739370424406717">"Nenhum"</string>
    <string name="certificate_management_app_description" msgid="8507306554200869005">"Os certificados confirmarão sua identidade quando você usar os apps e URLs abaixo"</string>
    <string name="uninstall_certs_credential_management_app" msgid="4945883254446077354">"Desinstalar certificados"</string>
    <string name="remove_credential_management_app" msgid="6089291496976812786">"Remover app"</string>
    <string name="remove_credential_management_app_dialog_title" msgid="5713525435104706772">"Remover este app?"</string>
    <string name="remove_credential_management_app_dialog_message" msgid="7739474298063646935">"Este app não gerenciará certificados, mas ficará no seu dispositivo. Todos os certificados instalados por ele serão desinstalados."</string>
    <string name="number_of_urls" msgid="1128699121050872188">"{count,plural, =1{# URL}one{# URL}other{# URLs}}"</string>
    <string name="emergency_tone_title" msgid="6673118505206685168">"Sinal de discagem de emergência"</string>
    <string name="emergency_tone_summary" msgid="2519776254708767388">"Definir comportamento durante uma chamada de emergência"</string>
    <string name="privacy_settings_title" msgid="6437057228255974577">"Backup"</string>
    <string name="backup_section_title" msgid="6539706829848457794">"Backup e restauração"</string>
    <string name="personal_data_section_title" msgid="6368610168625722682">"Dados pessoais"</string>
    <string name="backup_data_title" msgid="507663517227498525">"Fazer backup"</string>
    <string name="backup_data_summary" msgid="8054551085241427531">"Fazer backup de dados de apps, senhas de redes Wi-Fi e outras configurações nos servidores do Google"</string>
    <string name="backup_configure_account_title" msgid="8574055186903658842">"Conta de backup"</string>
    <string name="backup_data_management_title" msgid="6596830198441939702">"Gerenciar conta de backup"</string>
    <string name="include_app_data_title" msgid="2969603876620594523">"Incluir dados de apps"</string>
    <string name="auto_restore_title" msgid="4124345897936637561">"Restauração automática"</string>
    <string name="auto_restore_summary" msgid="6830198851045584001">"Restaurar as configurações de backup e dados ao reinstalar um app"</string>
    <string name="backup_inactive_title" msgid="6753265378043349277">"O serviço de backup não está ativo"</string>
    <string name="backup_configure_account_default_summary" msgid="5323225330966306690">"Nenhuma conta está armazenando o backup dos dados"</string>
    <string name="backup_erase_dialog_title" msgid="5892431263348766484"></string>
    <string name="backup_erase_dialog_message" msgid="2250872501409574331">"Interromper o backup de suas senhas de redes Wi-Fi, favoritos, outras configurações e dados de apps e apagar todas as cópias nos servidores do Google?"</string>
    <string name="fullbackup_erase_dialog_message" msgid="2379053988557486162">"Interromper o backup de dados do dispositivo (como senhas de Wi-Fi e histórico de ligações) e de dados de apps (como configurações e arquivos armazenados por apps) e limpar todas as cópias em servidores remotos?"</string>
    <string name="fullbackup_data_summary" msgid="971587401251601473">"Fazer backup automático de dados do dispositivo (como senhas de Wi-Fi e histórico de ligações) e dados de apps (como configurações e arquivos armazenados por apps) remotamente.\n\nQuando você ativa o backup automático, os dados do dispositivo e de apps são salvos periodicamente de modo remoto. Dados de apps podem ser quaisquer dados que um app tenha salvo (com base nas configurações de desenvolvedores), incluindo dados potencialmente confidenciais, como contatos, mensagens e fotos."</string>
    <string name="device_admin_settings_title" msgid="31392408594557070">"Configurações do administrador do dispositivo"</string>
    <string name="active_device_admin_msg" msgid="7744106305636543184">"App de administrador do dispositivo"</string>
    <string name="remove_device_admin" msgid="3143059558744287259">"Desativar este app de administrador do dispositivo"</string>
    <string name="uninstall_device_admin" msgid="4481095209503956916">"Desinstalar app"</string>
    <string name="remove_and_uninstall_device_admin" msgid="707912012681691559">"Desativar e desinstalar"</string>
    <string name="select_device_admin_msg" msgid="5501360309040114486">"Apps do administrador do dispositivo"</string>
    <string name="no_device_admins" msgid="8888779888103079854">"Nenhum app de administrador do dispositivo disponível"</string>
    <string name="no_trust_agents" msgid="8659098725864191600">"Nenhum agente de confiança disponível"</string>
    <string name="add_device_admin_msg" msgid="7730006568970042119">"Ativar app de admin. do dispositivo?"</string>
    <string name="add_device_admin" msgid="6252128813507932519">"Ativar o app de administrador deste dispositivo"</string>
    <string name="device_admin_add_title" msgid="6087481040932322289">"Administrador do dispositivo"</string>
    <string name="device_admin_warning" msgid="1889160106787280321">"A ativação deste administrador permitirá que o app <xliff:g id="APP_NAME">%1$s</xliff:g> execute as seguintes operações:"</string>
    <string name="device_admin_warning_simplified" msgid="2715756519899116115">"Este dispositivo será gerenciado e monitorado por <xliff:g id="APP_NAME">%1$s</xliff:g>."</string>
    <string name="device_admin_status" msgid="6332571781623084064">"Este app de administrador está ativado e permite que o <xliff:g id="APP_NAME">%1$s</xliff:g> execute as seguintes operações:"</string>
    <string name="profile_owner_add_title" msgid="2774489881662331549">"Ativar Gerenciador de perfis?"</string>
    <string name="profile_owner_add_title_simplified" msgid="2320828996993774182">"Permitir supervisão?"</string>
    <string name="adding_profile_owner_warning" msgid="6868275476058020513">"Ao prosseguir, o usuário será gerenciado pelo seu administrador, que também poderá armazenar dados associados, bem como dados pessoais.\n\nSeu administrador pode monitorar e gerenciar configurações, acesso, apps e dados associados a esse usuário, incluindo informações de atividade de rede e local do dispositivo."</string>
    <string name="admin_disabled_other_options" msgid="8122039047419172139">"Outras opções estão desativadas pelo seu administrador"</string>
    <string name="admin_more_details" msgid="4928985331640193758">"Saiba mais"</string>
    <string name="notification_log_title" msgid="2812594935014664891">"Registro de notificação"</string>
    <string name="notification_history_title" msgid="8821060912502593309">"Histórico de notificações"</string>
    <string name="notification_history_today" msgid="6081829638548808795">"Últimas %d horas"</string>
    <string name="notification_history_snooze" msgid="3980568893290512257">"Adiadas"</string>
    <string name="notification_history_dismiss" msgid="6180321217375722918">"Dispensadas recentemente"</string>
    <string name="notification_history_count" msgid="885305572972482838">"{count,plural, =1{# notificação}one{# notificação}other{# notificações}}"</string>
    <string name="sound_category_call_ringtone_vibrate_title" msgid="9090693401915654528">"Toque e vibração de chamadas"</string>
    <string name="wifi_setup_detail" msgid="2012898800571616422">"Detalhes da rede"</string>
    <string name="accessibility_sync_enabled" msgid="5308864640407050209">"Sincronização ativada"</string>
    <string name="accessibility_sync_disabled" msgid="5507600126380593611">"Sincronização desativada"</string>
    <string name="accessibility_sync_in_progress" msgid="3229428197779196660">"Sincronizando agora"</string>
    <string name="accessibility_sync_error" msgid="7248490045013170437">"Erro de sincronização."</string>
    <string name="sync_failed" msgid="3806495232114684984">"Falha na sincronização"</string>
    <string name="sync_active" msgid="5787407579281739975">"Sincronização ativa"</string>
    <string name="account_sync_settings_title" msgid="2684888109902800966">"Sincronização"</string>
    <string name="sync_is_failing" msgid="6738004111400633331">"A sincronização está enfrentando problemas no momento. Ela retornará em breve."</string>
    <string name="add_account_label" msgid="7134707140831385869">"Adicionar conta"</string>
    <string name="managed_profile_not_available_label" msgid="7500578232182547365">"Perfil de trabalho ainda indisponível"</string>
    <string name="work_mode_label" msgid="4687734487641548872">"Apps de trabalho"</string>
    <string name="remove_managed_profile_label" msgid="1294933737673830431">"Remover perfil de trabalho"</string>
    <string name="background_data" msgid="321903213000101158">"Dados de segundo plano"</string>
    <string name="background_data_summary" msgid="6572245922513522466">"Aplicat. sincronizam, enviam e recebem dados a qualquer hora"</string>
    <string name="background_data_dialog_title" msgid="1692005302993229867">"Des. dados 2º plan.?"</string>
    <string name="background_data_dialog_message" msgid="7760280837612824670">"A desativação dos dados de segundo plano estende a vida útil da bateria e diminui o uso dos dados. Alguns apps ainda podem usar a conexão de dados de segundo plano."</string>
    <string name="sync_enabled" msgid="5794103781356455043">"A sinc. está ATIVADA"</string>
    <string name="sync_disabled" msgid="1636223106968593391">"Sincronização DESATIVADA"</string>
    <string name="sync_error" msgid="846923369794727644">"Erro na sinc."</string>
    <string name="last_synced" msgid="1527008461298110443">"Última sincronização em <xliff:g id="LAST_SYNC_TIME">%1$s</xliff:g>"</string>
    <string name="sync_in_progress" msgid="6200093151211458977">"Sincronizando agora..."</string>
    <string name="settings_backup" msgid="5357973563989458049">"Fazer backup das configurações"</string>
    <string name="settings_backup_summary" msgid="6803046376335724034">"Fazer backup de minhas configurações"</string>
    <string name="sync_menu_sync_now" msgid="3948443642329221882">"Sincronizar agora"</string>
    <string name="sync_menu_sync_cancel" msgid="2422994461106269813">"Cancelar sincronização"</string>
    <string name="sync_one_time_sync" msgid="8114337154112057462">"Toque para sincronizar agora<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">"Agenda"</string>
    <string name="sync_contacts" msgid="2376465611511325472">"Contatos"</string>
    <string name="header_application_sync_settings" msgid="7427706834875419243">"Configurações de sincronização do app"</string>
    <string name="header_data_and_synchronization" msgid="453920312552838939">"Dados e sincronização"</string>
    <string name="preference_change_password_title" msgid="5465821666939825972">"Alterar senha"</string>
    <string name="header_account_settings" msgid="1189339410278750008">"Configurações da conta"</string>
    <string name="remove_account_label" msgid="4169490568375358010">"Remover conta"</string>
    <string name="header_add_an_account" msgid="3919151542338822661">"Adicionar uma conta"</string>
    <string name="really_remove_account_title" msgid="253097435885652310">"Remover conta?"</string>
    <string name="remove_account_failed" msgid="3709502163548900644">"Esta alteração não é permitida pelo administrador"</string>
    <string name="cant_sync_dialog_title" msgid="2613000568881139517">"Não é possível sincronizar manualmente"</string>
    <string name="cant_sync_dialog_message" msgid="7612557105054568581">"A sincronização para o item está desativada no momento. Para alterar essa configuração, ative os dados de segundo plano e a sincronização automática temporariamente."</string>
    <string name="delete" msgid="8330605554706263775">"Excluir"</string>
    <string name="select_all" msgid="7898929601615536401">"Selecionar tudo"</string>
    <string name="data_usage_summary_title" msgid="394067070764360142">"Uso de dados"</string>
    <string name="data_usage_app_summary_title" msgid="4933742247928064178">"Dados móveis e Wi‑Fi"</string>
    <string name="account_settings_menu_auto_sync_personal" msgid="2905595464540145671">"Sincronizar dados pessoais"</string>
    <string name="account_settings_menu_auto_sync_work" msgid="8561102487795657789">"Sincronizar dados de trabalho automaticamente"</string>
    <string name="account_settings_menu_auto_sync_private" msgid="2315144351530596228">"Sincronizar dados particulares automaticamente"</string>
    <string name="data_usage_change_cycle" msgid="4501026427365283899">"Alterar ciclo..."</string>
    <string name="data_usage_pick_cycle_day" msgid="3548922497494790123">"Dia do mês para redefinir o ciclo de uso dos dados:"</string>
    <string name="data_usage_empty" msgid="5619908658853726866">"Nenhum app usou dados durante o período."</string>
    <string name="data_usage_label_foreground" msgid="8782117644558473624">"Primeiro plano"</string>
    <string name="data_usage_label_background" msgid="8862781660427421859">"Segundo plano"</string>
    <string name="data_usage_app_restricted" msgid="312065316274378518">"restrito"</string>
    <string name="data_usage_disable_mobile" msgid="6183809500102606801">"Desativar os dados móveis?"</string>
    <string name="data_usage_disable_mobile_limit" msgid="1370147078938479538">"Definir limite de dados móveis"</string>
    <string name="data_usage_disable_4g_limit" msgid="3084868504051520840">"Definir limite de dados 4G"</string>
    <string name="data_usage_disable_3g_limit" msgid="8867555130268898044">"Definir limite de dados 2G/3G"</string>
    <string name="data_usage_disable_wifi_limit" msgid="7222459951785404241">"Limitar dados 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óvel"</string>
    <string name="data_usage_tab_4g" msgid="3265237821331861756">"4G"</string>
    <string name="data_usage_tab_3g" msgid="6111070409752123049">"2G e 3G"</string>
    <string name="data_usage_list_mobile" msgid="3738130489722964291">"Celular"</string>
    <string name="data_usage_list_none" msgid="2091924522549134855">"Nenhum"</string>
    <string name="data_usage_enable_mobile" msgid="1996943748103310201">"Dados móveis"</string>
    <string name="data_usage_enable_3g" msgid="2818189799905446932">"Dados 2G e 3G"</string>
    <string name="data_usage_enable_4g" msgid="1526584080251993023">"Dados 4G"</string>
    <string name="data_roaming_enable_mobile" msgid="5745287603577995977">"Itinerância"</string>
    <string name="data_usage_forground_label" msgid="5762048187044975428">"Primeiro plano:"</string>
    <string name="data_usage_background_label" msgid="5363718469293175279">"Segundo plano:"</string>
    <string name="data_usage_app_settings" msgid="5693524672522122485">"Configurar app"</string>
    <string name="data_usage_app_restrict_background" msgid="5728840276368097276">"Dados em segundo plano"</string>
    <string name="data_usage_app_restrict_background_summary" msgid="2997942775999602794">"Ativar o uso de dados móveis em segundo plano"</string>
    <string name="data_usage_app_restrict_background_summary_disabled" msgid="8213268097024597864">"Definir um limite de dados para restringir dados em 2º plano"</string>
    <string name="data_usage_app_restrict_dialog_title" msgid="5383874438677899255">"Restringir dados de segundo plano?"</string>
    <string name="data_usage_app_restrict_dialog" msgid="5534272311979978297">"Este recurso pode fazer com que um app que depende de dados de segundo plano pare de funcionar quando somente redes de acesso limitado estiverem disponíveis.\n\nVocê pode encontrar controles de uso de dados mais apropriados nas configurações disponíveis no app."</string>
    <string name="data_usage_restrict_denied_dialog" msgid="8599940395497268584">"A restrição de dados de segundo plano só é possível quando você define um limite de dados móveis."</string>
    <string name="data_usage_auto_sync_on_dialog_title" msgid="2048411447974361181">"Ativar sincronização automática?"</string>
    <string name="data_usage_auto_sync_off_dialog_title" msgid="1783917145440587470">"Desativar sincroniz. automática?"</string>
    <string name="data_usage_auto_sync_off_dialog" msgid="6523112583569674837">"Isso vai preservar o uso de dados e da bateria, mas será necessário sincronizar manualmente cada conta para acessar as informações mais recentes, e você não vai receber notificações de novas atualizações."</string>
    <string name="data_usage_cycle_editor_title" msgid="2019035830921480941">"Escolha o dia de início do ciclo"</string>
    <string name="data_usage_cycle_editor_subtitle" msgid="1026234456777365545">"Data de cada mês:"</string>
    <string name="data_usage_cycle_editor_positive" msgid="6110165528024717527">"Definir"</string>
    <string name="data_usage_warning_editor_title" msgid="5252748452973120016">"Definir alerta de uso de dados"</string>
    <string name="data_usage_limit_editor_title" msgid="8826855902435008518">"Definir limite do uso de dados"</string>
    <string name="data_usage_limit_dialog_title" msgid="2053134451707801439">"Limitar o uso de dados"</string>
    <string name="data_usage_sweep_warning" msgid="2072854703184614828"><font size="12">"Alerta:"</font>\n<font size="18">"<xliff:g id="NUMBER">^1</xliff:g>"</font>" "<font size="9">"<xliff:g id="UNIT">^2</xliff:g>"</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">"limite"</font></string>
    <string name="data_usage_uninstalled_apps" msgid="9065885396147675694">"Apps removidos"</string>
    <string name="data_usage_uninstalled_apps_users" msgid="1262228664057122983">"Apps e usuários removidos"</string>
    <string name="wifi_metered_title" msgid="6623732965268033931">"Uso da rede"</string>
    <string name="data_usage_metered_yes" msgid="4262598072030135223">"Limitada"</string>
    <string name="vpn_name" msgid="3806456074909253262">"Nome"</string>
    <string name="vpn_type" msgid="5533202873260826663">"Tipo"</string>
    <string name="vpn_server" msgid="2908816134941973935">"Endereço do servidor"</string>
    <string name="vpn_ipsec_identifier" msgid="8511842694369254801">"Identificador IPSec"</string>
    <string name="vpn_ipsec_secret" msgid="532007567355505963">"Chave pré-compartilhada IPSec"</string>
    <string name="vpn_ipsec_user_cert" msgid="2714372103705048405">"Certificado de usuário IPSec"</string>
    <string name="vpn_ipsec_ca_cert" msgid="5558498943577474987">"Certificado de CA IPSec"</string>
    <string name="vpn_ipsec_server_cert" msgid="1411390470454731396">"Certificado de servidor IPSec"</string>
    <string name="vpn_show_options" msgid="6105437733943318667">"Mostrar opções avançadas"</string>
    <string name="vpn_username" msgid="8671768183475960068">"Nome de usuário"</string>
    <string name="vpn_password" msgid="1183746907642628127">"Senha"</string>
    <string name="vpn_save_login" msgid="5986762519977472618">"Salvar informações sobre a conta"</string>
    <string name="vpn_not_used" msgid="7229312881336083354">"Não utilizado"</string>
    <string name="vpn_no_ca_cert" msgid="3687379414088677735">"(não verificar servidor)"</string>
    <string name="vpn_no_server_cert" msgid="8106540968643125407">"(recebido de um servidor)"</string>
    <string name="vpn_always_on_invalid_reason_other" msgid="4571905303713233321">"As informações inseridas não são compatíveis com VPN sempre ativa"</string>
    <string name="vpn_cancel" msgid="5929410618112404383">"Cancelar"</string>
    <string name="vpn_done" msgid="5137858784289564985">"Dispensar"</string>
    <string name="vpn_save" msgid="683868204634860888">"Salvar"</string>
    <string name="vpn_connect" msgid="7102335248484045354">"Conectar"</string>
    <string name="vpn_replace" msgid="1533147558671640341">"Substituir"</string>
    <string name="vpn_edit" msgid="5862301148429324911">"Editar perfil de VPN"</string>
    <string name="vpn_forget" msgid="2913950864877236737">"Esquecer"</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">"Desconectar esta VPN?"</string>
    <string name="vpn_disconnect" msgid="7753808961085867345">"Desconectar"</string>
    <string name="vpn_version" msgid="6344167191984400976">"Versão"</string>
    <string name="vpn_forget_long" msgid="729132269203870205">"Esquecer VPN"</string>
    <string name="vpn_replace_vpn_title" msgid="3994226561866340280">"Substituir VPN já existente?"</string>
    <string name="vpn_set_vpn_title" msgid="1667539483005810682">"Configurar VPN sempre ativa?"</string>
    <string name="vpn_first_always_on_vpn_message" msgid="2769478310633047870">"Quando essa configuração estiver ativada, sua conexão com a Internet não estará disponível até que a VPN se conecte"</string>
    <string name="vpn_replace_always_on_vpn_enable_message" msgid="9154843462740876652">"Sua VPN já existente será substituída, e você não terá uma conexão com a Internet até que a VPN se conecte"</string>
    <string name="vpn_replace_always_on_vpn_disable_message" msgid="4299175336198481106">"Você já está conectado a uma VPN sempre ativa. Caso se conecte a uma diferente, a VPN já existente será substituída, e o modo sempre ativo será desativado."</string>
    <string name="vpn_replace_vpn_message" msgid="1094297700371463386">"Você já está conectado a uma VPN. Caso se conecte a uma diferente, a VPN já existente será substituída."</string>
    <string name="vpn_turn_on" msgid="3568307071295211187">"Ativar"</string>
    <string name="vpn_cant_connect_title" msgid="5670787575925519386">"Não é possível conectar-se a <xliff:g id="VPN_NAME">%1$s</xliff:g>"</string>
    <string name="vpn_cant_connect_message" msgid="2139148820719163694">"Este app não é compatível com VPN sempre ativa"</string>
    <string name="vpn_title" msgid="3068868814145870274">"VPN"</string>
    <string name="vpn_create" msgid="7546073242936894638">"Adicionar perfil de VPN"</string>
    <string name="vpn_menu_edit" msgid="5100387853773792379">"Editar perfil"</string>
    <string name="vpn_menu_delete" msgid="4455966182219039928">"Excluir perfil"</string>
    <string name="vpn_menu_lockdown" msgid="5284041663859541007">"VPN sempre ativa"</string>
    <string name="vpn_no_vpns_added" msgid="7387080769821533728">"Nenhuma VPN adicionada"</string>
    <string name="vpn_always_on_summary" msgid="2171252372476858166">"Sempre manter-se conectado à VPN"</string>
    <string name="vpn_always_on_summary_not_supported" msgid="9084872130449368437">"Não compatível com este app"</string>
    <string name="vpn_always_on_summary_active" msgid="175877594406330387">"Sempre ativado"</string>
    <string name="vpn_insecure_summary" msgid="4450920215186742859">"Não segura"</string>
    <string name="vpn_require_connection" msgid="1027347404470060998">"Bloquear conexões sem VPN"</string>
    <string name="vpn_require_connection_title" msgid="4186758487822779039">"Conexão VPN necessária?"</string>
    <string name="vpn_insecure_dialog_subtitle" msgid="1857621742868835300">"Não seguro. Atualize para uma VPN IKEv2"</string>
    <string name="vpn_start_unsupported" msgid="7139925503292269904">"Falha ao iniciar a VPN sem suporte."</string>
    <string name="vpn_lockdown_summary" msgid="4700625960550559029">"Selecione um perfil de VPN para permanecer sempre conectado. O tráfego de rede somente será permitido quando conectado a esta VPN."</string>
    <string name="vpn_lockdown_none" msgid="455915403560910517">"Nenhuma"</string>
    <string name="vpn_lockdown_config_error" msgid="1992071316416371316">"A VPN sempre ativa requer um endereço IP para o servidor e o DNS."</string>
    <string name="vpn_no_network" msgid="7187593680049843763">"Nenhuma conexão de rede. Tente novamente mais tarde."</string>
    <string name="vpn_disconnected" msgid="7694522069957717501">"Desconectado da VPN"</string>
    <string name="vpn_disconnected_summary" msgid="721699709491697712">"Nenhuma"</string>
    <string name="vpn_missing_cert" msgid="5397309964971068272">"Falta um certificado. Edite o perfil."</string>
    <string name="trusted_credentials_system_tab" msgid="675362923690364722">"Sistema"</string>
    <string name="trusted_credentials_user_tab" msgid="4978365619630094339">"Usuário"</string>
    <string name="trusted_credentials_disable_label" msgid="6649583220519447947">"Desativar"</string>
    <string name="trusted_credentials_enable_label" msgid="5551204878588237991">"Ativar"</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">"Ativar o certificado de CA do sistema?"</string>
    <string name="trusted_credentials_disable_confirmation" msgid="5131642563381656676">"Desativar o certificado de CA do sistema?"</string>
    <string name="trusted_credentials_remove_confirmation" msgid="3420345440353248381">"Remover permanentemente o certificado de CA do usuário?"</string>
    <string name="credential_being_used_by" msgid="3682869943025283499">"Em uso por"</string>
    <string name="credential_contains" msgid="3146519680449595771">"Esta entrada contém"</string>
    <string name="one_userkey" msgid="6363426728683951234">"1 chave de usuário"</string>
    <string name="one_usercrt" msgid="2097644070227688983">"1 certificado do usuário"</string>
    <string name="one_cacrt" msgid="982242103604501559">"1 certificado de CA"</string>
    <string name="n_cacrts" msgid="5886462550192731627">"%d certificados CA"</string>
    <string name="user_credential_title" msgid="4686178602575567298">"Detalhes de credenciais"</string>
    <string name="user_credential_removed" msgid="4087675887725394743">"Credencial removida: <xliff:g id="CREDENTIAL_NAME">%s</xliff:g>"</string>
    <string name="user_credential_none_installed" msgid="918620912366836994">"Nenhuma credencial de usuário instalada"</string>
    <string name="spellcheckers_settings_title" msgid="2799021700580591443">"Corretor ortográfico"</string>
    <string name="spellcheckers_settings_for_work_title" msgid="6471603934176062893">"Corretor ortográfico para o trabalho"</string>
    <string name="current_backup_pw_prompt" msgid="4962276598546381140">"Digite sua senha de backup completo atual aqui"</string>
    <string name="new_backup_pw_prompt" msgid="4884439230209419503">"Digite uma nova senha para backups completos aqui"</string>
    <string name="confirm_new_backup_pw_prompt" msgid="5753796799743881356">"Digite mais uma vez a nova senha de backup completo aqui"</string>
    <string name="backup_pw_set_button_text" msgid="8892357974661340070">"Definir a senha de backup"</string>
    <string name="backup_pw_cancel_button_text" msgid="2244399819018756323">"Cancelar"</string>
    <string name="additional_system_update_settings_list_item_title" msgid="7230385345152138051">"Mais atualizações do sistema"</string>
    <string name="ssl_ca_cert_warning" msgid="3898387588657346106">"A rede pode ser monitorada"</string>
    <string name="done_button" msgid="6269449526248267">"Concluído"</string>
    <string name="ssl_ca_cert_dialog_title" msgid="1032088078702042090">"{count,plural, =1{Confiar ou remover certificado}one{Confiar ou remover certificado}other{Confiar ou remover certificados}}"</string>
    <string name="ssl_ca_cert_info_message_device_owner" msgid="7528581447864707873">"{numberOfCertificates,plural, =1{A organização {orgName} instalou uma autoridade certificadora no seu dispositivo, o que pode permitir que ela monitore sua atividade na rede dele, incluindo e-mails, apps e sites seguros.\n\nPara acessar mais informações sobre esse certificado, entre em contato com o administrador.}one{A organização {orgName} instalou uma autoridade certificadora no seu dispositivo, o que pode permitir que ela monitore sua atividade na rede dele, incluindo e-mails, apps e sites seguros.\n\nPara acessar mais informações sobre esse certificado, entre em contato com o administrador.}other{A organização {orgName} instalou autoridades certificadoras no seu dispositivo, o que pode permitir que ela monitore sua atividade na rede dele, incluindo e-mails, apps e sites seguros.\n\nPara acessar mais informações sobre esses certificados, entre em contato com o administrador.}}"</string>
    <string name="ssl_ca_cert_info_message" msgid="3111724430981667845">"{numberOfCertificates,plural, =1{A organização {orgName} instalou uma autoridade certificadora para seu perfil de trabalho, o que pode permitir que ela monitore sua atividade profissional na rede, incluindo e-mails, apps e sites seguros.\n\nPara acessar mais informações sobre esse certificado, entre em contato com o administrador.}one{A organização {orgName} instalou uma autoridade certificadora para seu perfil de trabalho, o que pode permitir que ela monitore sua atividade profissional na rede, incluindo e-mails, apps e sites seguros.\n\nPara acessar mais informações sobre esse certificado, entre em contato com o administrador.}other{A organização {orgName} instalou autoridades certificadoras para seu perfil de trabalho, o que pode permitir que ela monitore sua atividade profissional na rede, incluindo e-mails, apps e sites seguros.\n\nPara acessar mais informações sobre esses certificados, entre em contato com o administrador.}}"</string>
    <string name="ssl_ca_cert_warning_message" msgid="4374052724815563051">"Sua atividade na rede, incluindo e-mails, apps e websites seguros, pode ser monitorada por terceiros.\n\nUma credencial confiável instalada no dispositivo permite isso."</string>
    <string name="ssl_ca_cert_settings_button" msgid="2044927302268394991">"{count,plural, =1{Verificar certificado}one{Verificar certificado}other{Verificar certificados}}"</string>
    <string name="user_settings_title" msgid="6550866465409807877">"Vários usuários"</string>
    <string name="user_list_title" msgid="1387379079186123404">"Usuários e perfis"</string>
    <string name="user_add_user_or_profile_menu" msgid="305851380425838287">"Adicionar usuário ou perfil"</string>
    <string name="user_summary_restricted_profile" msgid="451650609582185813">"Perfil restrito"</string>
    <string name="user_summary_not_set_up" msgid="4602868481732886115">"Não configurado"</string>
    <string name="user_summary_restricted_not_set_up" msgid="1658946988920104613">"Não configurado - perfil restrito"</string>
    <string name="user_summary_managed_profile_not_set_up" msgid="5739207307082458746">"Não configurado - perfil de trabalho"</string>
    <string name="user_admin" msgid="4024553191395768119">"Administrador"</string>
    <string name="user_you" msgid="3070562015202859996">"Você (<xliff:g id="NAME">%s</xliff:g>)"</string>
    <string name="user_add_max_count" msgid="3328539978480663740">"Não é possível adicionar mais usuários. Remova um para adicionar outro."</string>
    <string name="user_cannot_add_accounts_message" msgid="2351326078338805337">"Perfis restritos não podem adicionar contas"</string>
    <string name="user_remove_user_menu" msgid="2183714948094429367">"Excluir <xliff:g id="USER_NAME">%1$s</xliff:g> do dispositivo"</string>
    <string name="user_lockscreen_settings" msgid="4596612658981942092">"Configurações de tela de bloqueio"</string>
    <string name="user_add_on_lockscreen_menu" msgid="2539059062034644966">"Adicionar usuários na tela de bloqueio"</string>
    <string name="switch_to_dock_user_when_docked" msgid="2324395443311905635">"Mudar para usuário admin quando encaixado na base"</string>
    <string name="user_confirm_remove_self_title" msgid="926265330805361832">"Excluir a si mesmo?"</string>
    <string name="user_confirm_remove_title" msgid="3626559103278006002">"Excluir este usuário?"</string>
    <string name="user_profile_confirm_remove_title" msgid="3131574314149375354">"Remover este perfil?"</string>
    <string name="work_profile_confirm_remove_title" msgid="6229618888167176036">"Remover perfil de trabalho?"</string>
    <string name="user_confirm_remove_message" msgid="362545924965977597">"Todos os apps e dados serão excluídos."</string>
    <string name="work_profile_confirm_remove_message" msgid="1037294114103024478">"Todos os apps e dados desse perfil serão excluídos se você continuar."</string>
    <string name="user_profile_confirm_remove_message" msgid="3641289528179850718">"Todos os apps e dados serão excluídos."</string>
    <string name="user_adding_new_user" msgid="7439602720177181412">"Adicionando novo usuário..."</string>
    <string name="user_delete_user_description" msgid="7764153465503821011">"Excluir usuário"</string>
    <string name="user_delete_button" msgid="3833498650182594653">"Excluir"</string>
    <string name="user_exit_guest_confirm_message" msgid="8995296853928816554">"Todos os apps e dados nesta sessão serão excluídos."</string>
    <string name="user_exit_guest_dialog_remove" msgid="7067727314172605181">"Remover"</string>
    <string name="guest_category_title" msgid="5562663588315329152">"Visitante (você)"</string>
    <string name="user_category_title" msgid="4368580529662699083">"Usuários"</string>
    <string name="other_user_category_title" msgid="7089976887307643217">"Outros usuários"</string>
    <string name="remove_guest_on_exit" msgid="8202972371459611066">"Excluir atividade de visitante"</string>
    <string name="remove_guest_on_exit_summary" msgid="3969962695703280353">"Excluir todos os apps e dados do visitante ao sair do modo visitante"</string>
    <string name="remove_guest_on_exit_dialog_title" msgid="2310442892536079416">"Excluir atividade do convidado?"</string>
    <string name="remove_guest_on_exit_dialog_message" msgid="8112409834021851883">"Os apps e dados desta sessão de convidado serão excluídos agora e toda a atividade futura será excluída sempre que você sair do modo convidado"</string>
    <string name="remove_guest_on_exit_keywords" msgid="4961310523576166193">"excluir, convidado, atividade, remover, dados, visitante, apagar"</string>
    <string name="enable_guest_calling" msgid="4620657197834392094">"Permitir que o visitante faça ligações"</string>
    <string name="enable_guest_calling_summary" msgid="4748224917641204782">"O histórico de ligações será compartilhado com o usuário visitante"</string>
    <string name="user_enable_calling_sms" msgid="8546430559552381324">"Ativar chamadas telefônicas e SMS"</string>
    <string name="user_grant_admin" msgid="5942118263054572074">"Tornar esse usuário um administrador"</string>
    <string name="user_remove_user" msgid="8468203789739693845">"Excluir usuário"</string>
    <string name="user_enable_calling_and_sms_confirm_title" msgid="4041510268838725520">"Ativar chamadas telefônicas e SMS?"</string>
    <string name="user_enable_calling_and_sms_confirm_message" msgid="367792286597449922">"O histórico de ligações e SMS será compartilhado com este usuário."</string>
    <string name="user_revoke_admin_confirm_title" msgid="3057842401861731863">"Remover privilégios de administrador?"</string>
    <string name="user_revoke_admin_confirm_message" msgid="9207187319308572958">"Se você remover os privilégios de administrador desse usuário, eles poderão ser restituídos por outro administrador."</string>
    <string name="emergency_info_title" msgid="8233682750953695582">"Informações de emergência"</string>
    <string name="emergency_info_summary" msgid="8463622253016757697">"Informações e contatos 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 apps e conteúdo"</string>
    <string name="apps_with_restrictions_header" msgid="5277698582872267931">"Apps com restrições"</string>
    <string name="apps_with_restrictions_settings_button" msgid="2648355133416902221">"Expandir configuração para app"</string>
    <string name="user_choose_copy_apps_to_another_user" msgid="5914037067347012870">"Escolher apps para instalar"</string>
    <string name="user_copy_apps_menu_title" msgid="5354300105759670300">"Instalar apps disponíveis"</string>
    <string name="nfc_payment_settings_title" msgid="2043139180030485500">"Pagamentos por aproximação"</string>
    <string name="nfc_default_payment_settings_title" msgid="2150504446774382261">"App de pagamento padrão"</string>
    <string name="nfc_default_payment_footer" msgid="978535088340021360">"Para usar um app de pagamento, aproxime a parte traseira do dispositivo a um terminal de pagamento."</string>
    <string name="nfc_more_details" msgid="1700713533074275233">"Saiba mais"</string>
    <string name="nfc_default_payment_workapp_confirmation_title" msgid="746921251872504687">"Definir app de trabalho como app de pagamento padrão?"</string>
    <string name="nfc_default_payment_workapp_confirmation_message_title" msgid="1533022606333010329">"Para pagar usando um app de trabalho:"</string>
    <string name="nfc_default_payment_workapp_confirmation_message_1" msgid="2917430119080702912">"o perfil de trabalho precisa estar ativado."</string>
    <string name="nfc_default_payment_workapp_confirmation_message_2" msgid="8161184137833245628">"você precisará digitar seu PIN, padrão ou senha de trabalho, se houver."</string>
    <string name="nfc_payment_how_it_works" msgid="3658253265242662010">"Como funciona"</string>
    <string name="nfc_payment_no_apps" msgid="6840001883471438798">"Pague com seu smartphone nas lojas"</string>
    <string name="nfc_payment_default" msgid="3769788268378614608">"Pagamento padrão"</string>
    <string name="nfc_payment_default_not_set" msgid="6471905683119084622">"Não definido"</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">"Usar o app de pagamento padrão"</string>
    <string name="nfc_payment_use_default_dialog" msgid="8556328090777785383">"Usar o app de pagamento padrão"</string>
    <string name="nfc_payment_favor_default" msgid="4508491832174644772">"Sempre"</string>
    <string name="nfc_payment_favor_open" msgid="8554643344050373346">"Exceto quando outro app de pagamento estiver aberto"</string>
    <string name="nfc_payment_pay_with" msgid="3001320460566523453">"Em um terminal por aproximação, pagar com:"</string>
    <string name="nfc_how_it_works_title" msgid="1363791241625771084">"Como pagar no terminal"</string>
    <string name="nfc_how_it_works_content" msgid="1141382684788210772">"Configure um app de pagamento. Em seguida, basta segurar a parte traseira do seu smartphone em direção a qualquer terminal com o símbolo indicando pagamento por aproximação."</string>
    <string name="nfc_how_it_works_got_it" msgid="4717868843368296630">"Entendi"</string>
    <string name="nfc_more_title" msgid="1041094244767216498">"Mais…"</string>
    <string name="nfc_payment_set_default_label" msgid="7395939287766230293">"Definir app de pagamento padrão"</string>
    <string name="nfc_payment_update_default_label" msgid="8201975914337221246">"Atualizar app de pagamento padrão"</string>
    <string name="nfc_payment_set_default" msgid="4101484767872365195">"Em um terminal por aproximação, pagar com <xliff:g id="APP">%1$s</xliff:g>"</string>
    <string name="nfc_payment_set_default_instead_of" msgid="565237441045013280">"Em um terminal por aproximação, pagar com <xliff:g id="APP_0">%1$s</xliff:g>.\n\nIsso substitui <xliff:g id="APP_1">%2$s</xliff:g> como seu app de pagamento padrão."</string>
    <string name="nfc_payment_btn_text_set_deault" msgid="1821065137209590196">"Definir padrão"</string>
    <string name="nfc_payment_btn_text_update" msgid="5159700960497443832">"Atualizar"</string>
    <string name="nfc_work_text" msgid="2496515165821504077">"Trabalho"</string>
    <string name="restriction_settings_title" msgid="4293731103465972557">"Restrições"</string>
    <string name="restriction_menu_reset" msgid="92859464456364092">"Remover restrições"</string>
    <string name="restriction_menu_change_pin" msgid="2505923323199003718">"Alterar PIN"</string>
    <string name="help_label" msgid="2896538416436125883">"Ajuda e feedback"</string>
    <string name="user_account_title" msgid="6389636876210834864">"Conta para conteúdo"</string>
    <string name="user_picture_title" msgid="7176437495107563321">"ID de foto"</string>
    <string name="extreme_threats_title" msgid="1098958631519213856">"Ameaças extremas"</string>
    <string name="extreme_threats_summary" msgid="3560742429496902008">"Receba alertas para ameaças extremas: materiais ou à vida"</string>
    <string name="severe_threats_title" msgid="8962959394373974324">"Ameaças graves"</string>
    <string name="severe_threats_summary" msgid="4982256198071601484">"Receber alertas para ameaças graves, materiais ou à vida"</string>
    <string name="amber_alerts_title" msgid="5238275758191804575">"Alertas AMBER"</string>
    <string name="amber_alerts_summary" msgid="5755221775246075883">"Receber boletins sobre crianças sequestradas"</string>
    <string name="repeat_title" msgid="8676570486899483606">"Repetir"</string>
    <string name="cell_broadcast_settings" msgid="2416980110093867199">"Alertas de emergência sem fio"</string>
    <string name="network_operators_settings" msgid="5105453353329748954">"Operadores de rede"</string>
    <string name="access_point_names" msgid="5768430498022188057">"Nomes dos pontos de acesso"</string>
    <string name="enhanced_4g_lte_mode_title" msgid="6624700245232361149">"VoLTE"</string>
    <string name="enhanced_4g_lte_mode_title_advanced_calling" msgid="7066009898031465265">"Chamada avançada"</string>
    <string name="enhanced_4g_lte_mode_title_4g_calling" msgid="7445853566718786195">"Chamada 4G"</string>
    <string name="enhanced_4g_lte_mode_summary" msgid="1067066329756036427">"Usar serviços de LTE para melhorar chamadas de voz (recomendado)"</string>
    <string name="enhanced_4g_lte_mode_summary_4g_calling" msgid="2575004054914178405">"Usar serviços 4G para melhorar chamadas de voz (recomendado)"</string>
    <string name="nr_advanced_calling_title" msgid="6106286679535355939">"Vo5G"</string>
    <string name="nr_advanced_calling_summary" msgid="6926192539172030330">"Usar o 5G em chamadas de voz"</string>
    <string name="contact_discovery_opt_in_title" msgid="8708034790649773814">"Enviar contatos para a operadora"</string>
    <string name="contact_discovery_opt_in_summary" msgid="6539010458256667300">"Enviar os números de telefone dos contatos para fornecer recursos avançados"</string>
    <string name="contact_discovery_opt_in_dialog_title" msgid="2230536282911854114">"Enviar contatos para a <xliff:g id="CARRIER">%1$s</xliff:g>?"</string>
    <string name="contact_discovery_opt_in_dialog_title_no_carrier_defined" msgid="2028983133745990320">"Enviar contatos para a operadora?"</string>
    <string name="contact_discovery_opt_in_dialog_message" msgid="8818310894782757538">"Os números de telefone dos seus contatos serão enviados periodicamente para a <xliff:g id="CARRIER">%1$s</xliff:g>.<xliff:g id="EMPTY_LINE">

</xliff:g>Essa informação identifica se os contatos podem usar recursos específicos, como videochamadas ou alguns recursos de mensagem."</string>
    <string name="contact_discovery_opt_in_dialog_message_no_carrier_defined" msgid="1914894516552445911">"Os números de telefone dos seus contatos serão enviados periodicamente para a operadora.<xliff:g id="EMPTY_LINE">

</xliff:g>Essa informação identifica se os contatos podem usar recursos específicos, como videochamadas ou alguns recursos de mensagem."</string>
    <string name="preferred_network_type_title" msgid="812509938714590857">"Tipo de rede preferencial"</string>
    <string name="preferred_network_type_summary" msgid="8786291927331323061">"LTE (recomendado)"</string>
    <string name="mms_message_title" msgid="6624505196063391964">"Mensagens MMS"</string>
    <string name="mms_message_summary" msgid="2855847140141698341">"Enviar e receber quando os dados móveis estiverem desativados"</string>
    <string name="auto_data_switch_title" msgid="5862200603753603464">"Trocar para dados móveis automaticamente"</string>
    <string name="auto_data_switch_summary" msgid="1934340931995429057">"Usar esta rede quando ela tiver melhor disponibilidade"</string>
    <string name="work_sim_title" msgid="8999872928646924429">"Chip de trabalho"</string>
    <string name="user_restrictions_title" msgid="4068914244980335993">"Acesso a apps e conteúdo"</string>
    <string name="user_rename" msgid="8735940847878484249">"RENOMEAR"</string>
    <string name="app_restrictions_custom_label" msgid="6949268049087435132">"Definir restrições do app"</string>
    <string name="user_restrictions_controlled_by" msgid="2821526006742851624">"Controlado por <xliff:g id="APP">%1$s</xliff:g>"</string>
    <string name="app_sees_restricted_accounts" msgid="3526008344222566318">"Este app pode acessar suas contas"</string>
    <string name="app_sees_restricted_accounts_and_controlled_by" msgid="8338520379923447143">"Este app pode acessar suas contas. Controlado por <xliff:g id="APP">%1$s</xliff:g>"</string>
    <string name="restriction_wifi_config_title" msgid="2630656989926554685">"Wi‑Fi e redes móveis"</string>
    <string name="restriction_wifi_config_summary" msgid="920419010472168694">"Permitir modificação das configurações de Wi-Fi e redes móveis"</string>
    <string name="restriction_bluetooth_config_title" msgid="220586273589093821">"Bluetooth"</string>
    <string name="restriction_bluetooth_config_summary" msgid="7558879931011271603">"Permitir modificação dos pareamentos e configurações de Bluetooth"</string>
    <string name="restriction_location_enable_title" msgid="4872281754836538066">"Localização"</string>
    <string name="restriction_location_enable_summary" msgid="7139292323897390221">"Permitir que os apps utilizem suas informações de local"</string>
    <string name="wizard_back" msgid="8257697435061870191">"Voltar"</string>
    <string name="wizard_next" msgid="3884832431439072471">"Próxima"</string>
    <string name="wizard_back_adoptable" msgid="1447814356855134183">"Formatar de outra maneira"</string>
    <string name="regulatory_info_text" msgid="1154461023369976667"></string>
    <string name="sim_settings_title" msgid="2254609719033946272">"Chips"</string>
    <string name="sim_cellular_data_unavailable" msgid="4653591727755387534">"Os dados móveis estão indisponíveis"</string>
    <string name="sim_cellular_data_unavailable_summary" msgid="6505871722911347881">"Toque para selecionar um chip de dados"</string>
    <string name="sim_calls_always_use" msgid="967857230039768111">"Sempre usar esta opção para chamadas"</string>
    <string name="select_sim_for_data" msgid="2642305487659432499">"Escolha o chip usado para dados móveis"</string>
    <string name="select_sim_for_sms" msgid="5335510076282673497">"Selecione um chip para SMS"</string>
    <string name="data_switch_started" msgid="6292759843974720112">"Trocando chip de dados. Isso pode demorar um minuto…"</string>
    <string name="select_specific_sim_for_data_title" msgid="5851980301321577985">"Usar o chip <xliff:g id="NEW_SIM">%1$s</xliff:g> para dados móveis?"</string>
    <string name="select_specific_sim_for_data_msg" msgid="7401698123430573637">"Se você mudar para o chip <xliff:g id="NEW_SIM">%1$s</xliff:g>, o <xliff:g id="OLD_SIM">%2$s</xliff:g> não vai mais ser usado para dados móveis."</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">"Ligar com"</string>
    <string name="sim_name_hint" msgid="8231524869124193119">"Inserir nome do chip"</string>
    <string name="sim_editor_title" msgid="918655391915256859">"Slot para chip %1$d"</string>
    <string name="color_orange" msgid="216547825489739010">"Laranja"</string>
    <string name="color_purple" msgid="6603701972079904843">"Roxo"</string>
    <string name="sim_status_title" msgid="6188770698037109774">"Status do chip"</string>
    <string name="sim_status_title_sim_slot" msgid="4932996839194493313">"Status do chip (slot para SIM %1$d)"</string>
    <string name="sim_signal_strength" msgid="6351052821700294501">"<xliff:g id="DBM">%1$d</xliff:g> dBm <xliff:g id="ASU">%2$d</xliff:g> asu"</string>
    <string name="sim_notification_title" msgid="6839556577405929262">"Seus chips foram trocados"</string>
    <string name="sim_notification_summary" msgid="5593339846307029991">"Toque para configurar"</string>
    <string name="sim_calls_ask_first_prefs_title" msgid="3077694594349657933">"Perguntar sempre"</string>
    <string name="sim_selection_required_pref" msgid="231437651041498359">"Seleção necessária"</string>
    <string name="sim_selection_channel_title" msgid="3193666315607572484">"Seleção de chip"</string>
    <string name="dashboard_title" msgid="5660733037244683387">"Configurações"</string>
    <string name="network_dashboard_title" msgid="788543070557731240">"Rede e Internet"</string>
    <string name="network_dashboard_summary_mobile" msgid="7750924671970583670">"Rede móvel, Wi-Fi, ponto de acesso"</string>
    <string name="network_dashboard_summary_no_mobile" msgid="4022575916334910790">"Wi‑Fi, ponto de acesso"</string>
    <string name="connected_devices_dashboard_title" msgid="19868275519754895">"Dispositivos conectados"</string>
    <string name="connected_devices_dashboard_default_summary" msgid="7211769956193710397">"Bluetooth, pareamento"</string>
    <string name="connected_devices_dashboard_summary" msgid="6927727617078296491">"Bluetooth, Modo carro, NFC"</string>
    <string name="connected_devices_dashboard_no_nfc_summary" msgid="8424794257586524040">"Bluetooth, Modo carro"</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 carro, NFC"</string>
    <string name="connected_devices_dashboard_android_auto_no_nfc_summary" msgid="2532811870469405527">"Bluetooth, Android Auto, modo carro"</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">"Indisponível porque a NFC está desativada"</string>
    <string name="nfc_and_payment_settings_no_payment_installed_summary" msgid="4879818114908207465">"Para usar, instale um app de pagamento"</string>
    <string name="app_and_notification_dashboard_summary" msgid="8047683010984186106">"Apps recentes, apps padrão"</string>
    <string name="notification_settings_work_profile" msgid="6076211850526353975">"O acesso às notificações não está disponível para apps no perfil de trabalho."</string>
    <string name="account_dashboard_title" msgid="8228773251948253914">"Senhas e contas"</string>
    <string name="account_dashboard_default_summary" msgid="7976899924144356939">"Sugestões de login e preenchimento automático"</string>
    <string name="app_default_dashboard_title" msgid="4071015747629103216">"Apps padrão"</string>
    <string name="cloned_apps_dashboard_title" msgid="5542076801222950921">"Apps clonados"</string>
    <string name="desc_cloned_apps_intro_text" msgid="1369621522882622476">"Crie uma segunda instância de um app para que você possa usar duas contas ao mesmo tempo."</string>
    <string name="desc_cloneable_app_list_text" msgid="3354586725814708688">"Apps que podem ser clonados."</string>
    <string name="cloned_apps_summary" msgid="8805362440770795709">"Clonados: <xliff:g id="CLONED_APPS_COUNT">%1$s</xliff:g>. Disponíveis para clonagem: <xliff:g id="ALLOWED_APPS_COUNT">%2$d</xliff:g>"</string>
    <string name="delete_all_app_clones" msgid="3489053361980624999">"Excluir todos os apps clonados"</string>
    <string name="delete_all_app_clones_failure" msgid="6821033414547132335">"A exclusão dos apps clonados falhou"</string>
    <string name="cloned_app_creation_summary" msgid="4642627294993918502">"Criando…"</string>
    <string name="cloned_app_created_summary" msgid="7277912971544890710">"Clonado"</string>
    <string name="cloned_app_creation_toast_summary" msgid="3854494347144867870">"Criando clone de <xliff:g id="PACKAGE_LABEL">%1$s</xliff:g>"</string>
    <string name="cloned_app_created_toast_summary" msgid="755225403495544163">"O clone de <xliff:g id="PACKAGE_LABEL">%1$s</xliff:g> foi criado"</string>
    <string name="system_dashboard_summary" msgid="7400745270362833832">"Idiomas, gestos, hora, backup"</string>
    <string name="languages_setting_summary" msgid="2650807397396180351">"Idiomas do sistema, idiomas do app, preferências regionais, fala"</string>
    <string name="keywords_wifi" msgid="8156528242318351490">"wifi, Wi-Fi, conexão de rede, Internet, sem fio, dados, wi fi"</string>
    <string name="keywords_wifi_notify_open_networks" msgid="6580896556389306636">"Notificação de Wi‑Fi, notificação de wifi"</string>
    <string name="keywords_wifi_data_usage" msgid="4718555409695862085">"uso de dados"</string>
    <string name="keywords_time_format" msgid="5384803098766166820">"Usar formato de 24 horas"</string>
    <string name="keywords_app_default" msgid="8977706259156428770">"Abrir com"</string>
    <string name="keywords_applications_settings" msgid="999926810912037792">"Apps"</string>
    <string name="keywords_time_zone" msgid="6402919157244589055">"fuso horário"</string>
    <string name="keywords_draw_overlay" msgid="3170036145197260392">"Ícone do chat, sistema, alerta, janela, diálogo, tela, sobre outros apps, sobrepor"</string>
    <string name="keywords_flashlight" msgid="2133079265697578183">"Lanterna, Luz, Luminária"</string>
    <string name="keywords_change_wifi_state" msgid="7573039644328488165">"wifi, wi-fi, alternar, controle"</string>
    <string name="keywords_more_mobile_networks" msgid="5041272719326831744">"celular, dispositivo móvel, operadora de celular, sem fio, dados, 4g, 3g, 2g, lte"</string>
    <string name="keywords_wifi_calling" msgid="4319184318421027136">"wifi, wi-fi, chamada, chamando"</string>
    <string name="keywords_display" msgid="874738809280751745">"tela, touchscreen"</string>
    <string name="keywords_display_brightness_level" msgid="850742707616318056">"escurecer tela, touchscreen, bateria, alto brilho"</string>
    <string name="keywords_display_night_display" msgid="4711054330804250058">"escurecer tela, noite, tonalidade, noturno, brilho, cor da tela, cor"</string>
    <string name="keywords_display_wallpaper" msgid="8478137541939526564">"segundo plano, personalizar, personalizar tela"</string>
    <string name="keywords_display_font_size" msgid="3593317215149813183">"tamanho do texto"</string>
    <string name="keywords_display_cast_screen" msgid="2572331770299149370">"projetar, transmitir, Espelhamento de tela, \"Compartilhamento de tela\", espelhamento, compartilhar tela, transmissão de tela"</string>
    <string name="keywords_storage" msgid="3004667910133021783">"espaço, disco, disco rígido, uso do dispositivo"</string>
    <string name="keywords_battery" msgid="7040323668283600530">"uso de energia, carregar"</string>
    <string name="keywords_battery_usage" msgid="1763573071014260220">"ver o uso da bateria, uso da bateria, consumo de energia"</string>
    <string name="keywords_battery_saver" msgid="6289682844453234359">"economia de bateria, economia de energia, econômico"</string>
    <string name="keywords_battery_adaptive_preferences" msgid="1774870663426502938">"preferências adaptáveis, bateria adaptável"</string>
    <string name="keywords_spell_checker" msgid="5148906820603481657">"ortografia, dicionário, correção ortográfica, correção automática"</string>
    <string name="keywords_voice_input" msgid="7534900094659358971">"reconhecedor, entrada, fala, falar, idioma, viva-voz, viva voz reconhecimento ofensivo palavra, áudio, histórico, fone de ouvido bluetooth"</string>
    <string name="keywords_text_to_speech_output" msgid="6728080502619011668">"classificação, idioma, padrão, falar, fala, tts, acessibilidade, leitor de tela, deficiência visual"</string>
    <string name="keywords_date_and_time" msgid="4402136313104901312">"relógio, militar"</string>
    <string name="keywords_network_reset" msgid="4075670452112218042">"redefinir, restaurar, configurações originais"</string>
    <string name="keywords_factory_data_reset" msgid="4979623326958976773">"excluir permanentemente, excluir, restaurar, limpar, remover, redefinição para a configuração original"</string>
    <string name="keywords_printing" msgid="3528250034669909466">"impressora"</string>
    <string name="keywords_sounds" msgid="187191900698371911">"aviso sonoro do alto-falante, alto-falante, volume, desativar som, silenciar, áudio, música, retorno tátil, vibração, vibrar"</string>
    <string name="keywords_sounds_and_notifications_interruptions" msgid="1500312884808362467">"não perturbe, interromper, interrupção"</string>
    <string name="keywords_app" msgid="7983814237980258061">"RAM"</string>
    <string name="keywords_location" msgid="8016374808099706213">"por perto, local, histórico, relatório, GPS"</string>
    <string name="keywords_accounts" msgid="3013897982630845506">"conta, adicionar uma conta, perfil de trabalho, adicionar conta, remover, excluir"</string>
    <string name="keywords_users" msgid="3497517660077620843">"restrição, restringir, restrito"</string>
    <string name="keywords_keyboard_and_ime" msgid="4741098648730042570">"correção de texto, corrigir, som, vibrar, automático, idioma, gesto, sugerir, sugestão, tema, ofensivo, palavra, digitar, emoji, internacional"</string>
    <string name="keywords_reset_apps" msgid="8254315757754930862">"redefinir, preferências, padrão"</string>
    <string name="keywords_all_apps" msgid="9016323378609007166">"apps, download, aplicativos, sistema"</string>
    <string name="keywords_app_permissions" msgid="2061773665663541610">"apps, permissões, segurança"</string>
    <string name="keywords_default_apps" msgid="4601664230800605416">"apps, padrão"</string>
    <string name="keywords_ignore_optimizations" msgid="8967142288569785145">"ignorar otimizações, soneca, app em espera"</string>
    <string name="keywords_color_mode" msgid="1193896024705705826">"vibrante, RGB, sRGB, cor, natural, padrão"</string>
    <string name="keywords_screen_resolution" msgid="6652125115386722875">"FHD, QHD, resolução, 1080p, 1440p"</string>
    <string name="keywords_color_temperature" msgid="8159539138837118453">"cor, temperatura, D65, D73, branco, amarelo, azul, quente, frio"</string>
    <string name="keywords_lockscreen" msgid="3656926961043485797">"deslizar para desbloquear, senha, padrão, pin"</string>
    <string name="keywords_app_pinning" msgid="1564144561464945019">"Fixar tela"</string>
    <string name="keywords_profile_challenge" msgid="5135555521652143612">"desafio de trabalho, trabalho, perfil"</string>
    <string name="keywords_unification" msgid="2677472004971453468">"perfil de trabalho, perfil gerenciado, unificar, unificação, trabalho, perfil"</string>
    <string name="keywords_fold_lock_behavior" msgid="6278990772113341581">"ativar, suspender, não bloquear, deixar desbloqueado ao dobrar, dobra, fechar, dobrar, fechado, tela desligada"</string>
    <string name="keywords_gesture" msgid="3456930847450080520">"gestos"</string>
    <string name="keywords_wallet" msgid="3757421969956996972">"carteira"</string>
    <string name="keywords_payment_settings" msgid="6268791289277000043">"pagar, tocar, pagamentos"</string>
    <string name="keywords_backup" msgid="707735920706667685">"backup, back up"</string>
    <string name="keywords_face_unlock" msgid="545338452730885392">"desbloqueio, facial, autenticação, login"</string>
    <string name="keywords_biometric_unlock" msgid="8569545388717753692">"rosto, desbloqueio, autenticação, login, impressão digital, biometria"</string>
    <string name="keywords_imei_info" msgid="8848791606402333514">"imei, meid, min, versão prl, imei sv"</string>
    <string name="keywords_sim_status" msgid="4221401945956122228">"rede, estado da rede móvel, status do serviço, potência do sinal, tipo de rede móvel, roaming"</string>
    <string name="keywords_sim_status_esim" msgid="3338719238556853609">"rede, estado da rede móvel, status do serviço, potência do sinal, tipo de rede móvel, roaming, eid"</string>
    <string name="keywords_sim_status_iccid" msgid="4775398796251969759">"rede, estado da rede móvel, status do serviço, potência do sinal, tipo de rede móvel, roaming, iccid"</string>
    <string name="keywords_sim_status_iccid_esim" msgid="4634015619840979184">"rede, estado da rede móvel, status do serviço, potência do sinal, tipo de rede móvel, roaming, iccid, eid"</string>
    <string name="keywords_esim_eid" msgid="8128175058237372457">"EID"</string>
    <string name="keywords_model_and_hardware" msgid="4723665865709965044">"número de série, versão do hardware"</string>
    <string name="keywords_battery_info" msgid="3319796850366687033">"informações da bateria, data de fabricação, contagem de ciclos, primeiro uso"</string>
    <string name="keywords_android_version" msgid="1629882125290323070">"nível do patch de segurança do android, versão da banda de base, versão do kernel"</string>
    <string name="keywords_dark_ui_mode" msgid="6373999418195344014">"tema, claro, escuro, modo, sensibilidade à luz, fotofobia, escurecer, deixar mais escuro, modo escuro, enxaqueca"</string>
    <string name="keywords_systemui_theme" msgid="6341194275296707801">"tema escuro"</string>
    <string name="keywords_device_feedback" msgid="5489930491636300027">"bug"</string>
    <string name="keywords_ambient_display_screen" msgid="661492302323274647">"Tela ambiente, exibição na tela de bloqueio"</string>
    <string name="keywords_lock_screen_notif" msgid="6363144436467429932">"notificação de tela de bloqueio, notificações"</string>
    <string name="keywords_face_settings" msgid="1360447094486865058">"rosto"</string>
    <string name="keywords_fingerprint_settings" msgid="7345121109302813358">"impressão digital, adicionar impressão digital"</string>
    <string name="keywords_biometric_settings" msgid="2173605297939326549">"rosto, impressão digital, adicionar impressão digital"</string>
    <string name="keywords_active_unlock_settings" msgid="4511320720304388889">"desbloqueio do relógio, adicionar desbloqueio do relógio"</string>
    <string name="keywords_display_auto_brightness" msgid="7162942396941827998">"escurecer tela, touchscreen, bateria, brilho inteligente, brilho dinâmico, brilho automático"</string>
    <string name="keywords_display_adaptive_sleep" msgid="4905300860114643966">"inteligente, escurecer tela, suspensão, bateria, tempo limite, atenção, display, tela, inatividade"</string>
    <string name="keywords_auto_rotate" msgid="7288697525101837071">"câmera, inteligente, giro automático, girar automaticamente, girar, virar, rotação, retrato, paisagem, orientação, vertical, horizontal"</string>
    <string name="keywords_system_update_settings" msgid="5769003488814164931">"upgrade, android"</string>
    <string name="keywords_zen_mode_settings" msgid="7810203406522669584">"não perturbe, programação, notificações, bloquear, silenciar, vibrar, suspender, trabalho, focar, som, desativar som, dia, dia da semana, final de semana, durante a semana à noite, evento"</string>
    <string name="keywords_screen_timeout" msgid="8921857020437540572">"tela, tempo até o bloqueio, tempo limite, tela de bloqueio"</string>
    <string name="keywords_storage_settings" msgid="6018856193950281898">"memória, cache, dados, excluir, limpar, liberar, espaço"</string>
    <string name="keywords_bluetooth_settings" msgid="2588159530959868188">"conectado, dispositivo, fones de ouvido, headset, alto-falante, sem fio, parear, música, mídia"</string>
    <string name="keywords_wallpaper" msgid="7332890404629446192">"plano de fundo, tema, grade, personalizar"</string>
    <string name="keywords_styles" msgid="3367789885254807447">"ícone, destaque, cor, tela inicial, tela de bloqueio, atalho, tamanho do relógio"</string>
    <string name="keywords_assist_input" msgid="3086289530227075593">"padrão, assistente"</string>
    <string name="keywords_default_payment_app" msgid="5162298193637362104">"pagamento, padrão"</string>
    <string name="keywords_ambient_display" msgid="3149287105145443697">"notificação recebida"</string>
    <string name="keywords_hotspot_tethering" msgid="3688439689671232627">"tethering por usb, tethering por Bluetooth, ponto de acesso Wi-Fi"</string>
    <string name="keywords_accessibility_vibration_primary_switch" msgid="730692154347231253">"retorno tátil, vibrar, vibração"</string>
    <string name="keywords_touch_vibration" msgid="1125291201902251273">"funcionalidade tátil, vibrar, tela, sensibilidade"</string>
    <string name="keywords_ring_vibration" msgid="1736301626537417541">"funcionalidade tátil, vibração, telefone, chamada, sensibilidade, toque"</string>
    <string name="keywords_ramping_ringer_vibration" msgid="3678966746742257366">"funcionalidade tátil, vibração, telefone, chamada, toque, gradualmente"</string>
    <string name="keywords_notification_vibration" msgid="2620799301276142183">"funcionalidade tátil, vibrar, sensibilidade, notificação"</string>
    <string name="keywords_alarm_vibration" msgid="4833220371621521817">"funcionalidade tátil, vibrar, sensibilidade, alarme"</string>
    <string name="keywords_media_vibration" msgid="723896490102792327">"funcionalidade tátil, vibrar, sensibilidade, mídia"</string>
    <string name="keywords_vibration" msgid="670455132028025952">"retorno tátil, vibrar, vibração"</string>
    <string name="keywords_battery_saver_sticky" msgid="1646191718840975110">"economia de bateria, fixo, persistir, economia de energia, bateria"</string>
    <string name="keywords_battery_saver_schedule" msgid="8240483934368455930">"rotina, agenda, economia de bateria, economia de energia, bateria, automático, percentagem"</string>
    <string name="keywords_enhance_4g_lte" msgid="658889360486800978">"volte, chamada avançada, chamadas por 4g"</string>
    <string name="keywords_nr_advanced_calling" msgid="4157823099610141014">"vo5g, vonr, chamada avançada, chamada 5G"</string>
    <string name="keywords_add_language" msgid="1882751300359939436">"adicionar idioma, adicionar um idioma"</string>
    <string name="keywords_font_size" msgid="1643198841815006447">"tamanho do texto, letras grandes, fonte grande, texto grande, baixa visão, aumentar texto, ampliador de fonte, aumento de fonte"</string>
    <string name="keywords_always_show_time_info" msgid="1066752498285497595">"tela ambiente sempre ativada, AOD"</string>
    <string name="keywords_change_nfc_tag_apps_state" msgid="9032287964590554366">"nfc, etiqueta, leitor"</string>
    <string name="keywords_keyboard_vibration" msgid="6485149510591654697">"teclado, retorno tátil, vibrar,"</string>
    <string name="sound_dashboard_summary" msgid="6574444810552643312">"Volume, vibração, Não perturbe"</string>
    <string name="media_volume_option_title" msgid="5966569685119475630">"Volume de mídia"</string>
    <string name="remote_media_volume_option_title" msgid="8760846743943305764">"Volume da transmissão"</string>
    <string name="call_volume_option_title" msgid="1461105986437268924">"Volume das chamadas"</string>
    <string name="alarm_volume_option_title" msgid="6398641749273697140">"Volume do alarme"</string>
    <string name="ring_volume_option_title" msgid="1520802026403038560">"Volume de toques e notificações"</string>
    <string name="separate_ring_volume_option_title" msgid="2212910223857375951">"Volume do toque"</string>
    <string name="notification_volume_option_title" msgid="4838818791683615978">"Volume das notificações"</string>
    <string name="ringer_content_description_silent_mode" msgid="1442257660889685934">"Campainha silenciosa"</string>
    <string name="ringer_content_description_vibrate_mode" msgid="5946432791951870480">"Vibração da campainha"</string>
    <string name="notification_volume_content_description_vibrate_mode" msgid="6097212000507408288">"O som das notificações está desativado. Elas só farão o dispositivo vibrar."</string>
    <string name="volume_content_description_silent_mode" msgid="377680514551405754">"Desativado: <xliff:g id="VOLUME_TYPE">%1$s</xliff:g>"</string>
    <string name="notification_volume_disabled_summary" msgid="8679988555852056079">"Indisponível porque o toque foi silenciado"</string>
    <string name="ringtone_title" msgid="3271453110387368088">"Toque do telefone"</string>
    <string name="notification_ringtone_title" msgid="6924501621312095512">"Som de notificação padrão"</string>
    <string name="notification_unknown_sound_title" msgid="1319708450698738980">"Som fornecido pelo app"</string>
    <string name="notification_sound_default" msgid="8630353701915294299">"Som de notificação padrão"</string>
    <string name="alarm_ringtone_title" msgid="6680761007731764726">"Som de alarme padrão"</string>
    <string name="vibrate_when_ringing_option_ramping_ringer" msgid="2798848945803840348">"Vibrar primeiro e usar o toque gradual"</string>
    <string name="spatial_audio_title" msgid="1775370104206884711">"Áudio espacial"</string>
    <string name="dial_pad_tones_title" msgid="3536945335367914892">"Sons do teclado"</string>
    <string name="screen_locking_sounds_title" msgid="5695030983872787321">"Som do bloqueio da tela"</string>
    <string name="charging_sounds_title" msgid="5261683808537783668">"Sons e vibração ao carregar"</string>
    <string name="docking_sounds_title" msgid="5341616179210436159">"Sons da base"</string>
    <string name="touch_sounds_title" msgid="826964355109667449">"Sons de toque e clique"</string>
    <string name="vibrate_icon_title" msgid="1281100105045362530">"Sempre mostrar o ícone no modo de vibração"</string>
    <string name="dock_audio_media_title" msgid="6474579339356398330">"Repr. de alto-falante em base"</string>
    <string name="dock_audio_media_disabled" msgid="8499927008999532341">"Todo o áudio"</string>
    <string name="dock_audio_media_enabled" msgid="4039126523653131281">"Somente áudio de mídia"</string>
    <string name="emergency_tone_silent" msgid="5048069815418450902">"Silêncio"</string>
    <string name="emergency_tone_alert" msgid="1977698889522966589">"Tons"</string>
    <string name="emergency_tone_vibrate" msgid="6282296789406984698">"Vibrações"</string>
    <string name="boot_sounds_title" msgid="5033062848948884111">"Ativar sons"</string>
    <string name="live_caption_title" msgid="8617086825712756983">"Legenda Instantânea"</string>
    <string name="live_caption_summary" msgid="2898451867595161809">"Legendar mídias automaticamente"</string>
    <string name="spatial_audio_wired_headphones" msgid="2237355789145828648">"Fones de ouvido com fio"</string>
    <string name="spatial_audio_text" msgid="8201387855375146000">"O áudio de dispositivos de mídia compatíveis fica mais imersivo"</string>
    <string name="spatial_summary_off" msgid="8272678804629774378">"Desativado"</string>
    <string name="spatial_summary_on_one" msgid="6239933399496282994">"Ativado / <xliff:g id="OUTPUT_DEVICE">%1$s</xliff:g>"</string>
    <string name="spatial_summary_on_two" msgid="4526919818832483883">"Ativado / <xliff:g id="OUTPUT_DEVICE_0">%1$s</xliff:g> e <xliff:g id="OUTPUT_DEVICE_1">%2$s</xliff:g>"</string>
    <string name="spatial_audio_footer_title" msgid="8775010547623606088">"Também é possível ativar o áudio espacial para dispositivos Bluetooth"</string>
    <string name="spatial_audio_footer_learn_more_text" msgid="3826811708094366301">"Configurações de dispositivos conectados"</string>
    <string name="zen_mode_settings_schedules_summary" msgid="2047688589286811617">"{count,plural, =0{Nenhuma}=1{1 programação definida}one{# programação definida}other{# programações definidas}}"</string>
    <string name="zen_mode_settings_title" msgid="682676757791334259">"Não perturbe"</string>
    <string name="zen_mode_settings_summary" msgid="6040862775514495191">"Receber notificações apenas de pessoas e apps importantes"</string>
    <string name="zen_mode_slice_subtitle" msgid="6849372107272604160">"Limitar interrupções"</string>
    <string name="zen_mode_settings_turn_on_dialog_title" msgid="7500702838426404527">"Ativar o Não perturbe"</string>
    <string name="zen_mode_behavior_alarms_only" msgid="2956938533859578315">"Alarmes e sons de mídia podem interromper"</string>
    <string name="zen_mode_automation_settings_title" msgid="3709324184191870926">"Programações"</string>
    <string name="zen_mode_delete_automatic_rules" msgid="5020468289267191765">"Excluir programações"</string>
    <string name="zen_mode_schedule_delete" msgid="5383420576833765114">"Excluir"</string>
    <string name="zen_mode_rule_name_edit" msgid="1053237022416700481">"Editar"</string>
    <string name="zen_mode_automation_settings_page_title" msgid="6217433860514433311">"Programações"</string>
    <string name="zen_mode_automatic_rule_settings_page_title" msgid="5264835276518295033">"Programação"</string>
    <string name="zen_mode_schedule_category_title" msgid="1381879916197350988">"Programação"</string>
    <string name="zen_mode_automation_suggestion_title" msgid="7776129050500707960">"Silenciar smartphone em horários específicos"</string>
    <string name="zen_mode_automation_suggestion_summary" msgid="1946750790084170826">"Definir regras do modo \"Não perturbe\""</string>
    <string name="zen_mode_schedule_title" msgid="7064866561892906613">"Programação"</string>
    <string name="zen_mode_use_automatic_rule" msgid="733850322530002484">"Usar programação"</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">"Permitir interrupções que emitem sons"</string>
    <string name="zen_mode_visual_interruptions_settings_title" msgid="7806181124566937214">"Bloquear perturbações visuais"</string>
    <string name="zen_mode_visual_signals_settings_subtitle" msgid="7433077540895876672">"Permitir sinais visuais"</string>
    <string name="zen_mode_restrict_notifications_title" msgid="4169952466106040297">"Mostrar opções para notificações ocultas"</string>
    <string name="zen_mode_restrict_notifications_category" msgid="5870944770935394566">"Quando o Não perturbe estiver ativado"</string>
    <string name="zen_mode_restrict_notifications_mute" msgid="6692072837485018287">"Desativar som de notificações"</string>
    <string name="zen_mode_restrict_notifications_mute_summary" msgid="966597459849580949">"Você verá as notificações na sua tela"</string>
    <string name="zen_mode_restrict_notifications_mute_footer" msgid="2152115038156049608">"O smartphone não vai emitir nenhum som ou vibrar ao receber notificações."</string>
    <string name="zen_mode_restrict_notifications_hide" msgid="5997930361607752541">"Ocultar avisos visuais ou sonoros de notificações"</string>
    <string name="zen_mode_restrict_notifications_hide_summary" msgid="6005445725686969583">"Você não verá nem ouvirá notificações"</string>
    <string name="zen_mode_restrict_notifications_hide_footer" msgid="3761837271201073330">"Seu smartphone não vai mostrar notificações novas ou existentes nem emitir sons ou vibrações para elas. As notificações críticas para a atividade e o status do dispositivo ainda serão mostradas.\n\nDepois de desativar o \"Não perturbe\", você pode acessar as notificações perdidas deslizando de cima para baixo na tela."</string>
    <string name="zen_mode_restrict_notifications_custom" msgid="5469078057954463796">"Personalizado"</string>
    <string name="zen_mode_restrict_notifications_enable_custom" msgid="4303255634151330401">"Ativar configuração personalizada"</string>
    <string name="zen_mode_restrict_notifications_disable_custom" msgid="5062332754972217218">"Remover configuração personalizada"</string>
    <string name="zen_mode_restrict_notifications_summary_muted" msgid="4750213316794189968">"Desativar som de notificações"</string>
    <string name="zen_mode_restrict_notifications_summary_custom" msgid="3918461289557316364">"Parcialmente ocultas"</string>
    <string name="zen_mode_restrict_notifications_summary_hidden" msgid="636494600775773296">"Ocultar avisos visuais ou sonoros de notificações"</string>
    <string name="zen_mode_what_to_block_title" msgid="5692710098205334164">"Restrições personalizadas"</string>
    <string name="zen_mode_block_effects_screen_on" msgid="8780668375194500987">"Quando a tela estiver ligada"</string>
    <string name="zen_mode_block_effects_screen_off" msgid="2291988790355612826">"Quado a tela estiver desligada"</string>
    <string name="zen_mode_block_effect_sound" msgid="7929909410442858327">"Desativar som e vibração"</string>
    <string name="zen_mode_block_effect_intent" msgid="7621578645742903531">"Não ligar a tela"</string>
    <string name="zen_mode_block_effect_light" msgid="1997222991427784993">"Não piscar a luz"</string>
    <string name="zen_mode_block_effect_peek" msgid="2525844009475266022">"Não mostrar notificações na tela"</string>
    <string name="zen_mode_block_effect_status" msgid="5765965061064691918">"Ocultar ícones da barra de status na parte de cima da tela"</string>
    <string name="zen_mode_block_effect_badge" msgid="332151258515152429">"Ocultar pontos de notificação nos ícones de apps"</string>
    <string name="zen_mode_block_effect_ambient" msgid="1247740599476031543">"Notificações não ativam a tela"</string>
    <string name="zen_mode_block_effect_list" msgid="7549367848660137118">"Ocultar da aba suspensa"</string>
    <string name="zen_mode_block_effect_summary_none" msgid="6688519142395714659">"Nunca"</string>
    <string name="zen_mode_block_effect_summary_screen_off" msgid="6989818116297061488">"Quando a tela está desativada"</string>
    <string name="zen_mode_block_effect_summary_screen_on" msgid="4876016548834916087">"Quando a tela está ativada"</string>
    <string name="zen_mode_block_effect_summary_sound" msgid="1559968890497946901">"Som e vibração"</string>
    <string name="zen_mode_block_effect_summary_some" msgid="2730383453754229650">"Som, vibração e alguns sinais visuais de notificações"</string>
    <string name="zen_mode_block_effect_summary_all" msgid="3131918059492425222">"Som, vibração e sinais visuais de notificações"</string>
    <string name="zen_mode_blocked_effects_footer" msgid="6403365663466620328">"As notificações necessárias para status e atividades básicas do dispositivo nunca vão ficar ocultas."</string>
    <string name="zen_mode_no_exceptions" msgid="1580136061336585873">"Nenhuma"</string>
    <string name="zen_mode_other_options" msgid="3399967231522580421">"outras opções"</string>
    <string name="zen_mode_add" msgid="8789024026733232566">"Adicionar"</string>
    <string name="zen_mode_enable_dialog_turn_on" msgid="1971034397501675078">"Ativar"</string>
    <string name="zen_mode_button_turn_on" msgid="6583862599681052347">"Ativar agora"</string>
    <string name="zen_mode_button_turn_off" msgid="2060862413234857296">"Desativar agora"</string>
    <string name="zen_mode_settings_dnd_manual_end_time" msgid="8251503918238985549">"O modo \"Não perturbe\" fica ativado até <xliff:g id="FORMATTED_TIME">%s</xliff:g>"</string>
    <string name="zen_mode_settings_dnd_manual_indefinite" msgid="1436568478062106132">"O modo Não perturbe ficará ativado até que você o desative."</string>
    <string name="zen_mode_settings_dnd_automatic_rule" msgid="1958092329238152236">"O \"Não perturbe\" foi ativado automaticamente por uma programação (<xliff:g id="RULE_NAME">%s</xliff:g>)"</string>
    <string name="zen_mode_settings_dnd_automatic_rule_app" msgid="3401685760954156067">"O modo \"Não perturbe\" foi ativado automaticamente por um app (<xliff:g id="APP_NAME">%s</xliff:g>)"</string>
    <string name="zen_mode_settings_dnd_custom_settings_footer" msgid="6566115866660865385">"O \"Não perturbe\" está ativado para <xliff:g id="RULE_NAMES">%s</xliff:g> com configurações personalizadas."</string>
    <string name="zen_mode_settings_dnd_custom_settings_footer_link" msgid="8255159194653341835">" "<annotation id="link">"Ver configurações personalizadas"</annotation></string>
    <string name="zen_interruption_level_priority" msgid="4854123502362861192">"Somente prioridade"</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">"Ativado / <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="zen_mode_sound_summary_on" msgid="9077659040104989899">"Ativado"</string>
    <string name="zen_mode_duration_summary_always_prompt" msgid="7658172853423383037">"Perguntar sempre"</string>
    <string name="zen_mode_duration_summary_forever" msgid="5551992961329998606">"Até você desativar"</string>
    <string name="zen_mode_duration_summary_time_hours" msgid="2602655749780428308">"{count,plural, =1{1 hora}one{# hora}other{# horas}}"</string>
    <string name="zen_mode_duration_summary_time_minutes" msgid="5755536844016835693">"{count,plural, =1{1 minuto}one{# minuto}other{# minutos}}"</string>
    <string name="zen_mode_sound_summary_off" msgid="7350437977839985836">"{count,plural, =0{Desativado}=1{Desativado / 1 programação pode ser ativada automaticamente}one{Desativado / # programação pode ser ativada automaticamente}other{Desativado / # programações podem ser ativadas automaticamente}}"</string>
    <string name="zen_category_behavior" msgid="3214056473947178507">"O que pode interromper o \"Não perturbe\""</string>
    <string name="zen_category_people" msgid="8252926021894933047">"Pessoas"</string>
    <string name="zen_category_apps" msgid="1167374545618451925">"Apps"</string>
    <string name="zen_category_exceptions" msgid="1316097981052752811">"Alarmes e outras interrupções"</string>
    <string name="zen_category_schedule" msgid="2003707171924226212">"Programações"</string>
    <string name="zen_category_duration" msgid="7515850842082631460">"Duração das Configurações rápidas"</string>
    <string name="zen_settings_general" msgid="2704932194620124153">"Geral"</string>
    <string name="zen_sound_footer" msgid="4090291351903631977">"Quando o Não perturbe estiver ativado, sons e vibrações serão desativados, com exceção dos itens permitidos por você acima."</string>
    <string name="zen_custom_settings_dialog_title" msgid="4613603772432720380">"Configurações personalizadas"</string>
    <string name="zen_custom_settings_dialog_review_schedule" msgid="4674671820584759928">"Revisar programação"</string>
    <string name="zen_custom_settings_dialog_ok" msgid="8842373418878278246">"Ok"</string>
    <string name="zen_custom_settings_notifications_header" msgid="7635280645171095398">"Notificações"</string>
    <string name="zen_custom_settings_duration_header" msgid="5065987827522064943">"Duração"</string>
    <string name="zen_msg_event_reminder_title" msgid="5362025129007417554">"Mensagens, eventos e lembretes"</string>
    <string name="zen_msg_event_reminder_footer" msgid="2700459146293750387">"Quando o Não perturbe estiver ativado, mensagens, lembretes e eventos serão silenciados, com exceção dos itens permitidos por você acima. É possível ajustar as configurações de mensagens para permitir que seus amigos, familiares ou outros contatos falem com você."</string>
    <string name="zen_onboarding_ok" msgid="8764248406533833392">"Concluído"</string>
    <string name="zen_onboarding_settings" msgid="2815839576245114342">"Configurações"</string>
    <string name="zen_onboarding_new_setting_title" msgid="8813308612916316657">"Ocultar avisos visuais ou sonoros de notificações"</string>
    <string name="zen_onboarding_current_setting_title" msgid="5024603685220407195">"Desativar som de notificações"</string>
    <string name="zen_onboarding_new_setting_summary" msgid="7695808354942143707">"Você não verá nem ouvirá notificações. As chamadas de contatos marcados com estrela e de autores de chamadas repetidas serão permitidas."</string>
    <string name="zen_onboarding_current_setting_summary" msgid="8864567406905990095">"(Configuração atual)"</string>
    <string name="zen_onboarding_dnd_visual_disturbances_header" msgid="8639698336231314609">"Alterar as configurações de notificação do \"Não perturbe\"?"</string>
    <string name="sound_work_settings" msgid="752627453846309092">"Sons do perfil de trabalho"</string>
    <string name="work_use_personal_sounds_title" msgid="7729428677919173609">"Usar sons do perfil pessoal"</string>
    <string name="work_use_personal_sounds_summary" msgid="608061627969077231">"Usar os mesmos sons que o perfil pessoal"</string>
    <string name="work_ringtone_title" msgid="4810802758746102589">"Toque do telefone de trabalho"</string>
    <string name="work_notification_ringtone_title" msgid="2955312017013255515">"Som de notificação de trabalho padrão"</string>
    <string name="work_alarm_ringtone_title" msgid="3369293796769537392">"Som de alarme de trabalho padrão"</string>
    <string name="work_sound_same_as_personal" msgid="1836913235401642334">"Igual ao do perfil pessoal"</string>
    <string name="work_sync_dialog_title" msgid="7810248132303515469">"Usar sons do perfil pessoal?"</string>
    <string name="work_sync_dialog_yes" msgid="5785488304957707534">"Confirmar"</string>
    <string name="work_sync_dialog_message" msgid="5066178064994040223">"Seu perfil de trabalho vai usar os mesmos sons que o perfil pessoal"</string>
    <string name="configure_notification_settings" msgid="1492820231694314376">"Notificações"</string>
    <string name="notification_dashboard_summary" msgid="7530169251902320652">"Histórico de notificações, conversas"</string>
    <string name="conversation_notifs_category" msgid="2549844862379963273">"Conversa"</string>
    <string name="general_notification_header" msgid="3669031068980713359">"Gerenciar"</string>
    <string name="app_notification_field" msgid="3208079070539894909">"Notificações de apps"</string>
    <string name="app_notification_field_summary" msgid="5981393613897713471">"Controlar as notificações de apps individuais"</string>
    <string name="advanced_section_header" msgid="6478709678084326738">"Geral"</string>
    <string name="profile_section_header" msgid="4970209372372610799">"Notificações de trabalho"</string>
    <string name="profile_section_header_for_advanced_privacy" msgid="8385775428904838579">"Perfil de trabalho"</string>
    <string name="asst_capability_prioritizer_title" msgid="1181272430009156556">"Prioridade de notificação adaptável"</string>
    <string name="asst_capability_prioritizer_summary" msgid="954988212366568737">"Definir automaticamente as notificações de prioridade baixa como \"Discretas\""</string>
    <string name="asst_capability_ranking_title" msgid="312998580233257581">"Classificação adaptativa de notificações"</string>
    <string name="asst_capability_ranking_summary" msgid="2293524677144599450">"Classificar notificações automaticamente por relevância"</string>
    <string name="asst_feedback_indicator_title" msgid="5169801869752395354">"Feedback de notificação adaptável"</string>
    <string name="asst_feedback_indicator_summary" msgid="5862082842073307900">"Indicar os ajustes feitos nas notificações e mostrar a opção de enviar feedback ao sistema"</string>
    <string name="asst_importance_reset_title" msgid="6191265591976440115">"Redefinir importância de notificações"</string>
    <string name="asst_importance_reset_summary" msgid="684794589254282667">"Redefina as configurações de importância mudadas pelo usuário e permita que o assistente de notificação decida a prioridade"</string>
    <string name="asst_capabilities_actions_replies_title" msgid="4392470465646394289">"Respostas e ações sugeridas"</string>
    <string name="asst_capabilities_actions_replies_summary" msgid="416234323365645871">"Mostrar automaticamente as respostas e ações sugeridas"</string>
    <string name="notification_history_summary" msgid="5434741516307706892">"Mostrar notificações recentes e adiadas"</string>
    <string name="notification_history" msgid="8663811361243456201">"Histórico de notificações"</string>
    <string name="notification_history_toggle" msgid="9093762294928569030">"Usar histórico de notificações"</string>
    <string name="notification_history_off_title_extended" msgid="853807652537281601">"Histórico de notificações desativado"</string>
    <string name="notification_history_off_summary" msgid="671359587084797617">"Ative o histórico de notificações para ver notificações recentes e adiadas"</string>
    <string name="history_toggled_on_title" msgid="4518001110492652830">"Nenhuma notificação recente"</string>
    <string name="history_toggled_on_summary" msgid="9034278971358282728">"As notificações recentes e adiadas aparecerão aqui"</string>
    <string name="notification_history_view_settings" msgid="5269317798670449002">"ver configurações de notificação"</string>
    <string name="notification_history_open_notification" msgid="2655071846911258371">"abrir notificação"</string>
    <string name="snooze_options_title" msgid="2109795569568344617">"Permitir adiar notificações"</string>
    <string name="notification_badging_title" msgid="5469616894819568917">"Ponto de notificação no ícone do app"</string>
    <string name="notification_bubbles_title" msgid="5681506665322329301">"Balões"</string>
    <string name="bubbles_app_toggle_title" msgid="5319021259954576150">"Balões"</string>
    <string name="bubbles_conversation_toggle_title" msgid="5225039214083311316">"Mostrar conversa em um balão"</string>
    <string name="bubbles_conversation_toggle_summary" msgid="720229032254323578">"Mostrar ícone flutuante sobre outros apps"</string>
    <string name="bubbles_feature_disabled_dialog_title" msgid="1794193899792284007">"Ativar balões no dispositivo?"</string>
    <string name="bubbles_feature_disabled_dialog_text" msgid="5275666953364031055">"Ativar os balões neste app fará o mesmo no dispositivo.\n\nIsso afeta outros apps e conversas que têm permissão para usar balões."</string>
    <string name="bubbles_feature_disabled_button_approve" msgid="2042628067101419871">"Ativar"</string>
    <string name="bubbles_feature_disabled_button_cancel" msgid="8963409459448350600">"Cancelar"</string>
    <string name="notifications_bubble_setting_on_summary" msgid="4641572377430901196">"Ativados / As conversas podem aparecer como ícones flutuantes"</string>
    <string name="notifications_bubble_setting_title" msgid="8287649393774855268">"Permitir que os apps mostrem balões"</string>
    <string name="notifications_bubble_setting_description" msgid="7336770088735025981">"Algumas conversas aparecerão como ícones flutuantes sobre outros apps"</string>
    <string name="bubble_app_setting_all" msgid="312524752846978277">"Todas as conversas podem gerar balões"</string>
    <string name="bubble_app_setting_selected" msgid="4324386074198040675">"Conversas selecionadas podem gerar balões"</string>
    <string name="bubble_app_setting_none" msgid="8643594711863996418">"Nenhuma conversa pode gerar balões"</string>
    <string name="bubble_app_setting_selected_conversation_title" msgid="3060958976857529933">"Conversas"</string>
    <string name="bubble_app_setting_excluded_conversation_title" msgid="324818960338773945">"Todas as conversas podem aparecer como balões, exceto"</string>
    <string name="bubble_app_setting_unbubble_conversation" msgid="1769789500566080427">"Desativar balões para esta conversa"</string>
    <string name="bubble_app_setting_bubble_conversation" msgid="1461981680982964285">"Ativar balões para esta conversa"</string>
    <string name="swipe_direction_ltr" msgid="5137180130142633085">"Deslize para a direita para dispensar e para esquerda para mostrar o menu"</string>
    <string name="swipe_direction_rtl" msgid="1707391213940663992">"Deslize para esquerda para dispensar ou para direita para mostrar o menu"</string>
    <string name="silent_notifications_status_bar" msgid="6113307620588767516">"Ocultar notificações silenciosas na barra de status"</string>
    <string name="notification_pulse_title" msgid="8013178454646671529">"Piscar a luz"</string>
    <string name="lock_screen_notifications_title" msgid="2876323153692406203">"Privacidade"</string>
    <string name="lockscreen_bypass_title" msgid="6519964196744088573">"Pular tela de bloqueio"</string>
    <string name="lockscreen_bypass_summary" msgid="4578154430436224161">"Após o desbloqueio, a última tela usada será mostrada. Deslize de cima para baixo para conferir as notificações, que não vão aparecer na tela de bloqueio."</string>
    <string name="keywords_lockscreen_bypass" msgid="41035425468915498">"Bloquear tela, tela de bloqueio, pular, ignorar"</string>
    <string name="locked_work_profile_notification_title" msgid="279367321791301499">"Quando o perfil está bloqueado"</string>
    <string name="unseen_notifs_lock_screen" msgid="6910701117021324612">"Mostrar somente notificações novas na tela de bloqueio"</string>
    <string name="unseen_notifs_lock_screen_summary" msgid="5996722793868021391">"Remover automaticamente da tela de bloqueio as notificações visualizadas anteriormente"</string>
    <string name="lock_screen_notifs_title" msgid="3412042692317304449">"Notificações na tela de bloqueio"</string>
    <string name="lock_screen_notifs_show_all_summary" msgid="4226586018375762117">"Mostrar conversas, padrão e silenciosas"</string>
    <string name="lock_screen_notifs_show_all" msgid="1300418674456749664">"Mostrar conversas, padrão e silenciosas"</string>
    <string name="lock_screen_notifs_show_alerting" msgid="6584682657382684566">"Ocultar notificações e conversas silenciosas"</string>
    <string name="lock_screen_notifs_show_none" msgid="1941044980403067101">"Não mostrar notificações"</string>
    <string name="lock_screen_notifs_redact" msgid="9024158855454642296">"Notificações sensíveis"</string>
    <string name="lock_screen_notifs_redact_summary" msgid="1395483766035470612">"Mostrar conteúdo confidencial quando o dispositivo estiver bloqueado"</string>
    <string name="lock_screen_notifs_redact_work" msgid="3833920196569208430">"Notificações confidenciais do perfil de trabalho"</string>
    <string name="lock_screen_notifs_redact_work_summary" msgid="3238238380405430156">"Mostrar conteúdo confidencial do perfil de trabalho quando estiver bloqueado"</string>
    <string name="lock_screen_notifications_summary_show" msgid="6540443483088311328">"Mostrar todo o conteúdo das notificações"</string>
    <string name="lock_screen_notifications_summary_hide" msgid="7837303171531166789">"Só mostrar conteúdo sensível quando desbloqueado"</string>
    <string name="lock_screen_notifications_summary_disable" msgid="3388290397947365744">"Não mostrar nenhuma notificação"</string>
    <string name="lock_screen_notifications_interstitial_message" msgid="6326229471276829730">"O que você quer que apareça na sua tela de bloqueio?"</string>
    <string name="lock_screen_notifications_interstitial_title" msgid="1360388192096354315">"Tela de bloqueio"</string>
    <string name="lock_screen_notifications_summary_show_profile" msgid="8373401288962523946">"Mostre todo o conteúdo de notificação de trabalho"</string>
    <string name="lock_screen_notifications_summary_hide_profile" msgid="2183455323048921579">"Ocultar conteúdo de trabalho confidencial"</string>
    <string name="lock_screen_notifications_interstitial_message_profile" msgid="1456262034599029028">"Como você quer que as notificações sejam exibidas quando o dispositivo estiver bloqueado?"</string>
    <string name="lock_screen_notifications_interstitial_title_profile" msgid="6950124772255324448">"Notificações do perfil"</string>
    <string name="notifications_title" msgid="4221655533193721131">"Notificações"</string>
    <string name="app_notifications_title" msgid="248374669037385148">"Notificações de apps"</string>
    <string name="notification_channel_title" msgid="8859880871692797611">"Categoria da notificação"</string>
    <string name="notification_importance_title" msgid="1545158655988342703">"Comportamento"</string>
    <string name="conversations_category_title" msgid="5586541340846847798">"Conversas"</string>
    <string name="conversation_section_switch_title" msgid="3332885377659473775">"Seção de conversa"</string>
    <string name="conversation_section_switch_summary" msgid="6123587625929439674">"Permitir que o app use uma seção de conversa"</string>
    <string name="demote_conversation_title" msgid="6355383023376508485">"Não é uma conversa"</string>
    <string name="demote_conversation_summary" msgid="4319929331165604112">"Remover da seção de conversa"</string>
    <string name="promote_conversation_title" msgid="4731148769888238722">"Esta é uma conversa"</string>
    <string name="promote_conversation_summary" msgid="3890724115743515035">"Adicionar à seção de conversas"</string>
    <string name="priority_conversation_count_zero" msgid="3862289535537564713">"Nenhuma conversa prioritária"</string>
    <string name="priority_conversation_count" msgid="7291234530844412077">"{count,plural, =1{# conversa prioritária}one{# conversa prioritária}other{# conversas prioritárias}}"</string>
    <string name="important_conversations" msgid="1233893707189659401">"Conversas prioritárias"</string>
    <string name="important_conversations_summary_bubbles" msgid="614327166808117644">"Aparecem na parte superior da seção de conversa, na forma de balões"</string>
    <string name="important_conversations_summary" msgid="3184022761562676418">"Aparecem na parte superior da seção de conversa"</string>
    <string name="other_conversations" msgid="551178916855139870">"Conversas sem prioridade"</string>
    <string name="other_conversations_summary" msgid="3487426787901236273">"Conversas que você modificou"</string>
    <string name="recent_conversations" msgid="471678228756995274">"Conversas recentes"</string>
    <string name="conversation_settings_clear_recents" msgid="8940398397663307054">"Limpar conversas recentes"</string>
    <string name="recent_convos_removed" msgid="2122932798895714203">"Conversas recentes removidas"</string>
    <string name="recent_convo_removed" msgid="8686414146325958281">"Conversa removida"</string>
    <string name="clear" msgid="5092178335409471100">"Limpar"</string>
    <string name="clear_conversation" msgid="5564321180363279096">"Limpar <xliff:g id="CONVERSATION_NAME">%1$s</xliff:g>"</string>
    <string name="conversation_onboarding_title" msgid="5194559958353468484">"As conversas prioritárias e modificadas aparecem aqui"</string>
    <string name="conversation_onboarding_summary" msgid="2484845363368486941">"Depois de marcar como prioritária ou fazer qualquer mudança nas conversas, elas aparecem aqui. \n\nPara mudar as configurações: \ndeslize o dedo de cima para baixo na tela para abrir a aba suspensa. Em seguida, toque na conversa e mantenha pressionada."</string>
    <string name="notification_importance_min_title" msgid="7676541266705442501">"Minimizar"</string>
    <string name="notification_importance_high_title" msgid="394129291760607808">"Aparecer na tela"</string>
    <string name="notification_silence_title" msgid="4085829874452944989">"Silencioso"</string>
    <string name="notification_alert_title" msgid="1632401211722199217">"Padrão"</string>
    <string name="allow_interruption" msgid="5237201780159482716">"Permitir interrupções"</string>
    <string name="allow_interruption_summary" msgid="9044131663518112543">"Permitir que o app emita um som, vibre e/ou mostre notificações na tela"</string>
    <string name="notification_priority_title" msgid="5554834239080425229">"Prioritárias"</string>
    <string name="notification_channel_summary_priority" msgid="7225362351439076913">"Aparecem na parte superior de uma seção de conversa, na forma de balões, mostrando a foto do perfil na tela de bloqueio"</string>
    <string name="convo_not_supported_summary" msgid="4285471045268268048">"O app <xliff:g id="APP_NAME">%1$s</xliff:g> não é compatível com a maioria dos recursos de conversa. Não é possível definir uma conversa como prioritária, e as conversas não aparecerão em forma de balões."</string>
    <string name="notification_channel_summary_min" msgid="8823399508450176842">"Na aba suspensa, recolher notificações para uma única linha"</string>
    <string name="notification_channel_summary_low" msgid="5549662596677692000">"Som e vibração desativados"</string>
    <string name="notification_conversation_summary_low" msgid="6352818857388412326">"O som e a vibração estão desativados, e o balão aparece na parte inferior da seção de conversa"</string>
    <string name="notification_channel_summary_default" msgid="1168420867670390611">"Pode vibrar ou tocar com base nas configurações do dispositivo"</string>
    <string name="notification_channel_summary_high" msgid="3411637309360617621">"Quando o dispositivo está desbloqueado, mostra notificações em um banner no topo da tela"</string>
    <string name="notification_switch_label" msgid="8029371325967501557">"Todas as notificações de <xliff:g id="APP_NAME">%1$s</xliff:g>"</string>
    <string name="notification_app_switch_label" msgid="4422902423925084193">"Todas as notificações do app <xliff:g id="APP_NAME">%1$s</xliff:g>"</string>
    <string name="notifications_sent_daily" msgid="10274479224185437">"{count,plural, =1{Cerca de # notificação por dia}one{Cerca de # notificação por dia}other{Cerca de # notificações por dia}}"</string>
    <string name="notifications_sent_weekly" msgid="7895656213187555346">"{count,plural, =1{Cerca de # notificação por semana}one{Cerca de # notificação por semana}other{Cerca de # notificações por semana}}"</string>
    <string name="notifications_sent_never" msgid="9081278709126812062">"Nunca"</string>
    <string name="manage_notification_access_title" msgid="6481256069087219982">"Notificações de apps e do dispositivo"</string>
    <string name="manage_notification_access_summary" msgid="2907135226478903997">"Controlar quais apps e dispositivos podem ler as notificações"</string>
    <string name="work_profile_notification_access_blocked_summary" msgid="8643809206612366067">"O acesso às notificações do perfil de trabalho está bloqueado"</string>
    <string name="notification_assistant_title" msgid="5889201903272393099">"Notificações avançadas"</string>
    <string name="notification_assistant_summary" msgid="1957783114840908887">"Receber sugestões de ações, respostas e muito mais"</string>
    <string name="no_notification_assistant" msgid="2533323397091834096">"Nenhuma"</string>
    <string name="no_notification_listeners" msgid="2839354157349636000">"Nenhum app instalado solicitou o acesso a notificações."</string>
    <string name="notification_access_detail_switch" msgid="46386786409608330">"Permitir acesso às notificações"</string>
    <string name="notification_assistant_security_warning_summary" msgid="4846559755787348129">"No Android 12, as notificações avançadas substituíram as notificações adaptáveis. Esse recurso exibe ações e respostas sugeridas, além de organizar suas notificações. \n\nAs notificações avançadas podem acessar o conteúdo das notificações, incluindo informações pessoais como nomes de contatos e mensagens. Elas também podem dispensar ou responder às notificações, como atender ligações telefônicas e controlar o Não perturbe."</string>
    <string name="notification_listener_security_warning_title" msgid="5791700876622858363">"Permitir que <xliff:g id="SERVICE">%1$s</xliff:g> acesse as notificações?"</string>
    <string name="notification_listener_security_warning_summary" msgid="1131986567509818121">"O app <xliff:g id="NOTIFICATION_LISTENER_NAME">%1$s</xliff:g> poderá ler todas as notificações, incluindo informações pessoais como nomes de contatos, fotos e o texto das mensagens que você receber. Ele também poderá adiar ou dispensar notificações, assim como acionar botões que elas contenham, inclusive para atender ligações. \n\nIsso também autoriza o app a ativar ou desativar o modo \"Não perturbe\" e mudar as configurações relacionadas."</string>
    <string name="nls_warning_prompt" msgid="1486887096703743841">"O app <xliff:g id="NOTIFICATION_LISTENER_NAME">%1$s</xliff:g> poderá:"</string>
    <string name="nls_feature_read_title" msgid="7629713268744220437">"Ler suas notificações"</string>
    <string name="nls_feature_read_summary" msgid="1064698238110273593">"Ele pode ler suas notificações, incluindo informações pessoais como contatos, mensagens e fotos."</string>
    <string name="nls_feature_reply_title" msgid="7925455553821362039">"Responder a mensagens"</string>
    <string name="nls_feature_reply_summary" msgid="4492543411395565556">"Ele pode responder a mensagens e acionar botões nas notificações, como ativar a soneca, dispensar notificações ou atender ligações."</string>
    <string name="nls_feature_settings_title" msgid="8208164329853194414">"Mudar configurações"</string>
    <string name="nls_feature_settings_summary" msgid="3770028705648985689">"Ele pode ativar e desativar o modo Não perturbe e mudar as configurações relacionadas a ele."</string>
    <string name="notification_listener_disable_warning_summary" msgid="8373396293802088961">"Se você desativar o acesso a notificações para <xliff:g id="NOTIFICATION_LISTENER_NAME">%1$s</xliff:g>, é possível que o acesso ao Não perturbe também seja desativado."</string>
    <string name="notification_listener_disable_warning_confirm" msgid="841492108402184976">"Desativar"</string>
    <string name="notification_listener_disable_warning_cancel" msgid="8802784105045594324">"Cancelar"</string>
    <string name="notif_type_ongoing" msgid="135675014223627555">"Em tempo real"</string>
    <string name="notif_type_ongoing_summary" msgid="2348867528527573574">"Comunicação em andamento de apps em uso, navegação, chamadas telefônicas e muito mais"</string>
    <string name="notif_type_conversation" msgid="4383931408641374979">"Conversas"</string>
    <string name="notif_type_conversation_summary" msgid="179142405410217101">"SMS, mensagens de texto e outras comunicações"</string>
    <string name="notif_type_alerting" msgid="4713073696855718576">"Notificações"</string>
    <string name="notif_type_alerting_summary" msgid="4681068287836313604">"Pode vibrar ou tocar com base nas configurações"</string>
    <string name="notif_type_silent" msgid="6273951794420331010">"Silenciosas"</string>
    <string name="notif_type_silent_summary" msgid="7820923063105060844">"Notificações que nunca fazem o dispositivo tocar ou vibrar"</string>
    <string name="notification_listener_allowed" msgid="5536962633536318551">"Permitidas"</string>
    <string name="notification_listener_not_allowed" msgid="3352962779597846538">"Não permitidas"</string>
    <string name="notif_listener_excluded_app_title" msgid="6679316209330349730">"Mostrar todos os apps"</string>
    <string name="notif_listener_excluded_app_summary" msgid="2914567678047195396">"Mude as configurações para cada app que envia notificações"</string>
    <string name="notif_listener_excluded_app_screen_title" msgid="8636196723227432994">"Apps que aparecem no dispositivo"</string>
    <string name="notif_listener_not_migrated" msgid="6265206376374278226">"O app não é compatível com as configurações avançadas."</string>
    <string name="notif_listener_more_settings" msgid="1348409392307208921">"Mais configurações"</string>
    <string name="notif_listener_more_settings_desc" msgid="7995492074281663658">"Mais configurações estão disponíveis neste app"</string>
    <string name="notification_polite_title" msgid="6121016426991791557">"Período de espera para notificações"</string>
    <string name="notification_polite_all_apps" msgid="1118651561594250059">"Aplicar um período de espera a todas as notificações"</string>
    <string name="notification_polite_all_apps_summary" msgid="540268373207498126">"Diminuir gradualmente o volume de notificações quando você receber muitas seguidas do mesmo app"</string>
    <string name="notification_polite_conversations" msgid="8197695136727245741">"Aplicar um período de espera a conversas"</string>
    <string name="notification_polite_conversations_summary" msgid="2677141765664359994">"Diminuir gradualmente o volume de notificações quando você receber muitas mensagens seguidas da mesma conversa em um curto período"</string>
    <string name="notification_polite_disabled" msgid="1378078021594282842">"Não usar o período de espera para notificações"</string>
    <string name="notification_polite_disabled_summary" msgid="1145341260283746936">"Nunca diminuir o volume de notificações, independente da quantidade de notificações seguidas do mesmo app"</string>
    <string name="notification_polite_vibrate_unlocked" msgid="6142573851761357903">"Vibrar quando desbloqueado"</string>
    <string name="notification_polite_vibrate_unlocked_summary" msgid="1678472892282874459">"Vibrar apenas quando a tela estiver desbloqueada"</string>
    <string name="notification_polite_work" msgid="8823596456640216391">"Aplicar a perfis de trabalho"</string>
    <string name="notification_polite_work_summary" msgid="8260947839104352075">"Aplique as configurações de período de espera para notificações do seu perfil pessoal ao seu perfil de trabalho"</string>
    <string name="vr_listeners_title" msgid="4960357292472540964">"Serviços de ajuda para RV"</string>
    <string name="no_vr_listeners" msgid="8442646085375949755">"Nenhum app instalado solicitou ser executado como serviço de ajuda para RV."</string>
    <string name="vr_listener_security_warning_title" msgid="7026351795627615177">"Permitir acesso ao serviço de RV para <xliff:g id="SERVICE">%1$s</xliff:g>?"</string>
    <string name="vr_listener_security_warning_summary" msgid="1888843557687017791">"Você poderá executar o <xliff:g id="VR_LISTENER_NAME">%1$s</xliff:g> quando estiver usando apps em modo de realidade virtual."</string>
    <string name="display_vr_pref_title" msgid="4850474436291113569">"Com o dispositivo no modo RV"</string>
    <string name="display_vr_pref_low_persistence" msgid="7039841277157739871">"Reduzir desfoque (recomendado)"</string>
    <string name="display_vr_pref_off" msgid="4008841566387432721">"Reduzir oscilação"</string>
    <string name="picture_in_picture_title" msgid="9001594281840542493">"Picture-in-picture"</string>
    <string name="picture_in_picture_empty_text" msgid="9123600661268731579">"Nenhum dos apps instalados é compatível com Picture-in-picture"</string>
    <string name="picture_in_picture_keywords" msgid="3605379820551656253">"pip picture in"</string>
    <string name="picture_in_picture_app_detail_title" msgid="4442235098255164650">"Picture-in-picture"</string>
    <string name="picture_in_picture_app_detail_switch" msgid="8544190716075624017">"Permitir picture-in-picture"</string>
    <string name="picture_in_picture_app_detail_summary" msgid="2503211101305358849">"Permite que esse app crie uma janela picture-in-picture enquanto o app é aberto ou depois que você sai dele (por exemplo, para continuar a assistir um vídeo). Essa janela é sobreposta a outros apps que você está usando."</string>
    <string name="interact_across_profiles_title" msgid="7285906999927669971">"Apps pessoais e de trabalho conectados"</string>
    <string name="interact_across_profiles_summary_allowed" msgid="1365881452153799092">"Conectado"</string>
    <string name="interact_across_profiles_summary_not_allowed" msgid="5802674212788171790">"Não conectado"</string>
    <string name="interact_across_profiles_empty_text" msgid="419061031064397168">"Nenhum app conectado"</string>
    <string name="interact_across_profiles_keywords" msgid="5996472773111665049">"perfil unificado app conectado apps de trabalho e pessoais"</string>
    <string name="interact_across_profiles_switch_enabled" msgid="7294719120282287495">"Conectados"</string>
    <string name="interact_across_profiles_switch_disabled" msgid="4312196170211463988">"Conectar esses apps"</string>
    <string name="interact_across_profiles_summary_1" msgid="6093976896137600231">"Os apps conectados compartilham permissões e podem acessar dados uns dos outros."</string>
    <string name="interact_across_profiles_summary_2" msgid="505748305453633885">"Só conecte apps em que você confia e que não compartilham seus dados pessoais com o administrador de TI."</string>
    <string name="interact_across_profiles_summary_3" msgid="444428694843299854">"Você pode desconectar apps a qualquer momento nas configurações de privacidade do seu dispositivo."</string>
    <string name="interact_across_profiles_consent_dialog_title" msgid="8530621211216508681">"Confiar seus dados pessoais ao app de trabalho <xliff:g id="NAME">%1$s</xliff:g>?"</string>
    <string name="interact_across_profiles_consent_dialog_summary" msgid="3949870271562055048">"Só conecte apps em que você confia e que não compartilham seus dados pessoais com o administrador de TI."</string>
    <string name="interact_across_profiles_consent_dialog_app_data_title" msgid="8436318876213958940">"Dados do app"</string>
    <string name="interact_across_profiles_consent_dialog_app_data_summary" msgid="6057019384328088311">"Esse app pode acessar dados do seu app pessoal <xliff:g id="NAME">%1$s</xliff:g>."</string>
    <string name="interact_across_profiles_consent_dialog_permissions_title" msgid="2316852600280487055">"Permissões"</string>
    <string name="interact_across_profiles_consent_dialog_permissions_summary" msgid="995051542847604039">"Esse app pode usar permissões do seu app pessoal <xliff:g id="NAME">%1$s</xliff:g>, como acesso ao local, armazenamento ou contatos."</string>
    <string name="interact_across_profiles_number_of_connected_apps_none" msgid="8573289199942092964">"Nenhum app conectado"</string>
    <string name="interact_across_profiles_number_of_connected_apps" msgid="4000424798291479207">"{count,plural, =1{# app conectado}one{# app conectado}other{# apps conectados}}"</string>
    <string name="interact_across_profiles_install_work_app_title" msgid="2821669067014436056">"Para conectar esses apps, instale o app <xliff:g id="NAME">%1$s</xliff:g> no seu perfil de trabalho"</string>
    <string name="interact_across_profiles_install_personal_app_title" msgid="4790651223324866344">"Para conectar esses apps, instale o app <xliff:g id="NAME">%1$s</xliff:g> no seu perfil pessoal"</string>
    <string name="interact_across_profiles_install_app_summary" msgid="7715324358034968657">"Toque para instalar o app"</string>
    <string name="manage_zen_access_title" msgid="1562322900340107269">"Acesso ao Não perturbe"</string>
    <string name="zen_access_detail_switch" msgid="4183681772666138993">"Permitir o Não perturbe"</string>
    <string name="zen_access_empty_text" msgid="3779921853282293080">"Nenhum app instalado solicitou o acesso \"Não perturbe\""</string>
    <string name="app_notifications_off_desc" msgid="2484843759466874201">"Você não permitiu notificações para este app"</string>
    <string name="channel_notifications_off_desc" msgid="6202042207121633488">"O Android está bloqueando essa categoria de notificações neste dispositivo, conforme você pediu."</string>
    <string name="channel_group_notifications_off_desc" msgid="9096417708500595424">"O Android está bloqueando esse grupo de notificações neste dispositivo, conforme seu pedido"</string>
    <string name="app_notifications_not_send_desc" msgid="5683060986735070528">"Esse app não envia notificações"</string>
    <string name="notification_channels" msgid="1502969522886493799">"Categorias"</string>
    <string name="notification_channels_other" msgid="18159805343647908">"Outros"</string>
    <string name="no_channels" msgid="4716199078612071915">"Este app não postou nenhuma notificação"</string>
    <string name="app_settings_link" msgid="6725453466705333311">"Configurações avançadas no app"</string>
    <string name="show_unused_channels" msgid="2754356124204058828">"Mostrar canais não usados"</string>
    <string name="hide_unused_channels" msgid="9049958190570733200">"Ocultar canais não usados"</string>
    <string name="deleted_channels" msgid="8489800381509312964">"{count,plural, =1{# categoria excluída}one{# categoria excluída}other{# categorias excluídas}}"</string>
    <string name="app_notification_block_title" msgid="3880322745749900296">"Bloquear tudo"</string>
    <string name="app_notification_block_summary" msgid="1804611676339341551">"Nunca mostrar essas notificações"</string>
    <string name="notification_content_block_title" msgid="6689085826061361351">"Mostrar notificações"</string>
    <string name="notification_content_block_summary" msgid="329171999992248925">"Nunca mostrar notificações na aba ou em dispositivos periféricos"</string>
    <string name="app_notification_fsi_permission_title" msgid="5424116606034705020">"Permitir notificações em tela cheia"</string>
    <string name="app_notification_fsi_permission_summary" msgid="7673487977631068039">"Permitir que as notificações ocupem toda a tela quando o dispositivo estiver bloqueado"</string>
    <string name="notification_badge_title" msgid="6854537463548411313">"Permitir ponto de notificação"</string>
    <string name="notification_channel_badge_title" msgid="6505542437385640049">"Mostrar ponto de notificação"</string>
    <string name="app_notification_override_dnd_title" msgid="3769539356442226691">"Ignorar o Não perturbe"</string>
    <string name="app_notification_override_dnd_summary" msgid="4894641191397562920">"Permitir que as notificações sejam mostradas mesmo quando o Não perturbe estiver ativado"</string>
    <string name="app_notification_visibility_override_title" msgid="7778628150022065920">"Tela de bloqueio"</string>
    <string name="app_notifications_dialog_done" msgid="573716608705273004">"Concluído"</string>
    <string name="notification_show_lights_title" msgid="5564315979007438583">"Piscar a luz"</string>
    <string name="notification_vibrate_title" msgid="1422330728336623351">"Vibração"</string>
    <string name="notification_channel_sound_title" msgid="9018031231387273476">"Som"</string>
    <string name="notification_conversation_important" msgid="4365437037763608045">"Prioritárias"</string>
    <string name="zen_mode_rule_name" msgid="7303080427006917702">"Nome da programação"</string>
    <string name="zen_mode_rule_name_hint" msgid="7029432803855827697">"Insira o nome da programação"</string>
    <string name="zen_mode_rule_name_warning" msgid="1244435780807634954">"O nome de programação já está em uso"</string>
    <string name="zen_mode_add_rule" msgid="4217731747959400770">"Adicionar mais"</string>
    <string name="zen_mode_add_event_rule" msgid="9179404395950854471">"Adicionar programação de evento"</string>
    <string name="zen_mode_add_time_rule" msgid="2621320450155364432">"Adicionar programação de horário"</string>
    <string name="zen_mode_choose_rule_type" msgid="7656308563653982975">"Escolher o tipo de programação"</string>
    <string name="zen_mode_delete_rule_confirmation" msgid="6195069346439736688">"Excluir a regra \"<xliff:g id="RULE">%1$s</xliff:g>\"?"</string>
    <string name="zen_mode_delete_rule_button" msgid="8328729110756882244">"Excluir"</string>
    <string name="zen_mode_app_set_behavior" msgid="4319517270279704677">"Não é possível alterar essas configurações no momento. Um app (<xliff:g id="APP_NAME">%1$s</xliff:g>) ativou automaticamente o modo \"Não perturbe\" com comportamento personalizado."</string>
    <string name="zen_mode_unknown_app_set_behavior" msgid="8544413884273894104">"Não é possível alterar essas configurações no momento. Um app ativou automaticamente o modo \"Não perturbe\" com comportamento personalizado."</string>
    <string name="zen_mode_qs_set_behavior" msgid="3805244555649172848">"Não é possível alterar essas configurações no momento. O modo \"Não perturbe\" foi ativado manualmente com comportamento personalizado."</string>
    <string name="zen_schedule_rule_type_name" msgid="8071428540221112090">"Horário"</string>
    <string name="zen_event_rule_type_name" msgid="1921166617081971754">"Evento"</string>
    <string name="zen_mode_event_rule_calendar" msgid="6279460374929508907">"Durante os eventos de"</string>
    <string name="zen_mode_event_rule_calendar_any" msgid="5152139705998281205">"Qualquer agenda"</string>
    <string name="zen_mode_event_rule_reply" msgid="6099405414361340225">"Quando a resposta for"</string>
    <string name="zen_mode_event_rule_reply_any_except_no" msgid="4672746760505346596">"Sim, Talvez ou Sem resposta"</string>
    <string name="zen_mode_event_rule_reply_yes_or_maybe" msgid="6584448788100186574">"Sim ou Talvez"</string>
    <string name="zen_mode_event_rule_reply_yes" msgid="7812120982734551236">"Sim"</string>
    <string name="zen_mode_rule_not_found_text" msgid="5303667326973891036">"Regra não encontrada."</string>
    <string name="zen_mode_rule_summary_enabled_combination" msgid="1183604368083885789">"Ativado / <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">"Dias"</string>
    <string name="zen_mode_schedule_rule_days_none" msgid="5636604196262227070">"Nenhuma"</string>
    <string name="zen_mode_schedule_alarm_title" msgid="305237266064819345">"O alarme pode substituir o horário de término"</string>
    <string name="zen_mode_schedule_alarm_summary" msgid="9162760856136645133">"A programação é desativada quando um alarme toca"</string>
    <string name="zen_mode_custom_behavior_title" msgid="92525364576358085">"Comportamento do Não perturbe"</string>
    <string name="zen_mode_custom_behavior_summary_default" msgid="3259312823717839148">"Usar as configurações padrão"</string>
    <string name="zen_mode_custom_behavior_summary" msgid="5390522750884328843">"Criar configurações personalizadas para essa programação"</string>
    <string name="zen_mode_custom_behavior_category_title" msgid="7815612569425733764">"Durante a programação \"<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">"Conversas"</string>
    <string name="zen_mode_from_all_conversations" msgid="3447000451361857061">"Todas as conversas"</string>
    <string name="zen_mode_from_important_conversations" msgid="528050873364229253">"Conversas prioritárias"</string>
    <string name="zen_mode_from_important_conversations_second" msgid="7588299891972136599">"conversas prioritárias"</string>
    <string name="zen_mode_from_no_conversations" msgid="3924593219855567165">"Nenhuma"</string>
    <string name="zen_mode_conversations_count" msgid="3199310723073707153">"{count,plural, =0{Nenhuma}=1{1 conversa}one{# conversa}other{# conversas}}"</string>
    <string name="zen_mode_people_calls_messages_section_title" msgid="6815202112413762206">"Quem pode interromper"</string>
    <string name="zen_mode_people_footer" msgid="7710707353004137431">"Mesmo se os apps de mensagens ou chamadas não puderem notificar você, as pessoas escolhidas aqui ainda vão poder entrar em contato por esses apps"</string>
    <string name="zen_mode_calls_title" msgid="2078578043677037740">"Chamadas"</string>
    <string name="zen_mode_calls" msgid="7653245854493631095">"Chamadas"</string>
    <string name="zen_mode_calls_list" msgid="5044730950895749093">"chamadas"</string>
    <string name="zen_mode_calls_header" msgid="8379225445095856726">"Chamadas que podem interromper"</string>
    <string name="zen_mode_calls_footer" msgid="2008079711083701243">"Para garantir que as chamadas permitidas emitam sons, verifique se o dispositivo está configurado para tocar."</string>
    <string name="zen_mode_custom_calls_footer" msgid="6521283204577441053">"Durante a programação \"<xliff:g id="SCHEDULE_NAME">%1$s</xliff:g>\", as chamadas recebidas são bloqueadas. Você pode ajustar as configurações para permitir que seus amigos, familiares ou outros contatos falem com você."</string>
    <string name="zen_mode_starred_contacts_title" msgid="630299631659575589">"Contatos marcados com estrela"</string>
    <string name="zen_mode_starred_contacts_summary_contacts" msgid="1629467178444895094">"{count,plural,offset:2 =0{Nenhum}=1{{contact_1}}=2{{contact_1} e {contact_2}}=3{{contact_1}, {contact_2} e {contact_3}}one{{contact_1}, {contact_2} e mais #}other{{contact_1}, {contact_2} e mais #}}"</string>
    <string name="zen_mode_starred_contacts_empty_name" msgid="2906404745550293688">"(Sem nome)"</string>
    <string name="zen_mode_messages" msgid="7315084748885170585">"Mensagens"</string>
    <string name="zen_mode_messages_list" msgid="5431014101342361882">"mensagens"</string>
    <string name="zen_mode_messages_title" msgid="1777598523485334405">"Mensagens"</string>
    <string name="zen_mode_messages_header" msgid="253721635061451577">"Mensagens que podem interromper"</string>
    <string name="zen_mode_messages_footer" msgid="6002468050854126331">"Para garantir que as mensagens permitidas emitam sons, verifique se o dispositivo está configurado para tocar"</string>
    <string name="zen_mode_custom_messages_footer" msgid="7545180036949550830">"Enquanto a programação \"<xliff:g id="SCHEDULE_NAME">%1$s</xliff:g>\" estiver ativada, as mensagens recebidas serão bloqueadas. Você pode ajustar as configurações para permitir que seus amigos, familiares ou outros contatos falem com você."</string>
    <string name="zen_mode_all_messages_summary" msgid="3756267858343104554">"Você vai receber todas as mensagens"</string>
    <string name="zen_mode_all_calls_summary" msgid="7337907849083824698">"Você pode receber todas as chamadas"</string>
    <string name="zen_mode_contacts_count" msgid="6568631261119795799">"{count,plural, =0{Nenhum}=1{1 contato}one{# contato}other{# contatos}}"</string>
    <string name="zen_mode_from_anyone" msgid="6027004263046694174">"Qualquer pessoa"</string>
    <string name="zen_mode_from_contacts" msgid="2989933306317064818">"Contatos"</string>
    <string name="zen_mode_from_starred" msgid="8616516644241652287">"Contatos marcados com estrela"</string>
    <string name="zen_mode_none_calls" msgid="2047166006414016327">"Nenhuma"</string>
    <string name="zen_mode_none_messages" msgid="1386626352943268342">"Nenhuma"</string>
    <string name="zen_mode_alarms" msgid="5989343060100771099">"Alarmes"</string>
    <string name="zen_mode_alarms_summary" msgid="3388679177457223967">"Timers, alarmes, sistemas de segurança e outros apps"</string>
    <string name="zen_mode_alarms_list" msgid="334782233067365405">"alarmes"</string>
    <string name="zen_mode_alarms_list_first" msgid="2780418316613576610">"Alarmes"</string>
    <string name="zen_mode_media" msgid="885017672250984735">"Sons de mídia"</string>
    <string name="zen_mode_media_summary" msgid="7174081803853351461">"Sons de vídeos, jogos e outras mídias"</string>
    <string name="zen_mode_media_list" msgid="2006413476596092020">"mídia"</string>
    <string name="zen_mode_media_list_first" msgid="7824427062528618442">"Mídia"</string>
    <string name="zen_mode_system" msgid="7301665021634204942">"Sons de toque"</string>
    <string name="zen_mode_system_summary" msgid="7225581762792177522">"Sons do teclado e de outros botões"</string>
    <string name="zen_mode_system_list" msgid="2256218792042306434">"sons de toque"</string>
    <string name="zen_mode_system_list_first" msgid="8590078626001067855">"Sons de toque"</string>
    <string name="zen_mode_reminders" msgid="1970224691551417906">"Lembretes"</string>
    <string name="zen_mode_reminders_summary" msgid="3961627037429412382">"Tarefas e lembretes"</string>
    <string name="zen_mode_reminders_list" msgid="3133513621980999858">"lembretes"</string>
    <string name="zen_mode_reminders_list_first" msgid="1130470396012190814">"Lembretes"</string>
    <string name="zen_mode_events" msgid="7425795679353531794">"Eventos da agenda"</string>
    <string name="zen_mode_events_summary" msgid="3241903481309766428">"Eventos futuros da agenda"</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 apps modifiquem o \"Não perturbe\""</string>
    <string name="zen_mode_bypassing_apps_header" msgid="60083006963906906">"Apps que podem fazer interrupções"</string>
    <string name="zen_mode_bypassing_apps_add_header" msgid="3201829605075172536">"Selecionar mais apps"</string>
    <string name="zen_mode_bypassing_apps_none" msgid="7944221631721778096">"Nenhum app selecionado"</string>
    <string name="zen_mode_bypassing_apps_subtext_none" msgid="5128770411598722200">"Nenhum app pode interromper"</string>
    <string name="zen_mode_bypassing_apps_add" msgid="5031919618521327102">"Adicionar apps"</string>
    <string name="zen_mode_bypassing_apps_summary_all" msgid="4684544706511555744">"Todas as notificações"</string>
    <string name="zen_mode_bypassing_apps_summary_some" msgid="5315750826830358230">"Algumas notificações"</string>
    <string name="zen_mode_bypassing_apps_footer" msgid="1454862989340760124">"As pessoas que você escolher ainda poderão entrar em contato, mesmo que você não permita a interrupção por apps."</string>
    <string name="zen_mode_bypassing_apps_subtext" msgid="5258652366929842710">"{count,plural,offset:2 =0{Nenhum app pode interromper}=1{{app_1} pode interromper}=2{{app_1} e {app_2} podem interromper}=3{{app_1}, {app_2} e {app_3} podem interromper}one{{app_1}, {app_2} e mais # podem interromper}other{{app_1}, {app_2} e mais # podem interromper}}"</string>
    <string name="zen_mode_bypassing_apps_title" msgid="371050263563164059">"Apps"</string>
    <string name="zen_mode_bypassing_app_channels_header" msgid="4011017798712587373">"Notificações que podem interromper"</string>
    <string name="zen_mode_bypassing_app_channels_toggle_all" msgid="1449462656358219116">"Permitir todas as notificações"</string>
    <string name="zen_mode_other_sounds_summary" msgid="8784400697494837032">"{count,plural,offset:2 =0{Nada pode interromper}=1{{sound_category_1} pode interromper}=2{{sound_category_1} e {sound_category_2} podem interromper}=3{{sound_category_1}, {sound_category_2} e {sound_category_3} podem interromper}one{{sound_category_1}, {sound_category_2} e mais # podem interromper}other{{sound_category_1}, {sound_category_2} e mais # podem interromper}}"</string>
    <string name="zen_mode_sounds_none" msgid="6557474361948269420">"Nada pode interromper"</string>
    <string name="zen_mode_people_none" msgid="4613147461974255046">"Ninguém pode interromper"</string>
    <string name="zen_mode_people_some" msgid="9101872681298810281">"Algumas pessoas podem interromper"</string>
    <string name="zen_mode_people_all" msgid="311036110283015205">"Todas as pessoas podem interromper"</string>
    <string name="zen_mode_repeat_callers" msgid="2270356100287792138">"Autores de chamadas repetidas"</string>
    <string name="zen_mode_repeat_callers_title" msgid="8016699240338264781">"Permitir autores de chamadas repetidas"</string>
    <string name="zen_mode_all_callers" msgid="8104755389401941875">"qualquer pessoa"</string>
    <string name="zen_mode_contacts_callers" msgid="5429267704011896833">"contatos"</string>
    <string name="zen_mode_starred_callers" msgid="1002370699564211178">"contatos marcados com estrela"</string>
    <string name="zen_mode_repeat_callers_list" msgid="181819778783743847">"autores de chamadas repetidas"</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> e <xliff:g id="CALLER_TYPE_1">%2$s</xliff:g>"</string>
    <string name="zen_mode_repeat_callers_summary" msgid="4121054819936083025">"Se a mesma pessoa ligar uma segunda vez em um período de <xliff:g id="MINUTES">%d</xliff:g> min"</string>
    <string name="zen_mode_start_time" msgid="1252665038977523332">"Horário de início"</string>
    <string name="zen_mode_end_time" msgid="223502560367331706">"Horário de término"</string>
    <string name="zen_mode_end_time_next_day_summary_format" msgid="419683704068360804">"<xliff:g id="FORMATTED_TIME">%s</xliff:g> do dia seguinte"</string>
    <string name="zen_mode_summary_alarms_only_indefinite" msgid="910047326128154945">"Alterar para \"Somente alarmes\" indefinidamente"</string>
    <string name="zen_mode_summary_alarms_only_by_minute" msgid="6673649005494939311">"{count,plural, =1{Mudar para somente alarmes por um minuto até {time}}one{Mudar para somente alarmes por # minuto (até{time})}other{Mudar para somente alarmes por # minutos (até {time})}}"</string>
    <string name="zen_mode_summary_alarms_only_by_hour" msgid="7400910210950788163">"{count,plural, =1{Mudar para somente alarmes por uma hora até {time}}one{Mudar para somente alarmes por # hora até {time}}other{Mudar para somente alarmes por # horas até {time}}}"</string>
    <string name="zen_mode_summary_alarms_only_by_time" msgid="8140619669703968810">"Alterar para \"Somente alarmes\" até <xliff:g id="FORMATTEDTIME">%1$s</xliff:g>"</string>
    <string name="zen_mode_summary_always" msgid="722093064250082317">"Alterar para \"Sempre interromper\""</string>
    <string name="warning_button_text" msgid="1274234338874005639">"Alerta"</string>
    <string name="suggestion_button_close" msgid="6865170855573283759">"Fechar"</string>
    <string name="device_feedback" msgid="5351614458411688608">"Enviar feedback sobre o dispositivo"</string>
    <string name="restr_pin_enter_admin_pin" msgid="4435410646541671918">"Inserir PIN do administrador"</string>
    <string name="switch_on_text" msgid="5664542327776075105">"Ativado"</string>
    <string name="switch_off_text" msgid="1315547447393646667">"Desativado"</string>
    <string name="nfc_setting_on" msgid="7701896496026725772">"Ativada"</string>
    <string name="nfc_setting_off" msgid="7142103438532732309">"Desativada"</string>
    <string name="screen_pinning_switch_on_text" msgid="6971386830247542552">"Ativado"</string>
    <string name="screen_pinning_switch_off_text" msgid="5032105155623003875">"Desativada"</string>
    <string name="screen_pinning_title" msgid="6927227272780208966">"Fixação de apps"</string>
    <string name="app_pinning_intro" msgid="6409063008733004245">"A fixação de apps faz com que o app atual fique aberto na tela até que você libere. Esse recurso pode ser usado, por exemplo, para deixar alguém acessar um jogo específico no seu smartphone."</string>
    <string name="screen_pinning_description" msgid="5822120806426139396">"Quando um app está fixado, ele pode abrir outros apps e os dados pessoais podem ficar acessíveis. \n\nPara usar a fixação de apps: 	\n{0,number,integer}. Ativar a fixação de apps 	\n{1,number,integer}. Abrir a Visão geral 	\n{2,number,integer}. Na parte de cima da tela, toque no ícone do app e depois em \"Fixar\"."</string>
    <string name="screen_pinning_guest_user_description" msgid="2307270321127139579">"Quando um app está fixado, ele pode abrir outros apps e os dados pessoais podem ficar acessíveis. \n\nSe você quiser compartilhar seu dispositivo com alguém de forma segura, tente fazer isso com um usuário convidado. \n\nPara usar a fixação de apps: 	\n{0,number,integer}. Ativar a fixação de apps 	\n{1,number,integer}. Abrir a Visão geral 	\n{2,number,integer}. Na parte de cima da tela, toque no ícone do app e depois em \"Fixar\"."</string>
    <string name="screen_pinning_dialog_message" msgid="8144925258679476654">"Quando o app está fixado, ele pode: \n\n•		acessar dados pessoais \n		(como contatos e conteúdo de e-mail); \n•		abrir outros apps. \n\nUse a fixação de apps apenas com pessoas em quem você confia."</string>
    <string name="screen_pinning_unlock_pattern" msgid="1345877794180829153">"Pedir padrão de desbloqueio antes de liberar a tela"</string>
    <string name="screen_pinning_unlock_pin" msgid="8716638956097417023">"Pedir PIN antes de liberar a tela"</string>
    <string name="screen_pinning_unlock_password" msgid="4957969621904790573">"Pedir senha antes de liberar a tela"</string>
    <string name="screen_pinning_unlock_none" msgid="2474959642431856316">"Bloquear dispositivo ao liberar a tela"</string>
    <string name="confirm_sim_deletion_title" msgid="7262127071183428893">"Confirme que você quer apagar o eSIM"</string>
    <string name="confirm_sim_deletion_description" msgid="4439657901673639063">"Confirme sua identidade antes de apagar um eSIM"</string>
    <string name="memtag_title" msgid="5096176296797727201">"Beta da Proteção de memória avançada"</string>
    <string name="memtag_toggle" msgid="8695028758462939212">"Proteção de memória avançada"</string>
    <string name="memtag_intro" msgid="579408691329568953">"Este recurso Beta ajuda a proteger seu dispositivo de bugs que podem colocar sua segurança em risco."</string>
    <string name="memtag_on" msgid="824938319141503923">"Ativada"</string>
    <string name="memtag_off" msgid="4835589640091709019">"Desativada"</string>
    <string name="memtag_on_pending" msgid="1592053425431532361">"Ativada após a reinicialização"</string>
    <string name="memtag_off_pending" msgid="1543177181383593726">"Desativada após a reinicialização"</string>
    <string name="memtag_force_off" msgid="1143468955988138470">"Indisponível para seu dispositivo no momento"</string>
    <string name="memtag_force_on" msgid="3254349938627883664">"Sempre ativada para seu dispositivo"</string>
    <string name="memtag_footer" msgid="8480784485124271376">"Vai ser necessário reiniciar o dispositivo para ativar ou desativar a Proteção de memória avançada. Quando ela está ativada, você pode notar um desempenho mais lento do dispositivo."</string>
    <string name="memtag_reboot_title" msgid="1413471876903578769">"Reiniciar dispositivo?"</string>
    <string name="memtag_reboot_message_on" msgid="3270256606602439418">"É necessário reiniciar o dispositivo para ativar a Proteção de memória avançada."</string>
    <string name="memtag_reboot_message_off" msgid="2567062468140476451">"É necessário reiniciar o dispositivo para desativar a Proteção de memória avançada."</string>
    <string name="memtag_reboot_yes" msgid="5788896350697141429">"Reiniciar"</string>
    <string name="memtag_reboot_no" msgid="2860671356184849330">"Agora não"</string>
    <string name="memtag_learn_more" msgid="1596145970669119776">"Saiba mais sobre a Proteção de memória avançada."</string>
    <string name="opening_paragraph_delete_profile_unknown_company" msgid="2951348192319498135">"O perfil de trabalho é gerenciado por:"</string>
    <string name="managing_admin" msgid="2633920317425356619">"Gerenciado por <xliff:g id="ADMIN_APP_LABEL">%s</xliff:g>"</string>
    <string name="launch_by_default" msgid="892824422067985734">"Abrir por padrão"</string>
    <string name="app_launch_open_domain_urls_title" msgid="4805388403977096285">"Abrir links compatíveis"</string>
    <string name="app_launch_top_intro_message" msgid="137370923637482459">"Permitir que links da Web abram este app"</string>
    <string name="app_launch_links_category" msgid="2380467163878760037">"Links abertos neste app"</string>
    <string name="app_launch_supported_domain_urls_title" msgid="5088779668667217369">"Links compatíveis"</string>
    <string name="app_launch_other_defaults_title" msgid="5674385877838735586">"Outras preferências padrão"</string>
    <string name="app_launch_add_link" msgid="8622558044530305811">"Adicionar link"</string>
    <string name="app_launch_footer" msgid="4521865035105622557">"Um app pode verificar links para abri-los automaticamente."</string>
    <string name="app_launch_verified_links_title" msgid="621908751569155356">"{count,plural, =1{# link verificado}one{# link verificado}other{# links verificados}}"</string>
    <string name="app_launch_verified_links_message" msgid="190871133877476176">"{count,plural, =1{O link foi verificado e vai ser aberto automaticamente neste app.}one{O link foi verificado e vai ser aberto automaticamente neste app.}other{Os links foram verificados e vão ser abertos automaticamente neste app.}}"</string>
    <string name="app_launch_dialog_ok" msgid="1446157681861409861">"OK"</string>
    <string name="app_launch_verified_links_info_description" msgid="7514750232467132117">"Mostrar lista de links verificados"</string>
    <string name="app_launch_checking_links_title" msgid="6119228853554114201">"Procurando outros links compatíveis…"</string>
    <string name="app_launch_dialog_cancel" msgid="6961071841814898663">"Cancelar"</string>
    <string name="app_launch_supported_links_title" msgid="2457931321701095763">"{count,plural, =1{# link de apoio}one{# link de apoio}other{# links de apoio}}"</string>
    <string name="app_launch_supported_links_add" msgid="3271247750388016131">"Adicionar"</string>
    <string name="app_launch_supported_links_subtext" msgid="4268004019469184113">"É aberto no app <xliff:g id="APP_LABEL">%s</xliff:g>"</string>
    <string name="storage_summary_format" msgid="5721782272185284276">"<xliff:g id="SIZE">%1$s</xliff:g> usados em <xliff:g id="STORAGE_TYPE">%2$s</xliff:g>"</string>
    <string name="storage_type_internal" msgid="979243131665635278">"armazenamento interno"</string>
    <string name="storage_type_external" msgid="125078274000280821">"armazenamento externo"</string>
    <string name="data_summary_format" msgid="8802057788950096650">"<xliff:g id="SIZE">%1$s</xliff:g> usados desde <xliff:g id="DATE">%2$s</xliff:g>"</string>
    <string name="storage_used" msgid="2591194906751432725">"Armazenamento usado"</string>
    <string name="change" msgid="273206077375322595">"Alterar"</string>
    <string name="change_storage" msgid="8773820275624113401">"Alterar armazenamento"</string>
    <string name="notifications_label" msgid="8471624476040164538">"Notificações"</string>
    <string name="notifications_enabled" msgid="7743168481579361019">"Ativado"</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">"Desativadas"</string>
    <string name="notifications_categories_off" msgid="7712037485557237328">"{count,plural, =1{# categoria desativada}one{# categoria desativada}other{# categorias desativadas}}"</string>
    <string name="runtime_permissions_additional_count" msgid="6071909675951786523">"{count,plural, =1{# outra permissão}one{# outra permissão}other{# outras permissões}}"</string>
    <string name="runtime_permissions_summary_no_permissions_granted" msgid="7456745929035665029">"Nenhuma permissão concedida"</string>
    <string name="runtime_permissions_summary_no_permissions_requested" msgid="7174876170116073356">"Nenhuma permissão solicitada"</string>
    <string name="runtime_permissions_summary_control_app_access" msgid="3744591396348990500">"Controla o acesso de apps aos seus dados"</string>
    <string name="permissions_usage_title" msgid="2942741460679049132">"Painel de privacidade"</string>
    <string name="permissions_usage_summary" msgid="6784310472062516454">"Mostra quais apps usaram as permissões recentemente"</string>
    <string name="unused_apps" msgid="4566272194756830656">"Apps não usados"</string>
    <string name="unused_apps_summary" msgid="4236371818881973021">"{count,plural, =1{# app não usado}one{# app não usado}other{# apps não usados}}"</string>
    <string name="unused_apps_category" msgid="8954930958175500851">"Configurações de apps não usados"</string>
    <string name="unused_apps_switch" msgid="7595419855882245772">"Pausar atividade no app quando não usado"</string>
    <string name="unused_apps_switch_summary" msgid="2171098908014596802">"Remove permissões, exclui arquivos temporários e para notificações"</string>
    <string name="unused_apps_switch_v2" msgid="7464060328451454469">"Gerenciar o app fora de uso"</string>
    <string name="unused_apps_switch_summary_v2" msgid="3182898279622036805">"Remover permissões, excluir arquivos temporários, parar notificações e arquivar o app"</string>
    <string name="filter_all_apps" msgid="6645539744080251371">"Todos os apps"</string>
    <string name="filter_enabled_apps" msgid="8868356616126759124">"Apps instalados"</string>
    <string name="filter_instant_apps" msgid="2292108467020380068">"Apps instantâneos"</string>
    <string name="filter_notif_blocked_apps" msgid="1065653868850012325">"Desativadas"</string>
    <string name="advanced_apps" msgid="7643010673326578815">"Avançado"</string>
    <string name="app_permissions" msgid="8666537659217653626">"Gestão de permissões"</string>
    <string name="app_data_sharing_updates_title" msgid="1694297952320402788">"Atualizações no compartilhamento de dados de local"</string>
    <string name="app_data_sharing_updates_summary" msgid="4465929918457739443">"Revise os apps que mudaram a forma como podem compartilhar seus dados de local"</string>
    <string name="tap_to_wake" msgid="3313433536261440068">"Tocar para ativar"</string>
    <string name="tap_to_wake_summary" msgid="6641039858241611072">"Toque duas vezes em qualquer parte da tela para ativar o dispositivo"</string>
    <string name="domain_urls_title" msgid="7012209752049678876">"Abrir links"</string>
    <string name="domain_urls_summary_none" msgid="1132578967643384733">"Não abrir links compatíveis"</string>
    <string name="domain_urls_summary_one" msgid="3312008753802762892">"Abrir <xliff:g id="DOMAIN">%s</xliff:g>"</string>
    <string name="domain_urls_summary_some" msgid="1197692164421314523">"Abrir <xliff:g id="DOMAIN">%s</xliff:g> e outros URLs"</string>
    <string name="app_link_open_always" msgid="9167065494930657503">"Permitir que apps abram links compatíveis"</string>
    <string name="app_link_open_ask" msgid="2422450109908936371">"Perguntar sempre"</string>
    <string name="app_link_open_never" msgid="5299808605386052350">"Não permitir que o app abra links"</string>
    <string name="app_link_open_always_summary" msgid="4524005594295855117">"{count,plural, =1{O app vai processar # link}one{O app vai processar # link}other{O app vai processar # links}}"</string>
    <string name="open_supported_links_footer" msgid="3188808142432787933">"O app processará estes links:"</string>
    <string name="assist_and_voice_input_title" msgid="6317935163145135914">"Assistivo e voz"</string>
    <string name="default_assist_title" msgid="1182435129627493758">"App assistente digital"</string>
    <string name="default_digital_assistant_title" msgid="5654663086385490838">"App padrão de assistentes digitais"</string>
    <string name="assistant_security_warning_agree" msgid="9013334158753473359">"Aceito"</string>
    <string name="default_browser_title" msgid="8342074390782390458">"App de navegação"</string>
    <string name="default_phone_title" msgid="7616730756650803827">"App de telefone"</string>
    <string name="system_app" msgid="1863291702508355041">"(Sistema)"</string>
    <string name="apps_storage" msgid="643866814746927111">"Armazenamento de apps"</string>
    <string name="usage_access" msgid="5487993885373893282">"Acesso ao uso"</string>
    <string name="permit_usage_access" msgid="179630895262172674">"Permitir acesso ao uso"</string>
    <string name="time_spent_in_app_pref_title" msgid="25327097913383330">"Tempo de uso"</string>
    <string name="usage_access_description" msgid="8547716253713890707">"O acesso ao uso permite que um app monitore que outros apps você está usando e com que frequência, bem como sua operadora, as configurações de idioma e outros detalhes."</string>
    <string name="memory_settings_title" msgid="6582588646363308430">"Memória"</string>
    <string name="always_running" msgid="9012705720688200252">"Sempre em execução (<xliff:g id="PERCENTAGE">%s</xliff:g>)"</string>
    <string name="sometimes_running" msgid="7954947311082655448">"Às vezes em execução (<xliff:g id="PERCENTAGE">%s</xliff:g>)"</string>
    <string name="rarely_running" msgid="2704869567353196798">"Raramente em execução (<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">"Otimização de bateria"</string>
    <string name="high_power_filter_on" msgid="447849271630431531">"Não otimizados"</string>
    <string name="high_power_on" msgid="8778058701270819268">"Não otimizada"</string>
    <string name="high_power_off" msgid="317000444619279018">"Utilização otimizada da bateria"</string>
    <string name="high_power_system" msgid="3966701453644915787">"Otimização de bateria não disponível"</string>
    <string name="high_power_prompt_title" msgid="2574478825228409124">"Permitir execução contínua do app em segundo plano?"</string>
    <string name="high_power_prompt_body" msgid="6029266540782139941">"A execução contínua do app <xliff:g id="APP_NAME">%1$s</xliff:g> em segundo plano pode reduzir a duração da bateria. \n\nÉ possível mudar isso mais tarde em Configurações &gt; Apps."</string>
    <string name="battery_summary" msgid="2491764359695671207">"<xliff:g id="PERCENTAGE">%1$s</xliff:g> de uso desde a última carga completa"</string>
    <string name="battery_summary_24hr" msgid="7656033283282656551">"<xliff:g id="PERCENTAGE">%1$s</xliff:g> de uso nas últimas 24 horas"</string>
    <string name="no_battery_summary" msgid="5769159953384122003">"Sem uso da bateria desde a última carga completa"</string>
    <string name="share_remote_bugreport_dialog_title" msgid="1575283098565582433">"Compartilhar relatório de bug?"</string>
    <string name="share_remote_bugreport_dialog_message_finished" msgid="4869053468609007680">"Seu administrador de TI solicitou um relatório de bug para ajudar a resolver problemas deste dispositivo. É possível que apps e dados sejam compartilhados."</string>
    <string name="share_remote_bugreport_dialog_message" msgid="8714439220818865391">"Seu administrador de TI solicitou um relatório de bug para ajudar a resolver problemas deste dispositivo. É possível que apps e dados sejam compartilhados, o que pode deixar seu dispositivo temporariamente mais lento."</string>
    <string name="sharing_remote_bugreport_dialog_message" msgid="3523877008096439251">"Este relatório de bug está sendo compartilhado com seu administrador de TI. Entre em contato com ele para saber mais detalhes."</string>
    <string name="share_remote_bugreport_action" msgid="7173093464692893276">"Compartilhar"</string>
    <string name="decline_remote_bugreport_action" msgid="1276509879613158895">"Recusar"</string>
    <string name="usb_use_charging_only" msgid="1743303747327057947">"Nenhuma transferência de dados"</string>
    <string name="usb_use_power_only" msgid="3408055485802114621">"Carregar dispositivo conectado"</string>
    <string name="usb_use_file_transfers" msgid="483915710802018503">"Transferência de arquivo"</string>
    <string name="usb_use_photo_transfers" msgid="4641181628966036093">"PTP (fotos)"</string>
    <string name="usb_use_uvc_webcam" msgid="6595429508472038732">"Webcam"</string>
    <string name="usb_transcode_files" msgid="2441954752105119109">"Converter vídeos para AVC"</string>
    <string name="usb_transcode_files_summary" msgid="307102635711961513">"Os vídeos poderão ser abertos em mais players de mídia, mas talvez a qualidade seja menor"</string>
    <string name="usb_use_tethering" msgid="2897063414491670531">"Tethering USB"</string>
    <string name="usb_use_MIDI" msgid="8621338227628859789">"Conexão MIDI (som)"</string>
    <string name="usb_use" msgid="6783183432648438528">"Usar USB para"</string>
    <string name="usb_default_label" msgid="3372838450371060750">"Configuração USB padrão"</string>
    <string name="usb_default_info" msgid="167172599497085266">"Quando outro dispositivo estiver conectado e seu smartphone estiver desbloqueado, essas configurações serão aplicadas. Conecte-se apenas a dispositivos confiáveis."</string>
    <string name="usb_power_title" msgid="5602112548385798646">"Opções de carregamento"</string>
    <string name="usb_file_transfer_title" msgid="2261577861371481478">"Opções de transferência de arquivo"</string>
    <string name="usb_pref" msgid="8521832005703261700">"USB"</string>
    <string name="usb_preference" msgid="5084550082591493765">"Preferências 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">"Alternando…"</string>
    <string name="usb_switching_failed" msgid="5721262697715454137">"Não foi possível alternar"</string>
    <string name="usb_summary_charging_only" msgid="678095599403565146">"Para carregamento do dispositivo"</string>
    <string name="usb_summary_power_only" msgid="4901734938857822887">"Carregando dispositivo conectado"</string>
    <string name="usb_summary_file_transfers" msgid="5498487271972556431">"Transferência de arquivo"</string>
    <string name="usb_summary_tether" msgid="2554569836525075702">"Tethering USB"</string>
    <string name="usb_summary_photo_transfers" msgid="7331503733435780492">"PTP (fotos)"</string>
    <string name="usb_summary_MIDI" msgid="2372443732675899571">"MIDI"</string>
    <string name="usb_summary_UVC" msgid="8733131110899174299">"Webcam"</string>
    <string name="usb_summary_file_transfers_power" msgid="2788374660532868630">"Transferência de arquivo e fornecimento de energia"</string>
    <string name="usb_summary_tether_power" msgid="4853034392919904792">"Tethering USB e fornecimento de energia"</string>
    <string name="usb_summary_photo_transfers_power" msgid="9077173567697482239">"PTP e fornecimento de energia"</string>
    <string name="usb_summary_MIDI_power" msgid="1184681982025435815">"MIDI e fornecimento de energia"</string>
    <string name="usb_summary_UVC_power" msgid="226810354412154061">"Webcam e fornecimento de energia"</string>
    <string name="background_check_pref" msgid="5304564658578987535">"Verificação em segundo plano"</string>
    <string name="assist_access_context_title" msgid="5201495523514096201">"Usar texto da tela"</string>
    <string name="assist_access_context_summary" msgid="6951814413185646275">"Permitir que o app assistivo acesse o conteúdo da tela como texto"</string>
    <string name="assist_access_screenshot_title" msgid="4395902231753643633">"Usar captura de tela"</string>
    <string name="assist_access_screenshot_summary" msgid="5276593070956201863">"Permitir que o app assistivo acesse uma imagem da tela"</string>
    <string name="assist_flash_title" msgid="5449512572885550108">"Piscar tela"</string>
    <string name="assist_flash_summary" msgid="3032289860177784594">"Piscar as bordas da tela quando o app assistivo acessar textos da tela ou fizer uma captura de tela"</string>
    <string name="assist_footer" msgid="8248015363806299068">"Apps assistivos podem ajudar com base nas informações da tela que você vê no momento. Alguns apps são compatíveis com a tela de início e com serviços de entrada de texto por voz para fornecer assistência integrada."</string>
    <string name="average_memory_use" msgid="717313706368825388">"Uso médio de memória"</string>
    <string name="maximum_memory_use" msgid="2171779724001152933">"Uso máximo de memória"</string>
    <string name="memory_usage" msgid="5594133403819880617">"Uso de memória"</string>
    <string name="app_list_memory_use" msgid="3178720339027577869">"Uso de apps"</string>
    <string name="memory_details" msgid="6133226869214421347">"Detalhes"</string>
    <string name="memory_use_summary" msgid="3915964794146424142">"<xliff:g id="SIZE">%1$s</xliff:g> de memória média usada nas últimas três horas"</string>
    <string name="no_memory_use_summary" msgid="6708111974923274436">"Nenhuma memória foi usada nas últimas três horas"</string>
    <string name="sort_avg_use" msgid="4416841047669186903">"Ordenar por uso médio"</string>
    <string name="sort_max_use" msgid="3370552820889448484">"Ordenar por uso máximo"</string>
    <string name="memory_performance" msgid="5448274293336927570">"Desempenho"</string>
    <string name="total_memory" msgid="5244174393008910567">"Memória total"</string>
    <string name="average_used" msgid="690235917394070169">"Média usada (%)"</string>
    <string name="free_memory" msgid="439783742246854785">"Disponível"</string>
    <string name="memory_usage_apps" msgid="5776108502569850579">"Memória usada por apps"</string>
    <string name="memory_usage_apps_summary" msgid="7168292864155527974">"{count,plural, =1{1 app usou a memória nos últimos {time}}one{# app usou a memória nos últimos {time}}other{# apps usaram a memória nos últimos {time}}}"</string>
    <string name="force_enable_pss_profiling_title" msgid="2253816522775341523">"Ativar a criação de perfil de uso da memória"</string>
    <string name="force_enable_pss_profiling_summary" msgid="7714294324548399136">"O perfil de uso de memória requer outros recursos do sistema."</string>
    <string name="pss_profiling_disabled" msgid="1967278421143514850">"Criação de perfil de memória"</string>
    <string name="running_frequency" msgid="7260225121706316639">"Frequência"</string>
    <string name="memory_maximum_usage" msgid="2047013391595835607">"Uso máximo"</string>
    <string name="no_data_usage" msgid="4665617440434654132">"Nenhum dado usado"</string>
    <string name="zen_access_warning_dialog_title" msgid="6323325813123130154">"Permitir que <xliff:g id="APP">%1$s</xliff:g> acesse o recurso \"Não perturbe\"?"</string>
    <string name="zen_access_warning_dialog_summary" msgid="8468714854067428987">"O app poderá ativar/desativar o recurso \"Não perturbe\" e fazer alterações nas configurações relacionadas."</string>
    <string name="zen_access_disabled_package_warning" msgid="6565908224294537889">"Deve permanecer ativado, pois o acesso a notificações está ativado"</string>
    <string name="zen_access_revoke_warning_dialog_title" msgid="7377261509261811449">"Revogar acesso a \"Não perturbe\" para <xliff:g id="APP">%1$s</xliff:g>?"</string>
    <string name="zen_access_revoke_warning_dialog_summary" msgid="8689801842914183595">"Todas as regras \"Não perturbe\" criadas por esse app serão removidas."</string>
    <string name="ignore_optimizations_on" msgid="6865583039303804932">"Não otimizar"</string>
    <string name="ignore_optimizations_off" msgid="9186557038453586295">"Otimizar"</string>
    <string name="ignore_optimizations_on_desc" msgid="1280043916460939932">"Isso pode esgotar a bateria mais rapidamente. A restrição do uso de bateria em segundo plano não se aplicará mais ao app."</string>
    <string name="ignore_optimizations_off_desc" msgid="3324571675983286177">"Recomendado para maior duração da bateria."</string>
    <string name="app_list_preference_none" msgid="1635406344616653756">"Nenhum"</string>
    <string name="work_profile_usage_access_warning" msgid="3477719910927319122">"A desativação do acesso ao uso deste app não impede que o administrador rastreie o uso de dados dos apps no seu perfil de trabalho."</string>
    <string name="draw_overlay" msgid="7902083260500573027">"Sobrepor a outros apps"</string>
    <string name="system_alert_window_settings" msgid="6458633954424862521">"Sobrepor a outros apps"</string>
    <string name="permit_draw_overlay" msgid="4468994037192804075">"Permitir sobreposição a outros apps"</string>
    <string name="allow_overlay_description" msgid="1607235723669496298">"Permite que este app apareça sobreposto a outros apps que você esteja usando. Este app poderá ver onde você toca ou mudar o que está sendo mostrado na tela."</string>
    <string name="media_routing_control_title" msgid="6402800638960066807">"Mudar saída de mídia"</string>
    <string name="allow_media_routing_control" msgid="4907036637509360616">"Permitir que um app mude a saída de mídia"</string>
    <string name="allow_media_routing_description" msgid="8343709701298051207">"Permite que este app escolha qual dispositivo conectado vai reproduzir áudio ou vídeo de outros apps. Se a permissão for concedida, o app poderá acessar uma lista de dispositivos disponíveis, por exemplo, fones de ouvido e alto-falantes, e escolher qual dispositivo de saída será usado para transmitir ou reproduzir áudio ou vídeo."</string>
    <string name="manage_external_storage_title" msgid="8024521099838816100">"Acesso a todos os arquivos"</string>
    <string name="permit_manage_external_storage" msgid="6928847280689401761">"Acesso para gerenciar todos os arquivos"</string>
    <string name="allow_manage_external_storage_description" msgid="5707948153603253225">"Permitir que o app leia, modifique e exclua todos os arquivos deste dispositivo ou de qualquer volume de armazenamento conectado. Se a permissão for concedida, o app poderá acessar arquivos sem nenhum aviso prévio."</string>
    <string name="filter_manage_external_storage" msgid="6751640571715343804">"Pode acessar todos os arquivos"</string>
    <string name="voice_activation_apps_title" msgid="7130045161611529825">"Apps com ativação por voz"</string>
    <string name="permit_voice_activation_apps" msgid="9152780172988949319">"Permitir ativação por voz"</string>
    <string name="allow_voice_activation_apps_description" msgid="6369745626995060656">"A ativação por voz ativa apps aprovados usando comando de voz. A detecção adaptativa integrada garante a privacidade dos seus dados.\n\n"<a href="">"Saiba mais sobre a detecção adaptativa"</a></string>
    <string name="full_screen_intent_title" msgid="747270185715224130">"Notificações em tela cheia"</string>
    <string name="permit_full_screen_intent" msgid="9035367640019960861">"Permitir que esse app mostre notificações em tela cheia"</string>
    <string name="footer_description_full_screen_intent" msgid="7716518411349225528">"Permita que o app mostre notificações que ocupam a tela inteira quando o dispositivo estiver bloqueado. Os apps poderão usar essa permissão para destacar alarmes, ligações recebidas ou outras notificações urgentes."</string>
    <string name="media_management_apps_title" msgid="8222942355578724582">"Apps de gerenciamento de mídia"</string>
    <string name="media_management_apps_toggle_label" msgid="166724270857067456">"Permitir que o app gerencie arquivos de mídia"</string>
    <string name="media_management_apps_description" msgid="8000565658455268524">"Se você permitir, esse app poderá modificar ou excluir arquivos de mídia criados com outros apps sem perguntar para você. É necessário autorizar o acesso do app aos arquivos e ao conteúdo de mídia."</string>
    <string name="keywords_media_management_apps" msgid="7499959607583088690">"Mídia, arquivos, gerenciamento, gerente, gerenciar, editar, editor, app, aplicativo, programa"</string>
    <string name="keywords_vr_listener" msgid="902737490270081131">"rv realidade virtual ouvinte estéreo serviço de ajuda"</string>
    <string name="overlay_settings" msgid="2030836934139139469">"Sobrepor a outros apps"</string>
    <string name="filter_overlay_apps" msgid="2483998217116789206">"Apps com permissão"</string>
    <string name="app_permission_summary_allowed" msgid="1155115629167757278">"Permitido"</string>
    <string name="app_permission_summary_not_allowed" msgid="2673793662439097900">"Não permitido"</string>
    <string name="keywords_install_other_apps" msgid="563895867658775580">"instalar apps fontes desconhecidas"</string>
    <string name="write_settings" msgid="6864794401614425894">"Mudar configurações do sistema"</string>
    <string name="keywords_write_settings" msgid="6908708078855507813">"gravar modificar configurações de modificação"</string>
    <string name="filter_install_sources_apps" msgid="6930762738519588431">"Pode instalar outros apps"</string>
    <string name="filter_write_settings_apps" msgid="4754994984909024093">"Pode modificar configurações do sistema"</string>
    <string name="write_settings_title" msgid="3011034187823288557">"Pode modificar configurações do sistema"</string>
    <string name="write_system_settings" msgid="5555707701419757421">"Mudar configurações do sistema"</string>
    <string name="permit_write_settings" msgid="3113056800709924871">"Permitir modificação de config. do sistema"</string>
    <string name="write_settings_description" msgid="1474881759793261146">"Esta permissão permite que um app modifique configurações do sistema."</string>
    <string name="external_source_switch_title" msgid="101571983954849473">"Permitir desta fonte"</string>
    <string name="camera_gesture_title" msgid="5559439253128696180">"Girar duas vezes para abrir a câmera"</string>
    <string name="camera_gesture_desc" msgid="7557645057320805328">"Abrir o app Câmera girando o pulso duas vezes"</string>
    <string name="screen_zoom_title" msgid="6928045302654960559">"Tamanho da exibição"</string>
    <string name="screen_zoom_short_summary" msgid="756254364808639194">"Deixe tudo maior ou menor"</string>
    <string name="screen_zoom_keywords" msgid="5964023524422386592">"densidade de exibição, zoom da tela, escala, dimensionamento"</string>
    <string name="screen_zoom_preview_title" msgid="5288355628444562735">"Visualização"</string>
    <string name="screen_zoom_make_smaller_desc" msgid="2628662648068995971">"Tornar menor"</string>
    <string name="screen_zoom_make_larger_desc" msgid="7268794713428853139">"Tornar maior"</string>
    <string name="disconnected" msgid="3469373726996129247">"Não conectado"</string>
    <string name="keyboard_disconnected" msgid="796053864561894531">"Não conectado"</string>
    <string name="apps_summary" msgid="4007416751775414252">"<xliff:g id="COUNT">%1$d</xliff:g> apps instalados"</string>
    <string name="storage_summary" msgid="5903562203143572768">"<xliff:g id="PERCENTAGE">%1$s</xliff:g> usado - <xliff:g id="FREE_SPACE">%2$s</xliff:g> livres"</string>
    <string name="display_dashboard_summary" msgid="1599453894989339454">"Tema escuro, tamanho da fonte, brilho"</string>
    <string name="memory_summary" msgid="8221954450951651735">"Média de <xliff:g id="USED_MEMORY">%1$s</xliff:g> de <xliff:g id="TOTAL_MEMORY">%2$s</xliff:g> de memória usados"</string>
    <string name="users_summary" msgid="8473589474976307510">"Conta conectada: <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="android_version_summary" msgid="7818952662015042768">"Atualizado para o Android <xliff:g id="VERSION">%1$s</xliff:g>"</string>
    <string name="android_version_pending_update_summary" msgid="5404532347171027730">"Atualização disponível"</string>
    <string name="disabled_by_policy_title" msgid="6852347040813204503">"Ação bloqueada pela política de trabalho"</string>
    <string name="disabled_by_policy_title_adjust_volume" msgid="1669689058213728099">"Não é possível alterar o volume"</string>
    <string name="disabled_by_policy_title_outgoing_calls" msgid="400089720689494562">"Não é possível fazer chamadas"</string>
    <string name="disabled_by_policy_title_sms" msgid="8951840850778406831">"Não é possível enviar mensagens SMS"</string>
    <string name="disabled_by_policy_title_camera" msgid="6616508876399613773">"Não é possível usar a câmera"</string>
    <string name="disabled_by_policy_title_screen_capture" msgid="6085100101044105811">"Não é possível capturar a tela"</string>
    <string name="disabled_by_policy_title_suspend_packages" msgid="4223983156635729793">"Não é possível abrir este app"</string>
    <string name="disabled_by_policy_title_financed_device" msgid="2328740314082888228">"Configuração bloqueada pelo provedor de crédito"</string>
    <string name="disabled_by_policy_title_biometric_parental_consent" msgid="2463673997797134678">"Consentimento necessário"</string>
    <string name="disabled_by_policy_content_biometric_parental_consent" msgid="7124116806784305206">"Para iniciar a configuração, entregue o smartphone ao seu familiar responsável"</string>
    <string name="disabled_by_policy_parental_consent" msgid="9166060049019018978">"Entregue o smartphone a um familiar responsável para que ele permita a mudança dessa configuração."</string>
    <string name="default_admin_support_msg" msgid="8816296554831532033">"Para mais informações, entre em contato com o administrador de TI"</string>
    <string name="admin_support_more_info" msgid="8407433155725898290">"Mais detalhes"</string>
    <string name="admin_profile_owner_message" msgid="8860709969532649195">"Seu administrador pode monitorar e gerenciar apps e dados associados ao seu perfil de trabalho, incluindo configurações, permissões, acesso corporativo, atividade de rede e informações de local do dispositivo."</string>
    <string name="admin_profile_owner_user_message" msgid="4929926887231544950">"Seu administrador pode monitorar e gerenciar apps e dados associados a este usuário, incluindo configurações, permissões, acesso corporativo, atividade de rede e informações de local do dispositivo."</string>
    <string name="admin_device_owner_message" msgid="5503131744126520590">"O administrador pode monitorar e gerenciar apps e dados associados a este dispositivo, incluindo configurações, permissões, acesso corporativo, atividade de rede e informações de local do dispositivo."</string>
    <string name="admin_financed_message" msgid="1156197630834947884">"O administrador do dispositivo pode gerenciar apps, mudar as configurações deste dispositivo e acessar dados associados a ele."</string>
    <string name="condition_turn_off" msgid="402707350778441939">"Desativar"</string>
    <string name="condition_turn_on" msgid="3911077299444314791">"Ativar"</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">"O ponto de acesso está ativo"</string>
    <string name="condition_airplane_title" msgid="5847967403687381705">"Modo avião ativado"</string>
    <string name="condition_airplane_summary" msgid="1964500689287879888">"Redes indisponíveis"</string>
    <string name="condition_zen_title" msgid="7674761111934567490">"O \"Não perturbe\" está ativado"</string>
    <string name="condition_zen_summary_phone_muted" msgid="6516753722927681820">"Smartphone silenciado"</string>
    <string name="condition_zen_summary_with_exceptions" msgid="9019937492602199663">"Com exceções"</string>
    <string name="condition_battery_title" msgid="6395113995454385248">"Economia de bateria ativada"</string>
    <string name="condition_battery_summary" msgid="8436806157833107886">"Recursos restritos"</string>
    <string name="condition_cellular_title" msgid="155474690792125747">"Dados móveis desativados"</string>
    <string name="condition_cellular_summary" msgid="1678098728303268851">"Internet disponível apenas por Wi‑Fi"</string>
    <string name="condition_bg_data_title" msgid="2719263664589753094">"Economia de dados"</string>
    <string name="condition_bg_data_summary" msgid="1736255283216193834">"Recursos restritos"</string>
    <string name="condition_work_title" msgid="174326145616998813">"Perfil de trabalho desativado"</string>
    <string name="condition_work_summary" msgid="7113473121312772398">"Para apps e notificações"</string>
    <string name="condition_device_muted_action_turn_on_sound" msgid="4078406807327674934">"Ativar som"</string>
    <string name="condition_device_muted_title" msgid="2446306263428466378">"Campainha desativada"</string>
    <string name="condition_device_muted_summary" msgid="3772178424510397327">"Para chamadas e notificações"</string>
    <string name="condition_device_vibrate_title" msgid="9058943409545158583">"Apenas vibração"</string>
    <string name="condition_device_vibrate_summary" msgid="7537724181691903202">"Para chamadas e notificações"</string>
    <string name="night_display_suggestion_title" msgid="5418911386429667704">"Programar o Modo noturno"</string>
    <string name="night_display_suggestion_summary" msgid="4218017907425509769">"Tinge a tela automaticamente todas as noites"</string>
    <string name="condition_night_display_title" msgid="1072880897812554421">"O Modo noturno está ativado"</string>
    <string name="condition_night_display_summary" msgid="3278349775875166984">"Tela em tom de âmbar"</string>
    <string name="condition_grayscale_title" msgid="9029271080007984542">"Escala de cinza"</string>
    <string name="condition_grayscale_summary" msgid="1306034149271251292">"Exibir somente na cor cinza"</string>
    <string name="homepage_condition_footer_content_description" msgid="1568313430995646108">"Recolher"</string>
    <string name="color_temperature" msgid="8256912135746305176">"Temperatura de cor fria"</string>
    <string name="color_temperature_desc" msgid="6713259535885669622">"Usar cores de tela mais frias"</string>
    <string name="color_temperature_toast" msgid="7611532183532407342">"Para aplicar a alteração de cor, desative a tela"</string>
    <string name="camera_laser_sensor_switch" msgid="7097842750947187671">"Sensor a laser da câmera"</string>
    <string name="ota_disable_automatic_update" msgid="1953894421412420231">"Atualizações automáticas do sistema"</string>
    <string name="ota_disable_automatic_update_summary" msgid="7803279951533276841">"Aplicar atualizações quando o dispositivo for reiniciado"</string>
    <string name="usage" msgid="287782903846013936">"Utilização"</string>
    <string name="cellular_data_usage" msgid="5874156338825285334">"Uso de dados móveis"</string>
    <string name="app_cellular_data_usage" msgid="7603292978956033926">"Uso de dados do app"</string>
    <string name="wifi_data_usage" msgid="6868503699134605707">"Uso de dados Wi-Fi"</string>
    <string name="non_carrier_data_usage" msgid="6494603202578414755">"Uso de dados em redes que não são da operadora"</string>
    <string name="ethernet_data_usage" msgid="4552227880905679761">"Uso de dados ethernet"</string>
    <string name="wifi" msgid="2932584495223243842">"Wi-Fi"</string>
    <string name="ethernet" msgid="4665162609974492983">"Ethernet"</string>
    <string name="cell_data_template" msgid="6077963976103260821">"<xliff:g id="AMOUNT">^1</xliff:g> de dados móveis"</string>
    <string name="wifi_data_template" msgid="935934798340307438">"<xliff:g id="AMOUNT">^1</xliff:g> de dados Wi-Fi"</string>
    <string name="ethernet_data_template" msgid="1429173767445201145">"<xliff:g id="AMOUNT">^1</xliff:g> de dados ethernet"</string>
    <string name="billing_cycle" msgid="6618424022653876279">"Alerta e limite de dados"</string>
    <string name="app_usage_cycle" msgid="341009528778520583">"Ciclo de uso de dados móveis"</string>
    <string name="cell_data_warning" msgid="5664921950473359634">"Alerta de uso de dados em <xliff:g id="ID_1">^1</xliff:g>"</string>
    <string name="cell_data_limit" msgid="256855024790622112">"Limite de dados em <xliff:g id="ID_1">^1</xliff:g>"</string>
    <string name="cell_data_warning_and_limit" msgid="8393200831986035724">"Alerta de uso de dados em <xliff:g id="ID_1">^1</xliff:g> / Limite de dados em <xliff:g id="ID_2">^2</xliff:g>"</string>
    <string name="non_carrier_data_usage_warning" msgid="4707184871368847697">"Exclui dados usados por redes de operadoras"</string>
    <string name="data_used_template" msgid="8229342096562327646">"<xliff:g id="ID_1">%1$s</xliff:g> usado(s)"</string>
    <string name="set_data_warning" msgid="1685771882794205462">"Definir alerta de uso de dados"</string>
    <string name="data_warning" msgid="2925054658166062884">"Alerta de uso de dados"</string>
    <string name="data_warning_footnote" msgid="5991901765915710592">"O alerta e o limite de dados são medidos pelo seu dispositivo e podem ser diferentes dos dados da operadora."</string>
    <string name="set_data_limit" msgid="9010326815874642680">"Definir limite de dados"</string>
    <string name="data_limit" msgid="8731731657513652363">"Limite de dados"</string>
    <string name="data_usage_template" msgid="3822452362629968010">"<xliff:g id="ID_1">%1$s</xliff:g> usado(s) entre <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">"Outros apps inclusos no uso"</string>
    <string name="data_saver_unrestricted_summary" msgid="7343571401172437542">"{count,plural, =1{1 app autorizado a usar dados irrestritos quando a economia de dados estiver ativada}one{# app autorizado a usar dados irrestritos quando a economia de dados estiver ativada}other{# apps autorizados a usar dados irrestritos quando a economia de dados estiver ativada}}"</string>
    <string name="data_usage_title" msgid="4039024073687469094">"Dados primários"</string>
    <string name="data_usage_wifi_title" msgid="1060495519280456926">"Dados Wi‑Fi"</string>
    <string name="data_used_formatted" msgid="7913920278059077938">"<xliff:g id="ID_1">^1</xliff:g> <xliff:g id="ID_2">^2</xliff:g> usados"</string>
    <string name="data_overusage" msgid="3680477320458707259">"<xliff:g id="ID_1">^1</xliff:g> acima do limite"</string>
    <string name="data_remaining" msgid="6316251496381922837">"<xliff:g id="ID_1">^1</xliff:g> restante(s)"</string>
    <string name="data_usage_chart_brief_content_description" msgid="5548074070258881530">"Gráfico que mostra o uso de dados entre <xliff:g id="START_DATE">%1$s</xliff:g> e <xliff:g id="END_DATE">%2$s</xliff:g>."</string>
    <string name="data_usage_chart_no_data_content_description" msgid="5481968839079467231">"Nenhum dado neste período"</string>
    <string name="billing_cycle_days_left" msgid="174337287346866400">"{count,plural, =1{# dia restante}one{# dia restante}other{# dias restantes}}"</string>
    <string name="billing_cycle_none_left" msgid="1694844019159277504">"Não há tempo restante"</string>
    <string name="billing_cycle_less_than_one_day_left" msgid="1210202399053992163">"Resta menos de um dia"</string>
    <string name="carrier_and_update_text" msgid="5363656651921656280">"Atualizado pela <xliff:g id="ID_1">^1</xliff:g> há <xliff:g id="ID_2">^2</xliff:g>"</string>
    <string name="no_carrier_update_text" msgid="5432798085593055966">"Atualizado há <xliff:g id="ID_1">^2</xliff:g>"</string>
    <string name="carrier_and_update_now_text" msgid="5075861262344398849">"Atualizado pela <xliff:g id="ID_1">^1</xliff:g> agora mesmo"</string>
    <string name="no_carrier_update_now_text" msgid="7898004907837200752">"Atualizado agora"</string>
    <string name="launch_wifi_text" msgid="976421974332512894">"Mais detalhes"</string>
    <string name="data_saver_title" msgid="2593804270788863815">"Economia de dados"</string>
    <string name="unrestricted_data_saver" msgid="7922563266857367495">"Dados ilimitados"</string>
    <string name="restrict_background_blocklisted" msgid="2308345280442438232">"Os dados em segundo plano estão desativados"</string>
    <string name="data_saver_on" msgid="7848893946018448793">"Ativada"</string>
    <string name="data_saver_off" msgid="5891210864117269045">"Desativada"</string>
    <string name="data_saver_switch_title" msgid="7111538580123722959">"Usar o recurso Economia de dados"</string>
    <string name="unrestricted_app_title" msgid="7117585996574329284">"Uso irrestrito de dados"</string>
    <string name="unrestricted_app_summary" msgid="282698963532000403">"Permitir acesso irrestrito a dados quando a Economia de dados estiver ativada"</string>
    <string name="home_app" msgid="6056850504746902747">"App de início"</string>
    <string name="suggestion_additional_fingerprints" msgid="4726777300101156208">"Adicionar outra impressão digital"</string>
    <string name="suggestion_additional_fingerprints_summary" msgid="2825364645039666674">"Desbloqueie com um dedo diferente"</string>
    <string name="battery_saver_on_summary" msgid="4605146593966255848">"Ativada"</string>
    <string name="battery_saver_off_scheduled_summary" msgid="2193875981740829819">"Será ativada em <xliff:g id="BATTERY_PERCENTAGE">%1$s</xliff:g>"</string>
    <string name="battery_saver_off_summary" msgid="4411561435493109261">"Desativada"</string>
    <string name="app_battery_usage_title" msgid="346558380609793334">"Uso da bateria por apps"</string>
    <string name="app_battery_usage_summary" msgid="6349965904306339539">"Definir o uso da bateria para apps"</string>
    <string name="battery_tips_card_action_button" msgid="4897793527424711648">"Mostrar configurações"</string>
    <string name="battery_tips_card_action_button_check" msgid="1535140204105479318">"Conferir"</string>
    <string name="battery_tips_card_dismiss_button" msgid="1885756985544936618">"Entendi"</string>
    <string name="battery_tips_card_feedback_info" msgid="767117835675157298">"Essa mensagem foi útil?"</string>
    <string name="battery_hints_warning_icon_a11y" msgid="5312542323401447620">"Ícone de aviso de dicas da bateria"</string>
    <string name="battery_tips_settings_summary_brightness" msgid="546145032616077783">"Ative o brilho adaptável para prolongar a duração da bateria"</string>
    <string name="battery_tips_settings_summary_screen_timeout" msgid="556801426050962077">"Diminua o tempo limite da tela para prolongar a duração da bateria"</string>
    <string name="battery_tips_apps_summary_always_high" msgid="6334519477067044920">"<xliff:g id="APP_LABEL">%1$s</xliff:g> usou mais bateria"</string>
    <string name="battery_tips_apps_summary_higher_than_usual" msgid="95676961671544628">"<xliff:g id="APP_LABEL">%1$s</xliff:g> usou bateria além do normal"</string>
    <string name="battery_tips_apps_summary_always_high_in_background" msgid="2953858181710181126">"<xliff:g id="APP_LABEL">%1$s</xliff:g> usou mais bateria em segundo plano"</string>
    <string name="battery_tips_apps_summary_higher_than_usual_in_background" msgid="1585002072567422199">"<xliff:g id="APP_LABEL">%1$s</xliff:g> usou bateria além do normal em segundo plano"</string>
    <string name="battery_tips_apps_summary_always_high_in_foreground" msgid="1910991243576404700">"<xliff:g id="APP_LABEL">%1$s</xliff:g> usou mais bateria em primeiro plano"</string>
    <string name="battery_tips_apps_summary_higher_than_usual_in_foreground" msgid="7937337570425168210">"<xliff:g id="APP_LABEL">%1$s</xliff:g> usou bateria além do normal em primeiro plano"</string>
    <string name="battery_usage_anomaly_content_description" msgid="3199380151630770476">"Anomalia no uso da bateria"</string>
    <string name="battery_app_item_hint" msgid="4850929961461039110">"Alto uso da bateria"</string>
    <string name="battery_app_item_hint_in_bg" msgid="596240821466388336">"Alto uso da bateria em segundo plano"</string>
    <string name="battery_app_item_hint_in_fg" msgid="5091860632260799910">"Alto uso da bateria em primeiro plano"</string>
    <string name="filter_battery_unrestricted_title" msgid="821027369424198223">"Sem restrições"</string>
    <string name="filter_battery_optimized_title" msgid="8236647176487754796">"Otimizada"</string>
    <string name="filter_battery_restricted_title" msgid="5886859505802563232">"Restrita"</string>
    <string name="default_spell_checker" msgid="7108373288347014351">"Corretor ortográfico padrão"</string>
    <string name="choose_spell_checker" msgid="7402513404783243675">"Escolher corretor ortográfico"</string>
    <string name="spell_checker_primary_switch_title" msgid="529240542284039243">"Usar o corretor ortográfico"</string>
    <string name="spell_checker_not_selected" msgid="8818618543474481451">"Não selecionado"</string>
    <string name="notification_log_details_delimiter" msgid="2475986465985309821">": "</string>
    <string name="notification_log_details_package" msgid="3205243985502010202">"pkg"</string>
    <string name="notification_log_details_key" msgid="2690467272328709046">"chave"</string>
    <string name="notification_log_details_group" msgid="1765952974599794393">"grupo"</string>
    <string name="notification_log_details_group_summary" msgid="4364622087007803822">"(resumo)"</string>
    <string name="notification_log_details_public_version" msgid="3057653571018432759">"publicVersion"</string>
    <string name="notification_log_details_importance" msgid="8516198274667183446">"importância"</string>
    <string name="notification_log_details_explanation" msgid="6966274549873070059">"explicação"</string>
    <string name="notification_log_details_badge" msgid="648647240928645446">"pode exibir selo"</string>
    <string name="notification_log_details_content_intent" msgid="2768423554375629089">"intent"</string>
    <string name="notification_log_details_delete_intent" msgid="8296434571041573503">"excluir intent"</string>
    <string name="notification_log_details_full_screen_intent" msgid="4151243693072002296">"intent de tela cheia"</string>
    <string name="notification_log_details_actions" msgid="2269605330470905236">"ações"</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">"visualização personalizada"</string>
    <string name="notification_log_details_extras" msgid="8602887256103970989">"extras"</string>
    <string name="notification_log_details_icon" msgid="6728710746466389675">"ícone"</string>
    <string name="notification_log_details_parcel" msgid="2098454650154230531">"tamanho do lote"</string>
    <string name="notification_log_details_ashmem" msgid="6163312898302809015">"ashmem"</string>
    <string name="notification_log_details_alerted" msgid="5285078967825048406">"alerta por notificação"</string>
    <string name="notification_log_channel" msgid="3406738695621767204">"canal"</string>
    <string name="notification_log_details_ranking_null" msgid="6607596177723101524">"O objeto de classificação está ausente."</string>
    <string name="notification_log_details_ranking_none" msgid="2484105338466675261">"O objeto de classificação não contém essa chave."</string>
    <string name="display_cutout_emulation" msgid="1421648375408281244">"Corte da tela"</string>
    <string name="display_cutout_emulation_keywords" msgid="4506580703807358127">"corte de tela, entalhe"</string>
    <string name="overlay_option_device_default" msgid="7986355499809313848">"Padrão do dispositivo"</string>
    <string name="overlay_toast_failed_to_apply" msgid="4839587811338164960">"Falha ao aplicar sobreposição"</string>
    <string name="special_access" msgid="1767980727423395147">"Acesso especial para apps"</string>
    <string name="special_access_more" msgid="132919514147475846">"Ver mais"</string>
    <string name="long_background_tasks_label" msgid="3169590134850226687">"Tarefas em segundo plano longas"</string>
    <string name="long_background_tasks_switch_title" msgid="2491623894899492543">"Permitir tarefas em segundo plano de longa duração"</string>
    <string name="long_background_tasks_title" msgid="3272230637974707490">"Tarefas em segundo plano longas"</string>
    <string name="long_background_tasks_footer_title" msgid="9117342254914743097">"Permitir que este app execute tarefas em segundo plano longas. Com essa permissão, o app pode executar tarefas que levariam algum tempo para serem concluídas, por exemplo, downloads e uploads. \n\nSe essa permissão for negada, o sistema vai limitar a duração das tarefas que o app pode executar em segundo plano."</string>
    <string name="keywords_long_background_tasks" msgid="5788956269136054574">"jobs longos, transferência de dados, tarefas em segundo plano"</string>
    <string name="run_backup_tasks_title" msgid="8572480651659803275">"Executar tarefas de backup em segundo plano"</string>
    <string name="run_backup_tasks_switch_title" msgid="4740767959730361777">"Permitir que o app execute tarefas em segundo plano relacionadas a backup"</string>
    <string name="run_backup_tasks_footer_title" msgid="1766222193265152388">"Indica que o app tem um caso de uso importante em que precisa fazer backup ou sincronizar conteúdo. Ao autorizar, você permite que o app seja executado em segundo plano por um período um pouco mais longo para concluir a tarefa relacionada ao backup. \n\nSe essa permissão for negada, o sistema não dará nenhuma isenção especial ao app para concluir o trabalho relacionado ao backup em segundo plano."</string>
    <string name="keywords_run_backup_tasks" msgid="632219905465766211">"tarefas de backup, jobs de backup"</string>
    <string name="reset_shortcut_manager_throttling" msgid="2183940254903144298">"Redefinir limite de taxa do ShortcutManager"</string>
    <string name="reset_shortcut_manager_throttling_complete" msgid="8949943009096885470">"O limite de taxa do ShortcutManager foi redefinido"</string>
    <string name="notification_suggestion_title" msgid="6309263655965785411">"Informações na tela de bloqueio"</string>
    <string name="notification_suggestion_summary" msgid="7615611244249276113">"Mostrar ou ocultar o conteúdo da notificação"</string>
    <string name="page_tab_title_support" msgid="3235725053332345773">"Dicas e suporte"</string>
    <string name="developer_smallest_width" msgid="632354817870920911">"Menor largura"</string>
    <string name="premium_sms_none" msgid="8737045049886416739">"Nenhum app instalado solicitou acesso a SMS premium."</string>
    <string name="premium_sms_warning" msgid="2192300872411073324">"O SMS premium pode gerar custos e será adicionado ao faturamento da sua operadora. Se você conceder permissão para um app, será possível enviar SMS premium usando esse app."</string>
    <string name="premium_sms_access" msgid="5605970342699013212">"Acesso a SMS premium"</string>
    <string name="bluetooth_disabled" msgid="835838280837359514">"Desativado"</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 vários dispositivos"</string>
    <string name="demo_mode" msgid="6566167465451386728">"Modo de demonstração da interface do sistema"</string>
    <string name="dark_ui_mode" msgid="898146394425795281">"Tema escuro"</string>
    <string name="dark_ui_mode_disabled_summary_dark_theme_on" msgid="4554134480159161533">"Desativado temporariamente pela Economia de bateria"</string>
    <string name="ambient_camera_summary_battery_saver_on" msgid="1787784892047029560">"Desativado temporariamente pela Economia de bateria"</string>
    <string name="ambient_camera_battery_saver_off" msgid="689825730569761613">"Desativar a Economia de bateria"</string>
    <string name="dark_ui_mode_disabled_summary_dark_theme_off" msgid="4154227921313505702">"Temporariamente ativado devido à Economia de bateria"</string>
    <string name="dark_theme_slice_title" msgid="4684222119481114062">"Teste o tema escuro"</string>
    <string name="dark_theme_slice_subtitle" msgid="5555724345330434268">"Ajuda a aumentar a duração da bateria"</string>
    <string name="quick_settings_developer_tiles" msgid="7336007844525766623">"Blocos de desenvolvedor para configurações rápidas"</string>
    <string name="adb_authorization_timeout_title" msgid="6996844506783749754">"Desativar o tempo limite da autorização adb"</string>
    <string name="adb_authorization_timeout_summary" msgid="409931540424019778">"Desativar a revogação automática de autorizações adb para sistemas que não foram reconectados no período padrão (7 dias) ou configurado pelo usuário (mínimo de 1 dia)."</string>
    <string name="sensors_off_quick_settings_title" msgid="8472151847125917167">"Sensores desativados"</string>
    <string name="managed_profile_settings_title" msgid="3400923723423564217">"Configurações do perfil de trabalho"</string>
    <string name="managed_profile_contact_search_title" msgid="6562061740814513737">"Pesquisar contatos do diretório de trabalho nos apps pessoais"</string>
    <string name="managed_profile_contact_search_summary" msgid="4974727886709219105">"Suas pesquisas e chamadas recebidas podem ser visíveis para seu administrador de TI"</string>
    <string name="cross_profile_calendar_title" msgid="7570277841490216947">"Agenda de perfil cruzado"</string>
    <string name="cross_profile_calendar_summary" msgid="8856185206722860069">"Mostrar eventos de trabalho na agenda pessoal"</string>
    <string name="managed_profile_settings_footer" msgid="996500759305118103">"Quando os apps de trabalho estão desativados, eles ficam em pausa e não podem ser acessados ou enviar notificações"</string>
    <string name="automatic_storage_manager_settings" msgid="519158151463974656">"Gerenciar armazenamento"</string>
    <string name="automatic_storage_manager_text" msgid="6900593059927987273">"Para ajudar a liberar espaço de armazenamento, o gerenciador de armazenamento remove fotos e vídeos do seu dispositivo salvos em backup."</string>
    <string name="automatic_storage_manager_days_title" msgid="5077286114860539367">"Remover fotos e vídeos"</string>
    <string name="automatic_storage_manager_preference_title" msgid="3483357910142595444">"Gerenciador de armazenamento"</string>
    <string name="automatic_storage_manager_primary_switch_title" msgid="9131959126462101994">"Usar gerenciador de armazenamento"</string>
    <string name="gesture_preference_title" msgid="8291899281322647187">"Gestos"</string>
    <string name="double_tap_power_for_camera_title" msgid="7982364144330923683">"Abrir a câmera rapidamente"</string>
    <string name="double_tap_power_for_camera_summary" msgid="1100926048598415509">"Para abrir a câmera rapidamente, pressione o botão liga/desliga duas vezes. O recurso funciona em qualquer tela."</string>
    <string name="double_twist_for_camera_mode_title" msgid="472455236910935684">"Virar câmera para tirar selfie"</string>
    <string name="double_twist_for_camera_mode_summary" msgid="592503740044744951"></string>
    <string name="system_navigation_title" msgid="4890381153527184636">"Modo de navegação"</string>
    <string name="swipe_up_to_switch_apps_title" msgid="6677266952021118342">"Navegação com dois botões"</string>
    <string name="swipe_up_to_switch_apps_summary" msgid="1415457307836359560">"Para mudar de app, deslize o botão home para cima. Para acessar todos os apps, deslize para cima novamente. Para retornar, toque no botão \"Voltar\"."</string>
    <string name="emergency_settings_preference_title" msgid="6183455153241187148">"Segurança e emergência"</string>
    <string name="emergency_dashboard_summary" msgid="401033951074039302">"SOS de emergência, informações de saúde, alertas"</string>
    <string name="edge_to_edge_navigation_title" msgid="714427081306043819">"Navegação por gestos"</string>
    <string name="edge_to_edge_navigation_summary" msgid="818109176611921504">"Para ir à tela inicial, deslize de baixo para cima. Para trocar de app, deslize de baixo para cima, mantenha a tela pressionada e depois solte-a. Para voltar, deslize para um dos lados de uma borda à outra."</string>
    <string name="legacy_navigation_title" msgid="7877402855994423727">"Navegação com três botões"</string>
    <string name="legacy_navigation_summary" msgid="5905301067778326433">"Volte, vá para a tela inicial e mude de app usando os botões na parte inferior da tela."</string>
    <string name="keywords_system_navigation" msgid="3131782378486554934">"navegação no sistema, navegação com dois botões, navegação com três botões, navegação por gestos, deslizar"</string>
    <string name="assistant_gesture_category_title" msgid="2478251256585807920">"Assistente digital"</string>
    <string name="assistant_corner_gesture_title" msgid="1895061522687002106">"Deslize para invocar o assistente"</string>
    <string name="assistant_corner_gesture_summary" msgid="5012534700233017955">"Deslize de baixo para cima no canto da tela para invocar o app assistente digital"</string>
    <string name="assistant_long_press_home_gesture_title" msgid="4865972278738178753">"Pressione o botão home para ativar o Google Assistente"</string>
    <string name="assistant_long_press_home_gesture_summary" msgid="592882226105081447">"Toque e pressione o botão home para chamar o app de assistente digital."</string>
    <string name="low_label" msgid="6525629096999711220">"Baixa"</string>
    <string name="high_label" msgid="357503396626018487">"Alta"</string>
    <string name="left_edge" msgid="1513576842959071849">"Borda esquerda"</string>
    <string name="right_edge" msgid="1505309103265829121">"Borda direita"</string>
    <string name="back_sensitivity_dialog_message" msgid="6638367716784103306">"O aumento da sensibilidade pode prejudicar gestos que usam as bordas da tela."</string>
    <string name="back_sensitivity_dialog_title" msgid="6153608904168908264">"Sensibilidade para voltar"</string>
    <string name="gesture_settings_activity_title" msgid="2025828425762595733">"Sensibilidade da navegação por gestos"</string>
    <string name="button_navigation_settings_activity_title" msgid="7335636045504461813">"Navegação com botões"</string>
    <string name="keywords_gesture_navigation_settings" msgid="667561222717238931">"navegação por gestos, sensibilidade para voltar, gestos de retorno"</string>
    <string name="keywords_button_navigation_settings" msgid="7888812253110553920">"navegação, botão home"</string>
    <string name="one_handed_title" msgid="2584414010282746195">"Modo uma mão"</string>
    <string name="one_handed_mode_enabled" msgid="3396864848786359651">"Usar o modo uma mão"</string>
    <string name="one_handed_mode_shortcut_title" msgid="1847871530184067369">"Atalho do modo uma mão"</string>
    <string name="keywords_one_handed" msgid="969440592493034101">"acesso com uma mão"</string>
    <string name="one_handed_mode_swipe_down_category" msgid="110178629274462484">"Deslizar para baixo para"</string>
    <string name="one_handed_mode_use_shortcut_category" msgid="1414714099339147711">"Usar o atalho para"</string>
    <string name="one_handed_mode_intro_text" msgid="7921988617828924342">"Puxe para baixo a metade de cima da tela para facilitar o uso com uma mão"</string>
    <string name="one_handed_mode_footer_text" msgid="6336209800330679840">" "<b>"Como usar o modo uma mão"</b>\n" • Confira se a navegação por gestos está selecionada nas configurações de navegação do sistema. \n • Deslize até perto da borda de baixo da tela."</string>
    <string name="one_handed_action_pull_down_screen_title" msgid="9187194533815438150">"Puxar a tela para que fique ao alcance"</string>
    <string name="one_handed_action_pull_down_screen_summary" msgid="7582432473450036628">"A parte superior da tela se moverá para ficar ao alcance do seu polegar."</string>
    <string name="one_handed_action_show_notification_title" msgid="8789305491485437130">"Mostrar notificações"</string>
    <string name="one_handed_action_show_notification_summary" msgid="8281689861222000436">"As notificações e configurações serão exibidas."</string>
    <string name="ambient_display_summary" msgid="2650326740502690434">"Para acessar a hora, as notificações e outras informações, toque duas vezes na tela."</string>
    <string name="ambient_display_wake_screen_title" msgid="7637678749035378085">"Ativar a tela"</string>
    <string name="ambient_display_tap_screen_summary" msgid="4480489179996521405">"Para acessar a hora, as notificações e outras informações, toque na tela."</string>
    <string name="emergency_gesture_screen_title" msgid="3280543310204360902">"SOS de emergência"</string>
    <string name="emergency_gesture_switchbar_title" msgid="7421353963329899514">"Usar o SOS de emergência"</string>
    <string name="emergency_gesture_screen_summary" msgid="6640521030845132507">"Pressione o botão liga/desliga rapidamente cinco vezes ou mais para iniciar as ações abaixo"</string>
    <string name="emergency_gesture_sound_setting_title" msgid="7153948164862156536">"Tocar alarme de contagem regressiva"</string>
    <string name="emergency_gesture_sound_setting_summary" msgid="6573377104470235173">"Tocar um som alto no início do SOS de emergência"</string>
    <string name="emergency_gesture_category_call_for_help_title" msgid="1680040129478289510">"Enviar uma notificação para receber ajuda"</string>
    <string name="emergency_gesture_call_for_help_title" msgid="4969340870836239982">"Pedir ajuda"</string>
    <string name="emergency_gesture_call_for_help_dialog_title" msgid="8901271205171421201">"Número para ligar e pedir ajuda"</string>
    <string name="emergency_gesture_call_for_help_summary" msgid="6552830427932669221">"<xliff:g id="PHONE_NUMBER">%1$s</xliff:g>. Toque para mudar"</string>
    <string name="emergency_gesture_number_override_notes" msgid="233018570696200402">"Ao inserir um número que não seja de emergência:\n • seu dispositivo precisa estar desbloqueado para usar o SOS de emergência;\n • pode ser que sua ligação não seja atendida."</string>
    <string name="fingerprint_swipe_for_notifications_title" msgid="2271217256447175017">"Usar impressão digital para ver as notificações"</string>
    <string name="fingerprint_gesture_screen_title" msgid="9086261338232806522">"Usar impressão digital"</string>
    <string name="fingerprint_swipe_for_notifications_suggestion_title" msgid="2956636269742745449">"Ver notificações rapidamente"</string>
    <string name="gesture_setting_on" msgid="3223448394997988591">"Ativado"</string>
    <string name="gesture_setting_off" msgid="3444029475726294919">"Desativado"</string>
    <string name="oem_unlock_enable_disabled_summary_bootloader_unlocked" msgid="65713754674288193">"O carregador de inicialização já está desbloqueado"</string>
    <string name="oem_unlock_enable_disabled_summary_connectivity_or_locked" msgid="7425519481227423860">"Conecte-se à Internet ou entre em contato com sua operadora"</string>
    <string name="oem_unlock_enable_disabled_summary_sim_locked_device" msgid="168124660162907358">"Indisponível em dispositivos bloqueados pela operadora"</string>
    <string name="oem_lock_info_message" msgid="8843145669619429197">"Reinicie o aparelho para ativar o recurso de proteção do dispositivo."</string>
    <string name="automatic_storage_manager_freed_bytes" msgid="706230592123831676">"Total de <xliff:g id="SIZE">%1$s</xliff:g> disponibilizado\n\nÚltima execução em <xliff:g id="DATE">%2$s</xliff:g>"</string>
    <string name="web_action_enable_title" msgid="6654581786741216382">"Apps instantâneos"</string>
    <string name="web_action_enable_summary" msgid="2658930257777545990">"Abrir links em apps, mesmo que eles não estejam instalados"</string>
    <string name="web_action_section_title" msgid="994717569424234098">"Apps instantâneos"</string>
    <string name="instant_apps_settings" msgid="4280942494969957858">"Preferências do Instant Apps"</string>
    <string name="domain_url_section_title" msgid="9028890472923474958">"Apps instalados"</string>
    <string name="automatic_storage_manager_activation_warning" msgid="170508173207142665">"Seu armazenamento está sendo controlado pelo gerenciador de armazenamento"</string>
    <string name="account_for_section_header" msgid="7466759342105251096">"Contas de <xliff:g id="USER_NAME">%1$s</xliff:g>"</string>
    <string name="auto_sync_account_title" msgid="1070908045600374254">"Sincronizar dados de apps automaticamente"</string>
    <string name="auto_sync_account_summary" msgid="7580352130028957346">"Permitir que os apps atualizem dados automaticamente"</string>
    <string name="account_sync_title" msgid="7036067017433297574">"Sincronização da conta"</string>
    <string name="account_sync_summary_some_on" msgid="911460286297968724">"Sincronização ativada para <xliff:g id="ID_1">%1$d</xliff:g> de <xliff:g id="ID_2">%2$d</xliff:g> itens"</string>
    <string name="account_sync_summary_all_on" msgid="2953682111836599841">"Sincronização ativada para todos os itens"</string>
    <string name="account_sync_summary_all_off" msgid="6378301874540507884">"Sincronização desativada para todos os itens"</string>
    <string name="enterprise_privacy_settings" msgid="786350385374794180">"Informações do dispositivo gerenciado"</string>
    <string name="enterprise_privacy_settings_summary_generic" msgid="5471858290610344646">"Alterações e configurações gerenciadas pela sua organização"</string>
    <string name="enterprise_privacy_settings_summary_with_name" msgid="1315413275836515937">"Alterações e configurações gerenciadas por <xliff:g id="ORGANIZATION_NAME">%s</xliff:g>"</string>
    <string name="enterprise_privacy_header" msgid="4626225398848641603">"Para fornecer acesso aos seus dados de trabalho, sua organização pode alterar configurações e instalar softwares no seu dispositivo.\n\nPara saber mais detalhes, entre em contato com o administrador da sua organização."</string>
    <string name="enterprise_privacy_exposure_category" msgid="2507761423540037308">"Tipos de informação que sua organização pode ver"</string>
    <string name="enterprise_privacy_exposure_changes_category" msgid="5459989751333816587">"Alterações feitas pelo administrador da sua organização"</string>
    <string name="enterprise_privacy_device_access_category" msgid="140157499478630004">"Seu acesso a este dispositivo"</string>
    <string name="enterprise_privacy_enterprise_data" msgid="3963070078195245028">"Dados associados à sua conta de trabalho, como e-mail e agenda"</string>
    <string name="enterprise_privacy_installed_packages" msgid="6707006112254572820">"Lista de apps no seu dispositivo"</string>
    <string name="enterprise_privacy_usage_stats" msgid="6328506963853465534">"Quantidade de tempo gasto e dados usados em cada app"</string>
    <string name="enterprise_privacy_network_logs" msgid="3081744541193695887">"Registro de tráfego de rede mais recente"</string>
    <string name="enterprise_privacy_bug_reports" msgid="2635897583413134123">"Relatório de bug mais recente"</string>
    <string name="enterprise_privacy_security_logs" msgid="8494681624247959075">"Registro de segurança mais recente"</string>
    <string name="enterprise_privacy_none" msgid="6026527690979756431">"Nenhum"</string>
    <string name="enterprise_privacy_enterprise_installed_packages" msgid="9114143640515900082">"Apps instalados"</string>
    <string name="enterprise_privacy_apps_count_estimation_info" msgid="7959907857710107792">"O número de apps é aproximado. Ele pode não incluir apps instalados fora da Play Store."</string>
    <string name="enterprise_privacy_number_packages_lower_bound" msgid="5317634640873658149">"{count,plural, =1{No mínimo # app}one{No mínimo # app}other{No mínimo # apps}}"</string>
    <string name="enterprise_privacy_location_access" msgid="8023838718108456971">"Permissões de localização"</string>
    <string name="enterprise_privacy_microphone_access" msgid="7242958026470143653">"Permissões do microfone"</string>
    <string name="enterprise_privacy_camera_access" msgid="7685460535880069016">"Permissões da câmera"</string>
    <string name="enterprise_privacy_enterprise_set_default_apps" msgid="7498546659083996300">"Apps padrão"</string>
    <string name="enterprise_privacy_number_packages" msgid="5294444005035188274">"{count,plural, =1{# app}one{# app}other{# apps}}"</string>
    <string name="enterprise_privacy_input_method" msgid="3278314982700662246">"Teclado padrão"</string>
    <string name="enterprise_privacy_input_method_name" msgid="2974859490559054584">"Definir como <xliff:g id="APP_LABEL">%s</xliff:g>"</string>
    <string name="enterprise_privacy_always_on_vpn_device" msgid="1735829327405126695">"\"VPN sempre ativa\" ativada"</string>
    <string name="enterprise_privacy_always_on_vpn_personal" msgid="8395903360175064841">"\"VPN sempre ativa\" ativada no seu perfil pessoal"</string>
    <string name="enterprise_privacy_always_on_vpn_work" msgid="2496961514592522377">"\"VPN sempre ativa\" ativada no seu perfil de trabalho"</string>
    <string name="enterprise_privacy_global_http_proxy" msgid="4350347418068037051">"Proxy HTTP geral definido"</string>
    <string name="enterprise_privacy_ca_certs_device" msgid="1816495877258727663">"Credenciais confiáveis"</string>
    <string name="enterprise_privacy_ca_certs_personal" msgid="1516422660828485795">"Credenciais confiáveis no seu perfil pessoal"</string>
    <string name="enterprise_privacy_ca_certs_work" msgid="4318941788592655561">"Credenciais confiáveis no seu perfil de trabalho"</string>
    <string name="enterprise_privacy_number_ca_certs" msgid="4540897122831942658">"{count,plural, =1{No mínimo # certificado de CA}one{No mínimo # certificado de CA}other{No mínimo # certificados de CA}}"</string>
    <string name="enterprise_privacy_lock_device" msgid="464054894363899866">"O administrador pode bloquear o dispositivo e redefinir a senha"</string>
    <string name="enterprise_privacy_wipe_device" msgid="869589182352244591">"O administrador pode excluir todos os dados do dispositivo"</string>
    <string name="enterprise_privacy_failed_password_wipe_device" msgid="7045164901334821226">"Tentativas de senha falhas antes de excluir todos os dados do dispositivo"</string>
    <string name="enterprise_privacy_failed_password_wipe_work" msgid="2537582942554484170">"Tentativas de senha falhas antes de excluir os dados do perfil de trabalho"</string>
    <string name="enterprise_privacy_number_failed_password_wipe" msgid="2695842143305867642">"{count,plural, =1{# tentativa}one{# tentativa}other{# tentativas}}"</string>
    <string name="do_disclosure_generic" msgid="3067459392402324538">"Este dispositivo é gerenciado pela sua organização."</string>
    <string name="do_disclosure_with_name" msgid="867544298924410766">"Este dispositivo é gerenciado por <xliff:g id="ORGANIZATION_NAME">%s</xliff:g>."</string>
    <string name="do_disclosure_learn_more_separator" msgid="5714364437437041671">" "</string>
    <string name="learn_more" msgid="3534519107947510952">"Saiba mais"</string>
    <string name="blocked_by_restricted_settings_title" msgid="7334715011474037399">"Configuração restrita"</string>
    <string name="toast_allows_restricted_settings_successfully" msgid="1219116121291466102">"Configurações restritas permitidas para <xliff:g id="APP_NAME">%s</xliff:g>"</string>
    <string name="blocked_by_restricted_settings_content" msgid="3628660029601161080">"Para sua segurança, essa configuração está indisponível no momento."</string>
    <string name="financed_privacy_settings" msgid="2575114436197204145">"Informações do dispositivo financiado"</string>
    <string name="financed_privacy_intro" msgid="7836497475568741579">"Sua provedora de crédito pode mudar configurações e instalar softwares neste dispositivo durante a definição.\n\nSe você perder a data do pagamento, ela poderá bloquear o dispositivo e mudar as configurações dele.\n\nPara saber mais, entre em contato com a provedora de crédito."</string>
    <string name="financed_privacy_restrictions_category" msgid="2472659467919651602">"Se o dispositivo for financiado, não será possível:"</string>
    <string name="financed_privacy_install_apps" msgid="7381718005710210851">"Instalar apps de fora da Play Store"</string>
    <string name="financed_privacy_safe_mode" msgid="5362149445732602578">"Reiniciar o dispositivo no modo de segurança"</string>
    <string name="financed_privacy_multi_users" msgid="1727194928477613081">"Adicionar vários usuários ao dispositivo"</string>
    <string name="financed_privacy_config_date_time" msgid="8567370445374984365">"Mudar data, hora e fuso horário"</string>
    <string name="financed_privacy_developer_options" msgid="7602001474669831672">"Usar as opções do desenvolvedor"</string>
    <string name="financed_privacy_credit_provider_capabilities_category" msgid="8737902277892987998">"Sua provedora de crédito pode:"</string>
    <string name="financed_privacy_IMEI" msgid="1852413860963824799">"Acessar o número IMEI"</string>
    <string name="financed_privacy_factory_reset" msgid="5505016667590160732">"Redefinir o dispositivo para a configuração original se ocorrer um problema"</string>
    <string name="financed_privacy_locked_mode_category" msgid="3708288398912647751">"Se o dispositivo estiver bloqueado, ele só poderá ser usado para:"</string>
    <string name="financed_privacy_emergency_calls" msgid="1108183987142736497">"Fazer chamadas de emergência"</string>
    <string name="financed_privacy_system_info" msgid="4158031444108708927">"Ver informações do sistema como data, hora, rede, status e bateria"</string>
    <string name="financed_privacy_turn_on_off_device" msgid="3331566753152790571">"Ligar e desligar o dispositivo"</string>
    <string name="financed_privacy_notifications" msgid="5932303271274089968">"Ver notificações e mensagens de texto"</string>
    <string name="financed_privacy_allowlisted_apps" msgid="8333040812194879963">"Acessar apps que têm permissão da provedora de crédito"</string>
    <string name="financed_privacy_fully_paid_category" msgid="9221763928564246923">"Depois que você pagar o valor completo:"</string>
    <string name="financed_privacy_restrictions_removed" msgid="3182636815294595072">"Todas as restrições serão removidas do dispositivo"</string>
    <string name="financed_privacy_uninstall_creditor_app" msgid="6339004120497310705">"É possível desinstalar o app da provedora de crédito"</string>
    <string name="financed_device_info" msgid="3871860346697308342">"Informações do dispositivo financiado"</string>
    <string name="default_camera_app_title" msgid="6546248868519965998">"{count,plural, =1{App de câmera}one{App de câmera}other{Apps de câmera}}"</string>
    <string name="default_calendar_app_title" msgid="1870095225089706093">"App Calendário"</string>
    <string name="default_contacts_app_title" msgid="7740028900741944569">"App Contatos"</string>
    <string name="default_email_app_title" msgid="5411280873093244250">"{count,plural, =1{App de cliente de e-mail}one{App de cliente de e-mail}other{Apps de cliente de e-mail}}"</string>
    <string name="default_map_app_title" msgid="7569231732944853320">"App Mapa"</string>
    <string name="default_phone_app_title" msgid="795025972645464135">"{count,plural, =1{App de telefone}one{App de telefone}other{Apps de telefone}}"</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">"Jogos"</string>
    <string name="storage_files" msgid="7968460921272772299">"Arquivos"</string>
    <string name="storage_images" msgid="2055893015567979387">"Imagens"</string>
    <string name="storage_videos" msgid="6117698226447251033">"Vídeos"</string>
    <string name="storage_audio" msgid="5994664984472140386">"Áudio"</string>
    <string name="storage_apps" msgid="3564291603258795216">"Apps"</string>
    <string name="storage_documents_and_other" msgid="3293689243732236480">"Documentos e outros"</string>
    <string name="storage_system" msgid="8472410119822911844">"Sistema"</string>
    <string name="storage_trash" msgid="2807138998886084856">"Lixeira"</string>
    <string name="storage_trash_dialog_title" msgid="2296169576049935200">"Esvaziar a lixeira?"</string>
    <string name="storage_trash_dialog_ask_message" msgid="8982602137242358798">"A lixeira tem <xliff:g id="TOTAL">%1$s</xliff:g> de arquivos. Todos os itens serão excluídos definitivamente, e você não poderá restaurá-los."</string>
    <string name="storage_trash_dialog_empty_message" msgid="7334670765528691400">"A lixeira está vazia"</string>
    <string name="storage_trash_dialog_confirm" msgid="1707723334982760436">"Esvaziar lixeira"</string>
    <string name="storage_usage_summary" msgid="4591121727356723463">"Usados: <xliff:g id="NUMBER">%1$s</xliff:g> <xliff:g id="UNIT">%2$s</xliff:g>"</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">"Limpar app"</string>
    <string name="clear_instant_app_confirmation" msgid="3964731334459209482">"Quer remover esse app instantâneo?"</string>
    <string name="launch_instant_app" msgid="8503927414339606561">"Abrir"</string>
    <string name="game_storage_settings" msgid="2521393115726178837">"Jogos"</string>
    <string name="app_info_storage_title" msgid="4076977173803093808">"Espaço utilizado"</string>
    <string name="webview_uninstalled_for_user" msgid="627352948986275488">"(desinstalado para o usuário <xliff:g id="USER">%s</xliff:g>)"</string>
    <string name="webview_disabled_for_user" msgid="5809886172032644498">"(desativado para o usuário <xliff:g id="USER">%s</xliff:g>)"</string>
    <string name="autofill_app" msgid="7595308061826307921">"Preenchimento automático"</string>
    <string name="default_autofill_app" msgid="372234803718251606">"Preenchimento automático padrão"</string>
    <string name="autofill_passwords" msgid="6708057251459761083">"Senhas"</string>
    <string name="credman_chosen_app_title" msgid="7735183808067729319">"Serviço preferido"</string>
    <string name="credman_credentials" msgid="2620352336624160642">"Serviços adicionais"</string>
    <string name="autofill_passwords_count" msgid="6359289285822955973">"{count,plural, =1{# senha}one{# senha}other{# senhas}}"</string>
    <string name="autofill_keywords" msgid="8598763328489346438">"preencher, automático, preenchimento automático, senha"</string>
    <string name="credman_keywords" msgid="8305600680836806170">"dados, chave de acesso, senha"</string>
    <string name="credman_autofill_keywords" msgid="701180623776848914">"automático, preenchimento, preenchimento automático, dados, chave de acesso, senha"</string>
    <string name="credman_button_change" msgid="4072629639218503790">"Mudar"</string>
    <string name="credman_button_open" msgid="7519871964170816850">"Abrir"</string>
    <string name="credman_app_list_preference_none" msgid="2509646651254971448">"Nenhum selecionado"</string>
    <string name="autofill_confirmation_message" msgid="4888767934273494272">"&lt;b&gt;Você precisa confiar nesse app&lt;/b&gt; &lt;br/&gt; &lt;br/&gt; &lt;xliff:g id=app_name example=O Preenchimento automático do Google&gt;%1$s&lt;/xliff:g&gt; usa o que está na sua tela para determinar o que pode ser preenchido automaticamente."</string>
    <string name="credman_autofill_confirmation_message" msgid="843829628024668466">"&lt;b&gt;Usar &lt;xliff:g id=app_name example=Provider&gt;%1$s&lt;/xliff:g&gt;?&lt;/b&gt; &lt;br/&gt; &lt;br/&gt; Senhas, chaves de acesso e outras informações novas serão salvas aqui a partir de agora. &lt;xliff:g id=app_name example=Provider&gt;%1$s&lt;/xliff:g&gt; pode usar o que aparece na tela para determinar o que pode ser preenchido automaticamente."</string>
    <string name="credman_picker_title" msgid="8442086614222006564">"Serviço preferido para senhas, chaves de acesso e preenchimento automático"</string>
    <string name="credman_confirmation_message_title" msgid="8847900085593880729">"Desativar %1$s?"</string>
    <string name="credman_confirmation_message" msgid="2357324543658635239">"&lt;b&gt;Desativar este serviço?&lt;/b&gt; &lt;br/&gt; &lt;br/&gt; Senhas, chaves de acesso, formas de pagamento e outras informações salvas não serão preenchidas quando você fizer login. Para usar suas informações salvas, escolha uma senha, uma chave de acesso ou um serviço de dados."</string>
    <string name="account_dashboard_title_with_passkeys" msgid="6214673787161409996">"Senhas, chaves de acesso e preenchimento automático"</string>
    <string name="credman_confirmation_message_new_ui" msgid="6126274509951156460">"&lt;b&gt;Desativar todos os serviços?&lt;/b&gt; &lt;br/&gt; &lt;br/&gt; Novas senhas, chaves de acesso e outras informações serão salvas aqui a partir de agora."</string>
    <string name="credman_autofill_confirmation_message_new_ui" msgid="6222139222478822267">"&lt;b&gt;Mudar seu serviço favorito para o &lt;xliff:g id=app_name example=Provider&gt;%1$s&lt;/xliff:g&gt;?&lt;/b&gt; &lt;br/&gt; &lt;br/&gt; Novas senhas, chaves de acesso e outras informações serão salvas aqui a partir de agora. O &lt;xliff:g id=app_name example=Provider&gt;%1$s&lt;/xliff:g&gt; pode usar o que aparece na tela para determinar o que pode ser preenchido automaticamente"</string>
    <string name="credman_enable_confirmation_message_title" msgid="1037501792652277829">"Usar %1$s?"</string>
    <string name="credman_confirmation_turn_off_positive_button" msgid="5678773011513369161">"Desativar"</string>
    <string name="credman_confirmation_change_provider_positive_button" msgid="7732302992885116967">"Mudar"</string>
    <string name="credman_limit_error_msg_title" msgid="1525814645803612135">"Só é possível ter 5 serviços ativados"</string>
    <string name="credman_limit_error_msg" msgid="2521803280130310063">"Desative pelo menos 1 serviço para adicionar outro"</string>
    <string name="credman_enable_confirmation_message" msgid="8407841892310870169">"%1$s usa o que aparece na tela para determinar o que pode ser preenchido automaticamente."</string>
    <string name="credman_error_message_title" msgid="4099557206946333568">"Limite de senhas, chaves de acesso e serviços de dados"</string>
    <string name="credman_error_message" msgid="8334797097200415449">"É possível ter até cinco senhas, chaves de acesso e serviços de dados ativos ao mesmo tempo. Desative um para adicionar outro."</string>
    <string name="credman_confirmation_message_positive_button" msgid="2812613187691345361">"Desativar"</string>
    <string name="debug_autofill_category" msgid="5998163555428196185">"Preenchimento automático"</string>
    <string name="autofill_logging_level_title" msgid="3733958845861098307">"Nível de registro"</string>
    <string name="autofill_max_partitions" msgid="7342195529574406366">"Máximo de solicitações por sessão"</string>
    <string name="autofill_max_visible_datasets" msgid="4970201981694392229">"Máximo de conjuntos de dados visíveis"</string>
    <string name="autofill_reset_developer_options" msgid="6425613608979498608">"Redefinir para valores padrão"</string>
    <string name="autofill_reset_developer_options_complete" msgid="1276741935956594965">"As opções do desenvolvedor de preenchimento automático foram redefinidas"</string>
    <string name="location_category" msgid="3496759112306219062">"Localização"</string>
    <string name="location_indicator_settings_title" msgid="6655916258720093451">"Indicador de local na barra de status"</string>
    <string name="location_indicator_settings_description" msgid="2888022085372804021">"Mostrar para todos os locais, incluindo rede e conectividade"</string>
    <string name="enable_gnss_raw_meas_full_tracking" msgid="1206679951510243341">"Forçar medições completas de GNSS"</string>
    <string name="enable_gnss_raw_meas_full_tracking_summary" msgid="3841463141138247167">"Rastrear todas as constelações e frequências do GNSS sem nenhum ciclo de trabalho"</string>
    <string name="input_method_category" msgid="2252659253631639005">"Método de entrada"</string>
    <string name="stylus_handwriting" msgid="2154591374132794563">"Escrita à mão com stylus"</string>
    <string name="stylus_handwriting_summary" msgid="6333425895172696950">"Quando essa opção for ativada, o método de entrada atual vai receber o MotionEvent da stylus se um Editor estiver em foco."</string>
    <string name="device_theme" msgid="5027604586494772471">"Tema do dispositivo"</string>
    <string name="default_theme" msgid="4815428567082263639">"Padrão"</string>
    <string name="show_operator_name_title" msgid="3355910331531144028">"Nome da rede"</string>
    <string name="show_operator_name_summary" msgid="5352696579216501773">"Exibir o nome da rede na barra de status"</string>
    <string name="install_type_instant" msgid="7685381859060486009">"App instantâneo"</string>
    <string name="automatic_storage_manager_deactivation_warning" msgid="4905106133215702099">"Desativar o gerenciador de armazenamento?"</string>
    <string name="zen_suggestion_title" msgid="4555260320474465668">"Atualizar o modo Não perturbe"</string>
    <string name="zen_suggestion_summary" msgid="1984990920503217">"Pausar notificações para manter o foco"</string>
    <string name="disabled_feature" msgid="7151433782819744211">"Recurso não disponível"</string>
    <string name="disabled_feature_reason_slow_down_phone" msgid="5743569256308510404">"Esse recurso foi desativado porque causa lentidão no seu smartphone"</string>
    <string name="show_first_crash_dialog" msgid="1696584857732637389">"Sempre mostrar a caixa de diálogo de falha"</string>
    <string name="show_first_crash_dialog_summary" msgid="4692334286984681111">"Mostrar a caixa de diálogo sempre que um app falha"</string>
    <string name="angle_enabled_app" msgid="6044941043384239076">"Selecionar app ativado para ANGLE"</string>
    <string name="angle_enabled_app_not_set" msgid="4472572224881726067">"Nenhum conjunto de aplicativos ativados para ANGLE"</string>
    <string name="angle_enabled_app_set" msgid="7811829383833353021">"Aplicativo ativado para ANGLE: <xliff:g id="APP_NAME">%1$s</xliff:g>"</string>
    <string name="graphics_driver_dashboard_title" msgid="5661084817492587796">"Preferências do driver de gráficos"</string>
    <string name="graphics_driver_dashboard_summary" msgid="6348759885315793654">"Modificar configurações do driver de gráficos"</string>
    <string name="graphics_driver_footer_text" msgid="5123754522284046790">"Quando houver vários drivers gráficos, você poderá usar o driver gráfico atualizado dos apps instalados no dispositivo."</string>
    <string name="graphics_driver_all_apps_preference_title" msgid="1343065382898127360">"Ativar para todos os apps"</string>
    <string name="graphics_driver_app_preference_title" msgid="3133255818657706857">"Selecionar driver gráfico"</string>
    <string name="graphics_driver_app_preference_default" msgid="764432460281859855">"Padrão"</string>
    <string name="graphics_driver_app_preference_production_driver" msgid="1515874802568434915">"Driver de jogo"</string>
    <string name="graphics_driver_app_preference_prerelease_driver" msgid="7355929161805829480">"Developer Driver"</string>
    <string name="graphics_driver_app_preference_system" msgid="3754748149113184126">"Driver gráfico do 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="enable_angle_as_system_driver" msgid="4648827560023949786">"Experimental: ativar ANGLE"</string>
    <string name="enable_angle_as_system_driver_summary" msgid="2170215556348477481">"Atenção: ative o ANGLE como o driver padrão do OpenGL ES. Esse recurso é experimental e pode não ser compatível com alguns apps de câmera e vídeo."</string>
    <string name="reboot_dialog_enable_angle_as_system_driver" msgid="2619263039763150810">"É necessário reiniciar o dispositivo para mudar o driver do OpenGL ES do sistema"</string>
    <string name="platform_compat_dashboard_title" msgid="1323980546791790236">"Mudanças na compatibilidade do app"</string>
    <string name="platform_compat_dashboard_summary" msgid="4036546607938791337">"Alternar mudanças de compatibilidade do app"</string>
    <string name="platform_compat_default_enabled_title" msgid="8973137337738388024">"Mudanças ativadas padrão"</string>
    <string name="platform_compat_default_disabled_title" msgid="3975847180953793602">"Mudanças desativadas padrão"</string>
    <string name="platform_compat_dialog_text_no_apps" msgid="5715226015751055812">"As mudanças na compatibilidade de apps só podem ser modificadas para apps depuráveis. Instale um app depurável e tente novamente."</string>
    <string name="disabled_dependent_setting_summary" msgid="4508635725315852504">"Depende de outra configuração"</string>
    <string name="my_device_info_account_preference_title" msgid="9197139254007133175">"Conta"</string>
    <string name="my_device_info_account_preference_summary" msgid="3510582677937510545">"%d contas"</string>
    <string name="my_device_info_device_name_preference_title" msgid="8053298498727237971">"Nome do dispositivo"</string>
    <string name="my_device_info_basic_info_category_title" msgid="381963187269356548">"Informações básicas"</string>
    <string name="my_device_info_legal_category_title" msgid="7732792841537995127">"Informações legais e regulatórias"</string>
    <string name="my_device_info_device_details_category_title" msgid="4848438695638348680">"Detalhes do dispositivo"</string>
    <string name="my_device_info_device_identifiers_category_title" msgid="2197063484127704153">"Identificadores de dispositivo"</string>
    <string name="change_wifi_state_title" msgid="5629648102837821525">"Controle de Wi-Fi"</string>
    <string name="change_wifi_state_app_detail_switch" msgid="1385358508267180745">"Permitir que o app controle o Wi-Fi"</string>
    <string name="change_wifi_state_app_detail_summary" msgid="8230854855584217111">"Permitir que este app ative ou desative o Wi-Fi, verifique redes Wi-Fi e conecte-se a elas, adicione ou remova redes ou inicie um ponto de acesso somente local."</string>
    <string name="change_nfc_tag_apps_title" msgid="91514009058149617">"Abrir via NFC"</string>
    <string name="change_nfc_tag_apps_detail_switch" msgid="240286205725043561">"Permitir a inicialização após a leitura da etiqueta NFC"</string>
    <string name="change_nfc_tag_apps_detail_summary" msgid="3338220223868942195">"Permitir que este app seja aberto quando a tag NFC for lida.\nSe esta permissão estiver ativada, o app vai ficar disponível como opção sempre que uma tag for detectada."</string>
    <string name="media_output_title" msgid="8283629315159510680">"Tocar mídia"</string>
    <string name="media_output_label_title" msgid="4139048973886819148">"Abrir <xliff:g id="LABEL">%s</xliff:g> no dispositivo abaixo:"</string>
    <string name="media_output_title_without_playing" msgid="3339321669132875821">"O áudio vai tocar"</string>
    <string name="media_output_default_summary" msgid="4200343059396412376">"Neste dispositivo"</string>
    <string name="media_out_summary_ongoing_call_state" msgid="475188726850090363">"Indisponível durante chamadas"</string>
    <string name="take_call_on_title" msgid="1159417893879946757">"Atender chamada"</string>
    <string name="cannot_change_apn_toast" msgid="296540724089240405">"Esse APN não pode ser alterado."</string>
    <string name="gesture_prevent_ringing_screen_title" msgid="8293094715267769349">"Impedir o toque do telefone"</string>
    <string name="gesture_prevent_ringing_title" msgid="5978577898997523581">"Pressione os botões Liga/desliga e Aumentar volume juntos para"</string>
    <string name="gesture_prevent_ringing_sound_title" msgid="4529077822282099235">"Atalho para impedir que o telefone toque"</string>
    <string name="prevent_ringing_option_vibrate" msgid="5456962289649581737">"Vibrar"</string>
    <string name="prevent_ringing_option_mute" msgid="7446121133560945051">"Desativar som"</string>
    <string name="prevent_ringing_option_vibrate_summary" msgid="3435299885425754304">"Vibrar"</string>
    <string name="prevent_ringing_option_mute_summary" msgid="3939350522269337013">"Desativar som"</string>
    <string name="prevent_ringing_option_unavailable_lpp_summary" msgid="8070356204398144241">"Para ativar, mude a opção \"Aperte o botão liga/desliga e o pressione\" para o menu liga/desliga."</string>
    <string name="pref_title_network_details" msgid="7329759534269363308">"Detalhes da rede"</string>
    <string name="devices_title" msgid="649715719278562515">"Dispositivos"</string>
    <string name="choose_network_title" msgid="5355609223363859430">"Escolher rede"</string>
    <string name="network_disconnected" msgid="8281188173486212661">"Desconectado"</string>
    <string name="network_connected" msgid="7637745547242487795">"Conectada"</string>
    <string name="network_connecting" msgid="6856124847029124041">"Conectando…"</string>
    <string name="network_could_not_connect" msgid="676574629319069922">"Não foi possível conectar"</string>
    <string name="empty_networks_list" msgid="6519489879480673428">"Nenhuma rede encontrada."</string>
    <string name="network_query_error" msgid="6406348372070035274">"Não foi possível encontrar redes. Tente novamente."</string>
    <string name="forbidden_network" msgid="7404863971282262991">"(proibida)"</string>
    <string name="sim_card" msgid="6381158752066377709">"Chip"</string>
    <string name="wifi_no_sim_card" msgid="7144290066491585672">"Sem chip"</string>
    <string name="wifi_no_related_sim_card" msgid="3568255415415630510">"Nenhuma"</string>
    <string name="wifi_require_sim_card_to_connect" msgid="1524984445750423666">"Chip necessário para se conectar"</string>
    <string name="wifi_require_specific_sim_card_to_connect" msgid="8136020469861668506">"Chip da <xliff:g id="WIRELESS_CARRIER">%s</xliff:g> necessário para se conectar"</string>
    <string name="preferred_network_mode_wcdma_perf_summary" msgid="230527592752934655">"Modo de rede preferencial: WCDMA"</string>
    <string name="preferred_network_mode_gsm_only_summary" msgid="2936969642076535162">"Modo de rede preferencial: somente GSM"</string>
    <string name="preferred_network_mode_wcdma_only_summary" msgid="632816273979433076">"Modo de rede preferencial: somente WCDMA"</string>
    <string name="preferred_network_mode_gsm_wcdma_summary" msgid="6419309630040697488">"Modo de rede preferencial: GSM / WCDMA"</string>
    <string name="preferred_network_mode_cdma_summary" msgid="5735467143380764681">"Modo de rede preferencial: CDMA"</string>
    <string name="preferred_network_mode_cdma_evdo_summary" msgid="1667358006735235626">"Modo de rede preferencial: CDMA / EvDo"</string>
    <string name="preferred_network_mode_cdma_only_summary" msgid="6305930965673800101">"Modo de rede preferencial: somente CDMA"</string>
    <string name="preferred_network_mode_evdo_only_summary" msgid="613903666107299289">"Modo de rede preferencial: somente EvDO"</string>
    <string name="preferred_network_mode_cdma_evdo_gsm_wcdma_summary" msgid="5643603478619124717">"Modo de rede preferencial: CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_lte_summary" msgid="4236015557975544307">"Modo de rede preferencial: LTE"</string>
    <string name="preferred_network_mode_lte_gsm_wcdma_summary" msgid="1377100995001285751">"Modo de rede preferencial: GSM/WCDMA/LTE"</string>
    <string name="preferred_network_mode_lte_cdma_evdo_summary" msgid="1221806410911793222">"Modo de rede preferencial: CDMA+LTE/EVDO"</string>
    <string name="preferred_network_mode_lte_cdma_evdo_gsm_wcdma_summary" msgid="8974263692041299883">"Modo de rede preferencial: LTE/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_global_summary" msgid="817118763629102239">"Modo de rede preferencial: global"</string>
    <string name="preferred_network_mode_lte_wcdma_summary" msgid="7326137039981934928">"Modo de rede preferencial: LTE / WCDMA"</string>
    <string name="preferred_network_mode_lte_gsm_umts_summary" msgid="5105989927899481131">"Modo de rede preferencial: LTE / GSM / UMTS"</string>
    <string name="preferred_network_mode_lte_cdma_summary" msgid="2364210682008525703">"Modo de rede preferencial: LTE / CDMA"</string>
    <string name="preferred_network_mode_tdscdma_summary" msgid="796303916110624922">"Modo de rede preferencial: TDSCDMA"</string>
    <string name="preferred_network_mode_tdscdma_wcdma_summary" msgid="1465990745594594173">"Modo de rede preferencial: TDSCDMA / WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_summary" msgid="3771917510642642724">"Modo de rede preferencial: LTE / TDSCDMA"</string>
    <string name="preferred_network_mode_tdscdma_gsm_summary" msgid="8906951876805688851">"Modo de rede preferencial: TDSCDMA / GSM"</string>
    <string name="preferred_network_mode_lte_tdscdma_gsm_summary" msgid="2264537129425897267">"Modo de rede preferencial: LTE/GSM/TDSCDMA"</string>
    <string name="preferred_network_mode_tdscdma_gsm_wcdma_summary" msgid="2469046704847661521">"Modo de rede preferencial: TDSCDMA/GSM/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_wcdma_summary" msgid="2276439307637315057">"Modo de rede preferencial: LTE/TDSCDMA/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_gsm_wcdma_summary" msgid="1640309016390119366">"Modo de rede preferencial: LTE/TDSCDMA/GSM/WCDMA"</string>
    <string name="preferred_network_mode_tdscdma_cdma_evdo_gsm_wcdma_summary" msgid="8918066490624875671">"Modo de rede preferencial: TDSCDMA/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_lte_tdscdma_cdma_evdo_gsm_wcdma_summary" msgid="1059705864131001171">"Modo de rede preferencial: LTE/TDSCDMA/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_nr_only_summary" msgid="9153575102136218656">"Modo de rede preferencial: somente NR"</string>
    <string name="preferred_network_mode_nr_lte_summary" msgid="4326679533556458480">"Modo de rede preferencial: NR / LTE"</string>
    <string name="preferred_network_mode_nr_lte_cdma_evdo_summary" msgid="4030662583832600005">"Modo de rede preferencial: NR/LTE/CDMA/EvDo"</string>
    <string name="preferred_network_mode_nr_lte_gsm_wcdma_summary" msgid="8327982533965785835">"Modo de rede preferencial: NR/LTE/GSM/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_cdma_evdo_gsm_wcdma_summary" msgid="7892233480076496041">"Modo de rede preferencial: NR/LTE/CDMA/EvDo/GSM/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_wcdma_summary" msgid="5762334298562095421">"Modo de rede preferencial: NR/LTE/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_summary" msgid="2356681171665091175">"Modo de rede preferencial: NR/LTE/TDSCDMA"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_gsm_summary" msgid="8889597344872814893">"Modo de rede preferencial: NR/LTE/TDSCDMA/GSM"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_wcdma_summary" msgid="506057560516483258">"Modo de rede preferencial: NR/LTE/TDSCDMA/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_gsm_wcdma_summary" msgid="4337061745216872524">"Modo de rede preferencial: NR/LTE/TDSCDMA/GSM/WCDMA"</string>
    <string name="preferred_network_mode_nr_lte_tdscdma_cdma_evdo_gsm_wcdma_summary" msgid="3396717432149544381">"Modo de rede preferencial: 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">"Selecionar a rede automaticamente"</string>
    <string name="carrier_settings_title" msgid="6959295328730560529">"Config. da operadora"</string>
    <string name="cdma_lte_data_service" msgid="6937443423651347345">"Configurar serviço de dados"</string>
    <string name="mobile_data_settings_title" msgid="3927524078598009792">"Dados móveis"</string>
    <string name="mobile_data_settings_summary" msgid="7323978798199919063">"Acessar os dados pela rede móvel"</string>
    <string name="mobile_data_settings_summary_auto_switch" msgid="7851549787645698945">"O smartphone mudará automaticamente para esta operadora quando estiver dentro do alcance"</string>
    <string name="mobile_data_settings_summary_unavailable" msgid="9176513507571883986">"Não há chips disponíveis"</string>
    <string name="calls_preference" msgid="2166481296066890129">"Preferência de chamadas"</string>
    <string name="sms_preference" msgid="7742964962568219351">"Preferência de SMS"</string>
    <string name="calls_and_sms_ask_every_time" msgid="3178743088737726677">"Perguntar sempre"</string>
    <string name="mobile_network_summary_add_a_network" msgid="9079866102827526779">"Adicionar uma rede"</string>
    <string name="default_for_calls" msgid="2788950217176988034">"Padrão para chamadas"</string>
    <string name="default_for_sms" msgid="1316988329407434771">"Padrão para SMS"</string>
    <string name="default_for_calls_and_sms" msgid="8223971369339958151">"Padrão para chamadas e SMS"</string>
    <string name="default_for_mobile_data" msgid="3725773640392315626">"Padrão para dados móveis"</string>
    <string name="mobile_data_active" msgid="8683694456401350210">"Dados móveis ativados"</string>
    <string name="mobile_data_off" msgid="2702029611959308269">"Dados móveis desativados"</string>
    <string name="subscription_available" msgid="2659722770210403365">"Disponível"</string>
    <string name="mobile_network_list_add_more" msgid="5076722903436552813">"Adicionar chip"</string>
    <string name="mobile_network_active_sim" msgid="6397581267971410039">"Ativo/chip"</string>
    <string name="mobile_network_inactive_sim" msgid="5829757490580409899">"Inativo/chip"</string>
    <string name="mobile_network_active_esim" msgid="3984452275968408382">"Ativo / eSIM"</string>
    <string name="mobile_network_inactive_esim" msgid="8777415108263057939">"Inativo / eSIM"</string>
    <string name="mobile_network_sim_name" msgid="3187192894150386537">"Nome e cor do chip"</string>
    <string name="mobile_network_sim_name_label" msgid="1452440641628369625">"Nome"</string>
    <string name="mobile_network_sim_color_label" msgid="5293944087609632340">"Cor (usada por apps compatíveis)"</string>
    <string name="mobile_network_sim_name_rename" msgid="5967588549571582924">"Salvar"</string>
    <string name="mobile_network_use_sim_on" msgid="5333182776279917886">"Usar este chip"</string>
    <string name="mobile_network_use_sim_off" msgid="6303281166199670639">"Desativado"</string>
    <string name="mobile_network_disable_sim_explanation" msgid="7182341033728911879">"Para desativar este chip, ele deve ser removido"</string>
    <string name="mobile_network_tap_to_activate" msgid="5280456487243915465">"Toque para ativar seu chip da operadora <xliff:g id="CARRIER">%1$s</xliff:g>"</string>
    <string name="mobile_network_erase_sim" msgid="5387971155494245850">"Limpar eSIM"</string>
    <string name="preferred_network_mode_title" msgid="3083431168988535628">"Tipo de rede preferencial"</string>
    <string name="preferred_network_mode_summary" msgid="537577807865497546">"Alterar o modo de operação de rede"</string>
    <string name="preferred_network_mode_dialogtitle" msgid="4179420486180351631">"Tipo de rede preferencial"</string>
    <string name="carrier_settings_version" msgid="3364919669057317776">"Versão das configurações da operadora"</string>
    <string name="call_category" msgid="641461844504128789">"Chamadas"</string>
    <string name="video_calling_settings_title" msgid="5490466306783552190">"Videochamadas pela operadora"</string>
    <string name="cdma_system_select_title" msgid="8261408056382123386">"Seleção de sistema"</string>
    <string name="cdma_system_select_summary" msgid="384128007068464145">"Alterar o modo de roaming CDMA"</string>
    <string name="cdma_system_select_dialogtitle" msgid="6143586810486936984">"Seleção de sistema"</string>
    <string name="network_operator_category" msgid="5309383730335681395">"Rede"</string>
    <string name="cdma_subscription_title" msgid="3107207913315872336">"Inscrição CDMA"</string>
    <string name="cdma_subscription_summary" msgid="7134032708555561334">"Alterar entre R-UIM/SIM e NV"</string>
    <string name="cdma_subscription_dialogtitle" msgid="555971296756231647">"inscrição"</string>
    <string name="register_automatically" msgid="5208258089316657167">"Registro automático…"</string>
    <string name="roaming_alert_title" msgid="9052791521868787985">"Permitir roaming de dados?"</string>
    <string name="roaming_check_price_warning" msgid="5876977438036791361">"Consulte os preços com seu provedor de rede."</string>
    <string name="mobile_network_mode_error" msgid="9222056129897416074">"Modo de rede <xliff:g id="NETWORKMODEID">%1$d</xliff:g> inválido. Ignorar."</string>
    <string name="satellite_setting_title" msgid="2543034229989047673">"Mensagem via satélite"</string>
    <string name="satellite_setting_enabled_summary" msgid="3554127722727530845">"Enviar e receber mensagens de texto via satélite. Incluído na sua conta."</string>
    <string name="satellite_setting_disabled_summary" msgid="6789122487534159857">"Enviar e receber mensagens de texto via satélite. Não incluído na sua conta."</string>
    <string name="keywords_satellite_setting" msgid="3312183289776517695">"Mensagem via satélite"</string>
    <string name="category_name_about_satellite_messaging" msgid="3756205049485508340">"Sobre mensagens via satélite"</string>
    <string name="title_about_satellite_setting" msgid="9212860038048311345">"É possível enviar e receber mensagens de texto via satélite como parte de uma conta qualificada da operadora <xliff:g id="CARRIER_NAME">%1$s</xliff:g>"</string>
    <string name="category_title_your_satellite_plan" msgid="3017895097366691841">"Seu plano da operadora <xliff:g id="CARRIER_NAME">%1$s</xliff:g>"</string>
    <string name="title_have_satellite_plan" msgid="2048372355699977947">"Mensagens via satélite estão incluídas na sua conta"</string>
    <string name="title_no_satellite_plan" msgid="2876056203035197505">"Mensagens via satélite não estão incluídas na sua conta"</string>
    <string name="summary_add_satellite_setting" msgid="3815254731634052432">"Adicionar mensagens via satélite"</string>
    <string name="category_name_how_it_works" msgid="585303230539269496">"Como funciona"</string>
    <string name="title_satellite_connection_guide" msgid="3294802307913609072">"Quando uma rede móvel não estiver disponível"</string>
    <string name="summary_satellite_connection_guide" msgid="3496123195218418456">"Seu smartphone vai se conectar automaticamente a um satélite. Para conseguir a melhor conexão, vá até um local com céu aberto."</string>
    <string name="title_supported_service" msgid="4275535165812691571">"Depois que o smartphone se conectar a um satélite"</string>
    <string name="summary_supported_service" msgid="4320535903444834786">"É possível enviar mensagens de texto para qualquer pessoa, inclusive para serviços de emergência. O smartphone vai se reconectar a uma rede móvel quando estiver disponível."</string>
    <string name="satellite_setting_summary_more_information" msgid="4008690241760925372">"As mensagens via satélite podem demorar mais e estão disponíveis apenas em algumas áreas. O clima e certas estruturas podem afetar sua conexão via satélite. Chamadas via satélite não estão disponíveis.\n\nPode levar algum tempo para que as mudanças na sua conta apareçam nas Configurações. Entre em contato com a <xliff:g id="CARRIER_NAME">%1$s</xliff:g> para mais detalhes."</string>
    <string name="more_about_satellite_messaging" msgid="3385673133561348509">"Mais informações sobre mensagens via satélite"</string>
    <string name="mobile_network_apn_title" msgid="5582995550142073054">"Nomes dos pontos de acesso"</string>
    <string name="keywords_access_point_names" msgid="8174967126858505945">"apn"</string>
    <string name="manual_mode_disallowed_summary" msgid="4243142645520152175">"Indisponível quando conectado à <xliff:g id="CARRIER">%1$s</xliff:g>"</string>
    <string name="see_more" msgid="7499355691042812723">"Ver mais"</string>
    <string name="sim_action_enable_sub_dialog_title" msgid="4003377033815971802">"Ativar <xliff:g id="CARRIER_NAME">%1$s</xliff:g>?"</string>
    <string name="sim_action_enable_sub_dialog_title_without_carrier_name" msgid="4842051610633654278">"Ativar o chip?"</string>
    <string name="sim_action_switch_sub_dialog_title" msgid="9180969453358718635">"Mudar para a <xliff:g id="CARRIER_NAME">%1$s</xliff:g>?"</string>
    <string name="sim_action_switch_psim_dialog_title" msgid="5613177333235213024">"Começar a usar o chip?"</string>
    <string name="sim_action_switch_sub_dialog_mep_title" msgid="933856847099933004">"Usar <xliff:g id="CARRIER_NAME">%1$s</xliff:g>?"</string>
    <string name="sim_action_switch_sub_dialog_text" msgid="7474905814976249607">"Somente 1 chip pode ficar ativo por vez.\n\nMudar para a operadora <xliff:g id="TO_CARRIER_NAME">%1$s</xliff:g> não cancela o serviço da <xliff:g id="FROM_CARRIER_NAME">%2$s</xliff:g>."</string>
    <string name="sim_action_switch_sub_dialog_text_downloaded" msgid="6415848271400253954">"Apenas um eSIM pode ficar ativo por vez.\n\nMudar para a operadora <xliff:g id="TO_CARRIER_NAME">%1$s</xliff:g> não cancela o serviço da <xliff:g id="FROM_CARRIER_NAME">%2$s</xliff:g>."</string>
    <string name="sim_action_switch_sub_dialog_text_single_sim" msgid="421658355882679837">"Apenas 1 chip pode ficar ativo por vez.\n\nMudar o chip não cancela o serviço da operadora <xliff:g id="TO_CARRIER_NAME">%1$s</xliff:g>."</string>
    <string name="sim_action_switch_sub_dialog_mep_text" msgid="8348764755143679582">"Você pode usar dois chips ao mesmo tempo. Para usar a operadora <xliff:g id="CARRIER_NAME">%1$s</xliff:g>, desative o outro chip."</string>
    <string name="sim_action_switch_sub_dialog_confirm" msgid="1901181581944638961">"Mudar para <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">"Desativar chip da operadora <xliff:g id="CARRIER_NAME">%1$s</xliff:g>"</string>
    <string name="sim_action_switch_sub_dialog_info_outline_for_turning_off" msgid="1617619100229136888">"A desativação de um chip não cancela o serviço"</string>
    <string name="sim_action_enabling_sim_without_carrier_name" msgid="8144175623622669136">"Ativando chip…"</string>
    <string name="sim_action_switch_sub_dialog_progress" msgid="697127154780501304">"Mudando para a operadora <xliff:g id="CARRIER_NAME">%1$s</xliff:g>…"</string>
    <string name="sim_action_enable_sim_fail_title" msgid="2718084141744769701">"Não é possível trocar de chip"</string>
    <string name="sim_action_enable_sim_fail_text" msgid="8332742656111984482">"Algo deu errado. Não é possível trocar de chip."</string>
    <string name="privileged_action_disable_sub_dialog_title" msgid="3298942357601334418">"Desativar <xliff:g id="CARRIER_NAME">%1$s</xliff:g>?"</string>
    <string name="privileged_action_disable_sub_dialog_title_without_carrier" msgid="6518373229436331608">"Desativar chip?"</string>
    <string name="privileged_action_disable_sub_dialog_progress" msgid="5900243067681478102">"Desativando o chip<xliff:g id="ELLIPSIS">…</xliff:g>"</string>
    <string name="privileged_action_disable_fail_title" msgid="1808735136395980905">"Não é possível desativar o chip"</string>
    <string name="privileged_action_disable_fail_text" msgid="6236231745255527458">"Algo deu errado e seu chip não foi desativado."</string>
    <string name="sim_action_enable_dsds_title" msgid="226508711751577169">"Usar dois chips?"</string>
    <string name="sim_action_enable_dsds_text" msgid="970986559326263949">"Este dispositivo pode ter dois chips ativos ao mesmo tempo. Para continuar usando um chip por vez, toque em \"Agora não\"."</string>
    <string name="sim_action_restart_title" msgid="7054617569121993825">"Reiniciar dispositivo?"</string>
    <string name="sim_action_yes" msgid="8076556020131395515">"Sim"</string>
    <string name="sim_action_reboot" msgid="3508948833333441538">"Reiniciar"</string>
    <string name="sim_action_no_thanks" msgid="435717748384544195">"Agora não"</string>
    <string name="sim_action_cancel" msgid="2668099867029610910">"Cancelar"</string>
    <string name="sim_switch_button" msgid="1405772571706095387">"Mudar"</string>
    <string name="sim_action_turn_off" msgid="3506698692916473000">"Desativar"</string>
    <string name="dsds_activation_failure_title" msgid="4467364110584914794">"Não foi possível ativar o chip"</string>
    <string name="dsds_activation_failure_body_msg2" msgid="73044349546544410">"Tente ativar o chip novamente. Se o problema continuar, reinicie o dispositivo."</string>
    <string name="sim_onboarding_bottomsheets_title" msgid="143711121394213711">"Configure seu chip"</string>
    <string name="sim_onboarding_bottomsheets_msg" msgid="7367245016476460849">"Defina suas preferências de rede móvel para usar vários chips neste dispositivo"</string>
    <string name="sim_onboarding_label_sim_title" msgid="273162565849288273">"Rotule seus chips"</string>
    <string name="sim_onboarding_label_sim_msg" msgid="5105859235219529056">"Esses rótulos vão aparecer ao fazer ligações, enviar mensagens de texto e usar dados, além de aparecerem nas Configurações"</string>
    <string name="sim_onboarding_label_sim_dialog_title" msgid="5839073125605286120">"Rótulo do chip"</string>
    <string name="sim_onboarding_label_sim_dialog_label" msgid="9020433985426525185">"Rótulo"</string>
    <string name="sim_onboarding_select_sim_title" msgid="5895262188167744055">"Selecione quais chips usar"</string>
    <string name="sim_onboarding_select_sim_msg" msgid="5638859405391915048">"Você pode usar dois chips ao mesmo tempo"</string>
    <string name="sim_onboarding_primary_sim_title" msgid="2793090401371135675">"Defina seus chips principais"</string>
    <string name="sim_onboarding_primary_sim_msg" msgid="5484656671490558032">"Escolha quais chips usar por padrão para fazer ligações, enviar mensagens de texto e usar dados"</string>
    <string name="primary_sim_title" msgid="2508161011657571566">"Seus principais chips"</string>
    <string name="primary_sim_calls_title" msgid="4961189133582615685">"Ligações"</string>
    <string name="primary_sim_texts_title" msgid="1287584042733097749">"Mensagens de texto"</string>
    <string name="primary_sim_automatic_data_title" msgid="1265528923229642480">"Troca de dados automática"</string>
    <string name="primary_sim_automatic_data_msg" msgid="1612203837010785203">"Usar dados de qualquer chip dependendo da cobertura e disponibilidade"</string>
    <string name="sim_onboarding_phoneNumber_data_only" msgid="8158409121949373662">"Somente dados"</string>
    <string name="sim_onboarding_setup" msgid="5750393553605388463">"Configurar"</string>
    <string name="sim_onboarding_next" msgid="6415025179929475355">"Próxima"</string>
    <string name="sim_onboarding_progressbar_turning_sim_on" msgid="1163318788393361574">"Ativando <xliff:g id="CARRIER_NAME">%1$s</xliff:g>…"</string>
    <string name="mobile_network_spn_title" msgid="3053793174495329077">"Rede móvel"</string>
    <string name="mobile_network_phone_number_title" msgid="2090794402855021784">"Número de telefone"</string>
    <string name="mobile_network_sim_label_color_title" msgid="2401352348041132876">"Rótulo e cor do chip"</string>
    <string name="sim_setup_channel_id" msgid="8797972565087458515">"Ativação de rede"</string>
    <string name="sim_switch_channel_id" msgid="4927038626791837861">"Mudança de operadora"</string>
    <string name="post_dsds_reboot_notification_title_with_carrier" msgid="975447139749692794">"Seu chip da operadora <xliff:g id="CARRIER_NAME">%1$s</xliff:g> está ativo"</string>
    <string name="post_dsds_reboot_notification_text" msgid="7533428378211541410">"Toque para atualizar as configurações do chip"</string>
    <string name="switch_to_removable_notification" msgid="7640342063449806296">"Mudou para <xliff:g id="CARRIER_NAME">%1$s</xliff:g>"</string>
    <string name="switch_to_removable_notification_no_carrier_name" msgid="7384856964036215338">"Mudou para outra operadora"</string>
    <string name="network_changed_notification_text" msgid="2407908598496951243">"Sua rede móvel foi alterada"</string>
    <string name="dsds_notification_after_suw_title" msgid="3738898232310273982">"Configurar outro chip"</string>
    <string name="dsds_notification_after_suw_text" msgid="1287357774676361084">"Selecione seu chip ativo ou use dois chips ao mesmo tempo"</string>
    <string name="choose_sim_title" msgid="66509047151583877">"Escolha um chip para usar"</string>
    <string name="choose_sim_text" msgid="8992163497852069924">"{count,plural, =1{Há 1 chip disponível neste dispositivo. É possível usar apenas um por vez}=2{Há 2 chips disponíveis neste dispositivo, mas é possível usar apenas um por vez}one{Há # chip disponível neste dispositivo. É possível usar apenas um por vez}other{Há # chips disponíveis neste dispositivo, mas é possível usar apenas um por vez}}"</string>
    <string name="choose_sim_activating" msgid="6485547671356386998">"Ativando<xliff:g id="ELLIPSIS">…</xliff:g>"</string>
    <string name="choose_sim_could_not_activate" msgid="866488735834045525">"Não foi possível ativar o chip no momento"</string>
    <string name="switch_sim_dialog_title" msgid="5407316878973237773">"Usar <xliff:g id="CARRIER_NAME">%1$s</xliff:g>?"</string>
    <string name="switch_sim_dialog_text" msgid="7530186862171635464">"A operadora <xliff:g id="CARRIER_NAME">%1$s</xliff:g> será usada para dados móveis, chamadas e SMS."</string>
    <string name="switch_sim_dialog_no_switch_title" msgid="809763410787744247">"Nenhum chip ativo disponível"</string>
    <string name="switch_sim_dialog_no_switch_text" msgid="7053939850026876088">"Para usar dados móveis, recursos de chamada e SMS mais tarde, acesse as configurações de rede"</string>
    <string name="sim_card_label" msgid="6263064316075963775">"Chip"</string>
    <string name="erase_sim_dialog_title" msgid="4742077437653028326">"Você quer mesmo apagar este eSIM?"</string>
    <string name="erase_sim_dialog_text" msgid="1406141218170595272">"Essa ação remove o serviço da operadora <xliff:g id="CARRIER_NAME_A">%1$s</xliff:g> deste dispositivo, mas o plano da <xliff:g id="CARRIER_NAME_B">%1$s</xliff:g> não será cancelado."</string>
    <string name="erase_sim_confirm_button" msgid="8309115684335320541">"Limpar"</string>
    <string name="erasing_sim" msgid="4237180547590463930">"Apagando o eSIM…"</string>
    <string name="erase_sim_fail_title" msgid="1445700500168357303">"Não foi possível apagar o eSIM"</string>
    <string name="erase_sim_fail_text" msgid="6898841004987411547">"Ocorreu um erro e este eSIM não foi apagado.\n\nReinicie o dispositivo e tente de novo."</string>
    <string name="wifi_warning_dialog_title" msgid="7328515476966592390">"Conecte ao Wi‑Fi antes de apagar"</string>
    <string name="wifi_warning_dialog_text" msgid="6584060137703953174">"Isso facilita usar o eSIM de novo no futuro, sem a necessidade de entrar em contato com a operadora"</string>
    <string name="wifi_warning_continue_button" msgid="8171574741789688214">"Apagar mesmo assim"</string>
    <string name="wifi_warning_return_button" msgid="6226063181583906340">"OK"</string>
    <string name="network_connection_request_dialog_title" msgid="1896186380874289434">"Conectar ao dispositivo"</string>
    <string name="network_connection_request_dialog_summary" msgid="7693038309792726170">"O app <xliff:g id="APPNAME">%1$s</xliff:g> quer usar uma rede Wi-Fi temporária para se conectar ao seu dispositivo"</string>
    <string name="network_connection_timeout_dialog_message" msgid="598509083077743772">"Nenhum dispositivo foi encontrado. Os dispositivos precisam estar ligados e disponíveis para conexão."</string>
    <string name="network_connection_timeout_dialog_ok" msgid="6022675321823723755">"Tentar novamente"</string>
    <string name="network_connection_errorstate_dialog_message" msgid="3360714322047603239">"Algo deu errado. O aplicativo cancelou a solicitação para selecionar um dispositivo."</string>
    <string name="network_connection_connect_successful" msgid="2587314077675642476">"Conexão realizada"</string>
    <string name="network_connection_connect_failure" msgid="6803313816657494319">"Falha na conexão"</string>
    <string name="network_connection_request_dialog_showall" msgid="6392059758456994944">"Mostrar tudo"</string>
    <string name="network_connection_searching_message" msgid="8521819623516926482">"Procurando dispositivo…"</string>
    <string name="network_connection_connecting_message" msgid="433189540877274889">"Conectando ao dispositivo…"</string>
    <string name="bluetooth_left_name" msgid="7440064067910080502">"Esquerdo"</string>
    <string name="bluetooth_right_name" msgid="7588088072444124949">"Direito"</string>
    <string name="bluetooth_middle_name" msgid="3909371955137442319">"Estojo"</string>
    <string name="settings_panel_title" msgid="346363079938069215">"Painel de configurações"</string>
    <string name="force_desktop_mode" msgid="1336913605091334238">"Forçar modo de área de trabalho"</string>
    <string name="force_desktop_mode_summary" msgid="4587416867846930479">"Forçar o modo de área de trabalho experimental em telas secundárias"</string>
    <string name="enable_non_resizable_multi_window" msgid="6832903754625404477">"Ativar recursos não redimensionáveis em várias janelas"</string>
    <string name="enable_non_resizable_multi_window_summary" msgid="3275763753261901999">"Permitir que apps não redimensionáveis sejam usados em várias janelas"</string>
    <string name="hwui_force_dark_title" msgid="4256904905631994219">"Manter o recurso Forçar modo escuro ativado"</string>
    <string name="hwui_force_dark_summary" msgid="6515748781487952769">"Fazer com que o recurso Forçar modo escuro fique sempre ativado"</string>
    <string name="privacy_dashboard_title" msgid="6845403825611829558">"Privacidade"</string>
    <string name="privacy_dashboard_summary" msgid="5775090172422786808">"Permissões, atividade da conta, dados pessoais"</string>
    <string name="privacy_controls_title" msgid="1383047169455206604">"Controles"</string>
    <string name="contextual_card_dismiss_remove" msgid="8636557343011606722">"Remover"</string>
    <string name="contextual_card_dismiss_keep" msgid="440516181066490747">"Manter"</string>
    <string name="contextual_card_dismiss_confirm_message" msgid="6434344989238055188">"Remover esta sugestão?"</string>
    <string name="low_storage_summary" msgid="1979492757417779718">"Pouco espaço de armazenamento. <xliff:g id="PERCENTAGE">%1$s</xliff:g> usado(s) e <xliff:g id="FREE_SPACE">%2$s</xliff:g> livre(s)"</string>
    <string name="contextual_card_feedback_send" msgid="7409408664417908922">"Enviar feedback"</string>
    <string name="contextual_card_feedback_confirm_message" msgid="3186334562157665381">"Quer enviar um feedback para nós sobre essa sugestão?"</string>
    <string name="copyable_slice_toast" msgid="1008251852798990606">"<xliff:g id="COPY_CONTENT">%1$s</xliff:g> copiado para a área de transferência."</string>
    <string name="search_bar_account_avatar_content_description" msgid="880523277036898350"></string>
    <string name="accessibility_usage_title" msgid="9190967143518779145">"Uso de acessibilidade"</string>
    <string name="accessibility_usage_summary" msgid="4348285359995227813">"{count,plural, =1{1 app com acesso total ao seu dispositivo}one{# app com acesso total ao seu dispositivo}other{# apps com acesso total ao seu dispositivo}}"</string>
    <string name="wfc_disclaimer_title_text" msgid="4617195934203523503">"Informações importantes"</string>
    <string name="wfc_disclaimer_agree_button_text" msgid="4082872292910770344">"CONTINUAR"</string>
    <string name="wfc_disclaimer_disagree_text" msgid="8424457394700137703">"NÃO"</string>
    <string name="wfc_disclaimer_location_title_text" msgid="7913919887475418423">"Localização"</string>
    <string name="wfc_disclaimer_location_desc_text" msgid="1417004513415772582">"A operadora poderá coletar sua localização quando você usar o serviço para fazer chamadas de emergência.\n\nAcesse a Política de Privacidade da operadora para ver mais detalhes."</string>
    <string name="forget_passpoint_dialog_message" msgid="2433875063907365760">"Você pode perder o acesso a qualquer tempo ou dado restante. Verifique essa informação com o provedor antes de remover."</string>
    <string name="content_capture" msgid="868372905432812238">"Conteúdo do app"</string>
    <string name="content_capture_summary" msgid="49720773699715531">"Permite que apps enviem conteúdo ao sistema Android"</string>
    <string name="capture_system_heap_dump_title" msgid="9210974110606886455">"Capturar heap dump do sistema"</string>
    <string name="development_memtag_page_title" msgid="3546667618748029188">"Memory Tagging Extension"</string>
    <string name="development_memtag_intro" msgid="8032596625527637164">"A Memory Tagging Extension (MTE) ajuda a detectar problemas de segurança com a memória no seu app e deixa o código nativo mais seguro."</string>
    <string name="development_memtag_footer" msgid="5681925148773626562">"Ativar a MTE pode deixar o dispositivo mais lento."</string>
    <string name="development_memtag_learn_more" msgid="8961984806973926704">"Saiba mais sobre a MTE"</string>
    <string name="development_memtag_toggle" msgid="2474420239518386894">"MTE ativada até você desativar"</string>
    <string name="development_memtag_reboot_message_on" msgid="8100075676107327847">"É necessário reiniciar o dispositivo para ativar a MTE."</string>
    <string name="development_memtag_reboot_message_off" msgid="3703925647922079456">"É necessário reiniciar o dispositivo para desativar a MTE."</string>
    <string name="reboot_with_mte_title" msgid="2320125810211279">"Ativar a MTE por uma única sessão"</string>
    <string name="reboot_with_mte_message" msgid="1232881567956207641">"O sistema será reiniciado e vai permitir experimentos com a Memory Tagging Extension (MTE). Isso pode ter um impacto negativo no desempenho e na estabilidade. A redefinição será feita na próxima reinicialização."</string>
    <string name="reboot_with_mte_summary" msgid="3896537791216432882">"Reiniciar para uma única sessão com a MTE ativada"</string>
    <string name="reboot_with_mte_already_enabled" msgid="4439168867613407167">"A MTE já foi ativada"</string>
    <string name="capturing_system_heap_dump_message" msgid="8410503247477360622">"Capturando despejo de heap do sistema"</string>
    <string name="error_capturing_system_heap_dump_message" msgid="2352983250048200052">"Não foi possível capturar o despejo de heap do sistema"</string>
    <string name="automatic_system_heap_dump_title" msgid="4093306504711109479">"Capturar automaticamente despejos de heap do sistema"</string>
    <string name="automatic_system_heap_dump_summary" msgid="4060846186592886986">"Capturar automaticamente um despejo de heap para o sistema Android quando ele usar muita memória"</string>
    <string name="wifi_disconnect_button_text" msgid="5698154296678571998">"Desconectar"</string>
    <string name="wfc_disclaimer_emergency_limitation_title_text" msgid="8276287227589397162">"Chamadas de emergência"</string>
    <string name="wfc_disclaimer_emergency_limitation_desc_text" msgid="5503902001191552196">"As chamadas de emergência feitas com o recurso \"Chamada no Wi-Fi\" não são compatíveis com sua operadora.\nO dispositivo alterna automaticamente para uma rede celular para fazer uma chamada de emergência.\nAs chamadas de emergência são possíveis apenas em áreas com cobertura de celular."</string>
    <string name="wifi_calling_summary" msgid="8566648389959032967">"Usar Wi-Fi nas chamadas para melhorar a qualidade"</string>
    <string name="enable_receiving_mms_notification_title" msgid="6465218559386990248">"Mensagem MMS recebida"</string>
    <string name="enable_sending_mms_notification_title" msgid="7120641300854953375">"Não é possível enviar mensagens MMS"</string>
    <string name="enable_mms_notification_summary" msgid="6432752438276672500">"Toque para permitir mensagens MMS pela <xliff:g id="OPERATOR_NAME">%1$s</xliff:g> quando os dados móveis estiverem desativados"</string>
    <string name="enable_mms_notification_channel_title" msgid="1798206332620642108">"Mensagem MMS"</string>
    <string name="sim_combination_warning_notification_title" msgid="1365401631492986487">"Problema com a combinação de chips"</string>
    <string name="dual_cdma_sim_warning_notification_summary" msgid="2826474790710586487">"Usar a <xliff:g id="OPERATOR_NAMES">%1$s</xliff:g> pode limitar a funcionalidade. Toque para saber mais."</string>
    <string name="dual_cdma_sim_warning_notification_channel_title" msgid="1049161096896074364">"Combinação de chips"</string>
    <string name="work_policy_privacy_settings" msgid="2702644843505242596">"Informações sobre sua política de trabalho"</string>
    <string name="work_policy_privacy_settings_summary" msgid="690118670737638405">"Configurações gerenciadas pelo administrador de TI"</string>
    <string name="track_frame_time_keywords" msgid="7885340257945922239">"GPU"</string>
    <string name="enable_16k_pages" msgid="5009476566957520607">"Inicializar com páginas de 16K"</string>
    <string name="enable_16k_pages_summary" msgid="428117226069445198">"Inicializar dispositivo usando o kernel com suporte a páginas de 16K"</string>
    <string name="confirm_enable_16k_pages_title" msgid="6751570067857011642">"Reiniciar com kernel compatível com páginas de 16 KB?"</string>
    <string name="confirm_enable_16k_pages_text" msgid="702888115148257215">"AVISO: alguns aplicativos podem não ser compatíveis com esse modo. O dispositivo será reiniciado após a confirmação."</string>
    <string name="confirm_enable_4k_pages_title" msgid="626987400420355263">"Reiniciar com kernel compatível com páginas de 4 KB?"</string>
    <string name="confirm_enable_4k_pages_text" msgid="6168921566226074524">"O dispositivo será reiniciado após a confirmação."</string>
    <string name="toast_16k_update_failed_text" msgid="8888858987184345567">"Falha ao atualizar para um kernel compatível com páginas de 16 KB."</string>
    <string name="progress_16k_ota_title" msgid="2117218313875523741">"Aplicando mudança"</string>
    <string name="bug_report_handler_title" msgid="713439959113250125">"Gerenciador de relatórios de bugs"</string>
    <string name="bug_report_handler_picker_footer_text" msgid="4935758328366585673">"Determina qual app gerencia o atalho para o Relatório de bug no dispositivo."</string>
    <string name="personal_profile_app_subtext" msgid="5586060806997067676">"Pessoais"</string>
    <string name="work_profile_app_subtext" msgid="5043419461440127879">"Trabalho"</string>
    <string name="system_default_app_subtext" msgid="5212055189703164839">"Padrão do sistema"</string>
    <string name="default_app_none" msgid="5420632042222036264">"Nenhum"</string>
    <string name="select_invalid_bug_report_handler_toast_text" msgid="8857326334015386692">"Essa opção não é mais válida. Tente novamente."</string>
    <string name="power_menu_setting_name" msgid="2394440932633137229">"Tocar e pressionar o botão liga/desliga"</string>
    <string name="power_menu_long_press_category_title" msgid="1051146091093775002">"Toque e pressione o botão liga/desliga para acessar"</string>
    <string name="power_menu_long_press_for_power_menu_title" msgid="477584639843663599">"Menu liga/desliga"</string>
    <string name="power_menu_long_press_for_assistant_title" msgid="6557738348262616455">"Assistente digital"</string>
    <string name="power_menu_summary_long_press_for_assistant" msgid="32706459458422952">"Acessar o assistente digital"</string>
    <string name="power_menu_summary_long_press_for_power_menu" msgid="7617247135239683710">"Acessar o menu liga/desliga"</string>
    <string name="lockscreen_privacy_not_secure" msgid="3251276389681975912">"Para usar, primeiro defina um bloqueio de tela"</string>
    <string name="power_menu_power_volume_up_hint" msgid="5619917593676125759">"Menu liga/desliga:\nAperte os botões liga/desliga e de aumentar volume ao mesmo tempo"</string>
    <string name="power_menu_power_prevent_ringing_hint" msgid="1169955014711158873">"Impedir o toque do telefone:\nAperte o botão de volume para usar o atalho"</string>
    <string name="power_menu_long_press_for_assist_sensitivity_title" msgid="1626808509158422185">"Duração do pressionamento"</string>
    <string name="power_menu_long_press_for_assist_sensitivity_summary" msgid="7550610071666801935">"Ajuste a sensibilidade escolhendo por quanto tempo manter o botão liga/desliga pressionado"</string>
    <string name="power_menu_long_press_for_assist_sensitivity_low_label" msgid="3430099983480845635">"Curto"</string>
    <string name="power_menu_long_press_for_assist_sensitivity_high_label" msgid="2059686170350829156">"Longo"</string>
    <string name="lockscreen_privacy_wallet_setting_toggle" msgid="4188327143734192000">"Mostrar carteira"</string>
    <string name="lockscreen_privacy_wallet_summary" msgid="3984851951621168573">"Permite acessar a carteira na tela de bloqueio"</string>
    <string name="lockscreen_privacy_qr_code_scanner_setting_toggle" msgid="1856477548806618829">"Mostrar leitor de QR code"</string>
    <string name="lockscreen_privacy_qr_code_scanner_summary" msgid="4577409244972250235">"Permitir acesso ao leitor de QR code na tela de bloqueio"</string>
    <string name="lockscreen_privacy_controls_setting_toggle" msgid="7445725343949588613">"Mostrar controles do dispositivo"</string>
    <string name="lockscreen_privacy_controls_summary" msgid="7522918441738915364">"Na tela de bloqueio"</string>
    <string name="lockscreen_trivial_controls_setting_toggle" msgid="2174300719855112358">"Usar os controles do dispositivo"</string>
    <string name="lockscreen_trivial_disabled_controls_summary" msgid="7593626010580689155">"Para usar, ative a opção \"Mostrar controles do dispositivo\""</string>
    <string name="lockscreen_double_line_clock_summary" msgid="4109235686687860393">"O tamanho do relógio muda de acordo com o conteúdo na tela de bloqueio"</string>
    <string name="lockscreen_double_line_clock_setting_toggle" msgid="802271087416091548">"Relógio dinâmico"</string>
    <string name="lockscreen_quick_affordances_title" msgid="8615741551327565793">"Atalhos"</string>
    <plurals name="lockscreen_quick_affordances_summary" formatted="false" msgid="4225396036524703997">
      <item quantity="one"><xliff:g id="FIRST_1">%1$s</xliff:g>, <xliff:g id="SECOND">%2$s</xliff:g></item>
      <item quantity="other"><xliff:g id="FIRST_1">%1$s</xliff:g>, <xliff:g id="SECOND">%2$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">"Desativar VoLTE?"</string>
    <string name="volte_5G_limited_text" msgid="7150583768725182345">"Isso também desativa sua conexão 5G.\nDurante uma ligação, não é possível usar a Internet, e alguns apps podem não funcionar."</string>
    <string name="cached_apps_freezer" msgid="1057519579761550350">"Suspender execução para apps em cache"</string>
    <string name="blob_never_expires_text" msgid="7293376386620106623">"Nunca expira."</string>
    <string name="accessor_never_expires_text" msgid="4647624492147788340">"O lease nunca expira."</string>
    <string name="overlay_settings_title" msgid="1032863083496396365">"Permitir sobreposições de tela no app Configurações"</string>
    <string name="overlay_settings_summary" msgid="2745336273786148166">"Permitir que apps que podem ser sobrepostos a outros sejam abertos sobre telas de configuração"</string>
    <string name="allow_mock_modem" msgid="3832264806530479214">"Permitir Mock Modem"</string>
    <string name="allow_mock_modem_summary" msgid="9097416612748005374">"Permita que este dispositivo execute o serviço Mock Modem para testes de instrumentação. Não ative esse recurso durante o uso normal do smartphone."</string>
    <string name="disable_screen_share_protections_for_apps_and_notifications" msgid="4987116103699222633">"Desativar as proteções do compartilhamento de tela"</string>
    <string name="disable_screen_share_protections_for_apps_and_notifications_summary" msgid="932295234626582052">"Desativa as proteções de apps e notificações aplicadas pelo sistema durante o compartilhamento de tela"</string>
    <string name="media_controls_title" msgid="403271085636252597">"Mídia"</string>
    <string name="media_controls_resume_title" msgid="855076860336652370">"Fixar player de mídia"</string>
    <string name="media_controls_resume_description" msgid="3163482266454802097">"Para retomar a reprodução rapidamente, o player de mídia fica aberto nas Configurações rápidas"</string>
    <string name="media_controls_lockscreen_title" msgid="2188311721857512510">"Mostrar mídia na tela de bloqueio"</string>
    <string name="media_controls_lockscreen_description" msgid="3320333660404439510">"Para retomar a reprodução rapidamente, o player de mídia fica aberto na tela de bloqueio"</string>
    <string name="media_controls_recommendations_title" msgid="3012692549413927608">"Mostrar recomendações de mídia do Google Assistente"</string>
    <string name="media_controls_recommendations_description" msgid="7596498733126824030">"Com base na sua atividade"</string>
    <string name="media_controls_hide_player" msgid="2751439192580884015">"Ocultar player"</string>
    <string name="media_controls_show_player" msgid="8504571042365814021">"Mostrar player"</string>
    <string name="keywords_media_controls" msgid="8345490568291778638">"mídia"</string>
    <string name="camera_extensions_fallback_title" msgid="3604579046777004989">"Permitir extensões de softwares da câmera"</string>
    <string name="camera_extensions_fallback_description" msgid="6939818294458854536">"Permite a implementação de softwares padrão com recursos avançados de câmera, como a videografia de acessibilidade."</string>
    <string name="connected_device_see_all_summary" msgid="2056010318537268108">"O Bluetooth será ativado"</string>
    <string name="provider_internet_settings" msgid="3831259474776313323">"Internet"</string>
    <string name="provider_network_settings_title" msgid="2624756136016346774">"Chips"</string>
    <string name="calls_and_sms" msgid="1931855083959003306">"Chamadas e SMS"</string>
    <string name="calls_and_sms_category" msgid="3788238090898237767">"Chamada no Wi-Fi"</string>
    <string name="calls_sms_wfc_summary" msgid="3940529919408667336">"Fazer e receber chamadas pelo Wi‑Fi"</string>
    <string name="calls_preference_title" msgid="7536882032182563800">"Chamadas"</string>
    <string name="sms_preference_title" msgid="8392745501754864395">"SMS"</string>
    <string name="calls_sms_preferred" msgid="6016477652522583496">"preferencial"</string>
    <string name="calls_sms_calls_preferred" msgid="9004261125829377885">"preferencial para chamadas"</string>
    <string name="calls_sms_sms_preferred" msgid="3855778890660922711">"preferencial para SMS"</string>
    <string name="calls_sms_unavailable" msgid="4055729705246556529">"indisponível"</string>
    <string name="calls_sms_temp_unavailable" msgid="8602291749338757424">"Temporariamente indisponível"</string>
    <string name="calls_sms_no_sim" msgid="2336377399761819718">"Sem chip"</string>
    <string name="network_and_internet_preferences_title" msgid="8635896466814033405">"Preferências de rede"</string>
    <string name="keywords_internet" msgid="7674082764898690310">"conexão de rede, internet, sem fio, dados, wifi, wi-fi, wi fi, celular, rede móvel, operadora de celular, 4g, 3g, 2g, lte"</string>
    <string name="reset_your_internet_title" msgid="4856899004343241310">"Redefinir sua Internet?"</string>
    <string name="resetting_internet_text" msgid="6696779371800051806">"Redefinindo sua Internet…"</string>
    <string name="fix_connectivity" msgid="2781433603228089501">"Corrigir conectividade"</string>
    <string name="networks_available" msgid="3299512933684383474">"Redes disponíveis"</string>
    <string name="to_switch_networks_disconnect_ethernet" msgid="6615374552827587197">"Para mudar de rede, desconecte o cabo Ethernet"</string>
    <string name="carrier_wifi_offload_title" msgid="7263365988016247722">"Conexões W+"</string>
    <string name="carrier_wifi_offload_summary" msgid="2980563718888371142">"Permitir que o Google Fi use redes W+ para melhorar a velocidade e cobertura"</string>
    <string name="carrier_wifi_network_title" msgid="5461382943873831770">"Rede W+"</string>
    <string name="sim_category_title" msgid="2341314000964710495">"Chip"</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="3077009911935592178">"Ativado"</string>
    <string name="sim_category_inactive_sim" msgid="7351553344148400450">"Desativado"</string>
    <string name="sim_category_default_active_sim" msgid="1208194173387987231">" / Padrão para <xliff:g id="ID_1">%1$s</xliff:g>"</string>
    <string name="default_active_sim_calls" msgid="2390973682556353558">"chamadas"</string>
    <string name="default_active_sim_sms" msgid="8041498593025994921">"SMS"</string>
    <string name="default_active_sim_mobile_data" msgid="6798083892814045301">"dados móveis"</string>
    <string name="wifi_scan_notify_message" msgid="1331238142061476869">"Para melhorar a experiência no dispositivo, os apps e serviços ainda podem procurar redes Wi-Fi a qualquer momento, mesmo quando essa conexão está desativada. Isso pode ser usado, por exemplo, para melhorar recursos e serviços baseados na localização. Você pode mudar essa opção nas configurações de busca por Wi-Fi."</string>
    <string name="wifi_scan_change" msgid="8438320311511852918">"Mudar"</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">"Conectado"</string>
    <string name="mobile_data_temp_connection_active" msgid="3430470299756236413">"Temporariamente conectado"</string>
    <string name="mobile_data_temp_using" msgid="5211002380149434155">"Temporariamente usando: <xliff:g id="SUBNAME">%1$s</xliff:g>"</string>
    <string name="mobile_data_no_connection" msgid="905897142426974030">"Sem conexão"</string>
    <string name="mobile_data_off_summary" msgid="1884248776904165539">"Não é possível se conectar aos dados móveis automaticamente"</string>
    <string name="mobile_data_disable_title" msgid="8438714772256088913">"Desativar os dados móveis?"</string>
    <string name="mobile_data_disable_message" msgid="7829414836454769970">"Você não terá acesso a dados ou à Internet pela <xliff:g id="CARRIER">%s</xliff:g>. A Internet estará disponível apenas pelo Wi-Fi."</string>
    <string name="mobile_data_disable_message_default_carrier" msgid="4449469407705838612">"sua operadora"</string>
    <string name="not_allowed_by_ent" msgid="1958611623122304411">"Não permitido pela sua organização"</string>
    <string name="aware_summary_when_bedtime_on" msgid="2063856008597376344">"Indisponível durante o Modo noite"</string>
    <string name="reset_importance_completed" msgid="3595536767426097205">"Redefinição da importância de notificações concluída."</string>
    <string name="apps_dashboard_title" msgid="3269953499954393706">"Apps"</string>
    <string name="bluetooth_message_access_notification_content" msgid="5111712860712823893">"Um dispositivo quer acessar suas mensagens. Toque para ver detalhes."</string>
    <string name="bluetooth_message_access_dialog_title" msgid="9009836130395061579">"Permitir acesso às mensagens?"</string>
    <string name="bluetooth_message_access_dialog_content" msgid="7186694737578788487">"Um dispositivo Bluetooth (<xliff:g id="DEVICE_NAME_0">%1$s</xliff:g>) quer acessar suas mensagens.\n\nVocê nunca se conectou a <xliff:g id="DEVICE_NAME_1">%2$s</xliff:g>."</string>
    <string name="bluetooth_phonebook_access_notification_content" msgid="9175220052703433637">"Um dispositivo quer acessar seus contatos e seu registro de chamadas. Toque para ver detalhes."</string>
    <string name="bluetooth_phonebook_access_dialog_title" msgid="7624607995928968721">"Permitir acesso aos contatos e ao registro de chamadas?"</string>
    <string name="bluetooth_phonebook_access_dialog_content" msgid="959658135522249170">"Um dispositivo Bluetooth (<xliff:g id="DEVICE_NAME_0">%1$s</xliff:g>) quer acessar seus contatos e seu registro de chamadas. Isso inclui dados sobre chamadas recebidas e realizadas.\n\nVocê nunca se conectou a <xliff:g id="DEVICE_NAME_1">%2$s</xliff:g>."</string>
    <string name="category_name_brightness" msgid="8520372392029305084">"Brilho"</string>
    <string name="category_name_lock_display" msgid="8310402558217129670">"Tela de bloqueio"</string>
    <string name="category_name_appearance" msgid="8287486771764166805">"Aparência"</string>
    <string name="category_name_color" msgid="937514550918977151">"Cor"</string>
    <string name="category_name_display_controls" msgid="7046581691184725216">"Outros controles de exibição"</string>
    <string name="category_name_general" msgid="7737273712848115886">"Geral"</string>
    <string name="dark_theme_main_switch_title" msgid="4045147031947562280">"Usar o tema escuro"</string>
    <string name="bluetooth_main_switch_title" msgid="8409835540311309632">"Usar o Bluetooth"</string>
    <string name="prevent_ringing_main_switch_title" msgid="4726252811262086643">"Impedir o toque do telefone"</string>
    <string name="use_wifi_hotsopt_main_switch_title" msgid="3909731167290690539">"Usar o ponto de acesso Wi-Fi"</string>
    <string name="app_pinning_main_switch_title" msgid="5465506660064032876">"Usar a Fixação de app"</string>
    <string name="developer_options_main_switch_title" msgid="1720074589554152501">"Usar as opções do desenvolvedor"</string>
    <string name="default_print_service_main_switch_title" msgid="4697133737128324036">"Usar o serviço de impressão"</string>
    <string name="multiple_users_main_switch_title" msgid="6686858308083037810">"Permitir vários usuários"</string>
    <string name="multiple_users_main_switch_keywords" msgid="4845954458094134356">"autorizar, vários, usuários, permitir, muitos"</string>
    <string name="wireless_debugging_main_switch_title" msgid="8463499572781441719">"Usar a depuração por Wi-Fi"</string>
    <string name="graphics_driver_main_switch_title" msgid="6125172901855813790">"Usar as preferências do driver gráfico"</string>
    <string name="night_light_main_switch_title" msgid="3428298022467805219">"Usar o Modo noturno"</string>
    <string name="nfc_main_switch_title" msgid="6295839988954817432">"Usar a NFC"</string>
    <string name="adaptive_brightness_main_switch_title" msgid="2681666805191642737">"Usar o Brilho adaptável"</string>
    <string name="wifi_calling_main_switch_title" msgid="4070224008346815634">"Usar a chamada no Wi-Fi"</string>
    <string name="default_see_all_apps_title" msgid="7481113230662612178">"Mostrar todos os apps"</string>
    <string name="smart_forwarding_title" msgid="8368634861971949799">"Encaminhamento inteligente"</string>
    <string name="smart_forwarding_summary_enabled" msgid="3341062878373185604">"Encaminhamento inteligente ativado"</string>
    <string name="smart_forwarding_summary_disabled" msgid="5033880700091914809">"Encaminhamento inteligente desativado"</string>
    <string name="smart_forwarding_ongoing_title" msgid="962226849074401228">"Configurações de chamada"</string>
    <string name="smart_forwarding_ongoing_text" msgid="2189209372407117114">"Atualizando configurações…"</string>
    <string name="smart_forwarding_failed_title" msgid="1859891191023516080">"Erro de configurações de chamada"</string>
    <string name="smart_forwarding_failed_text" msgid="8682640643264071789">"Ocorreu um erro de rede ou no chip."</string>
    <string name="smart_forwarding_failed_not_activated_text" msgid="997396203001257904">"O chip não está ativado."</string>
    <string name="smart_forwarding_input_mdn_title" msgid="5105463748849841763">"Inserir números de telefone"</string>
    <string name="smart_forwarding_input_mdn_dialog_title" msgid="7542216086697868415">"Inserir número de telefone"</string>
    <string name="smart_forwarding_missing_mdn_text" msgid="2907314684242542226">"O número de telefone não foi informado."</string>
    <string name="smart_forwarding_missing_alert_dialog_text" msgid="7870419247987316112">"OK"</string>
    <string name="enable_2g_title" msgid="8184757884636162942">"Permitir 2G"</string>
    <string name="enable_2g_summary" msgid="2794534052372565914">"O 2G é menos seguro, mas pode melhorar sua conexão em determinados lugares. Para chamadas de emergência, o 2G sempre é permitido."</string>
    <string name="enable_2g_summary_disabled_carrier" msgid="8141118453219482762">"A operadora <xliff:g id="CARRIER_NAME_2G">%1$s</xliff:g> requer a disponibilidade do 2G"</string>
    <string name="require_cellular_encryption_title" msgid="7516008146269371585">"Exigir criptografia"</string>
    <string name="require_cellular_encryption_summary" msgid="4813823321032908641">"A criptografia é mais segura, mas talvez você não consiga se conectar em alguns locais. A criptografia nunca é exigida para fazer ligações de emergência"</string>
    <string name="app_info_all_services_label" msgid="1487070364839071105">"Todos os serviços"</string>
    <string name="show_clip_access_notification" msgid="7782300987639778542">"Mostrar acesso à área de transferência"</string>
    <string name="show_clip_access_notification_summary" msgid="474090757777203207">"Mostrar uma mensagem quando os apps acessarem textos, imagens ou outros conteúdos copiados"</string>
    <string name="all_apps" msgid="3054120149509114789">"Todos os apps"</string>
    <string name="request_manage_bluetooth_permission_dont_allow" msgid="8798061333407581300">"Não permitir"</string>
    <string name="uwb_settings_title" msgid="8578498712312002231">"Banda ultralarga (UWB)"</string>
    <string name="uwb_settings_summary" msgid="3074271396764672268">"Ajuda a identificar a posição relativa de dispositivos com UWB por perto"</string>
    <string name="uwb_settings_summary_airplane_mode" msgid="1328864888135086484">"Desative o modo avião para usar a UWB"</string>
    <string name="uwb_settings_summary_no_uwb_regulatory" msgid="3465456428217979428">"UWB indisponível no local atual"</string>
    <string name="thread_network_settings_title" msgid="4212301030523859220">"Thread"</string>
    <string name="thread_network_settings_summary" msgid="8065599651021748339">"Conecte-se a dispositivos compatíveis usando a rede Thread para ter uma ótima experiência de casa inteligente"</string>
    <string name="thread_network_settings_summary_airplane_mode" msgid="7207252895832446979">"Desative o modo avião para usar a rede Thread"</string>
    <string name="camera_toggle_title" msgid="8952668677727244992">"Acesso à câmera"</string>
    <string name="mic_toggle_title" msgid="265145278323852547">"Acesso ao microfone"</string>
    <string name="perm_toggle_description" msgid="5754629581767319022">"Para apps e serviços"</string>
    <string name="mic_toggle_description" msgid="484139688645092237">"Para apps e serviços. Se esta configuração estiver desativada, os dados do microfone ainda poderão ser compartilhados quando você ligar para um número de emergência."</string>
    <string name="previous_page_content_description" msgid="6438292457923282991">"Anterior"</string>
    <string name="next_page_content_description" msgid="1641835099813416294">"Próxima"</string>
    <string name="colors_viewpager_content_description" msgid="2591751086138259565">"Visualização da cor"</string>
    <string name="bluetooth_sim_card_access_notification_title" msgid="7351015416346359536">"Solicitação de acesso ao chip"</string>
    <string name="bluetooth_sim_card_access_notification_content" msgid="8685623260103018309">"Um dispositivo quer acessar seu chip. Toque para ver detalhes."</string>
    <string name="bluetooth_sim_card_access_dialog_title" msgid="5616323725563125179">"Você quer mesmo permitir o acesso ao chip?"</string>
    <string name="bluetooth_sim_card_access_dialog_content" msgid="6281997628405909566">"Um dispositivo Bluetooth, <xliff:g id="DEVICE_NAME_0">%1$s</xliff:g>, quer acessar dados no seu chip. Isso inclui seus contatos.\n\nEnquanto estiver conectado, o <xliff:g id="DEVICE_NAME_1">%2$s</xliff:g> vai receber todas as chamadas feitas para o número <xliff:g id="PHONE_NUMBER">%3$s</xliff:g>."</string>
    <string name="bluetooth_connect_access_notification_title" msgid="2573547043170883947">"Dispositivo Bluetooth disponível"</string>
    <string name="bluetooth_connect_access_notification_content" msgid="1328465545685433304">"Um dispositivo quer se conectar. Toque para ver detalhes."</string>
    <string name="bluetooth_connect_access_dialog_title" msgid="1948056782712451381">"Conectar ao dispositivo Bluetooth?"</string>
    <string name="bluetooth_connect_access_dialog_content" msgid="4336436466468405850">"<xliff:g id="DEVICE_NAME_0">%1$s</xliff:g> quer se conectar a este smartphone.\n\nVocê nunca se conectou ao <xliff:g id="DEVICE_NAME_1">%2$s</xliff:g>."</string>
    <string name="bluetooth_connect_access_dialog_negative" msgid="4944672755226375059">"Não conectar"</string>
    <string name="bluetooth_connect_access_dialog_positive" msgid="3630561675207269710">"Conectar"</string>
    <string name="tare_settings" msgid="3788654800004869077">"Configurações do TARE"</string>
    <string name="tare_on" msgid="2386073225978684535">"Ativado"</string>
    <string name="tare_off" msgid="6305694402929756726">"Desativado"</string>
    <string name="tare_revert" msgid="3855325741125236638">"Reverter para as configurações padrão"</string>
    <string name="tare_settings_reverted_toast" msgid="8189887409285176731">"Configurações revertidas para o padrão."</string>
    <string name="tare_max_satiated_balance" msgid="3914973999573150340">"Saldo máximo saciado"</string>
    <string name="tare_balances" msgid="731881382594747961">"Saldos"</string>
    <string name="tare_consumption_limits" msgid="3230949387874396382">"Limites de consumo"</string>
    <string name="tare_initial_consumption_limit" msgid="2921646306374048384">"Limite de consumo inicial"</string>
    <string name="tare_min_consumption_limit" msgid="3293145670921755789">"Limite mínimo de consumo"</string>
    <string name="tare_max_consumption_limit" msgid="8335700580111808823">"Limite máximo de consumo"</string>
    <string name="tare_modifiers" msgid="8919975635360280820">"Modificadores"</string>
    <string name="tare_actions_ctp" msgid="5110104015354916401">"Ações (custo de produção)"</string>
    <string name="tare_actions_base_price" msgid="3300967942666376589">"Ações (preço base)"</string>
    <string name="tare_rewards_instantaneous" msgid="8358683519945340874">"Recompensas por um evento específico"</string>
    <string name="tare_rewards_ongoing" msgid="7657030286658143416">"Recompensas por segundo de duração do evento"</string>
    <string name="tare_rewards_max" msgid="5283055625642837010">"Máximo de recompensas por dia"</string>
    <string name="tare_app_install" msgid="7955806910408116882">"Instalação de app"</string>
    <string name="tare_top_activity" msgid="7266560655483385757">"Principal atividade"</string>
    <string name="tare_notification_seen" msgid="7829963536020087742">"Notificação vista"</string>
    <string name="tare_notification_seen_15_min" msgid="832174185809497764">"Notificação vista em 15 minutos"</string>
    <string name="tare_notification_interaction" msgid="3806204222322830129">"Interação com a notificação"</string>
    <string name="tare_widget_interaction" msgid="2260701564089214184">"Interação com o widget"</string>
    <string name="tare_other_interaction" msgid="8069163421115212751">"Outra interação do usuário"</string>
    <string name="tare_job_max_start" msgid="1586399578665940836">"Início de prioridade máxima da tarefa"</string>
    <string name="tare_job_max_running" msgid="2897217372986518495">"Execução de prioridade máxima da tarefa"</string>
    <string name="tare_job_high_start" msgid="7464143754932031022">"Início de alta prioridade da tarefa"</string>
    <string name="tare_job_high_running" msgid="6541171046405088669">"Execução de alta prioridade da tarefa"</string>
    <string name="tare_job_default_start" msgid="6744427210148953151">"Início padrão da tarefa"</string>
    <string name="tare_job_default_running" msgid="8429081804128945217">"Execução padrão da tarefa"</string>
    <string name="tare_job_low_start" msgid="4605440035856891746">"Início de baixa prioridade da tarefa"</string>
    <string name="tare_job_low_running" msgid="831668616902849604">"Execução de baixa prioridade da tarefa"</string>
    <string name="tare_job_min_start" msgid="6508233901992538188">"Início de prioridade mínima da tarefa"</string>
    <string name="tare_job_min_running" msgid="6167128996320622604">"Execução de prioridade mínima da tarefa"</string>
    <string name="tare_job_timeout_penalty" msgid="7644332836795492506">"Penalidade de tempo limite da tarefa"</string>
    <string name="tare_min_balance_exempted" msgid="6693710075762973485">"Saldo mínimo quando totalmente carregado (isento)"</string>
    <string name="tare_min_balance_headless_app" msgid="6906353766678577244">"Saldo mínimo quando totalmente carregado (app do sistema headless)"</string>
    <string name="tare_min_balance_other_app" msgid="3404774196832506476">"Saldo mínimo quando totalmente carregado (apps restantes)"</string>
    <string name="tare_min_balance_addition_app_updater" msgid="5391956072471201269">"Adição de saldo mínimo quando totalmente carregado (atualizadores de apps)"</string>
  <string-array name="tare_modifiers_subfactors">
    <item msgid="3325940509857535498">"Carregando"</item>
    <item msgid="658627268149681677">"Soneca"</item>
    <item msgid="1599558140284643834">"Modo de economia de energia"</item>
    <item msgid="588427840913221601">"Estado do processo"</item>
  </string-array>
    <string name="tare_dialog_confirm_button_title" msgid="9179397559760203348">"Confirmar"</string>
    <string name="dream_preview_button_title" msgid="6637456541851795952">"Prévia"</string>
    <string name="dream_picker_category" msgid="7726447836872744867">"Escolha um protetor de tela"</string>
    <string name="dream_complications_toggle_title" msgid="4273232303027449163">"Mostrar outras informações"</string>
    <string name="dream_complications_toggle_summary" msgid="8088911054987524904">"Mostra dados como o horário, o clima ou outras informações no protetor de tela"</string>
    <string name="dream_home_controls_toggle_title" msgid="706799741564479248">"Mostrar automação residencial"</string>
    <string name="dream_home_controls_toggle_summary" msgid="4102519907917430579">"Mostra o botão de automação residencial no protetor de tela"</string>
    <string name="dream_more_settings_category" msgid="3119192146760773748">"Mais configurações"</string>
    <string name="dream_setup_title" msgid="2458303874255396142">"Escolha o protetor de tela"</string>
    <string name="dream_setup_description" msgid="7508547154038580296">"Escolha o que ver na tela quando o tablet estiver na base. O dispositivo pode consumir mais energia quando o protetor de tela é usado."</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">"É necessário reiniciar o dispositivo para ativar o suporte ao formato livre."</string>
    <string name="reboot_dialog_force_desktop_mode" msgid="2021839270403432948">"É necessário reiniciar o dispositivo para forçar o modo área de trabalho em telas secundárias."</string>
    <string name="reboot_dialog_reboot_now" msgid="235616015988522355">"Reiniciar agora"</string>
    <string name="reboot_dialog_reboot_later" msgid="4261717094186904568">"Reiniciar mais tarde"</string>
    <string name="bluetooth_details_spatial_audio_title" msgid="1368071116994002707">"Áudio espacial"</string>
    <string name="bluetooth_details_spatial_audio_summary" msgid="5026859623681482668">"O áudio de dispositivos de mídia compatíveis se torna mais imersivo"</string>
    <string name="bluetooth_details_head_tracking_title" msgid="5416972521040337799">"Acompanhamento da cabeça"</string>
    <string name="bluetooth_details_head_tracking_summary" msgid="3942238746595985395">"O áudio muda conforme você move a cabeça para soar mais natural"</string>
    <string name="bluetooth_details_permissions_sync_title" msgid="7277580382321003521">"Sincronizar permissões do smartphone"</string>
    <string name="bluetooth_details_permissions_sync_summary" msgid="8125037984381432059">"Conceda ao relógio as mesmas permissões do app que você concedeu a este smartphone"</string>
    <string name="bluetooth_details_audio_device_types_title" msgid="3381941189346781614">"Tipo de dispositivo de áudio"</string>
    <string name="bluetooth_details_audio_device_type_unknown" msgid="839337391037998014">"Desconhecido"</string>
    <string name="bluetooth_details_audio_device_type_speaker" msgid="3706227767994792124">"Alto-falante"</string>
    <string name="bluetooth_details_audio_device_type_headphones" msgid="7644588291215033798">"Fones de ouvido"</string>
    <string name="bluetooth_details_audio_device_type_hearing_aid" msgid="1310631131071939859">"Aparelho auditivo"</string>
    <string name="bluetooth_details_audio_device_type_carkit" msgid="4439017600454703229">"Kit do carro"</string>
    <string name="bluetooth_details_audio_device_type_other" msgid="7019481234617207563">"Outro"</string>
    <string name="ingress_rate_limit_title" msgid="2106694002836274350">"Limitação da velocidade de download da rede"</string>
    <string name="ingress_rate_limit_summary" msgid="1097811019742438371">"Configurar a limitação da velocidade de entrada da largura de banda da rede para todas as redes que se conectam à Internet."</string>
    <string name="ingress_rate_limit_dialog_title" msgid="5359461052422633789">"Configurar a limitação da velocidade de download da rede"</string>
    <string name="ingress_rate_limit_no_limit_entry" msgid="8741098826008012163">"Sem limite"</string>
    <string name="disable_phantom_process_monitor_title" msgid="8348108346706188771">"Desativar restrições de processos filhos"</string>
    <string name="disable_phantom_process_monitor_summary" msgid="3044464635550256985">"Desativar as restrições no uso de recursos do sistema dos processos filhos do app"</string>
    <string name="enable_notes_role_title" msgid="7662702013496114763">"Forçar a ativação da função Notas"</string>
    <string name="enable_notes_role_summary" msgid="5495721409392395089">"Permitir integrações do sistema de anotações pela função Notas. Se essa função já estiver ativada, nada será feito. É necessário reinicializar o dispositivo."</string>
    <string name="bluetooth_broadcast_dialog_title" msgid="9172775308463135884">"Transmitir"</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">"Ouça transmissões que estão perto de você"</string>
    <string name="bluetooth_broadcast_dialog_broadcast_message" msgid="6198264676009094495">"Transmita arquivos de mídia para dispositivos perto de você ou ouça a transmissão de outra pessoa"</string>
    <string name="bluetooth_find_broadcast_title" msgid="5385985218699831970">"Transmissões"</string>
    <string name="bluetooth_find_broadcast_summary" msgid="3907899428626210673">"Ouvindo"</string>
    <string name="bluetooth_find_broadcast" msgid="1768337775649457586">"Encontrar transmissões"</string>
    <string name="bluetooth_find_broadcast_button_leave" msgid="7881206581147104908">"Sair da transmissão"</string>
    <string name="bluetooth_find_broadcast_button_scan" msgid="3995664694641895189">"Ler QR code"</string>
    <string name="find_broadcast_password_dialog_title" msgid="3176988702535737484">"Digite a senha"</string>
    <string name="find_broadcast_password_dialog_connection_error" msgid="47873617983439400">"Não foi possível se conectar. Tente de novo."</string>
    <string name="find_broadcast_password_dialog_password_error" msgid="243855327674765">"Senha incorreta"</string>
    <string name="find_broadcast_join_broadcast_error" msgid="5486980388774711346">"Não é possível participar da transmissão"</string>
    <string name="bt_le_audio_scan_qr_code_scanner" msgid="7614569515419813053">"Para começar a ouvir, centralize o QR code abaixo"</string>
    <string name="bt_le_audio_qr_code_is_not_valid_format" msgid="7821837654128137901">"O QR code não está em um formato válido"</string>
    <string name="convert_to_esim_title" msgid="71037864129009206">"Converter para eSIM"</string>
    <string name="transfer_esim_to_another_device_title" msgid="5286117866086383192">"Transferir eSIM para outro dispositivo"</string>
    <string name="background_install_preference_summary" msgid="3065219346519340364">"{count,plural, =1{# app}one{# app}other{# apps}}"</string>
    <string name="background_install_title" msgid="607913515188276168">"Apps instalados em segundo plano"</string>
    <string name="background_install_summary" msgid="3890296129543309666">"O fabricante do dispositivo pode instalar apps em segundo plano ou permitir que a operadora e outros parceiros façam isso.\n\nOs apps listados aqui não são necessários para que o dispositivo funcione normalmente. Você pode desinstalar os apps que quiser."</string>
    <string name="background_install_feature_list_no_entry" msgid="2071343281272266154">"Nenhum app instalado em 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 instalados no último # mês}one{Apps instalados no último # mês}other{Apps instalados nos últimos # meses}}"</string>
    <string name="background_install_after" msgid="7983488897570908149">"{count,plural, =1{Apps instalados há mais de # mês}one{Apps instalados há mais de # mês}other{Apps instalados há mais de # meses}}"</string>
    <string name="aspect_ratio_title" msgid="2451826875939676101">"Proporção"</string>
    <string name="aspect_ratio_summary" msgid="4056406351663726494">"Teste uma nova proporção para esse app caso ele não tenha sido criado para caber no seu dispositivo <xliff:g id="DEVICE_NAME">%1$s</xliff:g>"</string>
    <string name="aspect_ratio_main_summary" msgid="4141964559612756940">"Teste uma nova proporção para esse app caso ele não tenha sido criado para caber no seu dispositivo <xliff:g id="DEVICE_NAME">%1$s</xliff:g>. Talvez alguns apps não estejam otimizados para algumas proporções."</string>
    <string name="aspect_ratio_summary_text" msgid="4737461467467220325">"Teste uma nova proporção para um app caso ele não tenha sido criado para caber no seu dispositivo <xliff:g id="DEVICE_NAME">%1$s</xliff:g>"</string>
    <string name="aspect_ratio_main_summary_text" msgid="5544816872094235840">"Teste uma nova proporção para um app caso ele não tenha sido criado para caber no seu dispositivo <xliff:g id="DEVICE_NAME">%1$s</xliff:g>. Talvez alguns apps não estejam otimizados para certas proporções."</string>
    <string name="user_aspect_ratio_suggested_apps_label" msgid="8085934042329632039">"Apps sugeridos"</string>
    <string name="user_aspect_ratio_changed_apps_label" msgid="2096614916172567672">"Apps modificados"</string>
    <string name="user_aspect_ratio_app_default" msgid="270065763307617837">"Padrão do app"</string>
    <string name="user_aspect_ratio_fullscreen" msgid="1843427242540081996">"Tela cheia"</string>
    <string name="user_aspect_ratio_half_screen" msgid="1015852057094310209">"Meia tela"</string>
    <string name="user_aspect_ratio_device_size" msgid="2339820985120881199">"Proporção do dispositivo"</string>
    <string name="user_aspect_ratio_16_9" msgid="2286644872775170164">"16:9"</string>
    <string name="user_aspect_ratio_3_2" msgid="199262962518318932">"3:2"</string>
    <string name="user_aspect_ratio_4_3" msgid="5196232982878982220">"4:3"</string>
    <string name="user_aspect_ratio_option_a11y" msgid="1235801996029095219">"<xliff:g id="NUMERATOR">%1$s</xliff:g> por <xliff:g id="DENOMINATOR">%2$s</xliff:g>"</string>
    <string name="app_aspect_ratio_footer" msgid="4029509301182067475">"O app será reiniciado quando você mudar a proporção. É possível que você perca mudanças que não foram salvas. Talvez alguns apps não estejam otimizados para algumas proporções."</string>
    <string name="aspect_ratio_experimental_title" msgid="9088785421062044831">"Proporção (experimental)"</string>
    <string name="aspect_ratio_experiment_title" msgid="128614319422121040">"Proporção (experimento)"</string>
    <string name="aspect_ratio_labs_title" msgid="6733893837442759383">"Proporção (Labs)"</string>
    <string name="aspect_ratio_experimental_label" msgid="6319009297672567578">"Experimental"</string>
    <string name="aspect_ratio_experiment_label" msgid="7861871612376167784">"Experimento"</string>
    <string name="aspect_ratio_labs_label" msgid="7008498116297651342">"Labs"</string>
    <string name="accessibility_fingerprint_label" msgid="5017431423168191733">"Sensor de impressão digital"</string>
    <string name="flash_notifications_title" msgid="4490438861180492311">"Notificações com flash"</string>
    <string name="flash_notifications_about_title" msgid="9004351252928121214">"Sobre as notificação com flash"</string>
    <string name="flash_notifications_summary_off" msgid="6056282996770691461">"Desativadas"</string>
    <string name="flash_notifications_summary_on_camera" msgid="3286405833586333730">"Ativado / Flash da câmera"</string>
    <string name="flash_notifications_summary_on_screen" msgid="9040640799633336219">"Ativado / Flash da tela"</string>
    <string name="flash_notifications_summary_on_camera_and_screen" msgid="2326268141063768701">"Ativado / Flash da câmera e da tela"</string>
    <string name="flash_notifications_intro" msgid="8409873413480928249">"O flash da câmera ou a tela piscam ao receber notificações ou soar alarmes"</string>
    <string name="flash_notifications_intro_without_camera_flash" msgid="6297337174487793891">"Piscar a tela ao receber notificações ou soar alarmes"</string>
    <string name="flash_notifications_note" msgid="2426125248448055075">"Tenha cuidado com as notificações com flash se você tiver sensibilidade à luz"</string>
    <string name="flash_notifications_keywords" msgid="2458759275318514836">"flash, luz, deficiência auditiva, perda auditiva"</string>
    <string name="flash_notifications_preview" msgid="5320176885050440874">"Testar"</string>
    <string name="camera_flash_notification_title" msgid="2475084876382922732">"Flash da câmera"</string>
    <string name="screen_flash_notification_title" msgid="3773100725793316708">"Flash da tela"</string>
    <string name="screen_flash_notification_color_title" msgid="7213407653340970790">"Cor do flash da tela"</string>
    <string name="screen_flash_color_blue" msgid="3585766657607931371">"Azul"</string>
    <string name="screen_flash_color_azure" msgid="8691198532944992243">"Azure"</string>
    <string name="screen_flash_color_cyan" msgid="6878780006173747267">"Ciano"</string>
    <string name="screen_flash_color_spring_green" msgid="4466548514738457815">"Verde-folha"</string>
    <string name="screen_flash_color_green" msgid="8418019648507964564">"Verde"</string>
    <string name="screen_flash_color_chartreuse_green" msgid="7456381649919010366">"Verde-limão"</string>
    <string name="screen_flash_color_yellow" msgid="7413465411615454556">"Amarelo"</string>
    <string name="screen_flash_color_orange" msgid="979177126315557656">"Laranja"</string>
    <string name="screen_flash_color_red" msgid="8954162219886445491">"Vermelho"</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">"Concluído"</string>
    <string name="color_selector_dialog_cancel" msgid="8667350644753900701">"Cancelar"</string>
    <string name="contrast_title" msgid="6885768151336508075">"Contraste"</string>
    <string name="contrast_standard" msgid="1097297089917185235">"Padrão"</string>
    <string name="contrast_default" msgid="8918545965525226966">"Padrão"</string>
    <string name="contrast_medium" msgid="384414510709285811">"Médio"</string>
    <string name="contrast_high" msgid="3988567609694797696">"Alto"</string>
    <string name="dock_multi_instances_not_supported_text" msgid="3513493664467667084">"Esse app só pode ser aberto em uma única janela"</string>
    <string name="generic_accessibility_service_on" msgid="4466229372357726824">"Ativado"</string>
    <string name="generic_accessibility_service_off" msgid="4759859497651675724">"Desativado"</string>
    <string name="generic_accessibility_feature_shortcut_off" msgid="4022872394514077907">"Desativado"</string>
    <string name="accessibility_shortcut_state_off" msgid="8158137799007601475">"Desativado"</string>
    <string name="daltonizer_state_on" msgid="131013270022603983">"Ativado"</string>
    <string name="daltonizer_state_off" msgid="1162285688069856179">"Desativado"</string>
    <string name="color_inversion_state_on" msgid="1160969033636440368">"Ativada"</string>
    <string name="color_inversion_state_off" msgid="6925638668080451724">"Desativada"</string>
    <string name="color_inversion_feature_summary" msgid="1199876648549627647">"Transforma as telas claras em escuras e vice-versa"</string>
    <string name="magnification_feature_summary" msgid="2053971569640663564">"Aumentar o zoom na tela"</string>
    <string name="autoclick_disabled" msgid="3213396804955002120">"Desativado"</string>
    <string name="show_captions_disabled" msgid="690650956523818755">"Desativadas"</string>
    <string name="show_captions_enabled" msgid="7089043007924626">"Ativada"</string>
    <string name="live_caption_disabled" msgid="3562035026547887366">"Desativada"</string>
    <string name="live_caption_enabled" msgid="5269360946200718949">"Ativada"</string>
    <string name="about_phone_device_name_warning" msgid="3243226572404472381">"O nome do dispositivo fica visível para os apps que você instalou. Ele também vai ficar visível para outras pessoas quando você se conectar a dispositivos Bluetooth ou a uma rede Wi-Fi ou quando configurar um ponto de acesso Wi-Fi."</string>
    <string name="grammatical_gender_title" msgid="8584242850477270828">"Gênero gramatical"</string>
    <string name="grammatical_gender_dialog_title" msgid="8754048592099871587">"Selecionar gênero gramatical"</string>
    <string name="content_protection_preference_title" msgid="5069260032659193074">"Verificação de apps enganosos"</string>
    <string name="content_protection_preference_summary" msgid="2252393849408445391">"Verificar atividades no app para detectar phishing"</string>
    <string name="content_protection_preference_user_consent_switch_title" msgid="1797782616799594426">"Usar o recurso de verificação para detectar apps enganosos"</string>
    <string name="content_protection_preference_user_consent_work_profile_switch_title" msgid="3004347470520916069">"Usar o recurso de verificação para detectar apps enganosos que podem ser usados no perfil de trabalho"</string>
    <string name="content_protection_preference_subpage_summary" msgid="3595621220981703364"></string>
    <string name="content_protection_preference_subpage_info" msgid="6890886357653365489"></string>
    <string name="accessibility_setup_password_complete" msgid="6358749253318369077">"A senha foi configurada"</string>
    <string name="show_stylus_pointer_icon" msgid="1010583689203665786">"Mostrar ponteiro ao passar o cursor"</string>
</resources>
