# Brazilian Portuguese translations for gnulib package
# Traduções em português brasileiro para o pacote gnulib
# Copyright (C) 2019 Free Software Foundation, Inc.
# This file is distributed under the same license as the gnulib package.
# Cyro Mendes De Moraes Neto <neto@conectiva.com.br>, 1998.
# Rodrigo Stulzer Lopes <rodrigo@conectiva.com.br>, 2001.
# Juan Carlos Castro y Castro <jcastro@vialink.com.br>, 2003.
# Rafael Fontenelle <rafaelff@gnome.org>, 2013, 2017, 2019.
msgid ""
msgstr ""
"Project-Id-Version: gnulib 4.0.0.2567\n"
"Report-Msgid-Bugs-To: bug-gnulib@gnu.org\n"
"POT-Creation-Date: 2019-12-11 07:43+0100\n"
"PO-Revision-Date: 2019-05-19 09:10-0200\n"
"Last-Translator: Rafael Fontenelle <rafaelff@gnome.org>\n"
"Language-Team: Brazilian Portuguese <ldpbr-translation@lists.sourceforge."
"net>\n"
"Language: pt_BR\n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=2; plural=(n > 1);\n"
"X-Generator: Virtaal 1.0.0-beta1\n"
"X-Bugs: Report translation errors to the Language-Team address.\n"

# , c-format
#: lib/argmatch.c:132
#, c-format
msgid "invalid argument %s for %s"
msgstr "argumento inválido %s para %s"

#: lib/argmatch.c:133
#, c-format
msgid "ambiguous argument %s for %s"
msgstr "argumento ambíguo %s para %s"

#: lib/argmatch.c:152 lib/argmatch.h:223
msgid "Valid arguments are:"
msgstr "Argumentos válidos são:"

#: lib/bitset/stats.c:177
#, c-format
msgid "%u bitset_allocs, %u freed (%.2f%%).\n"
msgstr "%u bitset_allocs, %u liberados (%.2f%%).\n"

#: lib/bitset/stats.c:180
#, c-format
msgid "%u bitset_sets, %u cached (%.2f%%)\n"
msgstr "%u bitset_sets, %u em cache (%.2f%%)\n"

#: lib/bitset/stats.c:183
#, c-format
msgid "%u bitset_resets, %u cached (%.2f%%)\n"
msgstr "%u bitset_resets, %u em cache (%.2f%%)\n"

#: lib/bitset/stats.c:186
#, c-format
msgid "%u bitset_tests, %u cached (%.2f%%)\n"
msgstr "%u bitset_tests, %u em cache (%.2f%%)\n"

#: lib/bitset/stats.c:190
#, c-format
msgid "%u bitset_lists\n"
msgstr "%u bitset_lists\n"

#: lib/bitset/stats.c:192
msgid "count log histogram\n"
msgstr "histograma de log de contagem\n"

#: lib/bitset/stats.c:195
msgid "size log histogram\n"
msgstr "histograma de log de tamanho\n"

#: lib/bitset/stats.c:198
msgid "density histogram\n"
msgstr "histograma de densidade\n"

#: lib/bitset/stats.c:210
#, c-format
msgid ""
"Bitset statistics:\n"
"\n"
msgstr ""
"Estatística de bitset:\n"
"\n"

#: lib/bitset/stats.c:213
#, c-format
msgid "Accumulated runs = %u\n"
msgstr "Execuções acumuladas = %u\n"

# , c-format
#: lib/bitset/stats.c:255 lib/bitset/stats.c:260
msgid "cannot read stats file"
msgstr "não foi possível ler o arquivo de estado"

#: lib/bitset/stats.c:257
#, c-format
msgid "bad stats file size\n"
msgstr "tamanho inválido de arquivo de estado\n"

# , c-format
#: lib/bitset/stats.c:281 lib/bitset/stats.c:283
msgid "cannot write stats file"
msgstr "não foi possível escrever o arquivo de estado"

#: lib/bitset/stats.c:286
msgid "cannot open stats file for writing"
msgstr "não foi possível abrir o arquivo de estado para escrita"

#: lib/closeout.c:122
msgid "write error"
msgstr "erro de escrita"

#: lib/error.c:195
msgid "Unknown system error"
msgstr "Erro desconhecido de sistema"

#: lib/getopt.c:278
#, c-format
msgid "%s: option '%s%s' is ambiguous\n"
msgstr "%s: a opção \"%s%s\" é ambígua\n"

#: lib/getopt.c:284
#, c-format
msgid "%s: option '%s%s' is ambiguous; possibilities:"
msgstr "%s: a opção \"%s%s\" é ambígua; possibilidades:"

# , c-format
#: lib/getopt.c:319
#, c-format
msgid "%s: unrecognized option '%s%s'\n"
msgstr "%s: opção desconhecida \"%s%s\"\n"

#: lib/getopt.c:345
#, c-format
msgid "%s: option '%s%s' doesn't allow an argument\n"
msgstr "%s: a opção \"%s%s\" não permite um argumento\n"

#: lib/getopt.c:360
#, c-format
msgid "%s: option '%s%s' requires an argument\n"
msgstr "%s: a opção \"%s%s\" exige um argumento\n"

# , c-format
#: lib/getopt.c:621
#, c-format
msgid "%s: invalid option -- '%c'\n"
msgstr "%s: opção inválida -- \"%c\"\n"

#: lib/getopt.c:636 lib/getopt.c:682
#, c-format
msgid "%s: option requires an argument -- '%c'\n"
msgstr "%s: a opção exige um argumento -- \"%c\"\n"

#: lib/obstack.c:338 lib/obstack.c:340 lib/xalloc-die.c:34
msgid "memory exhausted"
msgstr "memória esgotada"

#. TRANSLATORS:
#. Get translations for open and closing quotation marks.
#. The message catalog should translate "`" to a left
#. quotation mark suitable for the locale, and similarly for
#. "'".  For example, a French Unicode local should translate
#. these to U+00AB (LEFT-POINTING DOUBLE ANGLE
#. QUOTATION MARK), and U+00BB (RIGHT-POINTING DOUBLE ANGLE
#. QUOTATION MARK), respectively.
#.
#. If the catalog has no translation, we will try to
#. use Unicode U+2018 (LEFT SINGLE QUOTATION MARK) and
#. Unicode U+2019 (RIGHT SINGLE QUOTATION MARK).  If the
#. current locale is not Unicode, locale_quoting_style
#. will quote 'like this', and clocale_quoting_style will
#. quote "like this".  You should always include translations
#. for "`" and "'" even if U+2018 and U+2019 are appropriate
#. for your locale.
#.
#. If you don't know what to put here, please see
#. <https://en.wikipedia.org/wiki/Quotation_marks_in_other_languages>
#. and use glyphs suitable for your language.
#: lib/quotearg.c:362
msgid "`"
msgstr "“"

#: lib/quotearg.c:363
msgid "'"
msgstr "”"

# , c-format
#: lib/spawn-pipe.c:141 lib/spawn-pipe.c:144 lib/spawn-pipe.c:265
#: lib/spawn-pipe.c:268
#, c-format
msgid "cannot create pipe"
msgstr "não foi possível criar redirecionamento"

# , c-format
#: lib/spawn-pipe.c:235 lib/spawn-pipe.c:349 lib/wait-process.c:290
#: lib/wait-process.c:364
#, c-format
msgid "%s subprocess failed"
msgstr "subprocesso %s falhou"

#: lib/timevar.c:316
msgid "Execution times (seconds)"
msgstr "Tempos de execução (segundos)"

#: lib/timevar.c:318
msgid "CPU user"
msgstr "CPU usuário"

#: lib/timevar.c:318
msgid "CPU system"
msgstr "CPU sistema"

# Sinal SIGALRM
#: lib/timevar.c:318
msgid "wall clock"
msgstr "relógio de parede"

#: lib/w32spawn.h:49
#, c-format
msgid "_open_osfhandle failed"
msgstr "_open_osfhandle falhou"

#: lib/w32spawn.h:90
#, c-format
msgid "cannot restore fd %d: dup2 failed"
msgstr "não foi possível restaurar descritor de arquivo %d: dup2 falhou"

# , c-format
#: lib/wait-process.c:231 lib/wait-process.c:263 lib/wait-process.c:325
#, c-format
msgid "%s subprocess"
msgstr "subprocesso %s"

# , c-format
#: lib/wait-process.c:282 lib/wait-process.c:354
#, c-format
msgid "%s subprocess got fatal signal %d"
msgstr "o subprocesso %s recebeu sinal fatal %d"

#~ msgid "Packaged by %s (%s)\n"
#~ msgstr "Empacotado por %s (%s)\n"

#~ msgid "Packaged by %s\n"
#~ msgstr "Empacotado por %s\n"

#~ msgid "(C)"
#~ msgstr "(C)"

#~ msgid ""
#~ "License GPLv3+: GNU GPL version 3 or later <%s>.\n"
#~ "This is free software: you are free to change and redistribute it.\n"
#~ "There is NO WARRANTY, to the extent permitted by law.\n"
#~ msgstr ""
#~ "Licença GPLv3+: GNU GPL versão 3 ou posterior <%s>\n"
#~ "Este é um software livre: você é livre para alterá-lo e redistribuí-lo.\n"
#~ "NÃO HÁ QUALQUER GARANTIA, na máxima extensão permitida em lei.\n"

#~ msgid "Written by %s.\n"
#~ msgstr "Escrito por %s.\n"

#~ msgid "Written by %s and %s.\n"
#~ msgstr "Escrito por %s e %s.\n"

#~ msgid "Written by %s, %s, and %s.\n"
#~ msgstr "Escrito por %s, %s e %s.\n"

#~ msgid ""
#~ "Written by %s, %s, %s,\n"
#~ "and %s.\n"
#~ msgstr ""
#~ "Escrito por %s, %s, %s\n"
#~ "e %s.\n"

#~ msgid ""
#~ "Written by %s, %s, %s,\n"
#~ "%s, and %s.\n"
#~ msgstr ""
#~ "Escrito por %s, %s, %s,\n"
#~ "%s e %s.\n"

#~ msgid ""
#~ "Written by %s, %s, %s,\n"
#~ "%s, %s, and %s.\n"
#~ msgstr ""
#~ "Escrito por %s, %s, %s,\n"
#~ "%s, %s e %s.\n"

#~ msgid ""
#~ "Written by %s, %s, %s,\n"
#~ "%s, %s, %s, and %s.\n"
#~ msgstr ""
#~ "Escrito por %s, %s, %s,\n"
#~ "%s, %s, %s e %s.\n"

#~ msgid ""
#~ "Written by %s, %s, %s,\n"
#~ "%s, %s, %s, %s,\n"
#~ "and %s.\n"
#~ msgstr ""
#~ "Escrito por %s, %s, %s,\n"
#~ "%s, %s, %s, %s\n"
#~ "e %s.\n"

#~ msgid ""
#~ "Written by %s, %s, %s,\n"
#~ "%s, %s, %s, %s,\n"
#~ "%s, and %s.\n"
#~ msgstr ""
#~ "Escrito por %s, %s, %s,\n"
#~ "%s, %s, %s, %s,\n"
#~ "%s e %s.\n"

#~ msgid ""
#~ "Written by %s, %s, %s,\n"
#~ "%s, %s, %s, %s,\n"
#~ "%s, %s, and others.\n"
#~ msgstr ""
#~ "Escrito por %s, %s, %s,\n"
#~ "%s, %s, %s, %s,\n"
#~ "%s, %s e outros.\n"

# Adicionado endereço de email da equipe, conforme solicitação do desenvolvedor -- Rafael
#~ msgid "Report bugs to: %s\n"
#~ msgstr ""
#~ "Relate erros para: %s\n"
#~ "Relate erros de tradução para <http://ldpbr-translation@lists.sourceforge."
#~ "net>\n"

#~ msgid "Report %s bugs to: %s\n"
#~ msgstr "Relate erros do %s para: %s\n"

#~ msgid "%s home page: <%s>\n"
#~ msgstr "Página do %s: <%s>\n"

#~ msgid "General help using GNU software: <%s>\n"
#~ msgstr "Ajuda para uso de softwares GNU: <%s>\n"

#~ msgid "ARGP_HELP_FMT: %s value is less than or equal to %s"
#~ msgstr "ARGP_HELP_FMT: O valor %s é menor do que ou igual a %s"

#~ msgid "%.*s: ARGP_HELP_FMT parameter requires a value"
#~ msgstr "%.*s: O parâmetro ARGP_HELP_FMT exige um valor"

#~ msgid "%.*s: Unknown ARGP_HELP_FMT parameter"
#~ msgstr "%.*s: Parâmetro ARGP_HELP_FMT desconhecido"

#~ msgid "Garbage in ARGP_HELP_FMT: %s"
#~ msgstr "Lixo em ARGP_HELP_FMT: %s"

#~ msgid ""
#~ "Mandatory or optional arguments to long options are also mandatory or "
#~ "optional for any corresponding short options."
#~ msgstr ""
#~ "Argumentos obrigatórios ou opcionais para opções longas também o são para "
#~ "quaisquer opções curtas correspondentes."

#~ msgid "Usage:"
#~ msgstr "Uso:"

#~ msgid "  or: "
#~ msgstr " ou: "

# , c-format
#~ msgid " [OPTION...]"
#~ msgstr " [OPÇÃO...]"

# , c-format
#~ msgid "Try '%s --help' or '%s --usage' for more information.\n"
#~ msgstr "Tente \"%s --help\" ou \"%s --usage\" para mais informação.\n"

#~ msgid "Report bugs to %s.\n"
#~ msgstr "Relate erros para %s.\n"

#~ msgid "give this help list"
#~ msgstr "fornece esta lista de ajuda"

#~ msgid "give a short usage message"
#~ msgstr "fornece uma mensagem de uso curta"

#~ msgid "NAME"
#~ msgstr "NOME"

#~ msgid "set the program name"
#~ msgstr "define o nome do programa"

#~ msgid "SECS"
#~ msgstr "SEGS"

#~ msgid "hang for SECS seconds (default 3600)"
#~ msgstr "segura por SEGS segundos (padrão 3600)"

#~ msgid "print program version"
#~ msgstr "mostra a versão do programa"

#~ msgid "(PROGRAM ERROR) No version known!?"
#~ msgstr "(ERRO NO PROGRAMA) Nenhuma versão conhecida!?"

#~ msgid "%s: Too many arguments\n"
#~ msgstr "%s: Número excessivo de argumentos\n"

#~ msgid "(PROGRAM ERROR) Option should have been recognized!?"
#~ msgstr "(ERRO NO PROGRAMA) A opção deveria ter sido reconhecida!?"

#~ msgid "program error"
#~ msgstr "erro do programa"

#~ msgid "stack overflow"
#~ msgstr "estouro de pilha"

#~ msgid "cannot find a temporary directory, try setting $TMPDIR"
#~ msgstr ""
#~ "não foi possível localizar um diretório temporário, tente definir $TMPDIR"

# , c-format
#~ msgid "cannot create a temporary directory using template \"%s\""
#~ msgstr ""
#~ "não foi possível criar um diretório temporário usando o modelo \"%s\""

# , c-format
#~ msgid "cannot remove temporary file %s"
#~ msgstr "não foi possível remover o arquivo temporário %s"

# , c-format
#~ msgid "cannot remove temporary directory %s"
#~ msgstr "não foi possível remover o diretório temporário %s"

#~ msgid "error closing file"
#~ msgstr "erro ao fechar o arquivo"

# , c-format
#~ msgid "preserving permissions for %s"
#~ msgstr "preservando permissões de %s"

#~ msgid "error while opening %s for reading"
#~ msgstr "erro ao abrir %s para leitura"

#~ msgid "cannot open backup file %s for writing"
#~ msgstr "não foi possível abrir o arquivo backup %s para escrita"

# , c-format
#~ msgid "error reading %s"
#~ msgstr "erro ao ler %s"

# , c-format
#~ msgid "error writing %s"
#~ msgstr "erro ao escrever %s"

# , c-format
#~ msgid "error after reading %s"
#~ msgstr "erro após leitura de %s"

#~ msgid "fdopen() failed"
#~ msgstr "fdopen() falhou"

#~ msgid "C# compiler not found, try installing mono"
#~ msgstr "O compilador C# não foi localizado, tente instalar mono"

#~ msgid "C# virtual machine not found, try installing mono"
#~ msgstr "A máquina virtual C# não foi localizada, tente instalar mono"

#~ msgid "unbalanced ["
#~ msgstr "[ não balanceado"

# , c-format
#~ msgid "invalid character class"
#~ msgstr "classe de caracteres inválida"

#~ msgid "character class syntax is [[:space:]], not [:space:]"
#~ msgstr "a sintaxe da classe de caracteres é [[:space:]], não [:space:]"

#~ msgid "unfinished \\ escape"
#~ msgstr "escape \\ não finalizado"

#~ msgid "invalid content of \\{\\}"
#~ msgstr "conteúdo inválido de \\{\\}"

# , c-format
#~ msgid "regular expression too big"
#~ msgstr "expressão regular grande demais"

#~ msgid "unbalanced ("
#~ msgstr "( não balanceado"

#~ msgid "no syntax specified"
#~ msgstr "nenhuma sintaxe especificada"

#~ msgid "unbalanced )"
#~ msgstr ") não balanceado"

#~ msgid "regular empty file"
#~ msgstr "arquivo comum vazio"

#~ msgid "regular file"
#~ msgstr "arquivo comum"

#~ msgid "directory"
#~ msgstr "diretório"

#~ msgid "symbolic link"
#~ msgstr "link simbólico"

#~ msgid "message queue"
#~ msgstr "fila de mensagem"

#~ msgid "semaphore"
#~ msgstr "semáforo"

#~ msgid "shared memory object"
#~ msgstr "objeto de memória compartilhada"

#~ msgid "typed memory object"
#~ msgstr "objeto de memória tipificada"

#~ msgid "block special file"
#~ msgstr "arquivo especial de bloco"

#~ msgid "character special file"
#~ msgstr "arquivo especial de caractere"

#~ msgid "contiguous data"
#~ msgstr "dados contíguos"

# first-in, first-out; abreviação muito usada no meio computacional em português -- Rafael
#~ msgid "fifo"
#~ msgstr "fifo"

# https://en.wikipedia.org/wiki/Unix_file_types#Door
# Não traduzir para porta para evitar confusão com "port"
#~ msgid "door"
#~ msgstr "door"

#~ msgid "multiplexed block special file"
#~ msgstr "arquivo multiplexado especial de bloco"

#~ msgid "multiplexed character special file"
#~ msgstr "arquivo multiplexado especial de caractere"

#~ msgid "multiplexed file"
#~ msgstr "arquivo multiplexado"

#~ msgid "named file"
#~ msgstr "arquivo nomeado"

#~ msgid "network special file"
#~ msgstr "arquivo especial de rede"

#~ msgid "migrated file with data"
#~ msgstr "arquivo migrado com dados"

#~ msgid "migrated file without data"
#~ msgstr "arquivo migrado sem dados"

#~ msgid "port"
#~ msgstr "porta"

#~ msgid "socket"
#~ msgstr "soquete"

#~ msgid "whiteout"
#~ msgstr "whiteout"

#~ msgid "weird file"
#~ msgstr "arquivo estranho"

#~ msgid "Address family for hostname not supported"
#~ msgstr "Não há suporte para família de endereços para nome de máquina"

#~ msgid "Temporary failure in name resolution"
#~ msgstr "Falha temporária na resolução de nome"

#~ msgid "Bad value for ai_flags"
#~ msgstr "Valor inválido para ai_flags"

#~ msgid "Non-recoverable failure in name resolution"
#~ msgstr "Falha irrecuperável na resolução de nome"

#~ msgid "ai_family not supported"
#~ msgstr "Não há suporte a ai_family"

#~ msgid "Memory allocation failure"
#~ msgstr "Falha na alocação de memória"

#~ msgid "No address associated with hostname"
#~ msgstr "Nenhum endereço associado ao nome de máquina"

#~ msgid "Name or service not known"
#~ msgstr "Nome ou serviço desconhecido"

#~ msgid "Servname not supported for ai_socktype"
#~ msgstr "Sem suporte ao nome de serviço pelo ai_socktype"

#~ msgid "ai_socktype not supported"
#~ msgstr "Não há suporte a ai_socktype"

#~ msgid "System error"
#~ msgstr "Erro de sistema"

#~ msgid "Argument buffer too small"
#~ msgstr "Buffer de argumentos é pequeno demais"

#~ msgid "Processing request in progress"
#~ msgstr "Processamento de requisição em andamento"

#~ msgid "Request canceled"
#~ msgstr "Requisição cancelada"

#~ msgid "Request not canceled"
#~ msgstr "Requisição não cancelada"

#~ msgid "All requests done"
#~ msgstr "Todas as requisições foram atendidas"

#~ msgid "Interrupted by a signal"
#~ msgstr "Interrompido por um sinal"

#~ msgid "Parameter string not correctly encoded"
#~ msgstr "Texto do parâmetro codificado incorretamente"

#~ msgid "Unknown error"
#~ msgstr "Erro desconhecido"

#~ msgid "invalid source_version argument to compile_java_class"
#~ msgstr "argumento source_version inválido para compile_java_class"

#~ msgid "invalid target_version argument to compile_java_class"
#~ msgstr "argumento target_version inválido para compile_java_class"

#~ msgid "failed to create \"%s\""
#~ msgstr "falha ao criar \"%s\""

# , c-format
#~ msgid "error while writing \"%s\" file"
#~ msgstr "erro ao escrever o arquivo \"%s\""

#~ msgid "Java compiler not found, try installing gcj or set $JAVAC"
#~ msgstr ""
#~ "O compilador de Java não foi localizado, tente instalar gcj ou definir "
#~ "$JAVAC"

#~ msgid "Java virtual machine not found, try installing gij or set $JAVA"
#~ msgstr ""
#~ "A máquina virtual de Java não foi localizada, tente instalar gij ou "
#~ "definir $JAVA"

# , c-format
#~ msgid "%s subprocess I/O error"
#~ msgstr "erro de E/S no subprocesso %s"

# , c-format
#~ msgid "cannot stat %s"
#~ msgstr "não foi possível obter estado de %s"

# , c-format
#~ msgid "cannot change permissions of %s"
#~ msgstr "não foi possível mudar permissões de %s"

# , c-format
#~ msgid "cannot create directory %s"
#~ msgstr "não foi possível criar o diretório %s"

# , c-format
#~ msgid "unable to record current working directory"
#~ msgstr "não foi possível registrar o diretório de trabalho atual"

# , c-format
#~ msgid "failed to return to initial working directory"
#~ msgstr "falha em retornar ao diretório de trabalho inicial"

# , c-format
#~ msgid "Failed to open /dev/zero for read"
#~ msgstr "Falha ao abrir /dev/zero para leitura"

#~ msgid "creation of reading thread failed"
#~ msgstr "a criação da thread de leitura falhou"

#~ msgid "cannot set up nonblocking I/O to %s subprocess"
#~ msgstr "não foi possível configurar E/S sem bloqueio para o subprocesso %s"

# , c-format
#~ msgid "communication with %s subprocess failed"
#~ msgstr "a comunicação com o subprocesso %s falhou"

# , c-format
#~ msgid "write to %s subprocess failed"
#~ msgstr "escrita no subprocesso %s falhou"

# , c-format
#~ msgid "read from %s subprocess failed"
#~ msgstr "leitura do subprocesso %s falhou"

#~ msgid "subprocess %s terminated with exit code %d"
#~ msgstr "o subprocesso %s terminou com o código de saída %d"

#~ msgid "creation of threads failed"
#~ msgstr "a criação das threads falhou"

#~ msgid "%s subprocess terminated with exit code %d"
#~ msgstr "subprocesso %s terminado com código de saída %d"

#~ msgid "Success"
#~ msgstr "Sucesso"

#~ msgid "No match"
#~ msgstr "Nenhuma ocorrência do padrão"

# , c-format
#~ msgid "Invalid regular expression"
#~ msgstr "Expressão regular inválida"

# , c-format
#~ msgid "Invalid collation character"
#~ msgstr "Caractere de combinação inválido"

# , c-format
#~ msgid "Invalid character class name"
#~ msgstr "Nome inválido de classe de caracteres"

#~ msgid "Trailing backslash"
#~ msgstr "Barra invertida no final"

#~ msgid "Invalid back reference"
#~ msgstr "Retrorreferência inválida"

#~ msgid "Unmatched [, [^, [:, [., or [="
#~ msgstr "[, [^, [:, [., ou [= sem correspondente"

#~ msgid "Unmatched ( or \\("
#~ msgstr "( ou \\( sem correspondente"

#~ msgid "Unmatched \\{"
#~ msgstr "\\{ sem correspondente"

#~ msgid "Invalid content of \\{\\}"
#~ msgstr "Conteúdo inválido de \\{\\}"

# , c-format
#~ msgid "Invalid range end"
#~ msgstr "Fim de intervalo inválido"

#~ msgid "Memory exhausted"
#~ msgstr "Memória esgotada"

# , c-format
#~ msgid "Invalid preceding regular expression"
#~ msgstr "A expressão regular precedente é inválida"

#~ msgid "Premature end of regular expression"
#~ msgstr "Fim prematuro da expressão regular"

# , c-format
#~ msgid "Regular expression too big"
#~ msgstr "Expressão regular grande demais"

#~ msgid "Unmatched ) or \\)"
#~ msgstr ") ou \\) sem correspondente"

#~ msgid "No previous regular expression"
#~ msgstr "Nenhuma expressão regular anterior"

# Valor exato de 'yesexpr', conforme mensagem do desenvolvedor -- Rafael
#~ msgid "^[yY]"
#~ msgstr "^[+1SsyY]"

# Valor exato de 'noexpr', conforme mensagem do desenvolvedor -- Rafael
#~ msgid "^[nN]"
#~ msgstr "^[-0nN]"

# , c-format
#~ msgid "setting permissions for %s"
#~ msgstr "definindo permissões de %s"

# Sinal SIGHUP
#~ msgid "Hangup"
#~ msgstr "Desconexão"

# Sinal SIGINT
#~ msgid "Interrupt"
#~ msgstr "Interrupção"

# Sinal SIGQUIT
#~ msgid "Quit"
#~ msgstr "Desistência"

# Sinal SIGILL
#~ msgid "Illegal instruction"
#~ msgstr "Instrução ilegal"

# AFAIK, o termo em inglês muito utilizado. Aceito sugestões -- Rafael
# Sinal SIGTRAP
#~ msgid "Trace/breakpoint trap"
#~ msgstr "Trap de trace/breakpoint"

# Sinal SIGABRT
#~ msgid "Aborted"
#~ msgstr "Abortado"

# Sinal SIGFPE
#~ msgid "Floating point exception"
#~ msgstr "Exceção de ponto flutuante"

# Sinal SIGKILL
#~ msgid "Killed"
#~ msgstr "Morto"

# Sinal SIGBUS
#~ msgid "Bus error"
#~ msgstr "Erro de barramento"

# Sinal SIGSEGV
#~ msgid "Segmentation fault"
#~ msgstr "Falha de segmentação"

# Sinal SIGPIPE
#~ msgid "Broken pipe"
#~ msgstr "Conexão interrompida"

# Sinal SIGALRM
#~ msgid "Alarm clock"
#~ msgstr "Despertador"

# Sinal SIGTERM
#~ msgid "Terminated"
#~ msgstr "Terminado"

# Sinal SIGURG
#~ msgid "Urgent I/O condition"
#~ msgstr "Condição urgente de E/S"

# Sinal SIGSTP
#~ msgid "Stopped (signal)"
#~ msgstr "Suspenso (sinal)"

# Sinal SIGTSTP
#~ msgid "Stopped"
#~ msgstr "Suspenso"

# Sinal SIGCONT
#~ msgid "Continued"
#~ msgstr "Continuado"

# Sinal SIGCHLD
#~ msgid "Child exited"
#~ msgstr "Processo filho saiu"

# Sinal SIGTTIN
#~ msgid "Stopped (tty input)"
#~ msgstr "Suspenso (entrada tty)"

# Sinal SIGTTOU
#~ msgid "Stopped (tty output)"
#~ msgstr "Suspenso (saída tty)"

# Sinal SIGIO
#~ msgid "I/O possible"
#~ msgstr "E/S possível"

# Sinal SIGXCPU
#~ msgid "CPU time limit exceeded"
#~ msgstr "Tempo na CPU excedido"

# Sinal SIGXFSZ
#~ msgid "File size limit exceeded"
#~ msgstr "Tamanho de arquivo excedido"

# Sinal SIGVTALRM
#~ msgid "Virtual timer expired"
#~ msgstr "Temporizador virtual expirou"

# Sinal SIGPROF
#~ msgid "Profiling timer expired"
#~ msgstr "Temporizador de perfil expirou"

#~ msgid "Window changed"
#~ msgstr "Janela alterada"

#~ msgid "User defined signal 1"
#~ msgstr "Sinal 1 definido pelo usuário"

#~ msgid "User defined signal 2"
#~ msgstr "Sinal 2 definido pelo usuário"

#~ msgid "EMT trap"
#~ msgstr "Trap de EMT"

#~ msgid "Bad system call"
#~ msgstr "Chamada de sistema inválida"

#~ msgid "Stack fault"
#~ msgstr "Falha na pilha"

#~ msgid "Information request"
#~ msgstr "Requisição de informação"

#~ msgid "Power failure"
#~ msgstr "Falha de energia"

#~ msgid "Resource lost"
#~ msgstr "Recurso perdido"

#~ msgid "error writing to a closed pipe or socket"
#~ msgstr "erro de escrita para um redirecionamento (pipe) ou soquete fechado"

#~ msgid "Real-time signal %d"
#~ msgstr "Sinal de tempo real %d"

#~ msgid "Unknown signal %d"
#~ msgstr "Sinal desconhecido %d"

#~ msgid "iconv function not usable"
#~ msgstr "função iconv não utilizável"

#~ msgid "iconv function not available"
#~ msgstr "função iconv não disponível"

# , c-format
#~ msgid "character out of range"
#~ msgstr "caractere fora do intervalo"

#~ msgid "cannot convert U+%04X to local character set"
#~ msgstr ""
#~ "não foi possível converter U+%04X para o conjunto de caracteres local"

#~ msgid "cannot convert U+%04X to local character set: %s"
#~ msgstr ""
#~ "não foi possível converter U+%04X para o conjunto de caracteres local: %s"

#~ msgid "invalid user"
#~ msgstr "usuário inválido"

#~ msgid "invalid group"
#~ msgstr "grupo inválido"

#~ msgid "invalid spec"
#~ msgstr "especificação inválida"

#~ msgid "unable to display error message"
#~ msgstr "não foi possível exibir a mensagem de erro"

#~ msgid "failed to set file descriptor text/binary mode"
#~ msgstr "falha ao definir modo texto/binário do descritor de arquivo"

#~ msgid "stdin"
#~ msgstr "entrada padrão (stdin)"

#~ msgid "stdout"
#~ msgstr "saída padrão (stdout)"

#~ msgid "stderr"
#~ msgstr "erro padrão (stderr)"

#~ msgid "unknown stream"
#~ msgstr "fluxo desconhecido"

#~ msgid "failed to reopen %s with mode %s"
#~ msgstr "falha ao reabrir %s com modo %s"

#~ msgid "string comparison failed"
#~ msgstr "a comparação de textos falhou"

#~ msgid "Set LC_ALL='C' to work around the problem."
#~ msgstr "Defina LC_ALL='C' para contornar o problema."

#~ msgid "The strings compared were %s and %s."
#~ msgstr "Os textos comparados foram %s e %s."

#~ msgid "cannot perform formatted output"
#~ msgstr "não foi possível fazer a saída formatada"

#~ msgid "standard file descriptors"
#~ msgstr "descritores de arquivo padrão"

# %s%s é hífen e opção, `%s' é o argumento da opção
# , c-format
#~ msgid "invalid %s%s argument '%s'"
#~ msgstr "argumento inválido para %s%s: \"%s\""

# %s%s é hífen e opção, `%s' é o argumento da opção
# , c-format
#~ msgid "invalid suffix in %s%s argument '%s'"
#~ msgstr "sufixo inválido no argumento para %s%s \"%s\""

# %s%s é hífen e opção, `%s' é o argumento da opção
#~ msgid "%s%s argument '%s' too large"
#~ msgstr "argumento para %s%s \"%s\" é grande demais"

#~ msgid "%s home page: <https://www.gnu.org/software/%s/>\n"
#~ msgstr "Página do %s: <https://www.gnu.org/software/%s/>\n"

#~ msgid "%.*s: ARGP_HELP_FMT parameter must be positive"
#~ msgstr "%.*s: O parâmetro ARGP_HELP_FMT deve ser positivo"

#~ msgid "%s: option '--%s' doesn't allow an argument\n"
#~ msgstr "%s: a opção \"--%s\" não permite um argumento\n"

# , c-format
#~ msgid "%s: unrecognized option '--%s'\n"
#~ msgstr "%s: opção desconhecida \"--%s\"\n"

#~ msgid "%s: option '-W %s' doesn't allow an argument\n"
#~ msgstr "%s: a opção \"-W %s\" não permite um argumento\n"

#~ msgid "%s: option '-W %s' requires an argument\n"
#~ msgstr "%s: a opção \"-W %s\" exige um argumento\n"

#~ msgid "Franc,ois Pinard"
#~ msgstr "François Pinard"

# , c-format
#~ msgid "%s: illegal option -- %c\n"
#~ msgstr "%s: opção inválida -- %c\n"

#~ msgid "block size"
#~ msgstr "tamanho do bloco"

#~ msgid "%s exists but is not a directory"
#~ msgstr "%s existe, mas não é um diretório"

#~ msgid "cannot change owner and/or group of %s"
#~ msgstr "não pode substituir dono e/ou grupo de %s"

# , c-format
#~ msgid "cannot chdir to directory %s"
#~ msgstr "impossível mudar para diretório %s"

#~ msgid "cannot get the login group of a numeric UID"
#~ msgstr "nao foi possivel obter um grupo e login de um UID numerico "

#, fuzzy
#~ msgid ""
#~ "\n"
#~ "This is free software.  You may redistribute copies of it under the terms "
#~ "of\n"
#~ "the GNU General Public License <http://www.gnu.org/licenses/gpl.html>.\n"
#~ "There is NO WARRANTY, to the extent permitted by law.\n"
#~ "\n"
#~ msgstr ""
#~ "Este programa é um software livre, você pode redistribuí-lo e/ou modificá-"
#~ "lo\n"
#~ "sobre os termos da licença pública geral GNU (GPL - General Public "
#~ "License)\n"
#~ "publicada pela Free Software Foundation, versão 2 ou posteriores.\n"
#~ "\n"
