# SOME DESCRIPTIVE TITLE.
# Copyright (C) 2001-2025, Python Software Foundation
# This file is distributed under the same license as the Python package.
# FIRST AUTHOR , YEAR.
#
# Translators:
# python-doc bot, 2025
#
#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: Python 3.11\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2025-09-22 20:37+0000\n"
"PO-Revision-Date: 2025-09-22 16:51+0000\n"
"Last-Translator: python-doc bot, 2025\n"
"Language-Team: Portuguese (Brazil) (https://app.transifex.com/python-doc/"
"teams/5390/pt_BR/)\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=3; plural=(n == 0 || n == 1) ? 0 : n != 0 && n % "
"1000000 == 0 ? 1 : 2;\n"

#: ../../tutorial/floatingpoint.rst:9
msgid "Floating Point Arithmetic:  Issues and Limitations"
msgstr "Aritmtica de ponto flutuante: problemas e limitaes"

#: ../../tutorial/floatingpoint.rst:14
msgid ""
"Floating-point numbers are represented in computer hardware as base 2 "
"(binary) fractions.  For example, the **decimal** fraction ``0.125`` has "
"value 1/10 + 2/100 + 5/1000, and in the same way the **binary** fraction "
"``0.001`` has value 0/2 + 0/4 + 1/8. These two fractions have identical "
"values, the only real difference being that the first is written in base 10 "
"fractional notation, and the second in base 2."
msgstr ""
"Os nmeros de ponto flutuante so representados no hardware do computador "
"como fraes de base 2 (binrias). Por exemplo, a frao **decimal** "
"``0.125`` tem valor 1/10 + 2/100 + 5/1000, e da mesma forma a frao "
"**binria** ``0.001`` tem valor 0/2 + 0/4 + 1/8. Essas duas fraes tm "
"valores idnticos, a nica diferena real  que a primeira  escrita em "
"notao fracionria de base 10 e a segunda em base 2."

#: ../../tutorial/floatingpoint.rst:21
msgid ""
"Unfortunately, most decimal fractions cannot be represented exactly as "
"binary fractions.  A consequence is that, in general, the decimal floating-"
"point numbers you enter are only approximated by the binary floating-point "
"numbers actually stored in the machine."
msgstr ""
"Infelizmente, muitas fraes decimais no podem ser representadas "
"precisamente como fraes binrias. O resultado  que, em geral, os nmeros "
"decimais de ponto flutuante que voc digita acabam sendo armazenados de "
"forma apenas aproximada, na forma de nmeros binrios de ponto flutuante."

#: ../../tutorial/floatingpoint.rst:26
msgid ""
"The problem is easier to understand at first in base 10.  Consider the "
"fraction 1/3.  You can approximate that as a base 10 fraction::"
msgstr ""
"O problema  mais fcil de entender primeiro em base 10. Considere a frao "
"1/3. Podemos represent-la aproximadamente como uma frao base 10::"

#: ../../tutorial/floatingpoint.rst:31 ../../tutorial/floatingpoint.rst:35
msgid "or, better, ::"
msgstr "ou melhor, ::"

#: ../../tutorial/floatingpoint.rst:39
msgid ""
"and so on.  No matter how many digits you're willing to write down, the "
"result will never be exactly 1/3, but will be an increasingly better "
"approximation of 1/3."
msgstr ""
"e assim por diante. No importa quantos dgitos voc est disposto a "
"escrever, o resultado nunca ser exatamente 1/3, mas ser uma aproximao de "
"cada vez melhor de 1/3."

#: ../../tutorial/floatingpoint.rst:43
msgid ""
"In the same way, no matter how many base 2 digits you're willing to use, the "
"decimal value 0.1 cannot be represented exactly as a base 2 fraction.  In "
"base 2, 1/10 is the infinitely repeating fraction ::"
msgstr ""
"Da mesma forma, no importa quantos dgitos de base 2 estejas disposto a "
"usar, o valor decimal 0.1 no pode ser representado exatamente como uma "
"frao de base 2. No sistema de base 2, 1/10  uma frao binria que se "
"repete infinitamente::"

#: ../../tutorial/floatingpoint.rst:49
msgid ""
"Stop at any finite number of bits, and you get an approximation.  On most "
"machines today, floats are approximated using a binary fraction with the "
"numerator using the first 53 bits starting with the most significant bit and "
"with the denominator as a power of two.  In the case of 1/10, the binary "
"fraction is ``3602879701896397 / 2 ** 55`` which is close to but not exactly "
"equal to the true value of 1/10."
msgstr ""
"Se parares em qualquer nmero finito de bits, obters uma aproximao. Hoje "
"em dia, na maioria dos computadores, as casas decimais so aproximados "
"usando uma frao binria onde o numerado utiliza os primeiros 53 bits "
"iniciando no bit mais significativo e tendo como denominador uma potncia de "
"dois. No caso de 1/10, a frao binria seria ``602879701896397 / 2 ** 55`` "
"o que chega bem perto, mas mesmo assim, no  igual ao valor original de "
"1/10."

#: ../../tutorial/floatingpoint.rst:56
msgid ""
"Many users are not aware of the approximation because of the way values are "
"displayed.  Python only prints a decimal approximation to the true decimal "
"value of the binary approximation stored by the machine.  On most machines, "
"if Python were to print the true decimal value of the binary approximation "
"stored for 0.1, it would have to display ::"
msgstr ""
"Muitos usurios no esto cientes da aproximao devido  forma como os "
"valores so exibidos. O Python exibe apenas uma aproximao decimal do "
"verdadeiro valor decimal da aproximao binria armazenada pela mquina. Na "
"maioria das mquinas, se o Python exibisse o verdadeiro valor decimal da "
"aproximao binria que representa o decimal 0.1, seria necessrio mostrar:"

#: ../../tutorial/floatingpoint.rst:65
msgid ""
"That is more digits than most people find useful, so Python keeps the number "
"of digits manageable by displaying a rounded value instead ::"
msgstr ""
"Isto contm muito mais dgitos do que  o esperado e utilizado pela grande "
"maioria dos desenvolvedores, portanto, o Python limita o nmero de dgitos "
"exibidos, apresentando um valor arredondado, ao invs de mostrar todas as "
"casas decimais:"

#: ../../tutorial/floatingpoint.rst:71
msgid ""
"Just remember, even though the printed result looks like the exact value of "
"1/10, the actual stored value is the nearest representable binary fraction."
msgstr ""
"Lembre-se, mesmo que o resultado impresso seja o valor exato de 1/10, o "
"valor que verdadeiramente estar armazenado ser uma frao binria "
"representvel que mais se aproxima."

#: ../../tutorial/floatingpoint.rst:74
msgid ""
"Interestingly, there are many different decimal numbers that share the same "
"nearest approximate binary fraction.  For example, the numbers ``0.1`` and "
"``0.10000000000000001`` and "
"``0.1000000000000000055511151231257827021181583404541015625`` are all "
"approximated by ``3602879701896397 / 2 ** 55``.  Since all of these decimal "
"values share the same approximation, any one of them could be displayed "
"while still preserving the invariant ``eval(repr(x)) == x``."
msgstr ""
"Curiosamente, existem muitos nmeros decimais diferentes que compartilham a "
"mesma frao binria aproximada. Por exemplo, os nmeros ``0.1`` ou o "
"``0.10000000000000001`` e "
"``0.1000000000000000055511151231257827021181583404541015625`` so todos "
"aproximaes de ``3602879701896397 / 2 ** 55``. Como todos esses valores "
"decimais compartilham um mesma de aproximao, qualquer um poder ser "
"exibido enquanto for preservado o invariante ``eval(repr(x)) == x``."

#: ../../tutorial/floatingpoint.rst:82
msgid ""
"Historically, the Python prompt and built-in :func:`repr` function would "
"choose the one with 17 significant digits, ``0.10000000000000001``.   "
"Starting with Python 3.1, Python (on most systems) is now able to choose the "
"shortest of these and simply display ``0.1``."
msgstr ""
"Historicamente, o prompt do Python e a funo embutida :func:`repr` "
"utilizariam o que contivesse 17 dgitos significativos, "
"``0.10000000000000001``. Desde a verso do Python 3.1, o Python (na maioria "
"dos sistemas) agora  possvel optar pela forma mais reduzida, exibindo "
"simplesmente o nmero ``0.1``."

#: ../../tutorial/floatingpoint.rst:87
msgid ""
"Note that this is in the very nature of binary floating-point: this is not a "
"bug in Python, and it is not a bug in your code either.  You'll see the same "
"kind of thing in all languages that support your hardware's floating-point "
"arithmetic (although some languages may not *display* the difference by "
"default, or in all output modes)."
msgstr ""
"Note que essa  a prpria natureza do ponto flutuante binrio: no  um bug "
"do Python, e nem  um bug do seu cdigo. Essa situao pode ser observada em "
"todas as linguagens que usam as instrues aritmticas de ponto flutuante do "
"hardware (apesar de algumas linguagens no *mostrarem* a diferena, por "
"padro, ou em todos os modos de sada)."

#: ../../tutorial/floatingpoint.rst:93
msgid ""
"For more pleasant output, you may wish to use string formatting to produce a "
"limited number of significant digits::"
msgstr ""
"Para obter um valor mais agradvel, poders utilizar a formatao de "
"sequncia de caracteres para produzir um nmero limitado de dgitos "
"significativos:"

#: ../../tutorial/floatingpoint.rst:105
msgid ""
"It's important to realize that this is, in a real sense, an illusion: you're "
"simply rounding the *display* of the true machine value."
msgstr ""
" importante perceber que tudo no passa de pura iluso: estas simplesmente "
"arredondando a *exibio* da verdadeira maquinaria do valor."

#: ../../tutorial/floatingpoint.rst:108
msgid ""
"One illusion may beget another.  For example, since 0.1 is not exactly 1/10, "
"summing three values of 0.1 may not yield exactly 0.3, either::"
msgstr ""
"Uma iluso pode gerar outra. Por exemplo, uma vez que 0.1 no  exatamente "
"1/10, somar trs vezes o valor 0.1, no garantir que o resultado seja "
"exatamente 0.3, isso porque:"

#: ../../tutorial/floatingpoint.rst:114
msgid ""
"Also, since the 0.1 cannot get any closer to the exact value of 1/10 and 0.3 "
"cannot get any closer to the exact value of 3/10, then pre-rounding with :"
"func:`round` function cannot help::"
msgstr ""
"Inclusive, uma vez que o 0.1 no consegue aproximar-se do valor exato de "
"1/10 e 0.3 no pode se aproximar mais do valor exato de 3/10, temos ento "
"que o pr-arredondamento com a funo :func:`round` no servir como ajuda:"

#: ../../tutorial/floatingpoint.rst:121
msgid ""
"Though the numbers cannot be made closer to their intended exact values, "
"the :func:`round` function can be useful for post-rounding so that results "
"with inexact values become comparable to one another::"
msgstr ""
"Embora os nmeros no possam se aproximar mais dos exatos valores que "
"desejamos, a funo :func:`round` poder ser til na obteno do ps-"
"arredondamento para que os resultados contendo valores inexatos se tornem "
"comparveis uns aos outros:"

#: ../../tutorial/floatingpoint.rst:128
msgid ""
"Binary floating-point arithmetic holds many surprises like this.  The "
"problem with \"0.1\" is explained in precise detail below, in the "
"\"Representation Error\" section.  See `Examples of Floating Point Problems "
"`_ for "
"a pleasant summary of how binary floating-point works and the kinds of "
"problems commonly encountered in practice.  Also see `The Perils of Floating "
"Point `_ for a more complete "
"account of other common surprises."
msgstr ""
"A aritmtica binria de ponto flutuante contm muitas surpresas como essa. O "
"problema com \"0.1\"  explicado em detalhes precisos abaixo, na seo "
"\"Erro de representao\". Consulte `Exemplos de problemas de ponto "
"flutuante `_ (em ingls) para obter um resumo agradvel de como o ponto "
"flutuante binrio funciona e os tipos de problemas comumente encontrados na "
"prtica. Veja tambm `Os perigos do ponto flutuante `_ (em ingls) para um relato mais completo de outras "
"surpresas comuns."

#: ../../tutorial/floatingpoint.rst:137
msgid ""
"As that says near the end, \"there are no easy answers.\"  Still, don't be "
"unduly wary of floating-point!  The errors in Python float operations are "
"inherited from the floating-point hardware, and on most machines are on the "
"order of no more than 1 part in 2\\*\\*53 per operation.  That's more than "
"adequate for most tasks, but you do need to keep in mind that it's not "
"decimal arithmetic and that every float operation can suffer a new rounding "
"error."
msgstr ""
"Como dizemos perto do final, \"no h respostas fceis\". Ainda assim, no "
"se percam indevidamente no uso do ponto flutuante! Os erros nas operaes do "
"tipo float do Python so heranas do hardware de ponto flutuante e, a "
"maioria dos computadores esto na ordem de no mais do que 1 parte em "
"2\\*\\*53 por operao. Isso  mais do que o suficiente para a maioria das "
"tarefas, portanto,  importante lembrar que no se trata de uma aritmtica "
"decimal e que toda operao com o tipo float poder via a apresentar novos "
"problemas referentes ao arredondamento."

#: ../../tutorial/floatingpoint.rst:144
msgid ""
"While pathological cases do exist, for most casual use of floating-point "
"arithmetic you'll see the result you expect in the end if you simply round "
"the display of your final results to the number of decimal digits you "
"expect. :func:`str` usually suffices, and for finer control see the :meth:"
"`str.format` method's format specifiers in :ref:`formatstrings`."
msgstr ""
"Embora existam casos patolgicos, na maior parte das vezes, ters como "
"resultado final o valor esperado, se simplesmente arredondares a exibio "
"final dos resultados para a quantidade de dgitos decimais que esperas a "
"funo :func:`str` geralmente ser o suficiente, e , para seja necessrio um "
"valor refinado, veja os especificadores de formato :meth:`str.format` "
"contido na seo :ref:`formatstrings`."

#: ../../tutorial/floatingpoint.rst:150
msgid ""
"For use cases which require exact decimal representation, try using the :mod:"
"`decimal` module which implements decimal arithmetic suitable for accounting "
"applications and high-precision applications."
msgstr ""
"Para as situaes que exijam uma representao decimal exata, experimente o "
"mdulo :mod:`decimal` que possui, a implementao de uma adequada aritmtica "
"decimal bastante utilizada nas aplicaes contbeis e pelas aplicaes que "
"demandam alta preciso."

#: ../../tutorial/floatingpoint.rst:154
msgid ""
"Another form of exact arithmetic is supported by the :mod:`fractions` module "
"which implements arithmetic based on rational numbers (so the numbers like "
"1/3 can be represented exactly)."
msgstr ""
"Uma outra forma de obter uma aritmtica exata tem suporte pelo mdulo :mod:"
"`fraces` que implementa a aritmtica baseada em nmeros racionais "
"(portanto, os nmeros fracionrios como o 1/3 conseguem uma representao "
"precisa)."

#: ../../tutorial/floatingpoint.rst:158
msgid ""
"If you are a heavy user of floating-point operations you should take a look "
"at the NumPy package and many other packages for mathematical and "
"statistical operations supplied by the SciPy project. See ."
msgstr ""
"Caso necessites fazer um intenso uso das operaes de ponto flutuante,  "
"importante que conheas o pacote NumPy e, tambm  importante dizer, que "
"existem diversos pacotes destinados ao trabalho intenso com operaes "
"matemticas e estatsticas que so fornecidas pelo projeto SciPy. Veja "
"."

#: ../../tutorial/floatingpoint.rst:162
msgid ""
"Python provides tools that may help on those rare occasions when you really "
"*do* want to know the exact value of a float.  The :meth:`float."
"as_integer_ratio` method expresses the value of a float as a fraction::"
msgstr ""
"O Python fornece ferramentas que podem ajudar nessas raras ocasies em que "
"realmente *faz* necessrio conhecer o valor exato de um ponto flutuante. O "
"mtodo :meth:`float.as_integer_ratio` expressa o valor de um nmero do tipo "
"float em sua forma fracionria:"

#: ../../tutorial/floatingpoint.rst:171
msgid ""
"Since the ratio is exact, it can be used to losslessly recreate the original "
"value::"
msgstr ""
"Uma vez que a relao seja exata, ser possvel utiliza-la para obter, sem "
"que haja quaisquer perda do valor original:"

#: ../../tutorial/floatingpoint.rst:177
msgid ""
"The :meth:`float.hex` method expresses a float in hexadecimal (base 16), "
"again giving the exact value stored by your computer::"
msgstr ""
"O mtodo :meth:`float.hex` expressa um ponto flutuante em hexadecimal (base "
"16), o mesmo tambm retornar o valor exato pelo computador:"

#: ../../tutorial/floatingpoint.rst:183
msgid ""
"This precise hexadecimal representation can be used to reconstruct the float "
"value exactly::"
msgstr ""
"Sua precisa representao hexadecimal poder ser utilizada para reconstruir "
"o valor exato do ponto flutuante:"

#: ../../tutorial/floatingpoint.rst:189
msgid ""
"Since the representation is exact, it is useful for reliably porting values "
"across different versions of Python (platform independence) and exchanging "
"data with other languages that support the same format (such as Java and "
"C99)."
msgstr ""
"Como a representao ser exata,  interessante utilizar valores confiveis "
"em diferentes verses do Python (independente da plataforma) e a troca de "
"dados entre idiomas diferentes que forneam o mesmo formato (como o Java e o "
"C99)."

#: ../../tutorial/floatingpoint.rst:193
msgid ""
"Another helpful tool is the :func:`math.fsum` function which helps mitigate "
"loss-of-precision during summation.  It tracks \"lost digits\" as values are "
"added onto a running total.  That can make a difference in overall accuracy "
"so that the errors do not accumulate to the point where they affect the "
"final total:"
msgstr ""
"Uma outra ferramenta que poder ser til  a funo :func:`math.fsum` que "
"ajuda a mitigar a perda de preciso durante a soma. Ele rastreia \"digitos "
"perdidos\" como valores para serem adicionados ao um total da execuo. Isso "
"poder fazer a diferena na preciso geral de forma que os erros no se "
"acumulem chegando ao ponto de afetar o resultado final:"

#: ../../tutorial/floatingpoint.rst:207
msgid "Representation Error"
msgstr "Erro de representao"

#: ../../tutorial/floatingpoint.rst:209
msgid ""
"This section explains the \"0.1\" example in detail, and shows how you can "
"perform an exact analysis of cases like this yourself.  Basic familiarity "
"with binary floating-point representation is assumed."
msgstr ""
"Esta seo explica o exemplo do \"0.1\" em detalhes, e mostra como poders "
"realizar uma anlise exata de casos semelhantes. Presumimos que tenhas uma "
"familiaridade bsica com a representao binria de ponto flutuante."

#: ../../tutorial/floatingpoint.rst:213
msgid ""
":dfn:`Representation error` refers to the fact that some (most, actually) "
"decimal fractions cannot be represented exactly as binary (base 2) "
"fractions. This is the chief reason why Python (or Perl, C, C++, Java, "
"Fortran, and many others) often won't display the exact decimal number you "
"expect."
msgstr ""
":dfn:`Erro de representao` refere-se ao fato de que algumas fraes "
"decimais (a maioria, na verdade) no podem ser representadas exatamente como "
"fraes binrias (base 2). Esta  a principal razo por que o Python (ou "
"Perl, C, C++, Java, Fortran, e muitas outras) frequentemente no exibe o "
"nmero decimal exato conforme o esperado::"

#: ../../tutorial/floatingpoint.rst:218
msgid ""
"Why is that?  1/10 is not exactly representable as a binary fraction.  Since "
"at least 2000, almost all machines use IEEE 754 binary floating-point "
"arithmetic, and almost all platforms map Python floats to IEEE 754 binary64 "
"\"double precision\" values.  IEEE 754 binary64 values contain 53 bits of "
"precision, so on input the computer strives to convert 0.1 to the closest "
"fraction it can of the form *J*/2**\\ *N* where *J* is an integer containing "
"exactly 53 bits. Rewriting ::"
msgstr ""
"Por que isso acontece? 1/10 no  representado exatamente sendo frao "
"binria. Desde pelo menos 2000, quase todas as mquinas usam aritmtica "
"binria de ponto flutuante da IEEE 754 e quase todas as plataformas "
"representam pontos flutuante do Python como valores binary64 de \"double "
"precision\" (dupla preciso) da IEEE 754. Os valores binary64 da IEEE 754 "
"tm 53 bits de preciso, por isso na entrada o computador se esfora para "
"converter \"0.1\" para a frao mais prxima que puder, na forma *J*/2**\\ "
"*N* onde *J*  um nmero inteiro contendo exatamente 53 bits. Reescrevendo::"

#: ../../tutorial/floatingpoint.rst:229
msgid "as ::"
msgstr "como ::"

#: ../../tutorial/floatingpoint.rst:233
msgid ""
"and recalling that *J* has exactly 53 bits (is ``>= 2**52`` but ``< "
"2**53``), the best value for *N* is 56::"
msgstr ""
"e recordando que *J* tenha exatamente 53 bits ( ``>= 2**52``, mas ``< "
"2**53``), o melhor valor para *N*  56::"

#: ../../tutorial/floatingpoint.rst:239
msgid ""
"That is, 56 is the only value for *N* that leaves *J* with exactly 53 bits.  "
"The best possible value for *J* is then that quotient rounded::"
msgstr ""
"Ou seja, 56  o nico valor de *N* que deixa *J* com exatamente 53 bits. "
"Portanto, o melhor valor que conseguimos obter pra *J* ser aquele que "
"possui o quociente arredondado:"

#: ../../tutorial/floatingpoint.rst:246
msgid ""
"Since the remainder is more than half of 10, the best approximation is "
"obtained by rounding up::"
msgstr ""
"Uma vez que o resto seja maior do que a metade de 10, a melhor aproximao "
"que poder ser obtida se arredondarmos para cima:"

#: ../../tutorial/floatingpoint.rst:252
msgid ""
"Therefore the best possible approximation to 1/10 in IEEE 754 double "
"precision is::"
msgstr ""
"Portanto, a melhor aproximao possvel de 1/10 como um \"IEEE 754 double "
"precision\" ::"

#: ../../tutorial/floatingpoint.rst:257
msgid ""
"Dividing both the numerator and denominator by two reduces the fraction to::"
msgstr "Dividir o numerador e o denominador por dois reduzir a frao para::"

#: ../../tutorial/floatingpoint.rst:261
msgid ""
"Note that since we rounded up, this is actually a little bit larger than "
"1/10; if we had not rounded up, the quotient would have been a little bit "
"smaller than 1/10.  But in no case can it be *exactly* 1/10!"
msgstr ""
"Note que, como arredondamos para cima, esse valor , de fato, um pouco maior "
"que 1/10; se no tivssemos arredondado para cima, o quociente teria sido um "
"pouco menor que 1/10. Mas em nenhum caso seria possvel obter *exatamente* o "
"valor 1/10!"

#: ../../tutorial/floatingpoint.rst:265
msgid ""
"So the computer never \"sees\" 1/10:  what it sees is the exact fraction "
"given above, the best IEEE 754 double approximation it can get:"
msgstr ""
"Por isso, o computador nunca \"v\" 1/10: o que ele v  exatamente a frao "
"que  obtida pra cima, a melhor aproximao \"IEEE 754 double\" possvel :"

#: ../../tutorial/floatingpoint.rst:271
msgid ""
"If we multiply that fraction by 10\\*\\*55, we can see the value out to 55 "
"decimal digits::"
msgstr ""
"Se multiplicarmos essa frao por 10\\*\\*55, podemos ver o valor contendo "
"os 55 dgitos mais significativos:"

#: ../../tutorial/floatingpoint.rst:277
msgid ""
"meaning that the exact number stored in the computer is equal to the decimal "
"value 0.1000000000000000055511151231257827021181583404541015625. Instead of "
"displaying the full decimal value, many languages (including older versions "
"of Python), round the result to 17 significant digits::"
msgstr ""
"o que significa que o nmero exato armazenado no computador  igual ao valor "
"decimal 0.1000000000000000055511151231257827021181583404541015625. Em vez de "
"exibir o valor decimal completo, muitas linguagens (incluindo verses mais "
"antigas do Python), arredondam o resultado para 17 dgitos significativos:"

#: ../../tutorial/floatingpoint.rst:285
msgid ""
"The :mod:`fractions` and :mod:`decimal` modules make these calculations "
"easy::"
msgstr ""
"Mdulos como o :mod:`fractions` e o :mod:`decimal` tornam esses clculos "
"muito mais fceis:"