<?xml version="1.0" encoding="utf-8"?>
<resources>
	<string name="role_admin">Administrador</string>
	<string name="role_editor">Editor</string>
	<string name="role_author">Autor</string>
	<string name="role_contributor">Colaborador</string>
	<string name="role_follower">Seguidor</string>
	<string name="role_viewer">Leitor</string>
	<string name="error_post_my_profile_no_connection">Sem conexão, não foi possível salvar seu perfil</string>
	<string name="alignment_left">Esquerda</string>
	<string name="alignment_right">Direita</string>
	<string name="alignment_none">Nenhum</string>
	<string name="site_settings_list_editor_action_mode_title">Selecionado %1$d</string>
	<string name="error_fetch_users_list">Não foi possível recuperar os usuários do site</string>
	<string name="plans_manage">Gerenciar o seu plano em\nWordPress.com/plans</string>
	<string name="title_follower">Seguidor</string>
	<string name="people_empty_list_filtered_viewers">Você não tem nenhum espectador ainda.</string>
	<string name="title_email_follower">Seguidor por e-mail</string>
	<string name="people_fetching">Buscando usuários...</string>
	<string name="people_empty_list_filtered_email_followers">Você não tem nenhum seguidores por e-mail ainda.</string>
	<string name="people_empty_list_filtered_followers">Você não tem seguidores ainda.</string>
	<string name="people_empty_list_filtered_users">Você não tem usuários ainda.</string>
	<string name="people_dropdown_item_viewers">Espectadores</string>
	<string name="people_dropdown_item_email_followers">Seguidores por e-mail</string>
	<string name="people_dropdown_item_followers">Seguidores</string>
	<string name="people_dropdown_item_team">Equipe</string>
	<string name="invite_message_usernames_limit">Convite até 10 endereços de e-mail e/ou usuários do WordPress.com. Serão enviadas instruções sobre como criar um nome de usuário para aqueles que necessitarem.</string>
	<string name="viewer_remove_confirmation_message">Caso você remova este espectador(a), ele ou ela não serão capazes de visitar este site.\n\nVocê gostaria ainda de remover este espectador(a)?</string>
	<string name="follower_remove_confirmation_message">Caso removido, este seguidor irá parar de receber notificações sobre este site, menos que ele comece a seguir novamente.\n\nVocê gostaria ainda de remover este seguidor?</string>
	<string name="follower_subscribed_since">Desde de %1$s</string>
	<string name="reader_label_view_gallery">Ver galeria</string>
	<string name="error_remove_follower">Não foi possível remover o seguidor</string>
	<string name="error_remove_viewer">Não foi possível remover o espectador</string>
	<string name="error_fetch_email_followers_list">Não foi possível recuperar os seguidores por e-mail do site</string>
	<string name="error_fetch_followers_list">Não foi possível recuperar os seguidos do site</string>
	<string name="editor_failed_uploads_switch_html">Alguns envios de mídia falharam. Você pode mudar para o modo de HTML no lugar. Remover todos os envios falhados e continuar?</string>
	<string name="format_bar_description_html">Modo HTML</string>
	<string name="visual_editor">Editor visual</string>
	<string name="image_thumbnail">Imagem em míniatura</string>
	<string name="format_bar_description_ul">Lista não ordenada</string>
	<string name="format_bar_description_ol">Lista ordenada</string>
	<string name="format_bar_description_media">Inserir mídia</string>
	<string name="format_bar_description_more">Inserir "leia mais"</string>
	<string name="format_bar_description_strike">Riscado</string>
	<string name="format_bar_description_quote">Bloco de citação</string>
	<string name="format_bar_description_link">Inserir link</string>
	<string name="format_bar_description_italic">Itálico</string>
	<string name="format_bar_description_underline">Sublinhado</string>
	<string name="image_settings_save_toast">Salvar alterações</string>
	<string name="image_caption">Legenda</string>
	<string name="image_alt_text">Texto alternativo</string>
	<string name="image_link_to">Link para</string>
	<string name="image_width">Largura</string>
	<string name="format_bar_description_bold">Negrito</string>
	<string name="image_settings_dismiss_dialog_title">Descartar alterações não salvas?</string>
	<string name="stop_upload_dialog_title">Parar envio?</string>
	<string name="stop_upload_button">Parar envio</string>
	<string name="alert_error_adding_media">Um erro ocorreu algo inserir o arquivo de mídia</string>
	<string name="alert_action_while_uploading">Você esta no momento enviando um arquivo de mídia. Aguarde até o processo ser completo.</string>
	<string name="alert_insert_image_html_mode">Não é possível inserir arquivo de mídia diretamente no modo HTML. Mude de volta para o modo visual.</string>
	<string name="uploading_gallery_placeholder">Enviando galeria...</string>
	<string name="invite_sent">Convite enviado com sucesso.</string>
	<string name="tap_to_try_again">Toque para tentar novamente!</string>
	<string name="invite_error_some_failed">Convite enviado, mas ocorreram erros!</string>
	<string name="invite_error_for_username">%1$s: %2$s</string>
	<string name="invite_error_sending">Um erro ocorreu ao tentar enviar o convite!</string>
	<string name="invite_error_invalid_usernames_multiple">Não pôde enviar: Contém nome de usuários ou e-mails inválidos</string>
	<string name="invite_error_invalid_usernames_one">Não pôde enviar: Um nome de usuário ou e-mail é inválido</string>
	<string name="invite_error_no_usernames">Adicione pelo menos um nome de usuário</string>
	<string name="invite_message_info">(Opcional) Você pode inserir uma mensagem personalizada de até 500 caracteres que será incluída no convite para os usuários.</string>
	<string name="invite_message_remaining_other">%d caracteres restantes</string>
	<string name="invite_message_remaining_one">1 caractere restante</string>
	<string name="invite_message_remaining_zero">0 caracteres restantes</string>
	<string name="invite_invalid_email">O endereço de e-mail \'%s\' é inválido</string>
	<string name="invite_message_title">Mensagem personalizada</string>
	<string name="invite_already_a_member">Já existe um membro com o nome de usuário \'%s\'</string>
	<string name="invite_username_not_found">Nenhum usuário foi encontrado para o nome de usuário \'%s\'</string>
	<string name="invite">Convidar</string>
	<string name="invite_names_title">Nome de usuários ou e-mails</string>
	<string name="send_link">Enviar link</string>
	<string name="my_site_header_external">Externo</string>
	<string name="invite_people">Convidar pessoas</string>
	<string name="signup_succeed_signin_failed">A sua conta foi criada, mas ocorreu um erro ao autenticar você. Tente entrar novamente com o seu novo nome de usuário e senha.</string>
	<string name="label_clear_search_history">Limpar histórico de pesquisa</string>
	<string name="dlg_confirm_clear_search_history">Limpar histórico de pesquisa?</string>
	<string name="reader_empty_posts_in_search_description">Nenhum post na sua língua foi encontrado para %s</string>
	<string name="reader_label_post_search_running">Pesquisando...</string>
	<string name="reader_label_related_posts">Leitura relacionada</string>
	<string name="reader_empty_posts_in_search_title">Nenhum post foi encontrado</string>
	<string name="reader_label_post_search_explainer">Pesquisar em todos os blogs públicos do WordPress.com</string>
	<string name="reader_hint_post_search">Pesquisar no WordPress.com</string>
	<string name="reader_title_search_results">Pesquisar por %s</string>
	<string name="reader_title_related_post_detail">Post relacionado</string>
	<string name="preview_screen_links_disabled">Os links são desabilitados na tela de visualização</string>
	<string name="draft_explainer">Este post é um rascunho que ainda não foi publicado</string>
	<string name="send">Enviar</string>
	<string name="person_removed">%1$s removido com sucesso</string>
	<string name="user_remove_confirmation_message">Caso você remova %1$s, o usuário não irá mais ser capaz de acessar este site, mas o conteúdo que foi criado por %1$s será mantido no site.\n\nAinda gostaria de remover este usuário?</string>
	<string name="person_remove_confirmation_title">Remover %1$s</string>
	<string name="reader_empty_posts_in_custom_list">Os sites desta lista não publicaram nada recentemente</string>
	<string name="people">Pessoa</string>
	<string name="edit_user">Editar usuário</string>
	<string name="role">Função</string>
	<string name="error_remove_user">Não foi possível remover usuário</string>
	<string name="error_update_role">Não foi possível atualizar a função do usuário</string>
	<string name="error_fetch_viewers_list">Não foi possível recuperar os espectadores do site</string>
	<string name="gravatar_camera_and_media_permission_required">São necessárias permissões para selecionar ou tirar uma foto</string>
	<string name="error_updating_gravatar">Erro ao enviar o seu Gravatar</string>
	<string name="error_refreshing_gravatar">Erro ao carregar o seu Gravatar</string>
	<string name="error_locating_image">Erro ao localizar o recorte da imagem</string>
	<string name="gravatar_tip">Novo! Toque no seu Gravatar para mudá-lo!</string>
	<string name="error_cropping_image">Erro ao cortar a imagem</string>
	<string name="not_on_wordpress_com">Não esta no WordPress.com?</string>
	<string name="launch_your_email_app">Inicie o seu aplicativo de e-mail</string>
	<string name="checking_email">Verificando e-mail</string>
	<string name="magic_link_unavailable_error_message">Atualmente indisponível. Digite sua senha</string>
	<string name="check_your_email">Verifique seu e-mail</string>
	<string name="logging_in">Fazendo login</string>
	<string name="get_a_link_sent_to_your_email_to_sign_in_instantly">Enviar um link para o seu e-mail para fazer login instantaneamente</string>
	<string name="enter_your_password_instead">Digite sua senha ao invés disso</string>
	<string name="web_address_dialog_hint">Exibido ao público quando você comentar.</string>
	<string name="username_email">E-mail ou nome de usuário</string>
	<string name="jetpack_not_connected_message">O plugin Jetpack esta instalado, mas não esta conectado com o WordPress.com. Você deseja conectar o Jetpack?</string>
	<string name="jetpack_not_connected">O plugin Jetpack não esta conectado</string>
	<string name="new_editor_reflection_error">O editor visual não é compatível com seu dispositivo. Ele foi\n        desativado automaticamente.</string>
	<string name="stats_insights_latest_post_no_title">(sem título)</string>
	<string name="capture_or_pick_photo">Tirar or selecionar uma foto</string>
	<string name="plans_post_purchase_text_themes">Você agora possui acesso ilimitado a Temas Premium. Visualize qualquer tema no seu site para começar.</string>
	<string name="plans_post_purchase_button_themes">Pesquisar temas</string>
	<string name="plans_post_purchase_title_themes">Encontre um tema premium perfeito</string>
	<string name="plans_post_purchase_button_video">Comece um novo post</string>
	<string name="plans_post_purchase_text_video">Você pode enviar e hospedar vídeos no seu site com VideoPress e seu armazenamento de mídia expandido.</string>
	<string name="plans_post_purchase_title_video">Dê vida aos seus posts com vídeos</string>
	<string name="plans_post_purchase_button_customize">Personalizar meu site</string>
	<string name="plans_post_purchase_text_customize">Você agora possui acesso a fontes personalizadas, cores personalizadas e o poder de editar CSS personalizado.</string>
	<string name="plans_post_purchase_text_intro">Seu site está pulando de alegria! Explore os novos recursos de seu site e escolha por onde quer começar.</string>
	<string name="plans_post_purchase_title_customize">Personalizar fontes e cores</string>
	<string name="plans_post_purchase_title_intro">É todo seu. Vamos nessa!</string>
	<string name="export_your_content_message">Seus posts, páginas e configurações serão enviados para você em %s</string>
	<string name="plan">Plano</string>
	<string name="plans">Planos</string>
	<string name="plans_loading_error">Não foi possível carregar os planos</string>
	<string name="export_your_content">Exporte seu conteúdo</string>
	<string name="exporting_content_progress">Exportando conteúdo...</string>
	<string name="export_email_sent">E-mail sobre a exportação enviado!</string>
	<string name="checking_purchases">Verificando compras</string>
	<string name="show_purchases">Mostrar compras</string>
	<string name="premium_upgrades_message">Você ativou upgrades Premium em seu site. Por favor, cancele seus upgrades antes de excluir seu site.</string>
	<string name="premium_upgrades_title">Upgrades premium</string>
	<string name="purchases_request_error">Algo deu errado. Não foi possível carregar as compras.</string>
	<string name="delete_site_progress">Excluindo site...</string>
	<string name="delete_site_summary">Essa ação não pode ser desfeita. Excluir seu site irá remover todo o conteúdo, contribuidores e domínios desse site.</string>
	<string name="delete_site_hint">Excluir site</string>
	<string name="are_you_sure">Você tem certeza?</string>
	<string name="export_site_hint">Exporte seu conteúdo para um arquivo XML</string>
	<string name="export_site_summary">Caso tenha certeza, por favor, invista algum tempo agora para exportar seu conteúdo. Não será possível recuperá-lo no futuro.</string>
	<string name="keep_your_content">Mantenha seu conteúdo</string>
	<string name="domain_removal_hint">Domínios que não funcionarão assim que você remover seu site</string>
	<string name="domain_removal_summary">Cuidado! Excluir seu site também excluirá o(s) domínio(s) listado(s) abaixo.</string>
	<string name="primary_domain">Domínio primário</string>
	<string name="domain_removal">Remover domínio</string>
	<string name="error_deleting_site_summary">Houve um erro ao excluir seu site. Por favor, entre em contato com o suporte.</string>
	<string name="error_deleting_site">Erro ao excluir o site</string>
	<string name="site_settings_export_content_title">Exportar conteúdo</string>
	<string name="confirm_delete_site_prompt">Por favor, digite %1$s no campo abaixo para confirmar. Então seu site desaparecerá para sempre.</string>
	<string name="confirm_delete_site">Confirme a exclusão do site</string>
	<string name="contact_support">Contatar o suporte</string>
	<string name="start_over_text">Caso você queira um site mas não queira manter nenhum post ou página que você tem agora, nosso time de suporte pode excluir seus posts, páginas, mídia e comentários por você.\n\nIsso manterá o endereço atual de seu site ativo, mas dará um site novinho em folha para seu novo conteúdo. Entre em contato conosco para ter seu conteúdo atual removido. </string>
	<string name="site_settings_start_over_hint">Apaga seu conteúdo e começa seu site do zero</string>
	<string name="let_us_help">Deixe-nos ajudar</string>
	<string name="start_over">Começar novamente</string>
	<string name="me_btn_app_settings">Configurações do aplicativo</string>
	<string name="editor_remove_failed_uploads">Remover envios com falha</string>
	<string name="editor_toast_failed_uploads">Alguns envios de mídia falharam. Você não pode salvar ou publicar\nseu post nesse estado. Você deseja remover todas as mídias que falharam?</string>
	<string name="site_settings_advanced_header">Avançado</string>
	<string name="comments_empty_list_filtered_trashed">Nenhum comentário na lixeira</string>
	<string name="comments_empty_list_filtered_pending">Nenhum comentário pendente</string>
	<string name="comments_empty_list_filtered_approved">Nenhum comentário aprovado</string>
	<string name="button_done">Pronto</string>
	<string name="button_skip">Pular</string>
	<string name="site_timeout_error">Não foi possível conectar-se ao Site WordPress devido a um erro no tempo limite.</string>
	<string name="xmlrpc_malformed_response_error">Não foi possível conectar. A instalação do WordPress respondeu com um documento XML-RPC inválido.</string>
	<string name="xmlrpc_missing_method_error">Não foi possível conectar. Alguns métodos XML-RPC necessários estão faltando no servidor.</string>
	<string name="post_format_status">Status</string>
	<string name="post_format_video">Vídeo</string>
	<string name="theme_free">Gratuito</string>
	<string name="theme_all">Tudo</string>
	<string name="theme_premium">Premium</string>
	<string name="alignment_center">Centro</string>
	<string name="post_format_chat">Chat</string>
	<string name="post_format_gallery">Galeria</string>
	<string name="post_format_image">Imagem</string>
	<string name="post_format_link">Link</string>
	<string name="post_format_quote">Citação</string>
	<string name="post_format_standard">Padrão</string>
	<string name="notif_events">Informações sobre cursos e eventos (online e presenciais) do WordPress.com.</string>
	<string name="post_format_aside">Notas</string>
	<string name="post_format_audio">Áudio</string>
	<string name="notif_surveys">Oportunidades para participar das pesquisas e enquetes do WordPress.com.</string>
	<string name="notif_tips">Dicas para aproveitar o máximo do WordPress.com</string>
	<string name="notif_community">Comunidade</string>
	<string name="replies_to_my_comments">Respostas aos meus comentários</string>
	<string name="notif_suggestions">Sugestões</string>
	<string name="notif_research">Pesquisa</string>
	<string name="site_achievements">Conquistas do site</string>
	<string name="username_mentions">Menções ao nome de usuário</string>
	<string name="likes_on_my_posts">Curtidas nos meus posts</string>
	<string name="site_follows">Seguidores do site</string>
	<string name="likes_on_my_comments">Curtidas nos meus comentários</string>
	<string name="comments_on_my_site">Comentários no meu site</string>
	<string name="site_settings_list_editor_summary_other">%d itens</string>
	<string name="site_settings_list_editor_summary_one">1 item</string>
	<string name="approve_auto_if_previously_approved">Comentários de usuários conhecidos</string>
	<string name="approve_auto">Todos os usuários</string>
	<string name="approve_manual">Sem comentários</string>
	<string name="site_settings_paging_summary_other">%d comentários por página</string>
	<string name="site_settings_paging_summary_one">1 comentário por página</string>
	<string name="site_settings_multiple_links_summary_other">Exige aprovação para mais de %d links</string>
	<string name="site_settings_multiple_links_summary_one">Exige aprovação para mais de 1 link</string>
	<string name="site_settings_multiple_links_summary_zero">Exige aprovação para mais de 0 links</string>
	<string name="detail_approve_auto">Aprovar automaticamente todos os comentários.</string>
	<string name="detail_approve_auto_if_previously_approved">Aprovar automaticamente se o usuário tiver um comentário aprovado anteriormente.</string>
	<string name="detail_approve_manual">Exigir aprovação manual para todos os comentários.</string>
	<string name="filter_trashed_posts">Na lixeira</string>
	<string name="days_quantity_one">1 dia</string>
	<string name="days_quantity_other">%d dias</string>
	<string name="filter_published_posts">Publicado</string>
	<string name="filter_draft_posts">Rascunhos</string>
	<string name="filter_scheduled_posts">Agendado</string>
	<string name="primary_site">Site principal</string>
	<string name="web_address">Endereço da web</string>
	<string name="pending_email_change_snackbar">Clique no link de verificação no e-mail enviado para %1$s para confirmar seu novo endereço</string>
	<string name="editor_toast_uploading_please_wait">Você está fazendo upload de mídia no momento. Aguarde até que o processo seja concluído.</string>
	<string name="error_refresh_comments_showing_older">Não foi possível atualizar os comentários no momento. Comentários mais antigos estão sendo exibidos</string>
	<string name="editor_post_settings_set_featured_image">Configurar imagem destacada</string>
	<string name="editor_post_settings_featured_image">Imagem destacada</string>
	<string name="new_editor_promo_desc">O aplicativo do WordPress para Android agora inclui um belo visual repaginado.\n editor. Experimente criando um novo post.</string>
	<string name="new_editor_promo_title">Novo editor</string>
	<string name="new_editor_promo_button_label">Ótimo, obrigado!</string>
	<string name="visual_editor_enabled">Editor visual ativado</string>
	<string name="editor_content_placeholder">Compartilhe sua história aqui...</string>
	<string name="editor_page_title_placeholder">Título da página</string>
	<string name="editor_post_title_placeholder">Título do post</string>
	<string name="email_address">Endereço de e-mail</string>
	<string name="preference_show_visual_editor">Exibir editor visual</string>
	<string name="dlg_sure_to_delete_comments">Excluir estes comentários permanentemente?</string>
	<string name="preference_editor">Editor</string>
	<string name="dlg_sure_to_delete_comment">Excluir este comentário permanentemente?</string>
	<string name="mnu_comment_delete_permanently">Excluir</string>
	<string name="comment_deleted_permanently">Comentário excluído</string>
	<string name="mnu_comment_untrash">Restaurar</string>
	<string name="comments_empty_list_filtered_spam">Nenhum comentário spam</string>
	<string name="could_not_load_page">Não foi possível carregar a página</string>
	<string name="comment_status_all">Tudo</string>
	<string name="interface_language">Idioma da interface</string>
	<string name="off">Desativado</string>
	<string name="about_the_app">Sobre o aplicativo</string>
	<string name="error_post_account_settings">Não foi possível salvar as configurações da sua conta</string>
	<string name="error_post_my_profile">Não foi possível salvar seu perfil</string>
	<string name="error_fetch_account_settings">Não foi possível recuperar as configurações da sua conta</string>
	<string name="error_fetch_my_profile">Não foi possível recuperar seu perfil</string>
	<string name="stats_widget_promo_ok_btn_label">Ok, entendido</string>
	<string name="stats_widget_promo_desc">Adicione o widget à sua tela inicial para acessar as Estatísticas com apenas um clique.</string>
	<string name="stats_widget_promo_title">Widget de Estatísticas para tela inicial</string>
	<string name="site_settings_unknown_language_code_error">Código de idioma não reconhecido</string>
	<string name="site_settings_threading_dialog_description">Permitir que os comentários sejam agrupados em tópicos.</string>
	<string name="site_settings_threading_dialog_header">Agrupar até</string>
	<string name="remove">Remover</string>
	<string name="search">Buscar</string>
	<string name="add_category">Adicionar categoria</string>
	<string name="disabled">Desativado</string>
	<string name="site_settings_image_original_size">Tamanho original</string>
	<string name="privacy_private">Seu site é visível apenas para você e usuários aprovados</string>
	<string name="privacy_public_not_indexed">Seu site está visível para todos mas solicita aos mecanismos de busca para não indexá-lo</string>
	<string name="privacy_public">Seu site está visível para todos e pode ser indexado por mecanismos de busca</string>
	<string name="about_me_hint">Algumas palavras sobre você...</string>
	<string name="about_me">Sobre mim</string>
	<string name="public_display_name_hint">O nome de exibição será o seu nome de usuário se não for configurado</string>
	<string name="public_display_name">Nome para exibição pública</string>
	<string name="first_name">Nome</string>
	<string name="last_name">Sobrenome</string>
	<string name="my_profile">Meu perfil</string>
	<string name="site_privacy_public_desc">Permitir que mecanismos de busca indexem este site</string>
	<string name="site_privacy_hidden_desc">Evitar que mecanismos de busca indexem este site</string>
	<string name="site_privacy_private_desc">Quero que meu site fique privado, visível apenas para os usuários que eu escolher</string>
	<string name="cd_related_post_preview_image">Imagem de visualização do post relacionado</string>
	<string name="error_post_remote_site_settings">Não foi possível salvar as informações do site</string>
	<string name="error_fetch_remote_site_settings">Não foi possível recuperar as informações do site</string>
	<string name="error_media_upload_connection">Ocorreu um erro de conexão durante o envio de mídia</string>
	<string name="site_settings_disconnected_toast">Sem conexão, edição desabilitada.</string>
	<string name="site_settings_unsupported_version_error">Versão do WordPress não suportada</string>
	<string name="site_settings_multiple_links_dialog_description">Exigir aprovação para comentários que incluem mais do que este número de links.</string>
	<string name="site_settings_close_after_dialog_switch_text">Fechar automaticamente</string>
	<string name="site_settings_close_after_dialog_description">Encerrar automaticamente comentários nos artigos.</string>
	<string name="site_settings_paging_dialog_description">Dividir tópicos de comentários em várias páginas.</string>
	<string name="site_settings_paging_dialog_header">Comentários por página</string>
	<string name="site_settings_close_after_dialog_title">Encerrar comentários</string>
	<string name="site_settings_blacklist_description">Quando um comentário tiver uma destas palavras em seu conteúdo, nome, URL, e-mail ou IP, ele será marcado como spam. Você pode inserir partes de palavras, então "press" corresponderá a "WordPress".</string>
	<string name="site_settings_hold_for_moderation_description">Quando um comentário contiver qualquer uma destas palavras em seu conteúdo, nome, URL, endereço de e-mail ou IP, o mesmo será retido na fila de moderação. Você pode inserir partes de palavras, então "press" corresponderá a "WordPress".</string>
	<string name="site_settings_list_editor_input_hint">Insira uma palavra ou frase</string>
	<string name="site_settings_list_editor_no_items_text">Nenhum item</string>
	<string name="site_settings_learn_more_caption">É possível substituir essas configurações para posts individuais.</string>
	<string name="site_settings_rp_preview3_site">em "Upgrade"</string>
	<string name="site_settings_rp_preview3_title">Foco da atualização: VideoPress para casamentos</string>
	<string name="site_settings_rp_preview2_site">em "Aplicativos"</string>
	<string name="site_settings_rp_preview2_title">O aplicativo WordPress para Android foi melhorado</string>
	<string name="site_settings_rp_preview1_site">em "Mobile"</string>
	<string name="site_settings_rp_preview1_title">Grande atualização para iPhone/iPad disponível</string>
	<string name="site_settings_rp_show_images_title">Mostrar imagens</string>
	<string name="site_settings_rp_show_header_title">Mostrar cabeçalho</string>
	<string name="site_settings_rp_switch_summary">Posts Relacionados exibe conteúdo relevante do seu site abaixo dos seus posts.</string>
	<string name="site_settings_rp_switch_title">Mostrar posts relacionados</string>
	<string name="site_settings_delete_site_hint">Remove os dados do seu site do aplicativo</string>
	<string name="site_settings_blacklist_hint">Comentários que corresponderem a um filtro serão marcados como spam</string>
	<string name="site_settings_moderation_hold_hint">Comentários que corresponderem a um filtro serão colocados em uma fila de moderação</string>
	<string name="site_settings_multiple_links_hint">Ignora o limite de links de usuários conhecidos</string>
	<string name="site_settings_whitelist_hint">O autor do comentário tem que ter um comentário aprovado anteriormente</string>
	<string name="site_settings_user_account_required_hint">Usuários devem estar registrados e logados para comentar</string>
	<string name="site_settings_identity_required_hint">O autor do comentário tem que preencher o nome e email</string>
	<string name="site_settings_manual_approval_hint">Os comentários devem ser aprovados manualmente</string>
	<string name="site_settings_paging_hint">Exibir comentários em grupos de tamanho especificado</string>
	<string name="site_settings_threading_hint">Permitir comentários agrupados em uma certa profundidade</string>
	<string name="site_settings_sort_by_hint">Determina a ordem de exibição dos comentários</string>
	<string name="site_settings_close_after_hint">Desabilitar comentários após um tempo específico</string>
	<string name="site_settings_receive_pingbacks_hint">Permitir notificações de link de outros blogs</string>
	<string name="site_settings_send_pingbacks_hint">Tentar notificar blogs com links a partir do artigo</string>
	<string name="site_settings_allow_comments_hint">Permitir que leitores publiquem comentários</string>
	<string name="site_settings_discussion_hint">Exibir e alterar as configurações de discussão dos sites</string>
	<string name="site_settings_more_hint">Exibir todas as configurações de Discussão disponíveis</string>
	<string name="site_settings_related_posts_hint">Mostrar ou ocultar posts relacionados no leitor</string>
	<string name="site_settings_upload_and_link_image_hint">Permitir que imagens sejam sempre enviadas no tamanho máximo</string>
	<string name="site_settings_image_width_hint">Redimensiona as imagens nos posts para esta largura</string>
	<string name="site_settings_format_hint">Define o formato do novo post</string>
	<string name="site_settings_category_hint">Define a categoria do novo post</string>
	<string name="site_settings_location_hint">Adicionar automaticamente os dados de localização aos posts</string>
	<string name="site_settings_password_hint">Alterar sua senha</string>
	<string name="site_settings_username_hint">Conta de usuário atual</string>
	<string name="site_settings_language_hint">Idioma em que este blog é normalmente escrito</string>
	<string name="site_settings_privacy_hint">Controle quem pode ver seu site</string>
	<string name="site_settings_address_hint">No momento, você não pode alterar o endereço</string>
	<string name="site_settings_tagline_hint">Uma breve descrição ou uma frase de efeito para descrever o seu blog</string>
	<string name="site_settings_title_hint">Em poucas palavras, explique sobre o que é este site</string>
	<string name="site_settings_whitelist_known_summary">Comentários de usuários conhecidos</string>
	<string name="site_settings_whitelist_all_summary">Comentários de todos os usuários</string>
	<string name="site_settings_threading_summary">%d níveis</string>
	<string name="site_settings_privacy_private_summary">Privado</string>
	<string name="site_settings_privacy_hidden_summary">Oculto</string>
	<string name="site_settings_privacy_public_summary">Público</string>
	<string name="site_settings_delete_site_title">Excluir site</string>
	<string name="site_settings_blacklist_title">Lista negra</string>
	<string name="site_settings_moderation_hold_title">Aguardar moderação</string>
	<string name="site_settings_multiple_links_title">Links nos comentários</string>
	<string name="site_settings_whitelist_title">Aprovar automaticamente</string>
	<string name="site_settings_threading_title">Threading</string>
	<string name="site_settings_paging_title">Paginação</string>
	<string name="site_settings_sort_by_title">Ordenar por</string>
	<string name="site_settings_account_required_title">Os usuários devem estar conectados</string>
	<string name="site_settings_identity_required_title">É necessário incluir nome e e-mail</string>
	<string name="site_settings_receive_pingbacks_title">Receber pingbacks</string>
	<string name="site_settings_send_pingbacks_title">Enviar pingbacks</string>
	<string name="site_settings_allow_comments_title">Habilitar comentários</string>
	<string name="site_settings_default_format_title">Formato padrão</string>
	<string name="site_settings_default_category_title">Categoria padrão</string>
	<string name="site_settings_location_title">Habilitar localização</string>
	<string name="site_settings_address_title">Endereço</string>
	<string name="site_settings_title_title">Título do site</string>
	<string name="site_settings_tagline_title">Tagline</string>
	<string name="site_settings_this_device_header">Este dispositivo</string>
	<string name="site_settings_discussion_new_posts_header">Padrões para novos posts</string>
	<string name="site_settings_writing_header">Escrevendo</string>
	<string name="site_settings_account_header">Conta</string>
	<string name="site_settings_general_header">Geral</string>
	<string name="newest_first">Mais novos primeiro</string>
	<string name="related_posts">Posts relacionados</string>
	<string name="comments">Comentários</string>
	<string name="discussion">Discussão</string>
	<string name="privacy">Privacidade</string>
	<string name="close_after">Encerrar após</string>
	<string name="oldest_first">Mais antigos primeiro</string>
	<string name="media_error_no_permission_upload">Você não tem permissão para enviar mídia para o site</string>
	<string name="never">Nunca</string>
	<string name="unknown">Desconhecido</string>
	<string name="reader_err_get_post_not_found">Este post não existe mais</string>
	<string name="reader_err_get_post_not_authorized">Você não possui autorização para ver este post</string>
	<string name="reader_err_get_post_generic">Falha ao carregar esse post</string>
	<string name="blog_name_no_spaced_allowed">O endereço do site não pode conter espaços</string>
	<string name="invalid_username_no_spaces">O nome de usuário não pode conter espaços</string>
	<string name="reader_empty_followed_blogs_no_recent_posts_description">Os sites que você segue não publicaram nada recentemente</string>
	<string name="reader_empty_followed_blogs_no_recent_posts_title">Não há posts recentes</string>
	<string name="edit_media">Editar mídia</string>
	<string name="media_details_copy_url_toast">A URL foi copiada para a área de transferência</string>
	<string name="media_details_copy_url">Copiar URL</string>
	<string name="media_details_label_date_uploaded">Upload completo</string>
	<string name="media_details_label_date_added">Adicionada</string>
	<string name="selected_theme">Tema selecionado</string>
	<string name="could_not_load_theme">Não foi possível carregar o tema</string>
	<string name="theme_activation_error">Algo deu errado. Não foi possível ativar o tema</string>
	<string name="theme_by_author_prompt_append"> por %1$s</string>
	<string name="theme_prompt">Obrigado por escolher %1$s</string>
	<string name="theme_view">Visualizar</string>
	<string name="theme_details">Detalhes</string>
	<string name="theme_support">Suporte</string>
	<string name="theme_done">Pronto</string>
	<string name="theme_manage_site">Gerenciar site</string>
	<string name="theme_try_and_customize">Testar e personalizar</string>
	<string name="title_activity_theme_support">Temas</string>
	<string name="theme_activate">Ativar</string>
	<string name="details">Detalhes</string>
	<string name="support">Suporte</string>
	<string name="active">Ativo</string>
	<string name="date_range_start_date">Data inicial</string>
	<string name="date_range_end_date">Data final</string>
	<string name="current_theme">Tema atual</string>
	<string name="customize">Personalizar</string>
	<string name="stats_referrers_spam_generic_error">Algo de errado aconteceu durante a operação. O estado de spam não foi mudado.</string>
	<string name="stats_referrers_marking_not_spam">Marcar como não spam</string>
	<string name="stats_referrers_unspam">Não é spam</string>
	<string name="stats_referrers_marking_spam">Marcar como spam</string>
	<string name="post_published">Post publicado</string>
	<string name="page_published">Página publicada</string>
	<string name="post_updated">Post atualizado</string>
	<string name="page_updated">Página atualizada</string>
	<string name="stats_referrers_spam">Spam</string>
	<string name="theme_auth_error_authenticate">Falha ao carregar temas: autenticação de usuário falhou</string>
	<string name="theme_no_search_result_found">Desculpe, nenhum tema encontrado.</string>
	<string name="media_file_name">Nome do arquivo: %s</string>
	<string name="media_dimensions">Dimensões: %s</string>
	<string name="media_uploaded_on">Enviado em: %s</string>
	<string name="media_file_type">Tipo de arquivo: %s</string>
	<string name="upload_queued">Enfileirado</string>
	<string name="reader_label_gap_marker">Carregar mais posts</string>
	<string name="notifications_no_search_results">Nenhum site corresponde a \'%s\'</string>
	<string name="search_sites">Pesquisar sites</string>
	<string name="notifications_empty_view_reader">Visualizar Leitor</string>
	<string name="unread">Não lida</string>
	<string name="notifications_empty_action_followers_likes">Seja notado: comente em posts que você leu.</string>
	<string name="notifications_empty_action_comments">Participe de uma conversa: comente em posts de blogs que você segue.</string>
	<string name="notifications_empty_action_unread">Reinicie a conversa: escrever um novo post.</string>
	<string name="notifications_empty_action_all">Seja ativo! Comente em posts de blogs que você segue.</string>
	<string name="notifications_empty_likes">Nenhuma nova curtida para exibir... ainda.</string>
	<string name="notifications_empty_followers">Nenhum novo seguidore para relatar... ainda.</string>
	<string name="notifications_empty_comments">Nenhum novo comentário... ainda.</string>
	<string name="notifications_empty_unread">Você está atualizado!</string>
	<string name="stats_widget_error_jetpack_no_blogid">Por favor, acesse as Estatísticas no aplicativo e tente adicionar o widget mais tarde</string>
	<string name="stats_widget_error_readd_widget">Por favor, remova o widget e adicione-o novamente</string>
	<string name="stats_widget_error_no_visible_blog">Estatísticas não podem ser carregadas sem um blog visível</string>
	<string name="stats_widget_error_no_permissions">Sua conta no WordPress.com não pode acessar as estatísticas deste blog</string>
	<string name="stats_widget_error_no_account">Por favor, faça login no WordPress</string>
	<string name="stats_widget_error_generic">As Estatísticas não puderam ser carregadas</string>
	<string name="stats_widget_loading_data">Carregando dados...</string>
	<string name="stats_widget_name_for_blog">Estatísticas de hoje para %1$s</string>
	<string name="stats_widget_name">Estatísticas de hoje do WordPress</string>
	<string name="add_location_permission_required">Permissões necessárias para adicionar localização</string>
	<string name="add_media_permission_required">Permissões necessárias para adicionar mídia</string>
	<string name="access_media_permission_required">Permissões necessárias para acessar mídia</string>
	<string name="stats_enable_rest_api_in_jetpack">Para ver suas estatísticas, ative o modulo JSON API do Jetpack.</string>
	<string name="error_open_list_from_notification">Este post ou página foi publicado em outro site</string>
	<string name="reader_short_comment_count_multi">%s comentários</string>
	<string name="reader_short_comment_count_one">1 comentário</string>
	<string name="reader_label_submit_comment">ENVIAR</string>
	<string name="reader_hint_comment_on_post">Responder ao post...</string>
	<string name="reader_discover_visit_blog">Acessar %s</string>
	<string name="reader_discover_attribution_blog">Originalmente publicado no %s</string>
	<string name="reader_discover_attribution_author">Originalmente publicado por %s</string>
	<string name="reader_discover_attribution_author_and_blog">Originalmente publicado por %1$s no %2$s</string>
	<string name="reader_short_like_count_multi">%s curtidas</string>
	<string name="reader_short_like_count_one">1 curtida</string>
	<string name="reader_label_follow_count">%,d seguidores</string>
	<string name="reader_short_like_count_none">Curtir</string>
	<string name="reader_menu_tags">Editar tags e blogs</string>
	<string name="reader_title_post_detail">Post do leitor</string>
	<string name="local_draft_explainer">Este post é um rascunho local que ainda não foi publicado</string>
	<string name="local_changes_explainer">Este post teve alterações locais que ainda não foram publicadas</string>
	<string name="notifications_push_summary">Configurações de notificações que são exibidas em seu dispositivo.</string>
	<string name="notifications_email_summary">Configurações de notificações que são enviadas ao e-mail vinculado à sua conta.</string>
	<string name="notifications_tab_summary">Configurações de notificações que são exibidas na guia Notificações.</string>
	<string name="notifications_disabled">Notificações de aplicativo foram desativadas. Toque aqui para ativá-las em Configurações.</string>
	<string name="notification_types">Tipos de notificação</string>
	<string name="error_loading_notifications">Não foi possível carregar as configurações de notificação</string>
	<string name="replies_to_your_comments">Respostas aos seus comentários</string>
	<string name="comment_likes">Curtidas do comentário</string>
	<string name="app_notifications">Notificações de aplicativo</string>
	<string name="notifications_tab">Guia Notificações</string>
	<string name="email">E-mail</string>
	<string name="notifications_comments_other_blogs">Comentários em outros sites</string>
	<string name="notifications_other">Outro</string>
	<string name="notifications_wpcom_updates">Novidades do WordPress.com</string>
	<string name="notifications_account_emails">Email do WordPress.com</string>
	<string name="notifications_account_emails_summary">Sempre enviaremos emails importantes sobre a sua conta, mas você também pode ter acesso a conteúdo extra.</string>
	<string name="notifications_sights_and_sounds">Aparência e sons</string>
	<string name="your_sites">Seus Sites</string>
	<string name="stats_insights_latest_post_trend">Faz %1$s desde que %2$s foi publicado. Este foi o desempenho do post até agora...</string>
	<string name="stats_insights_latest_post_summary">Resumo dos posts mais recentes</string>
	<string name="button_revert">Reverter</string>
	<string name="days_ago">Há %d dias</string>
	<string name="yesterday">Ontem</string>
	<string name="connectionbar_no_connection">Sem conexão</string>
	<string name="page_trashed">Página enviada para a lixeira</string>
	<string name="post_deleted">Post excluído</string>
	<string name="post_trashed">Post enviado para a lixeira</string>
	<string name="stats_no_activity_this_period">Nenhuma atividade no período</string>
	<string name="trashed">Na lixeira</string>
	<string name="button_back">Voltar</string>
	<string name="page_deleted">Página excluída</string>
	<string name="button_stats">Estatísticas</string>
	<string name="button_trash">Enviar para a lixeira</string>
	<string name="button_preview">Visualizar</string>
	<string name="button_view">Exibir</string>
	<string name="button_edit">Editar</string>
	<string name="button_publish">Publicar</string>
	<string name="my_site_no_sites_view_subtitle">Deseja adicionar um?</string>
	<string name="my_site_no_sites_view_title">Você não possui nenhum site do WordPress ainda.</string>
	<string name="my_site_no_sites_view_drake">Ilustração</string>
	<string name="reader_toast_err_follow_blog_not_authorized">Você não está autorizado a acessar este blog</string>
	<string name="reader_toast_err_follow_blog_not_found">Este blog não foi encontrado</string>
	<string name="undo">Desfazer</string>
	<string name="tabbar_accessibility_label_my_site">Meu site</string>
	<string name="tabbar_accessibility_label_me">Eu</string>
	<string name="passcodelock_prompt_message">Digite seu PIN</string>
	<string name="editor_toast_changes_saved">Modificações salvas</string>
	<string name="push_auth_expired">A solicitação expirou. Faça login no WordPress.com para tentar novamente.</string>
	<string name="stats_insights_most_popular_percent_views">%1$d%% de visualizações</string>
	<string name="stats_insights_best_ever">Melhores visualizações</string>
	<string name="ignore">Ignorar</string>
	<string name="stats_insights_most_popular_hour">Horário com maior número de visitações</string>
	<string name="stats_insights_most_popular_day">Dia com maior número de visitações</string>
	<string name="stats_insights_today">Estatísticas de hoje</string>
	<string name="stats_insights_popular">Dia e horário com maior número de visitantes</string>
	<string name="stats_insights_all_time">Todos os posts, visualizações e visitantes</string>
	<string name="stats_insights">Informações</string>
	<string name="stats_sign_in_jetpack_different_com_account">Para visualizar suas estatísticas, faça login na conta do WordPress.com que você usou para se conectar ao Jetpack.</string>
	<string name="stats_other_recent_stats_moved_label">Buscando suas outras estatísticas recentes? Nós as movemos para a página Informações.</string>
	<string name="me_disconnect_from_wordpress_com">Desconectar do WordPress.com</string>
	<string name="me_btn_login_logout">Entrar/Sair</string>
	<string name="me_connect_to_wordpress_com">Conectar ao WordPress.com</string>
	<string name="site_picker_cant_hide_current_site">"%s" não está escondido porque é o site atual</string>
	<string name="account_settings">Configurações da conta</string>
	<string name="me_btn_support">Ajuda e Suporte</string>
	<string name="site_picker_create_dotcom">Criar um site no WordPress.com</string>
	<string name="site_picker_add_self_hosted">Adicionar site auto-hospedado</string>
	<string name="site_picker_add_site">Adicionar site</string>
	<string name="site_picker_edit_visibility">Mostrar/esconder sites</string>
	<string name="my_site_btn_view_site">Ver site</string>
	<string name="my_site_btn_switch_site">Mudar de site</string>
	<string name="my_site_btn_view_admin">Ver Painel</string>
	<string name="site_picker_title">Escolher site</string>
	<string name="my_site_btn_blog_posts">Posts do blog</string>
	<string name="my_site_btn_site_settings">Configurações</string>
	<string name="my_site_header_look_and_feel">Aparência</string>
	<string name="my_site_header_publish">Publicar</string>
	<string name="reader_label_new_posts_subtitle">Toque para mostrar</string>
	<string name="my_site_header_configuration">Configuração</string>
	<string name="notifications_account_required">Fazer login no WordPress.com para notificações</string>
	<string name="stats_unknown_author">Autor desconhecido</string>
	<string name="image_added">Imagem adicionada</string>
	<string name="signout">Desconectar</string>
	<string name="sign_out_wpcom_confirm">Ao desconectar sua conta, os dados do @%s WordPress.com neste dispositivo serão removidos, incluindo rascunhos e alterações locais.</string>
	<string name="deselect_all">Desmarcar todos</string>
	<string name="select_all">Selecionar todos</string>
	<string name="show">Mostrar</string>
	<string name="hide">Esconder</string>
	<string name="select_from_new_picker">Selecione vários itens com o novo seletor</string>
	<string name="no_blog_images">Sem imagens</string>
	<string name="error_loading_blog_images">Impossível obter imagens</string>
	<string name="error_loading_blog_videos">Impossível obter vídeos</string>
	<string name="no_device_images">Sem imagens</string>
	<string name="no_blog_videos">Sem vídeos</string>
	<string name="error_loading_images">Erro ao carregar imagens</string>
	<string name="loading_blog_images">Obtendo imagens</string>
	<string name="error_loading_videos">Erro ao carregar vídeos</string>
	<string name="no_media_sources">Não foi possível obter mídia</string>
	<string name="loading_blog_videos">Obtendo vídeos</string>
	<string name="stats_generic_error">As estatísticas requisitadas não puderam ser carregadas</string>
	<string name="no_device_videos">Sem vídeos</string>
	<string name="loading_images">Carregando imagens</string>
	<string name="loading_videos">Carregando vídeos</string>
	<string name="no_media">Sem mídia</string>
	<string name="auth_required">Faça login novamente para continuar.</string>
	<string name="sign_in_jetpack">Faça login no WordPress.com para se conectar ao Jetpack.</string>
	<string name="two_step_footer_button">Enviar o código por mensagem de texto</string>
	<string name="two_step_footer_label">Insira o código do seu aplicativo de autenticação</string>
	<string name="verify">Verificar</string>
	<string name="verification_code">Código de verificação</string>
	<string name="editor_toast_invalid_path">Caminho do arquivo inválido</string>
	<string name="error_publish_no_network">Não é possível publicar enquanto não houver conexão. Salvo como rascunho.</string>
	<string name="tab_title_device_videos">Vídeos do dispositivo</string>
	<string name="tab_title_device_images">Imagens do dispositivo</string>
	<string name="take_video">Gravar um vídeo</string>
	<string name="take_photo">Tirar uma foto</string>
	<string name="add_to_post">Adicionar ao post</string>
	<string name="language">Idioma</string>
	<string name="device">Dispositivo</string>
	<string name="two_step_sms_sent">Verifique suas mensagens de texto para o código de verificação.</string>
	<string name="invalid_verification_code">Código de verificação inválido</string>
	<string name="tab_title_site_videos">Vídeos do site</string>
	<string name="tab_title_site_images">Imagens do site</string>
	<string name="media_picker_title">Selecionar mídia</string>
	<string name="media_details_label_file_type">Tipo de arquivo</string>
	<string name="media_details_label_file_name">Nome do arquivo</string>
	<string name="error_notification_open">Não foi possível abrir a notificação</string>
	<string name="publisher">Editor:</string>
	<string name="reader_empty_posts_request_failed">Não foi possível recuperar os posts</string>
	<string name="stats_search_terms_unknown_search_terms">Termos de busca desconhecidos</string>
	<string name="stats_followers_total_wpcom_paged">Exibindo de %1$d a %2$d de %3$s Seguidores WordPress.com</string>
	<string name="stats_view_search_terms">Termos de busca</string>
	<string name="stats_empty_search_terms_desc">Saiba mais sobre o seu tráfego de busca ao verificar os termos que seus visitantes pesquisaram para encontrar o seu site.</string>
	<string name="stats_empty_search_terms">Nenhum termo de busca registrado</string>
	<string name="stats_entry_search_terms">Termo de busca</string>
	<string name="stats_view_authors">Autores</string>
	<string name="pages_fetching">Obtendo páginas...</string>
	<string name="comments_fetching">Obtendo comentários...</string>
	<string name="toast_err_post_uploading">Não é possível abrir o post enquanto o upload está em andamento</string>
	<string name="posts_fetching">Obtendo posts...</string>
	<string name="media_fetching">Obtendo mídia…</string>
	<string name="stats_followers_total_email_paged">Exibindo de %1$d a %2$d de %3$s seguidores de e-mail</string>
	<string name="stats_period">Período</string>
	<string name="post_uploading">Fazendo upload</string>
	<string name="logs_copied_to_clipboard">O logs do aplicativo foram copiados para a área de transferência</string>
	<string name="reader_label_new_posts">Novos posts</string>
	<string name="reader_empty_posts_in_blog">Este blog está vazio</string>
	<string name="stats_recent_weeks">Semanas recentes</string>
	<string name="stats_average_per_day">Média por dia</string>
	<string name="error_copy_to_clipboard">Ocorreu um erro ao copiar o texto para a área de transferência</string>
	<string name="stats_months_and_years">Meses e anos</string>
	<string name="stats_overall">Geral</string>
	<string name="stats_total">Total</string>
	<string name="reader_page_recommended_blogs">Talvez você goste destes sites</string>
	<string name="stats_comments_total_comments_followers">Total de posts com comentários de seguidores: %1$s</string>
	<string name="stats_visitors">Visitantes</string>
	<string name="stats_pagination_label">Página %1$s de %2$s</string>
	<string name="stats_timeframe_years">Anos</string>
	<string name="stats_views">Visualizações</string>
	<string name="stats_view_countries">Países</string>
	<string name="stats_likes">Curtidas</string>
	<string name="stats_view_publicize">Publicize</string>
	<string name="stats_view_followers">Seguidores</string>
	<string name="stats_entry_clicks_link">Link</string>
	<string name="stats_view_top_posts_and_pages">Posts &amp; Páginas</string>
	<string name="stats_view_videos">Vídeos</string>
	<string name="stats_entry_publicize">Serviço</string>
	<string name="stats_entry_followers">Seguidor</string>
	<string name="stats_totals_publicize">Seguidores</string>
	<string name="stats_entry_video_plays">Vídeo</string>
	<string name="stats_entry_top_commenter">Autor</string>
	<string name="stats_empty_geoviews_desc">Explore a lista para descobrir que países e regiões geram mais visitas para o seu site.</string>
	<string name="stats_totals_followers">Desde</string>
	<string name="stats_empty_geoviews">Nenhum país registrado</string>
	<string name="stats_empty_top_posts_title">Nenhum post ou página visualizado</string>
	<string name="stats_empty_top_posts_desc">Descubra qual seu conteúdo mais visualizado e verifique o desempenho de posts e páginas individuais ao longo do tempo.</string>
	<string name="stats_empty_referrers_title">Nenhum referrer registrado</string>
	<string name="stats_empty_clicks_title">Nenhum clique registrado</string>
	<string name="stats_empty_referrers_desc">Descubra os sites e termos de pesquisa que mais direcionam visitantes para o seu site, e aprenda mais sobre sua visibilidade.</string>
	<string name="stats_empty_tags_and_categories">Nenhum post ou página marcado com tags foi visualizado.</string>
	<string name="stats_empty_clicks_desc">Caso seu conteúdo tenha links para outros sites, você verá quais os links mais clicados por seus visitantes.</string>
	<string name="stats_empty_top_authors_desc">Monitore as visualizações dos posts de cada colaborador e descubra em detalhes os conteúdos mais populares por autor.</string>
	<string name="stats_empty_tags_and_categories_desc">Obtenha uma visão geral dos tópicos mais populares do seu site, de acordo com os principais posts da semana passada.</string>
	<string name="stats_empty_comments_desc">Caso você permita comentários no site, monitore seus principais comentadores e descubra que tipo de conteúdo gera mais interesse, com base em seus 1.000 comentários mais recentes.</string>
	<string name="stats_empty_video_desc">Se você tiver feito upload de vídeos com o VideoPress, descubra quantas vezes eles foram assistidos.</string>
	<string name="stats_empty_video">Nenhum vídeo reproduzido</string>
	<string name="stats_empty_publicize">Nenhum seguidor do publicize registrado</string>
	<string name="stats_empty_followers">Nenhum seguidor</string>
	<string name="stats_empty_publicize_desc">Monitore seus seguidores em várias redes sociais usando o publicize.</string>
	<string name="stats_comments_by_posts_and_pages">Por posts &amp; páginas</string>
	<string name="stats_empty_followers_desc">Monitore seu número de seguidores e há quanto tempo cada um deles segue seu site.</string>
	<string name="stats_comments_by_authors">Por autores</string>
	<string name="stats_followers_total_wpcom">Total de seguidores do WordPress.com: %1$s</string>
	<string name="stats_followers_seconds_ago">segundos atrás</string>
	<string name="stats_followers_wpcom_selector">WordPress.com</string>
	<string name="stats_followers_hours">%1$d horas</string>
	<string name="stats_followers_a_day">Um dia</string>
	<string name="stats_followers_days">%1$d dias</string>
	<string name="stats_followers_a_minute_ago">um minuto atrás</string>
	<string name="stats_followers_a_year">Um ano</string>
	<string name="stats_followers_years">%1$d anos</string>
	<string name="stats_followers_a_month">Um mês</string>
	<string name="stats_followers_minutes">%1$d minutos</string>
	<string name="stats_followers_an_hour_ago">uma hora atrás</string>
	<string name="stats_for">Estatísticas para %s</string>
	<string name="stats_other_recent_stats_label">Outras estatísticas recentes</string>
	<string name="stats_view_all">Ver todos</string>
	<string name="stats_view">Exibir</string>
	<string name="stats_followers_months">%1$d meses</string>
	<string name="themes_fetching">Obtendo temas…</string>
	<string name="stats_followers_email_selector">E-mail</string>
	<string name="stats_followers_total_email">Total de seguidores por e-mail: %1$s</string>
	<string name="ssl_certificate_details">Detalhes</string>
	<string name="sure_to_remove_account">Remover este site?</string>
	<string name="delete_sure_post">Excluir este post</string>
	<string name="delete_sure">Excluir este rascunho</string>
	<string name="delete_sure_page">Excluir esta página</string>
	<string name="confirm_delete_multi_media">Excluir itens selecionados?</string>
	<string name="confirm_delete_media">Excluir item selecionado?</string>
	<string name="cab_selected">%d selecionados</string>
	<string name="media_gallery_date_range">Exibindo mídias de %1$s a %2$s</string>
	<string name="faq_button">Perguntas frequentes</string>
	<string name="agree_terms_of_service">Ao criar sua conta, você está concordando com os nossos %1$sTermos de Serviço%2$s</string>
	<string name="create_new_blog_wpcom">Crie um blog do WordPress.com</string>
	<string name="new_blog_wpcom_created">Seu blog do WordPress.com foi criado!</string>
	<string name="reader_empty_comments">Nenhum comentário</string>
	<string name="reader_empty_posts_in_tag">Nenhum post com esta tag</string>
	<string name="reader_label_comment_count_multi">%,d comentários</string>
	<string name="reader_label_view_original">Ver o artigo original</string>
	<string name="reader_label_like">Curtir</string>
	<string name="reader_label_liked_by">Curtido por</string>
	<string name="reader_label_comment_count_single">Um comentário</string>
	<string name="reader_label_comments_closed">Os comentários estão desativados</string>
	<string name="reader_label_comments_on">Comentários sobre</string>
	<string name="reader_title_photo_viewer">%1$d de %2$d</string>
	<string name="error_publish_empty_post">Não é possível publicar um post em branco</string>
	<string name="error_refresh_unauthorized_posts">Você não tem permissão para visualizar ou editar posts</string>
	<string name="error_refresh_unauthorized_pages">Você não tem permissão para visualizar ou editar páginas</string>
	<string name="error_refresh_unauthorized_comments">Você não tem permissão para visualizar ou editar comentários</string>
	<string name="older_month">Há mais de um mês</string>
	<string name="more">Mais</string>
	<string name="older_two_days">Há mais de 2 dias</string>
	<string name="older_last_week">Há mais de uma semana</string>
	<string name="stats_no_blog">Não foi possível carregar as estatísticas do blog</string>
	<string name="select_a_blog">Selecione um site do WordPress</string>
	<string name="uploading_total">Fazendo upload de %1$d de %2$d</string>
	<string name="mnu_comment_liked">Curtiu</string>
	<string name="comment">Comentário</string>
	<string name="comment_trashed">Comentário enviado para a lixeira</string>
	<string name="posts_empty_list">Nenhum post. Por que não criar um?</string>
	<string name="comment_reply_to_user">Responder %s</string>
	<string name="pages_empty_list">Nenhuma página. Por que não criar uma?</string>
	<string name="media_empty_list_custom_date">Nenhuma mídia no intervalo de tempo especificado</string>
	<string name="posting_post">Publicando "%s"</string>
	<string name="signing_out">Saindo…</string>
	<string name="reader_empty_posts_liked">Você não curtiu posts ainda</string>
	<string name="browse_our_faq_button">Veja nossa seção de Perguntas Frequentes</string>
	<string name="nux_help_description">Visite a central de ajuda para obter respostas para perguntas frequentes, ou visite os fóruns para fazer novas perguntas.</string>
	<string name="sending_content">Fazendo upload do conteúdo de %s</string>
	<string name="reader_empty_followed_blogs_title">Você ainda não está seguindo um site</string>
	<string name="reader_menu_block_blog">Bloquear este blog</string>
	<string name="reader_toast_err_block_blog">Não é possível bloquear este blog</string>
	<string name="reader_toast_err_generic">Não é possível executar esta ação</string>
	<string name="reader_toast_blog_blocked">Os posts deste blog não serão mais exibidos</string>
	<string name="contact_us">Contate nos</string>
	<string name="hs__conversation_detail_error">Descreva o problema que está experimentando</string>
	<string name="hs__new_conversation_header">Chat de Suporte</string>
	<string name="hs__conversation_header">Chat de Suporte</string>
	<string name="hs__username_blank_error">Digite um nome válido</string>
	<string name="hs__invalid_email_error">Digite um e-mail válido</string>
	<string name="add_location">Adicionar localização</string>
	<string name="current_location">Localização atual</string>
	<string name="search_location">Pesquisa</string>
	<string name="search_current_location">Localizar</string>
	<string name="edit_location">   Editar</string>
	<string name="preference_send_usage_stats">Enviar estatísticas</string>
	<string name="preference_send_usage_stats_summary">Envie estatísticas de uso automaticamente para nos ajudar a melhorar o WordPress para Android</string>
	<string name="update_verb">Atualizar</string>
	<string name="schedule_verb">Agendar</string>
	<string name="reader_title_subs">Tags e Blogs</string>
	<string name="reader_page_followed_tags">Tags seguidas</string>
	<string name="reader_label_followed_blog">Seguindo o blog</string>
	<string name="reader_label_tag_preview">Posts com tag %s</string>
	<string name="reader_toast_err_get_blog_info">Não é possível mostrar o blog</string>
	<string name="reader_toast_err_already_follow_blog">Você já segue o blog</string>
	<string name="reader_toast_err_follow_blog">Não é possível seguir o blog</string>
	<string name="reader_toast_err_unfollow_blog">Não é possível deixar de seguir o blog</string>
	<string name="reader_empty_recommended_blogs">Nenhum blog recomendado</string>
	<string name="reader_title_blog_preview">Blog do Leitor</string>
	<string name="reader_title_tag_preview">Tag do Leitor</string>
	<string name="reader_page_followed_blogs">Sites seguidos</string>
	<string name="reader_hint_add_tag_or_url">Insira um URL ou tag para seguir</string>
	<string name="saving">Salvando...</string>
	<string name="media_empty_list">Nenhuma mídia</string>
	<string name="ptr_tip_message">Dica: Arraste para baixo para atualizar</string>
	<string name="help">Ajuda</string>
	<string name="forgot_password">Perdeu a senha?</string>
	<string name="forums">Fóruns</string>
	<string name="help_center">Central de ajuda</string>
	<string name="ssl_certificate_error">Certificado SSL inválido</string>
	<string name="ssl_certificate_ask_trust">Se você geralmente se conecta a este site sem problemas, talvez este erro signifique que alguém está tentando imitar o site, e você não deve continuar. Deseja confiar no certificado mesmo assim?</string>
	<string name="notifications_empty_list">Sem notificações</string>
	<string name="out_of_memory">Dispositivo sem memória</string>
	<string name="no_network_message">Não há rede disponível</string>
	<string name="gallery_error">O item de mídia não pode ser recuperado</string>
	<string name="blog_not_found">Ocorreu um erro ao acessar este blog</string>
	<string name="wait_until_upload_completes">Aguarde até que o upload esteja completo</string>
	<string name="comments_empty_list">Sem comentários</string>
	<string name="mnu_comment_unspam">Não é spam</string>
	<string name="theme_auth_error_message">Tenha certeza que você tem privilégio para definir um tema</string>
	<string name="no_site_error">Não foi possível se conectar ao site do WordPress</string>
	<string name="adding_cat_failed">Problema ao adicionar categoria</string>
	<string name="could_not_remove_account">Não foi possível remover o site</string>
	<string name="stats_bar_graph_empty">Nenhuma estatística disponível</string>
	<string name="invalid_url_message">Verifique se a URL do blog inserida é válida</string>
	<string name="error_generic">Ocorreu um erro</string>
	<string name="error_edit_comment">Ocorreu um erro ao editar o comentário</string>
	<string name="error_load_comment">Não foi possível carregar o comentário</string>
	<string name="passcode_wrong_passcode">PIN errado</string>
	<string name="username_not_allowed">Nome de usuário não permitido</string>
	<string name="adding_cat_success">Categoria adicionada com êxito</string>
	<string name="cat_name_required">O campo de nome da categoria é obrigatório</string>
	<string name="category_automatically_renamed">O nome da categoria %1$s não é válido. Ela foi renomeada para %2$s.</string>
	<string name="no_account">Não foi encontrada uma conta WordPress, adicione uma conta e tente novamente</string>
	<string name="theme_fetch_failed">Falha ao buscar temas</string>
	<string name="theme_set_failed">Falha ao definir tema</string>
	<string name="sdcard_message">Um cartão SD montado é necessário para fazer upload de mídia</string>
	<string name="reply_failed">Ocorreu um erro na resposta</string>
	<string name="stats_empty_comments">Nenhum comentário</string>
	<string name="error_delete_post">Ocorreu um erro ao excluir o(a) %s</string>
	<string name="error_refresh_posts">Não foi possível atualizar os posts no momento</string>
	<string name="error_refresh_pages">Não foi possível atualizar as páginas no momento</string>
	<string name="error_refresh_notifications">Não foi possível atualizar as notificações no momento</string>
	<string name="error_refresh_comments">Não foi possível atualizar os comentários no momento</string>
	<string name="error_refresh_stats">Não foi possível atualizar as estatísticas no momento</string>
	<string name="error_moderate_comment">Ocorreu um erro ao moderar</string>
	<string name="error_upload">Ocorreu um erro ao carregar o(a) %s</string>
	<string name="error_downloading_image">Erro ao baixar a imagem</string>
	<string name="invalid_password_message">A senha deve ter 4 caracteres no mínimo</string>
	<string name="invalid_username_too_short">O nome de usuário deve ter mais de 4 caracteres</string>
	<string name="invalid_username_too_long">O nome de usuário deve ter 61 caracteres no máximo</string>
	<string name="username_only_lowercase_letters_and_numbers">O nome de usuário pode ter apenas letras minúsculas (a-z) e números</string>
	<string name="username_required">Digite um nome de usuário</string>
	<string name="username_must_be_at_least_four_characters">O nome de usuário deve ter 4 caracteres no mínimo</string>
	<string name="username_contains_invalid_characters">O nome de usuário não pode ter o caractere “_”</string>
	<string name="username_must_include_letters">O nome de usuário deve ter pelo menos uma letra (a-z)</string>
	<string name="username_exists">O nome de usuário já existe</string>
	<string name="username_reserved_but_may_be_available">No momento, o nome de usuário está reservado, mas pode estar disponível em alguns dias</string>
	<string name="blog_name_required">Digite um endereço de site</string>
	<string name="blog_name_not_allowed">O endereço do site não é permitido</string>
	<string name="blog_name_must_be_at_least_four_characters">O endereço do site deve ter 4 caracteres no mínimo</string>
	<string name="blog_name_must_be_less_than_sixty_four_characters">O endereço do site 64 caracteres</string>
	<string name="blog_name_contains_invalid_characters">O endereço do site não deve ter o caractere “_”</string>
	<string name="blog_name_cant_be_used">Não é possível usar esse endereço de site</string>
	<string name="blog_name_only_lowercase_letters_and_numbers">O endereço do site deve ter apenas letras minúsculas (a-z) e números</string>
	<string name="blog_name_exists">O site já existe</string>
	<string name="blog_name_reserved">O site está reservado</string>
	<string name="blog_name_reserved_but_may_be_available">No momento, o site está reservado, mas pode estar disponível em alguns dias</string>
	<string name="username_or_password_incorrect">O nome de usuário ou a senha digitada está incorreta</string>
	<string name="nux_cannot_log_in">Não é possível conectar</string>
	<string name="invalid_email_message">Seu endereço de e-mail é inválido</string>
	<string name="email_invalid">Digite um endereço de e-mail válido</string>
	<string name="email_not_allowed">O endereço de e-mail não é permitido</string>
	<string name="email_exists">O endereço de e-mail já está em uso</string>
	<string name="blog_removed_successfully">Site removido com sucesso</string>
	<string name="remove_account">Remover site</string>
	<string name="select_categories">Selecionar categorias</string>
	<string name="account_details">Detalhes da conta</string>
	<string name="edit_post">Editar post</string>
	<string name="add_comment">Adicionar comentário</string>
	<string name="connection_error">Erro de conexão</string>
	<string name="cancel_edit">Cancelar edição</string>
	<string name="post_not_found">Ocorreu um erro ao carregar o post. Atualize seus posts e tente novamente.</string>
	<string name="learn_more">Saiba mais</string>
	<string name="media_gallery_settings_title">Configurações da galeria</string>
	<string name="media_gallery_image_order">Ordem da imagem</string>
	<string name="media_gallery_num_columns">Número de colunas</string>
	<string name="media_gallery_edit">Editar galeria</string>
	<string name="theme_current_theme">Tema atual</string>
	<string name="create_a_link">Criar um link</string>
	<string name="page_settings">Configurações de página</string>
	<string name="local_draft">Rascunho local</string>
	<string name="horizontal_alignment">Alinhamento horizontal</string>
	<string name="delete_post">Excluir post</string>
	<string name="delete_page">Excluir página</string>
	<string name="comment_status_approved">Aprovado</string>
	<string name="comment_status_unapproved">Pendente</string>
	<string name="comment_status_spam">Spam</string>
	<string name="edit_comment">Editar comentário</string>
	<string name="mnu_comment_approve">Aprovar</string>
	<string name="mnu_comment_spam">Spam</string>
	<string name="dlg_approving_comments">Aprovando</string>
	<string name="dlg_spamming_comments">Marcando como spam</string>
	<string name="author_name">Nome do autor</string>
	<string name="author_url">URL do autor</string>
	<string name="hint_comment_content">Comentário</string>
	<string name="saving_changes">Salvando alterações</string>
	<string name="delete_draft">Excluir rascunho</string>
	<string name="preview_page">Visualizar página</string>
	<string name="preview_post">Visualizar post</string>
	<string name="comment_added">Comentário adicionado com êxito</string>
	<string name="add_new_category">Adicionar nova categoria</string>
	<string name="share_action_post">Novo post</string>
	<string name="share_action_media">Biblioteca de mídia</string>
	<string name="pending_review">Análise pendente</string>
	<string name="http_credentials">Credenciais HTTP (opcional)</string>
	<string name="new_post">Novo post</string>
	<string name="new_media">Nova mídia</string>
	<string name="privacy_policy">Política de privacidade</string>
	<string name="image_settings">Configurações de imagem</string>
	<string name="add_account_blog_url">Endereço do blog</string>
	<string name="reader_title_applog">Log do aplicativo</string>
	<string name="reader_share_link">Compartilhar link</string>
	<string name="required_field">Campo obrigatório</string>
	<string name="blog_name_invalid">Endereço de site inválido</string>
	<string name="xmlrpc_error">Não foi possível conectar. Digite o caminho completo para xmlrpc.php em seu site e tente novamente.</string>
	<string name="scaled_image_error">Insira um valor de largura dimensionado válido</string>
	<string name="media_gallery_type_thumbnail_grid">Grade de miniaturas</string>
	<string name="media_error_no_permission">Você não tem permissões para visualizar a biblioteca de mídia</string>
	<string name="cannot_delete_multi_media_items">No momento, não é possível excluir algumas mídias. Tente novamente mais tarde.</string>
	<string name="themes_live_preview">Visualização ao vivo</string>
	<string name="theme_premium_theme">Tema Premium</string>
	<string name="link_enter_url_text">Vincular texto (opcional)</string>
	<string name="upload_failed">Falha ao carregar</string>
	<string name="file_not_found">Não foi possível encontrar o arquivo de mídia para carregar. Ele foi excluído ou movido?</string>
	<string name="post_settings">Configurações do post</string>
	<string name="comment_status_trash">Na lixeira</string>
	<string name="mnu_comment_unapprove">Desaprovar</string>
	<string name="mnu_comment_trash">Lixeira</string>
	<string name="dlg_unapproving_comments">Desaprovando</string>
	<string name="dlg_trashing_comments">Enviando para a lixeira</string>
	<string name="dlg_confirm_trash_comments">Enviar para a lixeira?</string>
	<string name="trash_yes">Lixeira</string>
	<string name="trash_no">Não é lixo</string>
	<string name="trash">Lixeira</string>
	<string name="sure_to_cancel_edit_comment">Cancelar edição do comentário?</string>
	<string name="content_required">Comentário obrigatório</string>
	<string name="toast_comment_unedited">Comentário não foi alterado</string>
	<string name="view_in_browser">Exibir no navegador</string>
	<string name="category_name">Nome da categoria</string>
	<string name="category_slug">Slug da categoria (opcional)</string>
	<string name="category_desc">Descrição da categoria (opcional)</string>
	<string name="category_parent">Categoria secundária (opcional):</string>
	<string name="file_error_create">Não foi possível criar um arquivo temporário para carregar a mídia. Certifique-se de que há espaço livro suficiente em seu dispositivo.</string>
	<string name="location_not_found">Localização desconhecida</string>
	<string name="open_source_licenses">Abrir licenças da origem</string>
	<string name="http_authorization_required">Autorização obrigatória</string>
	<string name="post_format">Formato do post</string>
	<string name="view_site">Exibir site</string>
	<string name="local_changes">Alterações de local</string>
	<string name="wordpress_blog">Blog WordPress</string>
	<string name="error_blog_hidden">Este blog está oculto e não foi possível carregá-lo. Habilite-o em configurações e tente novamente.</string>
	<string name="fatal_db_error">Ocorreu um erro ao criar o banco de dados do aplicativo. Tente reinstalar o aplicativo.</string>
	<string name="jetpack_message_not_admin">O plug-in Jetpack é necessário para obter estatísticas. Contate o administrador do site.</string>
	<string name="reader_toast_err_add_tag">Não é possível adicionar a tag</string>
	<string name="reader_toast_err_remove_tag">Não é possível remover a tag</string>
	<string name="site_address">Seu endereço auto-hospedado (URL)</string>
	<string name="blog_name_must_include_letters">O endereço do site deve ter pelo menos uma letra (a-z)</string>
	<string name="blog_title_invalid">Título do site inválido</string>
	<string name="notifications_empty_all">Nenhuma notificação... ainda.</string>
	<string name="invalid_site_url_message">Verifique se a URL do site inserida é válida</string>
	<string name="page_not_published">A página não está publicada</string>
	<string name="post_not_published">O post não está publicado</string>
	<string name="author_email">E-mail do autor</string>
	<string name="email_hint">Endereço de e-mail</string>
	<string name="email_cant_be_used_to_signup">Não é possível usar esse endereço de e-mail para se inscrever. Esse provedor bloqueia alguns de nossos e-mails. Use outro provedor de e-mail.</string>
	<string name="email_reserved">Este endereço de e-mail já está em uso Verifique se há um e-mail de ativação na sua caixa de entrada. Se você não ativar, poderá tentar novamente em alguns dias.</string>
	<string name="deleting_page">Excluindo página</string>
	<string name="deleting_post">Excluindo post</string>
	<string name="share_url_post">Compartilhar post</string>
	<string name="share_url_page">Compartilhar página</string>
	<string name="share_link">Compartilhar link</string>
	<string name="creating_your_account">Criando sua conta</string>
	<string name="creating_your_site">Criando seu site</string>
	<string name="error_refresh_media">Alguma coisa deu errado durante a atualização da biblioteca de mídia. Tente novamente mais tarde.</string>
	<string name="reader_empty_posts_in_tag_updating">Coletando posts...</string>
	<string name="reader_likes_you_and_multi">Você e %,d outros curtiram isso</string>
	<string name="reader_likes_multi">%,d pessoas curtiram isso</string>
	<string name="reader_toast_err_get_comment">Não foi possível recuperar esse comentário</string>
	<string name="reader_label_reply">Responder</string>
	<string name="video">Vídeo</string>
	<string name="download">Fazendo download de mídia</string>
	<string name="comment_spammed">Comentário marcado como spam</string>
	<string name="cant_share_no_visible_blog">Você não pode compartilhar no WordPress sem um blog visível</string>
	<string name="select_time">Selecione o tempo</string>
	<string name="reader_likes_you_and_one">Você e mais um gostaram disso</string>
	<string name="select_date">Selecione a data</string>
	<string name="pick_photo">Selecione a foto</string>
	<string name="account_two_step_auth_enabled">Essa conta possui a autenticação em duas etapas ativada. Visite suas configurações de segurança no WordPress.com e gere uma senha específica para aplicativos.</string>
	<string name="pick_video">Selecionar vídeo</string>
	<string name="reader_toast_err_get_post">Não foi possível recuperar esse post</string>
	<string name="validating_user_data">Validando dados de usuário</string>
	<string name="validating_site_data">Validando dados do site</string>
	<string name="reader_empty_followed_blogs_description">Não se preocupe! Toque no ícone na parte superior direita para começar a explorar!</string>
	<string name="password_invalid">Você precisa de uma senha mais segura. Use mais de 7 caracteres, misture letras maiúsculas com minúsculas, números ou caracteres especiais.</string>
	<string name="nux_tap_continue">Continuar</string>
	<string name="nux_welcome_create_account">Criar conta</string>
	<string name="nux_add_selfhosted_blog">Adicionar site hospedado</string>
	<string name="nux_oops_not_selfhosted_blog">Entrar no WordPress.com</string>
	<string name="signing_in">Entrando...</string>
	<string name="media_add_popup_title">Adicionar à biblioteca de mídia</string>
	<string name="media_add_new_media_gallery">Criar galeria</string>
	<string name="select_from_media_library">Selecione a partir de biblioteca de mídia</string>
	<string name="jetpack_message">O plugin Jetpack é necessário para as estatísticas. Você quer instalar o Jetpack?</string>
	<string name="jetpack_not_found">Plugin Jetpack não encontrado</string>
	<string name="reader_btn_follow">Seguir </string>
	<string name="reader_btn_share">Compartilhar</string>
	<string name="reader_label_removed_tag">Excluído %s</string>
	<string name="reader_likes_one">Uma pessoa curte isto</string>
	<string name="reader_likes_only_you">Você curte isto</string>
	<string name="reader_toast_err_comment_failed">Não foi possível postar o seu comentário </string>
	<string name="reader_toast_err_tag_exists">Você já segue essa tag</string>
	<string name="reader_toast_err_tag_invalid">Esta tag não é válida</string>
	<string name="reader_toast_err_share_intent">Não é possível compartilhar </string>
	<string name="reader_toast_err_view_image">Não é possível visualizar a imagem </string>
	<string name="reader_toast_err_url_intent">Não é possível abrir %s</string>
	<string name="button_next">Próximo </string>
	<string name="reader_untitled_post">(Sem título)</string>
	<string name="reader_share_subject">Compartilhado de %s</string>
	<string name="reader_btn_unfollow">Seguindo</string>
	<string name="connecting_wpcom">Conectando ao WordPress.com</string>
	<string name="reader_hint_comment_on_comment">Responda para comentar</string>
	<string name="nux_tutorial_get_started_title">Iniciar Tutorial</string>
	<string name="username_invalid">Nome de usuário inválido</string>
	<string name="limit_reached">Limite atingido. Você pode tentar novamente em 1 minuto. Tentando novamente antes só vai aumentar o tempo de espera antes do impedimento ser levantado. Se você acha que isso é um erro, contate o suporte.</string>
	<string name="empty_list_default">Esta lista está vazia</string>
	<string name="reader_label_added_tag">Adicionado %s</string>
	<string name="reader_empty_followed_tags">Você não segue nenhuma tag</string>
	<string name="create_account_wpcom">Crie uma conta no WordPress.com</string>
	<string name="images">Imagens</string>
	<string name="all">Tudo</string>
	<string name="unattached">Desanexado</string>
	<string name="media_add_popup_capture_photo">Capturar foto</string>
	<string name="media_add_popup_capture_video">Capturar vídeo</string>
	<string name="themes">Temas</string>
	<string name="media_edit_title_text">Título</string>
	<string name="media_edit_caption_text">Legenda</string>
	<string name="media_edit_description_text">Descrição</string>
	<string name="media_gallery_type">Tipo</string>
	<string name="media_edit_description_hint">Escreva a descrição aqui</string>
	<string name="media_edit_success">Atualizado</string>
	<string name="media_edit_failure">Falha na atualização</string>
	<string name="themes_details_label">Detalhes</string>
	<string name="share_action_title">Adicionar para...</string>
	<string name="stats_view_tags_and_categories">Tags e Categorias</string>
	<string name="stats_view_clicks">Cliques</string>
	<string name="stats_timeframe_today">Hoje</string>
	<string name="stats_view_referrers">Referências</string>
	<string name="stats_timeframe_yesterday">Ontem</string>
	<string name="stats_timeframe_days">Dias</string>
	<string name="stats_timeframe_weeks">Semanas</string>
	<string name="stats_timeframe_months">Meses</string>
	<string name="stats_entry_country">Pais</string>
	<string name="stats_entry_posts_and_pages">Titulo</string>
	<string name="stats_entry_tags_and_categories">Tópico</string>
	<string name="stats_entry_authors">Autor</string>
	<string name="stats_totals_views">Vistas</string>
	<string name="stats_totals_clicks">Cliques</string>
	<string name="stats_entry_referrers">Referências</string>
	<string name="stats_totals_plays">Tocados</string>
	<string name="media_gallery_type_squares">Quadrados</string>
	<string name="media_gallery_type_circles">Circulos</string>
	<string name="media_gallery_type_slideshow">Slideshow</string>
	<string name="media_edit_caption_hint">Digite uma legenda aqui</string>
	<string name="media_edit_title_hint">Digite um título aqui</string>
	<string name="media_gallery_image_order_reverse">Ao contrário</string>
	<string name="post_excerpt">Resumo</string>
	<string name="share_action">Compartilhar</string>
	<string name="theme_activate_button">Ativado</string>
	<string name="theme_activating_button">Ativando</string>
	<string name="themes_features_label">Recursos</string>
	<string name="media_gallery_type_tiled">Mosaico</string>
	<string name="passcode_enter_passcode">Entre seu PIN</string>
	<string name="passcode_enter_old_passcode">Entre seu PIN antigo</string>
	<string name="passcode_re_enter_passcode">Entre seu PIN novamente</string>
	<string name="passcode_change_passcode">Mudar PIN</string>
	<string name="passcode_set">Definir PIN</string>
	<string name="custom_date">Data personalizada</string>
	<string name="media_gallery_image_order_random">Aleatório</string>
	<string name="theme_auth_error_title">Falhou ao obter temas</string>
	<string name="theme_set_success">Tema configurado com sucesso!</string>
	<string name="passcode_turn_off">Desligar o bloqueio do código PIN</string>
	<string name="passcode_turn_on">Ligar o bloqueio do código PIN</string>
	<string name="passcode_preference_title">Código PIN</string>
	<string name="passcode_manage">Gerenciar seu código PIN.</string>
	<string name="stats_view_visitors_and_views">Visitantes e Visualizações</string>
	<string name="stats">Estatísticas</string>
	<string name="upload">Enviar</string>
	<string name="discard">Descartar</string>
	<string name="notifications">Notificações</string>
	<string name="note_reply_successful">Resposta publicada</string>
	<string name="new_notifications">%d novas notificações</string>
	<string name="more_notifications">e %d mais.</string>
	<string name="sign_in">Entrar</string>
	<string name="follows">Segue</string>
	<string name="loading">Carregando...</string>
	<string name="httpuser">Usuário HTTP</string>
	<string name="httppassword">Senha HTTP</string>
	<string name="error_media_upload">Ocorreu um erro durante o envio de mídia</string>
	<string name="post_content">Conteúdo (Toque para adicionar texto e mídia)</string>
	<string name="publish_date">Publicar</string>
	<string name="content_description_add_media">Adicionar mídia</string>
	<string name="incorrect_credentials">Usuário ou senha incorreta.</string>
	<string name="password">Senha</string>
	<string name="username">Usuário</string>
	<string name="reader">Leitor</string>
	<string name="featured_in_post">Incluir imagem no conteúdo do post</string>
	<string name="pages">Páginas</string>
	<string name="caption">Legenda (opcional)</string>
	<string name="width">Largura</string>
	<string name="posts">Posts</string>
	<string name="anonymous">Anônimo</string>
	<string name="page">Página</string>
	<string name="post">Post</string>
	<string name="no_network_title">Não há rede disponível </string>
	<string name="featured">Usar uma Imagem Destacada</string>
	<string name="ok">OK</string>
	<string name="blogusername">usrenamedoblog</string>
	<string name="scaled_image">Largura da imagem</string>
	<string name="upload_scaled_image">Enviar e link para a imagem redimensionada</string>
	<string name="scheduled">Agendado</string>
	<string name="link_enter_url">URL</string>
	<string name="uploading">Enviando...</string>
	<string name="version">Versão</string>
	<string name="tos">Termos de Serviço</string>
	<string name="app_title">WordPress para Android</string>
	<string name="max_thumbnail_px_width">Largura padrão de imagem</string>
	<string name="image_alignment">Alinhamento</string>
	<string name="refresh">Atualizar</string>
	<string name="untitled">Sem Título</string>
	<string name="edit">Editar</string>
	<string name="post_id">Post</string>
	<string name="page_id">Página</string>
	<string name="post_password">Senha (opcional)</string>
	<string name="immediately">Imediatamente</string>
	<string name="quickpress_add_alert_title">Definir o nome do atalho</string>
	<string name="today">Hoje</string>
	<string name="settings">Configurações</string>
	<string name="share_url">Compartilhar URL</string>
	<string name="quickpress_window_title">Selecione blog para atalho QuickPress</string>
	<string name="quickpress_add_error">Nome do atalho não pode ser vazio</string>
	<string name="publish_post">Publicar</string>
	<string name="draft">Rascunho</string>
	<string name="post_private">Privado</string>
	<string name="upload_full_size_image">Fazer upload e obter link para a imagem no tamanho original</string>
	<string name="title">Título</string>
	<string name="tags_separate_with_commas">Tags (separe tags com vírgulas)</string>
	<string name="categories">Categorias</string>
	<string name="dlg_deleting_comments">Deletando comentários</string>
	<string name="notification_vibrate">Vibrar</string>
	<string name="notification_blink">Piscar luz de notificação</string>
	<string name="notification_sound">Som de notificação</string>
	<string name="status">Status</string>
	<string name="location">Localização</string>
	<string name="sdcard_title">Cartão SD necessário</string>
	<string name="select_video">Selecionar um vídeo da galeria</string>
	<string name="media">Mídia</string>
	<string name="delete">Excluir</string>
	<string name="none">Nenhum</string>
	<string name="blogs">Blogs</string>
	<string name="select_photo">Selecione uma foto da galeria</string>
	<string name="yes">Sim</string>
	<string name="no">Não</string>
	<string name="error">Erro</string>
	<string name="cancel">Cancelar</string>
	<string name="save">Salvar</string>
	<string name="add">Adicionar</string>
	<string name="category_refresh_error">Erro na atualização da categoria</string>
	<string name="on">em</string>
	<string name="reply">Responder</string>
	<string name="preview">Pré-visualizar</string>
	<string name="notification_settings">Configurações de notificações</string>
</resources>
