MATEMÁGICAS

MATEMÁGICAS
Como se tornar um matemágico de sucesso.

NÚMEROS

NÚMEROS
Conheça o maravilhoso universo dos números

DESAFIOS

DESAFIOS
Encontre e descubra aqui o seu nível de desafio

RECREIO

RECREIO
Matemática no recreio tem tudo a ver. Divirta-se!

Seguidores

sexta-feira, 18 de outubro de 2013

EXTRAÇÃO DA RAIZ CÚBICA PELAS DICAS... DO SEBÁ!!!!!

Ola´, prezados leitores!!!!!
Estou retornando só agora, pois, tive problemas (ainda estou tendo alguns sustos) com o meu 
equipamento e, sabem de uma coisa???? O melhor conserto para computadores... é você ter, pelo
 menos, dois PCs, rsrsrsrs!!!!!
Mas, aproveitei o tempo para atacar e avançar nos meus projetos sobre métodos e algoritmos para 
facilitar, solucionar, aprimorar e acelerar os estudos e/ou trabalhos com o cálculo!!!!!
Tenho uma "mania" de estar "inventando ou reformando coisas" e, nesse caminhar por estas 
paragens virtuais na grande rede, tive a satisfação de encontrar pessoas que pensam e agem da 
mesma forma, por exemplo, o Professor de matemática paraibano, Sebastião Vieira do Nascimento,
o... Prof. Sebá, é um desses incansáveis criadores, investigadores e divulgadores
(isto é mito importante) dos conhecimentos!!!!!



Faz poucos dias, ele me mandou um dos seus trabalhos (ele é autor de mais de 15 livros interessantes 
para o cálculo) e me autorizou a fazer a publicação aqui no meu blog, caso gostasse do artigo. É claro 
que eu gostei e também, é claro que eu quero levar esse conhecimento para todos os meus amigos
 leitores do Matemágicas e Números e... espero que vocês também gostem desse criativo trabalho do
 meu amigo Sebá!!!!



  
   



















É isso aí, galera inteligente do Brasil e do mundo!!!! Meus agradecimentos aos amigos; Professor Sebá 
e também ao meu amigo, Kleber Bandeira, um pela ajuda com trabalho e o outro... pela ajuda técnica, com a qual, permitiu que eu fizesse essa postagem superinteressante!!!!!
INTEL LOGO, pessoal!!!!

Um abraço!!!!! 

*********************************************************************************
ATENÇÃO!!!! Para aqueles leitores que gostam de ler ou saber sobre as minhas invenções, 
postei uma nova criação (2 em 1) com o título... "Nuvem Sólida" aqui no blog na página 
"PENSO, LOGO INVENTO"!!!!!
Obrigado!!!!!
*********************************************************************************

20/082014
*********************************************************************************
Heads up !!!! For those readers who like to read or know about my inventions, I 
posted a new creation (2 in 1) with the title ... "Solid Cloud" here on the blog page 
"THINK, THEN THE INVENTION" !!!!! 

Thank you !!!!!
********************************************************************************* 

Artigos Relacionados

17 comentários:

Educadores Multiplicadores disse...

Olá Multiplicador, seja feliz!

Antes de qualquer coisa, pedimos desculpas pela nossa ausência, é que fazem alguns meses que nosso tempo tem sido muito, mais muito curto mesmo. Porém, o projeto E.M. continua seguindo firme, graça a você, Francisco Valdir, que tem nos ajudado bastante para o crescimento de toda a família, muito obrigado.

Parabéns, você e seu blog continuam sendo destaques no Educadores Multiplicadores por ter contribuído para a educação de nosso país.

Link abaixo:
http://www.educadoresmultiplicadores.com.br/2013/11/educadores-multiplicadores-do-mes-de.html

Estamos de banners novos, e também, caso queira pegar o selo que caracteriza o destaque, fique a vontade. Lembramos que adicionar o selo do “Top Caneta de Ouro” e/ou “Top comentarista” é opcional.

O EDUCADORES MULTIPLICADORES e o MARQUECOMX agradecem pela amizade e confiança em nosso projeto, que é de todos nós.

Abraços, fiquemos na Paz de Deus e até breve.

IRIVAN

2 de novembro de 2013 05:30
Francisco Valdir disse...

Olá, Irivan e todos os amigos do EDUCADORES MULTIPLICADSORES e MARQUECOMX !!!!
Vocês são quem devem me desculpar pela minha ausência e... entre outras coisas, posso afirmar, que a maior, se deve à quebra do meu equipamento (remendo em roupa velha... dá nisso, rsrsrsrs!!!!), mas, também, nessa época do ano, dois "Valdir" ainda é pouco para atender à clientela ávida para tentar passar de ano e apelam para o "matemágico" de sempre!!!!
Muito obrigado, fico feliz em continuar fazendo o EM progredir e... "sigo devagar, pois, já tive pressa..." mas não desisto em continuar espalhando com vocês, o conhecimento pelos quatro cantos desse mundo!!!!
INTEL LOGO e um grande abaço!!!!

2 de novembro de 2013 11:47
João Labrego disse...

Prezados senhores:

Aproveitando-me de que o assunto RADICIAÇÃO encontra-se novamente em pauta neste BLOG, gostaria de fazer justiça ao senhor Édison Martins da Silva pela sua autoria do Método Geral da Radiciação.

Não sei por que ele não quis divulgá-lo na Internet mas num blog seu, há cerca de 2 anos atrás, deparei-me com alguns exemplos de raízes resolvidas por este método.

Como tinha o contato dele por telefone e e-mail, entrei em contato com ele pois no blog ele prometia enviar um curso completo sobre este método em apostila.

Ele alegou que ainda precisava compilar a apostila e assim que estivesse pronta ele me enviaria por um preço módico a mesma.

Claro que aceitei a proposta mas até hoje estou esperando essa apostila e ele sempre foge pela tangente quando é cobrado, como todo bom matemático amador meio desorganizado.

Resumindo, o método que apresentei no meu comentário no link http://matemagicasenumeros.blogspot.com.br/2011/02/extrair-raiz-quadrada-sem-usar.html#.UpahXMRDtHZ, é exatamente esse método.

Analisei vários exemplos que este Édison havia postado em seu blog e deduzi o método.

Garanto para vocês que este método funciona e é o mais rápido que já encontrei na execução de raízes centésimas, milésimas, milionésimas, etc... de números inteiros gigantes.

Somente para vocês terem uma ideia, elevei o número 9 seguindo de mais 19 dígitos 9, ou seja, um número composto de 20 dígitos 9, à centésima potência.

Em seguida, extraí a raiz centésima do resultado obtido e obtive novamente o número 9 seguido de 19 dígitos 9 em 4 segundos.

Num computador mais veloz em que testei no trabalho, demorou 2 segundos.

É claro que o tempo de demora se torna maior à medida em que se aumentam os dígitos, pois o número composto pela centésima potência do número que indiquei se compõe de 2000 dígitos.

Quando elevei o mesmo número à milésima potência, demorou 1 minuto e 20 segundos para retornar a raiz milésima do mesmo.

Em todos os outros algoritmos que testei, sempre demorou um tempo superior a este para retornar a raiz centésima ou milésima.

Por isso, deixo aqui meus agradecimentos ao senhor Édison Martins da Silva, por sua brilhante descoberta e que está me servindo no desenvolvimento de um projeto matemático bastante ambicioso.

Não quero entrar nos motivos do mesmo não haver divulgado seu método que no fundo é bastante simples, mas tenho certeza de que se não o divulgou foi por motivos alheios à sua vontade.



27 de novembro de 2013 18:15
Francisco Valdir disse...

Olá, meu prezado amigo e parceiro, João Labrego!!!!
Já estava para lhe avisar que não tivera contato com o senhor Édison Martins e também, perguntar ao amigo, como deveria postar um artigo falando sobe a descoberta dele e aperfeiçoada por você!!!! Bem, creio que com este comentário seu aqui, tudo ou quase tudo, ficou esclarecido sobre esse algoritmo para extração das enésimas raízes raízes de números inteiros!!!!
Dizem que; a montanha procura chegar ao Moisés se este não for à ela!!!! Então, claro que, sendo o mais honesto possível com o Sr. Édison, temos o prazer de conhecer e poder usar este revolucionário Método Geral da Radiciação, graças ao seu altruísmo e brilhante poder de trabalho criativo (ainda não terminado de todo), amigo João!!!!!
Parabéns, pela iniciativa pela divulgação dos devidos esclarecimentos por hora relevantes e pela busca do desenvolvimento aperfeiçoado desse método, o qual estamos curiosos e aguardando pela sua publicação!!!!!
Um abraço!!!!!

28 de novembro de 2013 09:28
João Labrego disse...

Prezado Francisco:

Obtive o contato do senhor Édison no comentário que ele deixou no link http://memoriavirtual.net/2008/10/01/site-de-resolucao-de-problemas-matematicos/

Por isso, tomo a liberdade de divulgá-lo para todos que desejam entrar em contato com ele:

http://rendiexame1961.com.br/
E-mail: edi.exemplo@hotmail.com
Telefone: (011) 4067:4304
edinho silva.
Édison Martins da Silva.

Como agora posso atestar cabalmente que tal método funciona e resolve qualquer tipo de radiciação com radicando e índices inteiros e, caso se queira o resultado com decimais basta incluir tantos grupos de zeros quantas forem as decimais desejadas, em breve já terei uma versão de planilha Excel com as operações adição, subtração, multiplicação, divisão, potenciação e a tão sonhada radiciação, com números gigantes de 1, 2, 3, ...., 1000, 2000, etc... dígitos numéricos.

Estou desenvolvendo atualmente em C# no DOT NET pois achei mais fácil e produtivo trabalhar nessa linguagem para efeito de testes dos algoritmos.

No momento, estou na fase de depuração, ou seja, testando várias possibilidades de cálculo com vários argumentos pequenos, grandes e gigantes.

Aliado à depuração, estou também otimizando os algoritmos para ficarem mais enxutos, econômicos e eficientes.

Consegui, por exemplo, calcular a mesma raiz centésima citada no comentário anterior em 2 segundos, graças a algumas otimizações que fiz no algoritmo.

Tentei calcular o mesmo número do comentário anterior elevado à milésima potência e, em seguida, determinar a raiz milésima do resultado.

A potenciação demorou 5 segundos mas a radiciação demorou 10 minutos. He, he...

Mas também imaginem o tamanho do radicando: 20 * 1.000 = 20.000 dígitos numéricos.

Eu poderia ganhar um tempo enorme nesse algoritmo se alguém pudesse me dar uma dica sobre o seguinte:

À cada iteração no algoritmo eu preciso "chutar" um dígito de 0 a 9 concatenado ao resultado anterior e, em seguida, elevá-lo ao índice da raiz.

O meu chute inicial é 5 e, em seguida, eu comparo o resultado com o valor parcial do radicando do qual desejo obter o próximo dígito da raiz.

Se a comparação falha eu tenho que subtrair 1 ou adicionar 1 ao dígito chutado, conforme deu maior ou menor que o valor do radicando parcial.

Nesse chutômetro, eu realizo: 5, 4, 3, 2, 1, 0 ou seja, 6 potenciações no pior caso quando dá maior na primeira vez. No melhor caso, se e 4, eu realizo apenas uma potenciação.

Quando dá menor na primeira vez eu realizo: 5, 6, 7, 8, 9, ou seja, 5 potenciações desnecessárias.

Postarei abaixo o código em VB DOT NET da função e caso alguém encontre uma solução melhor para esse chutômetro eu ficaria imensamente grato.

O código em VB está desatualizado e não confere muito com o descrito acima, pois estou dando continuidade agora em C#.

28 de novembro de 2013 10:27
João Labrego disse...

Public Shared Function RadiciaciationTrivial(ByVal radicand As String, ByVal degree As String, Optional ByRef remainder As String = Nothing) As String
Dim length As String = K_EMPTY_STRING, result As String = K_EMPTY_STRING, digit As String = K_EMPTY_STRING, root As Integer, _
power As String = K_EMPTY_STRING, compare As String, comparator As String, increment As Integer, lastPower As String, _
radicandAux As String
If Comparison(degree, K_NUMERAL_ONE) = K_SIGNAL_MINOR Or IsUndefined(radicand) Or IsUndefined(degree) Then
result = K_UNDEFINED_VALUE
remainder = K_UNDEFINED_VALUE
Else
Division(radicand.Length.ToString, degree, length)
If Comparison(length, K_NUMERAL_ZERO) = K_SIGNAL_EQUAL Then
length = degree
End If
radicandAux = radicand
Do While radicandAux <> K_EMPTY_STRING
digit += LeftString(radicandAux, length.ToString)
length = degree
comparator = K_EMPTY_STRING
root = 5
Do
lastPower = power
power = Potentiation(result + root.ToString, degree)
compare = Comparison(power, digit)
If root = 5 Then
comparator = compare
If compare = K_SIGNAL_MAJOR Then
increment = -1
ElseIf compare = K_SIGNAL_MINOR Then
increment = 1
Else
Exit Do
End If
ElseIf compare <> comparator Then
If comparator = K_SIGNAL_MINOR And compare <> K_SIGNAL_EQUAL Then
root -= 1
power = lastPower
End If
Exit Do
End If
root += increment
Loop
result += root.ToString
Loop
remainder = Subtraction(radicand, power)
result = result.TrimStart(K_NUMERAL_ZERO)
End If
Return result
End Function

28 de novembro de 2013 10:28
João Labrego disse...

Pronto! Ufa!

Consegui corrigir o bug da versão C#.

Esta versão está mais atualizada, melhorada, otimizada e eficiente que a versão em VB.

Que puder dar uma olhadinha e achar um jeito de otimizar o chutômetro descrito acima, eu agradeço.

Farei um teste com busca binária para esse dígito e verei como fica. Se funcionar, ótimo, senão, terei que procurar um método algébrico.

private static string Root(string radicand, string degree)
{
char compare, comparator;
string result = K_EMPTY_STRING, digit = K_EMPTY_STRING, power = K_EMPTY_STRING, lastPower,
countMissingDigits = Module(radicand.Length.ToString(), degree);
int increment, root;
if (!IsZero(countMissingDigits))
{
radicand = StringOfChar(Subtraction(degree, countMissingDigits)) + radicand;
}
REMAINDER_LAST_RADICIATION = K_EMPTY_STRING;
while (radicand != K_EMPTY_STRING)
{
digit += LeftString(radicand, degree);
radicand = RightString(radicand, degree);
increment = 1;
compare = K_SIGNAL_MINOR;
comparator = K_SIGNAL_MINOR;
root = K_INITIAL_DIGIT;
while (true)
{
lastPower = power;
power = Potentiation(result + root.ToString(), degree);
compare = Comparison(power, digit);
if (root == K_INITIAL_DIGIT)
{
if (compare == K_SIGNAL_MAJOR)
{
increment = -1;
comparator = K_SIGNAL_MAJOR;
}
else if (compare == K_SIGNAL_EQUAL)
{
break;
}
}
else if (compare != comparator)
{
if (comparator == K_SIGNAL_MINOR && compare != K_SIGNAL_EQUAL)
{
root--;
power = lastPower;
}
break;
}
root += increment;
}
result += root.ToString();
}
REMAINDER_LAST_RADICIATION = Subtraction(digit, power);
return result;
}

28 de novembro de 2013 11:15
João Labrego disse...

Mais um grande sucesso!!!

Implementei a busca binária no chutômetro e agora a função demora 1 a 2 segundos para apresentar os mesmos resultados.

He, he... Estou conseguindo me superar.

Abaixo o novo código em C# para análise dos demais e se tiverem alguma ideia para melhorar eu agradeço, se bem que está cada vez mais difícil melhorar o que já está quase perfeito.

private static string Root(string radicand, string degree)
{
char compare;
string result = K_EMPTY_STRING, digit = K_EMPTY_STRING, power = K_EMPTY_STRING, lastPower = K_EMPTY_STRING,
countMissingDigits = Module(radicand.Length.ToString(), degree);
int root, start, final;
if (!IsZero(countMissingDigits))
{
radicand = StringOfChar(Subtraction(degree, countMissingDigits)) + radicand;
}
REMAINDER_LAST_RADICIATION = K_EMPTY_STRING;
while (radicand != K_EMPTY_STRING)
{
digit += LeftString(radicand, degree);
radicand = RightString(radicand, degree);
start = 0;
final = 9;
while (true)
{
if (start > final)
{
root = final;
power = lastPower;
break;
}
root = (start + final) / 2;
lastPower = power;
power = Potentiation(result + root.ToString(), degree);
compare = Comparison(power, digit);
if (compare == K_SIGNAL_MINOR)
{
start = root + 1;
}
else if (compare == K_SIGNAL_MAJOR)
{
final = root - 1;
}
else
{
break;
}
}
result += root.ToString();
}
REMAINDER_LAST_RADICIATION = Subtraction(digit, power);
return result;
}

28 de novembro de 2013 11:41
João Labrego disse...

Alguns de vocês podem estar perguntando por que eu uso nomes de variáveis e funções em inglês se eu poderia criá-las com nomes em português.

Na verdade, eu costumo usar o inglês porque pretendo publicar estas bibliotecas na Internet para o mundo inteiro.

Como o inglês hoje é um idioma universal praticamente assim como foi o latim na Idade Média, quase todo trabalho que se deseja publicar para o mundo precisa ser escrito em inglês.

É claro que as mensagens ao usuário eu digitei em português e se alguém quiser mudar isso para o inglês fique à vontade.

Talvez amanhã eu já faça UPLOAD do código em C# completo das minhas funções e disponibilizarei o link para vocês.

Demorarei um certo tempo para produzir a versão EXCEL e por isso, para adiantar àqueles que entendem de programação C# DOT NET, deixarei os códigos para testes e análises.

28 de novembro de 2013 11:55
João Labrego disse...

Como eu havia prometido estou enviando o link do programa C# completo para quem tem como testar no DOT NET.

http://www.filefactory.com/file/6okxcvzekv/ULA_rar

28 de novembro de 2013 13:30
Francisco Valdir disse...

Olá, João Labrego!!!!!
Bom dia!!!!
Parabéns, meu amigo e parceiro!!!! O seu prêmio maior é a gratidão de milhares de pessoas na Terra irão se beneficiar com esse seu trabalho, João!!!!! Mas, (eu sei que você, é um dos altruístas, voluntariados da disseminação dos conhecimentos) em se tratando de além do reconhecimento pelo mérito do seu trabalho, caso haja ou que venha acontecer, você merece e eu o indicaria ou irei indicá-lo, para ser premiado com algo mais!!!!!
Obrigado por esse presente matemático, muita saúde, paz e sucessos, mais que merecidos, caro amigo João!!!!
INTEL LOGO!!!!
Um abraço!!!!!

29 de novembro de 2013 03:19
João Labrego disse...

Franscisco:

Tive a ingrata ou grata surpresa de reconstruir o algoritmo de radiciação usando o BIGINTEGER da Microsoft que vem com o DOT NET.

Surpresa!!! Não só a radiciação deles é meia-boca como eu já havia dito em algum lugar como também a potenciação deles é falível, além de também ser meia-boca pois só permite expoentes inteiros.

Por isso, adianto-lhes que não tentem fazer essa adaptação, pois a Microsoft, como espera que ninguém use tão exaustivamente como eu os seus algoritmos, não fez questão de fazer algo confiável, funcional e geral.

29 de novembro de 2013 05:04
Francisco Valdir disse...

Olá, João!!!!
Obrigado pelo aviso!!!! O fundador da Microsoft, o Bill Gattes dizia no início da era dos computadores, coisas do tipo: " apenas no mundo serão construídos de 4 a 5 computadores"!!!! Então, o espírito empreendedor dessa corporação é imbuído desses senões, tanto de previsão de demanda quanto de estado da arte e segurança de utilização de seus produtos!!!! Muitas e muitas vezes, por conta disso, já correram atrás do prejuízo e, pela força do "dinheiro" esmagaram a concorrência que a antecederam por acreditar numa visão de mercado para um produto ( condenado pela Microsoft) de qualidade!!!!!
Mas, felismente, nem só de BIGINTEGER vive a programação, João!!!!! Há outras ótimas opções!!!!!
Um abraço!!!!!

29 de novembro de 2013 09:57
João Labrego disse...

Caro Francisco:

Na verdade, o conceito BIGINTEGER é um Santo Graal na comunidade desenvolvedora da Internet.

Temos hoje, excelentes algoritmos para desenvolvermos um sistema numérico-aritmético próprio e de uso geral apenas utilizando recursos das linguagens já existentes que, por sinal, naquilo que elas foram feitas para realizarem com perfeição elas são perfeitas, inclusive as linguagens de programação da MICROSOFT.

O que o mundo inteiro está pecando e não conseguindo resolver é o maldito problema da radiciação que ninguém conseguiu ainda definir um algoritmo simples para suas resoluções.

Oras, uma das propriedades exigidas num sistema numérico é a propriedade de FECHAMENTO, ou seja, numa determinada operação aritmética de dois números pertencentes a um determinado conjunto numérico sempre que houver um resultado possível este deverá também pertencer ao conjunto numérico dos números envolvidos.

Exemplo: a e b pertencem a Z e a + b = c => c também pertence a Z.

O que vem ocorrendo e é um atentado às mínimas noções de matemática elementar é que as operações de potenciação e radiciação estão admitindo um radicando ou base BIGINTEGER mas o expoente e o índice são INTEGER comuns.

Isso para mim é inadmissível, pois eu prezo muito a perfeição em matemática.

Ainda assim, segundo descobri pelos meus testes com números imensos, a radiciação e até mesmo a potenciação falham depois de uma certa grandeza de número, dando resultados imprecisos.

Eu, como diz o Édson, garanto a eficiência de minhas funções 100%, sob qualquer grandeza de número, podendo ter até 100.000 dígitos numéricos ou muito mais ainda.

É claro que quanto maior a grandeza do número maior será o tempo dispendido em seu cálculo mas isso eu estou resolvendo criando essa mesma biblioteca de funções em DELPHI que é uma linguagem compilada em ASSEMBLER e não pseudo-códigos como são as linguagens da MICROSOFT para serem executadas em máquinas virtuais.

O DELPHI eu já tive oportunidade de testar sua velocidade em um algoritmo super-pesado de determinação de números primos.

O mesmo determinou a primalidade de um imenso número primo em 1 segundo ou menos.

Por isso, tenho certeza de que se a MICROSOFT ainda não resolveu muitos problemas é porque ela ainda não sabe resolvê-los e cabe aos matemáticos de plantão envidarem esforços na resolução desses percalços que ainda atravancam a evolução dos computadores.

Conversei ontem com o Edson e ele me reportou que tem registro em cartório desse método geral da radiciação e tudo o mais.

Continua...

29 de novembro de 2013 10:31
João Labrego disse...

Continuação:

Por isso, caso seu registro em cartório seja realmente válido como direitos autorais da ideia, pretendo conversar com ele sobre a possibilidade de enviarmos a minha biblioteca para a MICROSOFT avaliar, avisando-os dos direitos autorais relativos ao método de radiciação.

No link http://en.wikipedia.org/wiki/Shifting_nth-root_algorithm há um algoritmo parecido com este do método geral da radiciação mas o mesmo em termos de velocidade, confiabilidade pois apresentou alguns resultados errados, tempo de execução, operações envolvidas, condições de decisão, etc... é muito, mas muito mesmo inferior ao do Édson,

Eu, ontem, fiquei preocupado com essa semelhança e tomei de lápis e papel para entender aquele algoritmo.

Vi então que não havia perigo de o método geral da radiciação ser um plágio inconsciente desse outro método chamado polinomial.

Por todos esses motivos que lhe exponho, eu tenho certeza de que o Édson conquistará um lugar no mundo matemático com sua brilhante solução que vem atormentando a mente de muitos desenvolvedores que se não deslancharam ainda em seus projetos ambiciosos de se tornarem os criadores da melhor BIGINTEGER do mundo foi porque escorregaram nesse maldito e tão procurado algoritmo geral da radiciação.

Um grande abraço e procure se inteirar dos problemas que a informática atravessa justamente por causa dos problemas que a matemática ainda não resolveu e talvez até considere indignos de atenção.

29 de novembro de 2013 10:41
João Labrego disse...

Prezado Francisco:

Outra coisa inédita que gostaria que você colocasse em seu blog é um artigo sobre o cálculo manual de logaritmos decimais ou em qualquer outra base.

Vou te enviar um artigo por e-mail, escrito em espanhol que explica tintim por tintim como calcular um logaritmo de qualquer número com quantas casas decimais a pessoa desejar.

Encontrei esse artigo no site de Monografias (site espanhol, por sinal) e até já fiz uma função que implementa esse algoritmo no Excel ou em qualquer outra linguagem de programação.

29 de novembro de 2013 11:15
João Labrego disse...

Também tenho o algorítmo para, à partir do logarítmo, calcular o logaritmando que deu origem a ele.

Depois que você postar o artigo no blog eu passarei o algorítmo.

29 de novembro de 2013 11:20

Postar um comentário