For create hack, Assembly.

What is Assembler?
--------------------

Assembler could be one of my favorite languages ​​to work.
Not to be a linhguagem easy at first, but once you become familiar
with it, you understand how logical it is.

Assembler is a low-level language, which you can use in your programs
to speed slow tasks. Basically it consists of a meager sentences
represent instructions in machine language, and as it is close
to machine code, it is fast.

Long ago, when the 8086 appeared (yes, there were humans on Earth
Smile at that time, programming was not an easy task. When the first
computers were developed, the schedule had to be done in code
machine, which was _not_ an easy task, and so was born the assembler.


Why use it?
-----------------

As I said before, Assembler is fast. It also allows you to speak to
the machine at the hardware level, and gives you much greater control and flexibility
on the PC. One of the other advantages of assembler is that it allows you
Impress your friends with seemingly incomprehensible code pages.
Not seeing them crowded around you and impressed / laughing
his nerdeza? Smile


As this tutorial appeared?
------------------------------

Well, I had a couple of friends who wanted to learn Assembler to accelerate
their programs in Pascal, so I gave them some tutorials Assembler I
had. Since these tutorials have all the information you need, they
were not written for beginners to easily understand, so I decided
write my own.

If you are using this tutorial and find it useful and informative, so why
please write to me.



LESSON 1 - Registers
--------------------------

When you're working with Assembler, you have to use registers.
You can imagine them as being Variables already set for you. Most
common are listed below:

þ AX - the accumulator. Includes AH and AL, the high and low bytes
AX. Commonly used in mathematical operations and I / O

þ BX - the base. Comprises BH and BL. Commonly used as a base or
pointer register.

þ CX - the counter. Comprises CH and CL. Often used in loops.

þ DX - displacement, similar to the base register. Comprises DH
and DL. I think you're getting the hang of things now.

These registers are defined as general-purpose registers as we
actually store anything you want in them. They are also
16-bit registers, which means that we can store an integer
positive from 0 to 65535, or an integer from -32768 to 32768.

Incidentally, the issue of high and low byte of these resgistradores
caused much confusion in the past, so try to give some explanation here.
AX has a range of 0 to FFFFh. This means that you have a range
0 to FFh for AH and AL. (If you know little about hex, not
worry. The next tutorial will talk about it.)

Now, if we have in store 0A4Ch AX, AH will contain 0Ah, and AL contain
4ch. Dig? This is a very important concept, and I will speak about it
further in the next tutorial.


The segment registers: - ta da!

These are other registrars do not we see the first tutorial,
but we will see them in greater depth later. They are immensely useful,
but may also be dangerous.

þ CS - the code segment. The block mem ¢ ria where the code is stored.
DO NOT mess with this unless you know what you're doing.

þ DS - data segment. The area in memory where the data is stored.
During block operations, when large blocks of data are moved,
this is the segment to which the CPU commonly refers.

þ ES - extra segment. As another data segment, but this is
commonly used when accessing the video.

þ SS - no, not the German army. It is the stack segment, wherein
‡ CPU stores the return addresses of subroutines. Beware
it. Smile

Some others that you will commonly use:

þ SI - the font index. Often used for movements of blocks
instruction. This is a pointer within one segment, usually
DS is used by the CPU for reading.

þ DI - the target index. Again, you'll use a lot. Another
pointer within one segment, usually ES is used for writing
by the CPU.

þ BP - the pointer of the base used in conjunction with the stack segment. We
we will not use it much.

þ SP - the stack pointer, commonly used with the stack segment. NO
play with it at all. : |

By now you should know what are registers. There are other
Registrars also known as flags and stuff, but we will not
to them now.




THINGS TO DO:

1) Learn the various registers of color.
2) Arrange a calculator that supports hexadecimal - or at least a
ASCII table. This covers 0-255, or from 0h to FFh.




Lesson 2 - The instruction set of 8086:
----------------------------------------------

Okay, so you've learned about registers, but how to use them,
and how to code in assembler? Well, first you need some
instructions. The following instructions can be used on all CPUs
8086 upward.

þ <dest> MOV, <value> - MOVE. This statement allows a value MOVE
to a position in mem ¢ ria.

Example: MOV AX, 13h

This would move 13h (19 decimal) into the
AX register. So if AX value 0 before it
Now would be 13h.

THAT ONLY MOVE A VALUE FOR THE REGISTER,
DONT DO ANYTHING.

Ex: (in Pascal) AX: = $ 13;

þ INT <number> - INTERRUPTION. This instruction generates a interupção.
You can think of it as an almost
procedure.

Eg: INT 10h

Generate interrupt 10h (16 decimal). Now
what that would depend on the contents of register
AH, among other things. For example, if AX = 13h
and interrupt 10h is generated, the video would be
placed in 320x200x256 mode.

More precisely:

AH would be equal to 00 - set the subfunction
Similarly, and
AL would be equal to 13h - 320x200x256 graphics mode.

However, if AH = 2h, and 16h interrupt was
generated, this would instruct the CPU to check if
any key is pressed in the buffer
keyboard.

If AH = 2h, and BH = 0h and interrupt 10h was
generated, then the CPU would move the cursor to the
X position and Y position in DL DH.

DO NOT WORRY ABOUT IT FOR NOW! WE
We'll talk LATER ON THAT, WITH MORE DETAILS.

þ <dest> <value> ADD - ADD. This instruction adds a number to the value
stored in dest.

Ex: MOV AX, 0h; AX now equals 0h
ADD AX, 5h; AX now equals 5h
ADD AX, 10h; AX now equals 15h

Pretty simple, huh?

þ SUB <dest> <value> - SUBTRACT. I think you just can guess what it
makes.

Ex: MOV AX, 13h, AX now equals 13h (19 dec)
SUB AX, 5h; AX now equals 0Eh (14 dec.)

þ DEC <register> - DECREASE something.

Ex: MOV AX, 13h, AX now equals 13h
DEC AX, AX now equals 12h

þ INC <register> - INCREASES something.

Ex: MOV AX, 13h; Guess ...
INC AX, AX = AX + 1

þ JMP <position> - JUMPS to a position.

EG: JMP 020Ah; Pula for education in 020Ah
JMP @ MyLabel; Pula to @ MyLabel.

DO NOT WORRY IF THIS IS A LITTLE CONFUSED - GO
BE WORSE! THERE ARE 28 TO JUMP INSTRUCTIONS
LEARNING AND MAYBE MORE. We'll talk THEM LATER.

þ <Procedure> CALL - CALL a subfunction.

EG: Procedure MyProc;

Begin {} MyProc
{... }
End;} {MyProc

Begin {main}
Asm
CALL MyProc; Guess what that does!
End;
End

Or CALL F6E0h; Flame subfunction in F6E0h

þ LOOP <rótulo/label> - LOOPS (repetition) for a while.

EG: MOV CX, 10h; This is because CX be
, Called registration COUNTER.
, 10h = 16

@ MyLabel:

: Something
; More thing

LOOP @ MyLabel, Acts, that CX = 0
, Note: CX is decremented
; Each time. Ńŕéň decrement it
; Yourself (DEC CX).

, THIS WOULD REPEAT 16 times - i.e., 10
in hexadecimal.

þ LODSB - Loads a byte
LODSW - Loads a word
STOSB - Store a byte
STOSW - Store a word

These instructions are used to set or get something in a position
memory. Recorder DS: SI, (remember we talked about this before,
about SI be the font index?), points to the location where
we get the data, and DS: DI points to put where information.

Of course, we are not required to use DS - ES could be eg.
My procedure PutPixel put a byte at ES: DI.

Anyway, imagine we have the following configuration in mem ¢ ria:

Memory location ³ 06 ³ 07 ³ 08 ³ 09 ³ 10 ³ 11 ³ 12

Value ³ 50 ³ 32 ³ 38 ³ 03 ³ 23 ³ 01 ³ 12

When we use LODSB or STOSB, he returns and takes a number of AL.
Thus, if DS: SI pointing to 07 and an instruction executássemos LODSB,
AL would now be equal to 32.

Now, if we pinpoint DS: DI for 11, putting, say, 50 in
AL register, and execute STOSB, then we have the following result:

Position in Memory ³ 06 ³ 07 ³ 08 ³ 09 ³ 10 ³ 11 ³ 12

Value ³ 50 ³ 32 ³ 38 ³ 03 ³ 23 ³ 50 ³ 12

OBS.: When we LODSB / STOSB, use AL. This is because we
stirring with an 8 bit (one byte) only. We can
store an 8-bit number in AL, AH, and AX, but we can not
storing a 16-bit number in AH or AL because they are
REGISTERS OF 8 BITS.

As a result, when we use LODSW or STOSW, we must use
AL AX and not as we will be getting / setting a number of
16 bits.


þ MOVSB ​​- Move a byte
MOVSW - Moves one word

As an example let's take a byte from DS: SI and send it to ES: DI.

In DS: SI:

Position Memory ³ 06 ³ 07 ³ 08 ³ 09 ³ 10 ³ 11 ³ 12

Value ³ 50 ³ 32 ³ 38 ³ 03 ³ 23 ³ 50 ³ 12


In ES: DI:

Position Memory ³ 06 ³ 07 ³ 08 ³ 09 ³ 10 ³ 11 ³ 12

Value ³ 10 ³ 11 ³ 20 ³ 02 ³ 67 ³ 00 ³ 12

If we point DS: SI to position 07, we point ES: SI to position
11 MOVSB ​​and execute the result in ES: DI look like:

In ES: DI:

Position Memory ³ 06 ³ 07 ³ 08 ³ 09 ³ 10 ³ 11 ³ 12

Value ³ 10 ³ 11 ³ 20 ³ 02 ³ 67 ³ 32 ³ 12


HOPE YOU GET A GENERAL IDEA. HOWEVER, OF COURSE, IS NOT SO SIMPLE.
POSITIONS ARE NOT ARRUMADOAS MEMORY SHAPED ARRAY, ALTHOUGH I
WISH THEY WERE. WHEN MOVE / GET / PUT, YOU WILL
Stirring with a POSITION AS: 100:102 H. STILL, YOU SHOULD
GET THE IDEA.

þ REP - REPEAT the number of times specified in the CX register.
A REP in front of a MOVSB ​​/ LODSB / STOSB cause a repetition of the
instruction. Logo:

If CX = 5, and
if ES: DI pointing at 1000:1000 h,

then REP STOSB would store what was in the AL register
position 1000:1000 h 5 times.

THINGS TO DO:

1) Save all instructions above - is not that hard and there are so many
there.

2) Be sure you understand the theory behind them.

Português

O que é Assembler?
--------------------

Assembler conseguiu ser uma das minhas linguagens favoritas para trabalhar.
Não que seja uma linhguagem fácil no início, mas quando você fica familiar
com ela, você entende o quão lógica ela é.

Assembler é uma linguagem de baixo nível, que você pode usar em seus programas
para acelerar tarefas lentas. Basicamente ela consite de sentenças que
representam instruções em linguagem de máquina, e, como ela está próxima
ao código de máquina, ela é rápida.

Há muito tempo atrás, quando o 8086 apareceu (sim, existiam humanos na Terra
nessa época Smile, programar não era uma tarefa fácil. Quando os primeiros
computadores foram desenvolvidos, a programação tinha que ser feita em código
de máquina, que _não_ era uma tarefa fácil, e assim o Assembler nasceu.


Por que usá-lo?
-----------------

Como eu disse antes, Assembler é veloz. Ele também permite a você falar com
a máquina a nível de hardware, e lhe dá muito maior controle e flexibilidade
sobre o PC. Uma das outras vantagens do Assembler é que ele permite a você
impressionar seus amigos com páginas de código aparentemente incompreensível.
Não está vendo eles aglomerados em volta de você e impressionados/rindo
de sua nerdeza? Smile


Como este tutorial apareceu?
------------------------------

Bem, Eu tinha uma dupla de amigos que queriam aprender Assembler para acelerar
seus programas em Pascal, então eu dei-lhes alguns Tutoriais de Assembler que eu
tinha. Como esses tutoriais tinham toda a informação que você precisaria, eles
não foram escritos para os principiantes entenderem facilmente, então, decidi
escrever meu próprio.

Se você está usando este tutorial e o acha útil e informativo, então, por
favor escreva para mim.



LIÇÃO 1 - Registradores
--------------------------

Quando você está trabalhando com Assembler, você tem que usar registradores.
Você pode imaginá-los como sendo vari veis já definidas para você. Os mais
comuns estão listados abaixo:

þ AX - o acumulador. Compreende AH e AL, os bytes alto e baixo
de AX. Comumente usado em operações matemáticas e de E/S.

þ BX - a base. Compreende BH e BL. Comumente usado como uma base ou
registrador apontador.

þ CX - o contador. Compreende CH e CL. Usado frequentemente em loops.

þ DX - o deslocamento, similar ao registrador de base. Compreende DH
e DL. Acho que você está pegando o espírito da coisa agora.

Estes registradores são definidos como registradores de uso geral pois podemos
realmente armazenar qualquer coisa que quisermos neles. São também
registradores de 16 bits, o que significa que podemos armazenar um inteiro
positivo de 0 a 65535, ou um inteiro com sinal de -32768 to 32768.

Incidentalmente, o assunto do alto e do baixo byte destes resgistradores
causou muita confusão no passado, logo, tentarei dar alguma explicação aqui.
AX tem um intervalo de 0 até FFFFh. Isto significa que você tem um intervalo
de 0 até FFh para AH e AL. (Se sabe pouco sobre hexadecimal, não se
preocupe. O próximo tutorial vai falar sobre ele.)

Agora, se nós tivermos que armazenar 0A4Ch em AX, AH conterá 0Ah, e AL conterá
4Ch. Sacou? Este é um conceito muito importante, e eu falarei sobre ele
mais profundamente no próximo tutorial.


Os registradores de segmento: - ta da!

Estes são outros registradores que nós não vamos ver nos primeiros tutorias,
mas vamos vê-los em maior profundidade mais tarde. Eles são imensamente úteis,
mas podem ser também perigosos.

þ CS - o segmento de código. O bloco de mem¢ria onde o código ‚ armazenado.
NÃO brinque com esse, a menos que saiba o que está fazendo.

þ DS - o segmento de dados. A área na memória onde os dados são armazenados.
Durante operações de bloco, quando grandes blocos de dados são movidos,
este é o segmento a que a CPU comumente se refere.

þ ES - o segmento extra. Apenas outro segmento de dados, mas este é
comumente usado quando se quer acessar o vídeo.

þ SS - não, não é o exército alemão. É o segmento de pilha, em que a
CPU armazena endere‡os de retorno de subrotinas. Tome cuidado com
ele. Smile

Alguns outros que você vai comumente usar:

þ SI - o índice de fonte. Frequentemente usado para movimentações de blocos
de instruções. Este é um ponteiro que, com um segmento, geralmente
DS, é usado pela CPU para leitura.

þ DI - o índice de destino. Novamente, você o usará muito. Um outro
ponteiro que, com um segmento, geralmente ES, é usado para escrita
pela CPU.

þ BP - o apontador da base, usado em conjunto com o segmento de pilha. Nós
não vamos usá-lo muito.

þ SP - o apontador da pilha, comumente usado com o segmento de pilha. NÃO
brinque com isso de jeito nenhum. :|

Por enquanto você deveria saber o que são registradores. Há outros
registradores também, e coisas conhecidas como flags, mas nós não iremos
a eles agora.




COISAS PARA FAZER:

1) Aprender os vários registradores de cor.
2) Arrumar uma calculadora que suporte hexadecimal - ou pelo menos uma
tabela ASCII. Isso cobre 0 - 255, ou, de 0h a FFh.




LIÇÃO 2 - O conjunto de instruções do 8086:
----------------------------------------------

Okay, então você já aprendeu sobre registradores, mas, como usá-los,
e como se codifica em Assembler? Bem, primeiro você precisa de algumas
instruções. As seguintes instruções podem ser usadas em todas as CPU's
do 8086 para cima.

þ MOV <dest>, <valor> - MOVE. Esta instrução permite MOVER um valor
para uma posição na mem¢ria.

Ex.: MOV AX, 13h

Isso deveria mover 13h (19 em decimal) para o
registrador AX. Logo, se AX valia antes 0, ele
agora seria 13h.

ISSO APENAS MOVE UM VALOR PARA UM REGISTRADOR,
NÃO FAZ NADA MAIS.

Ex.: (Em Pascal) AX := $13;

þ INT <número> - INTERRUPÇÃO. Esta instrução gera uma interupção.
Você pode pensar nisso como sendo quase uma
procedure.

Ex.: INT 10h

Geraria a interrupção 10h (16 em decimal). Agora,
o que isso faria depende do conteúdo do registrador
AH, entre outras coisas. Por exemplo, se AX = 13h
e a interrupção 10h foi gerada, o vídeo seria
colocado no modo 320x200x256.

Mais precisamente:

AH seria igual a 00 - seleciona a subfunção do
modo, e
AL seria igual a 13h - modo gráfico 320x200x256.

Contudo, se AH = 2h, e a interrupção 16h foi
gerada, isso instruiria a CPU para checar se
alguma tecla pressionada está no buffer do
teclado.

Se AH = 2h, e BH = 0h e a interrupção 10h foi
gerada, então a CPU moveria o cursor para a
posição X em DL e posição Y DH.

NÃO SE PREOCUPE COM ISSO POR ENQUANTO! NÓS
FALAREMOS NISSO MAIS TARDE, COM MAIS DETALHES.

þ ADD <dest> <valor> - ADICIONA. Esta instrução soma um número ao valor
armazenado em dest.

Ex: MOV AX, 0h ; AX agora é igual a 0h
ADD AX, 5h ; AX agora é igual a 5h
ADD AX, 10h ; AX agora é igual a 15h

Bem simples, não?

þ SUB <dest> <valor> - SUBTRAI. Acho que dá pra você adivinhar o que isso
faz.

Ex: MOV AX, 13h ; AX agora é igual a 13h (19 dec)
SUB AX, 5h ; AX agora é igual a 0Eh (14 dec)

þ DEC <registrador> - DECREMENTA algo.

Ex: MOV AX, 13h ; AX agora é igual a 13h
DEC AX ; AX agora é igual a 12h

þ INC <registrador> - INCREMENTA algo.

Ex: MOV AX, 13h ; Adivinha...
INC AX ; AX = AX + 1

þ JMP <posição> - PULA para uma posição.

EG: JMP 020Ah ; Pula para a instrução em 020Ah
JMP @MyLabel ; Pula para @MyLabel.

NÃO SE PREOCUPE SE ISTO É UM POUCO CONFUSO - VAI
FICAR PIOR! HÁ OUTRAS 28 INSTRUÇÕES JUMP PARA
APRENDER, TALVEZ MAIS. FALAREMOS NELAS MAIS TARDE.

þ CALL <procedimento> - CHAMA uma subfunção.

EG: Procedure MyProc;

Begin { MyProc }
{ ... }
End; { MyProc }

Begin { Main }
Asm
CALL MyProc ; Adivinha o que isso faz!
End;
End.

Ou: CALL F6E0h ; Chama subfunção em F6E0h

þ LOOP <rótulo/label> - Faz LOOPS (repetição) durante um certo tempo.

EG: MOV CX, 10h ; Isto é o porque de CX ser
; chamado de registro CONTADOR.
; 10h = 16

@MyLabel:

; alguma coisa
; mais coisa

LOOP @MyLabel ; At‚ que CX = 0
; Note: CX é decrementado
; a cada vez. NÆo decremente-o
; você mesmo (DEC CX).

; ISSO DEVERIA SE REPETIR 16 vezes - i.e., 10
em hexadecimal.

þ LODSB - Carrega um byte
LODSW - Carrega uma word
STOSB - Armazena um byte
STOSW - Armazena uma word

Estas instruções são usadas para pôr ou conseguir algo numa posição na
memória. O registrador DS:SI, (lembra que nós falamos sobre isso antes,
sobre SI ser o índice de fonte?), aponta para a localização de onde
queremos obter os dados, e DS:DI aponta para onde colocaremos informações.

É claro, não somos obrigados a usar DS - poderia ser ES por exemplo.
Meu procedimento PutPixel colocar um byte em ES:DI.

De qualquer modo, imagine que temos a seguinte configuração na mem¢ria:

Posição na memória ³ 06 ³ 07 ³ 08 ³ 09 ³ 10 ³ 11 ³ 12

Valor ³ 50 ³ 32 ³ 38 ³ 03 ³ 23 ³ 01 ³ 12

Quando nós usamos LODSB ou STOSB, ele retorna ou pega um número de AL.
Assim, se DS:SI apontava para 07 e executássemos uma instrução LODSB,
AL seria agora igual a 32.

Agora, se nós apontássemos DS:DI para 11, colocando, diria, 50 no
registrador AL, e executasse STOSB, então teríamos o seguinte resultado:

Posição na Memória ³ 06 ³ 07 ³ 08 ³ 09 ³ 10 ³ 11 ³ 12

Valor ³ 50 ³ 32 ³ 38 ³ 03 ³ 23 ³ 50 ³ 12

OBS.: Quando usamos LODSB/STOSB, usamos AL. Isto porque estaremos
mexendo com um número de 8 bits (um byte), apenas. Podemos
armazenar um número de 8 bits em AL, AH, ou AX, mas não podemos
armazenar um número de 16 bits em AH ou AL porque eles são
REGISTRADORES DE 8 BITS.

Como resultado, quando usarmos LODSW ou STOSW, nós devemos usar
AX e não AL, já que estaremos pegando/colocando um número de
16 bits.


þ MOVSB - Move um byte
MOVSW - Move uma word

Como exemplo vamos pegar um byte de DS:SI e mandá-lo para ES:DI.

Em DS:SI:

Posição de Memória ³ 06 ³ 07 ³ 08 ³ 09 ³ 10 ³ 11 ³ 12

Valor ³ 50 ³ 32 ³ 38 ³ 03 ³ 23 ³ 50 ³ 12


Em ES:DI:

Posição de Memória ³ 06 ³ 07 ³ 08 ³ 09 ³ 10 ³ 11 ³ 12

Valor ³ 10 ³ 11 ³ 20 ³ 02 ³ 67 ³ 00 ³ 12

Se apontarmos DS:SI para a posição 07, apontarmos ES:SI para a posição
11 e executarmos MOVSB, o resultado em ES:DI pareceria com:

Em ES:DI:

Posição de Memória ³ 06 ³ 07 ³ 08 ³ 09 ³ 10 ³ 11 ³ 12

Valor ³ 10 ³ 11 ³ 20 ³ 02 ³ 67 ³ 32 ³ 12


ESPERO QUE VOCÊ PEGUE A IDÉIA GERAL. CONTUDO, É CLARO, NÃO É TÃO SIMPLES.
POSIÇÕES DE MEMÓRIA NÃO SÃO ARRUMADOAS EM FORMA DE ARRAY, EMBORA EU
DESEJASSE MUITO QUE FOSSEM. QUANDO FOR MOVER/PEGAR/COLOCAR, VOCE ESTARÁ
MEXENDO COM UMA POSIÇÃO TAL COMO: 100:102H. AINDA ASSIM, VOCÊ DEVERIA
PEGAR A IDÉIA.

þ REP - REPETE o número de vezes especificado no registrador CX.
Um REP na frente de um MOVSB/LODSB/STOSB causaria a repetição da
instrução. Logo:

Se CX = 5, e
se ES:DI apontava para 1000:1000h,

então REP STOSB armazenaria o que estava no registrador AL na
posição 1000:1000h 5 vezes.

COISAS A FAZER:

1) Memorizar todas as instruções acima - não é tão difícil assim e não há tantas
lá.

2) Tenha certeza que você entendeu a teoria por trás delas.

   Level Help 100%

If I helped you, thank

Muito bem elaborado, parabéns! Foi você quem fez ele?

Good!

Quote:

---

Originally Posted by CotocoV1 [Only registered and activated users can see links. Click Here To Register...]

Muito bem elaborado, parabéns! Foi você quem fez ele?

Good!

---

Frankly I asked my uncle here for facebook how it worked and he gave me this text, so there is!

Português

Sinceramente eu perguntei ao meu tio aqui pelo facebook como funcionava e ele me passou esse texto, então ai está!

Quote:

---

Originally Posted by patrickpp [Only registered and activated users can see links. Click Here To Register...]

Frankly I asked my uncle here for facebook how it worked and he gave me this text, so there is!

---

Muito bom, agradeça ao seu tio pelo facebook. Para não gerar problemas, aí vai a fonte! [Only registered and activated users can see links. Click Here To Register...]

There is the font [Only registered and activated users can see links. Click Here To Register...]

Nice post, but for who is starting programming this is not recommended.

Really, for who don't know programming it will be very difficult, since need a knowledge about ASM.

Quote:

---

Originally Posted by CotocoV1 [Only registered and activated users can see links. Click Here To Register...]

Muito bom, agradeça ao seu tio pelo facebook. Para não gerar problemas, aí vai a fonte! [Only registered and activated users can see links. Click Here To Register...]

There is the font [Only registered and activated users can see links. Click Here To Register...]

---

Well, since you said this with such certainty, my uncle gave me his source, in which case it would not be is you're going ...
And if I helped you thank ... At least this time it does not cost anything ...

Português

Bom, já que você disse isso com tanta certeza, meu tio me passou a fonte dele, que no caso não seria está que você está passando...
E se eu te ajudei agradeça... Pelo menos dessa vez não custa nada...

[Only registered and activated users can see links. Click Here To Register...]

heh vlw mas é muita treta essa parada, mas da para pegar de boa...

heh vlw but this is a lot of bullshit stop, but to get the good ...

Quote:

---

Originally Posted by kondlord [Only registered and activated users can see links. Click Here To Register...]

heh vlw mas é muita treta essa parada, mas da para pegar de boa...

heh vlw but this is a lot of bullshit stop, but to get the good ...

---

It is recommended for beginner to start from C and not C + + and thank if I helped. xD

Português

É recomendado se for iniciante que começe do C e não C++ e se ajudei agradeça. xD