
Chinese: 
嗨，我是凯莉安妮，这是速成班
计算机科学！
上一集结束时，我们把ALU（计算逻辑单元），控制
单元，一些存储器和时钟结合在一起，
做成了一个基本，但能够运行的中央处理单元 - 或者称之为CPU
计算机的心脏。
我们已经做了所有的前期工作
，将许多的这些电子组件组建起来，
现在，是时候给我们的
CPU一些实际的指导来运行！
CPU强大的原因是
它是可编程的。
如果你写不同序列的指令，
CPU将执行不同的任务。
所以CPU是一个可以被轻松修改的软件控制的硬件
让我们快速重温一下我们在上一集中讨论的一个简单程序。
计算机内存是这个样子>_<
每个地址包含着8位的数据，
对于我们假想的CPU，前四位指定了操作码，

English: 
Hi, I’m Carrie Anne and this is Crash Course
Computer Science!
Last episode, we combined an ALU, control
unit, some memory, and a clock together to
make a basic, but functional Central Processing
Unit – or CPU – the beating, ticking heart
of a computer.
We’ve done all the hard work of building
many of these components from the electronic
circuits up, and now it’s time to give our
CPU some actual instructions to process!
The thing that makes a CPU powerful is the
fact that it is programmable – if you write
a different sequence of instructions, then
the CPU will perform a different task.
So the CPU is a piece of hardware which is
controlled by easy-to-modify software!
INTRO
Let’s quickly revisit the simple program
that we stepped through last episode.
The computer memory looked like this.
Each address contained 8 bits of data.
For our hypothetical CPU, the first four bits
specified the operation code, or opcode, and

Korean: 
안녕하세요. 
Crash Course 컴퓨터 사이언스의 Carrie Anne입니다.
지난 에피소드에서 ALU, Control Unit, 약간의 메모리,
 그리고 클럭을 합쳐서
기본적이지만 동작 가능한 
중앙처리장치 (CPU)를 만들어 보았습니다.
컴퓨터의 똑딱거리는 심장이 뛰는 것이지요.
이 많은 부품들에 대해서 전자회로에서 부터 차례대로 
알아가는 어려운 일을 해왔습니다.
이제 우리 CPU에게 실제로 처리할 instruction(명령어)들을  줄 시간입니다.
CPU를 강력하게 만드는 점은 
프로그램이 가능하다는 것입니다.
명령어의 순서를 바꾸면, CPU는 다른 일을 수행합니다.
그래서, CPU는 변경하기 쉬운 소프트웨어로
 제어가 가능한 하드웨어 조각입니다.
 
지난 에피소드에서 차근차근 살펴본 간단한 프로그램을 빠르게 복습해 보겠습니다.
컴퓨터 메모리는 이렇게 생겼구요.
각 주소에는 8비트 데이터가 저장되어 있습니다.
우리가 만든 CPU에서 첫 4비트는 
operation code (opcode)를 나타냅니다.

Arabic: 
مرحباً, أنا كاري آني و هذه هي قناة كراش كورس للحاسوب التعليمية
في الحلقة السابقة، جمعنا ALU، وحدة التحكم، القليل من الذاكرة،  وساعة.. من أجل
أن نصنع وحدة معالجة مركزية، "سي بي يو" القلب النابض
و روح الكمبيوتر.
قد انتهينا من العمل الصعب الآن و صنعنا معظم
تلك الأجزاء من
الدوائر الكهربائية، والآن حان الوقت لإعطاء وحدة المعالجة المركزية بعض الأوامر لتقوم بها!
ما يجعل وحدة المعالجة المركزية قوية
هو أنها قابلة للبرمجة
تسلسل مختلف من التعليمات، حينئذ وحدة المعالجة المركزية سوف تؤدي مهمة مختلفة.
لهذا فإن وحدة المعالجة المركزية هي قطعة قابلة للبرمجة
بواسطة برامج سهلة التعديل
مقدمة
دعونا نعود بسرعة للبرنامج البسيط
الذي توقفنا عنده في الحلقة الماضية
ذاكرة الحاسوب بدت هكذا.
يحتوي كل عنوان 8 بت من البيانات.
لوحدة المعالجة المركزية الافتراضية، تمثل البتات الأربع الأولى رمز العملية "أوبكود"

Portuguese: 
Oi, eu sou a Carrie Anne e esse é o Crash Course de Ciência da Computação!
No último episódio nós juntamos uma ALU, unidade de controle, um pouco de memória e um relógio para fazer
Uma CPU, coração do computador, bem básica, mas funcional
Fizemos todo trabalho duro de montar esses componentes a partir dos circuitos eletrônicos
e agora é hora de dar à CPU algumas instruções para processar
o que torna a CPU poderosa é o fato de que ela é programável
Se você escrever um conjunto diferente de instruções então a CPU fará algo diferente
A CPU é um componente físico que é controlado por software que é fácil de alterar
INTRODUÇÃO
Vamos dar uma olhada no programa simples que examinamos no último episódio
A memória do computador estava assim. Cada endereço continha 8 bits de dados
Para nossa CPU hipotética os primeiros 4 bits especificavam o código de execução ou opcode e

Spanish: 
Hola, soy Carrie Anne y esto es Crash Course Computer Science
En el capítulo pasado, combinamos una unidad de control ALU, memoria, y un reloj para
hacer una unidad de Procesamiento Central básica o CPU. El corazón latiente
de una computadora
Hemos hecho el trabajo difícil de construir muchos de esos componentes
y ahora es momento de darle a nuestro CPU algunas instrucciones que procesar
Lo que hace poderoso a un CPU es el hecho de que es programable - si escribes
una secuencia de instrucciones diferentes, la CPU ejecutara una tarea distinta.
Por lo que el CPU es una pieza de hardware controlada por un software manipulable!
INTRO
Recapitulemos rápidamente el sencillo programa que analizamos el capítulo pasado
La memoria del computador se ve así
Cada direccion contiene datos de 8 bits
Para nuestra CPU hipotética, los primeros 4 bits especifican el código de operación u opcode

Chinese: 
后四位指定了数据地址或寄存器地址。
当内存地址为零，里边的数据是0010 1110。
同样，那些数据的前四位是我们的操作码，它们对应于“LOAD_A”指令。
该指令从指令后四位指定的内存读取数据
然后存到寄存器A；在这个例子中，是后四位是1110，或者说十进制的14.
因此，我们现在不考虑把这个内存地址
0作为“0010 1110”，而是作为指令
“LOAD_A 14”。
这是更容易阅读和理解！
也更利于我讲述！
我们可以在内存中对剩下的’的数据做同样的事情
在这种情况下，我们的程序仅仅只有四个指令长，而且我们也已经把一些数字到内存
同样，3和14。
因此，现在让我们逐步运行这个程序：
首先是LOAD_A 14，其
从地址14中取值，也就是数字3，
然后把它存储到寄存器A.
然后，我们有一个“LOAD_B 15”指令，
它从存储器位置15中取值，值为
数字14，并将其保存到
寄存器B.
好的。
这很容易的。

English: 
the second set of four bits specified an address
or registers.
In memory address zero we have 0010 1110.
Again, those first four bits are our opcode
which corresponds to a “LOAD_A” instruction.
This instruction reads data from a location
of memory specified in those last four bits
of the instruction and saves it into Register
A. In this case, 1110, or 14 in decimal.
So let’s not think of this of memory address
0 as “0010 1110”, but rather as the instruction
“LOAD_A 14”.
That’s much easier to read and understand!
And for me to say!
And we can do the same thing for the rest
of the data in memory.
In this case, our program is just four instructions
long, and we’ve put some numbers into memory
too, 3 and 14.
So now let’s step through this program:
First is LOAD_A 14, which takes the value
in address 14, which is the number 3, and
stores it into Register A.
Then we have a “LOAD_B 15” instruction,
which takes the value in memory location 15,
which is the number 14, and saves it into
Register B.
Okay.
Easy enough.

Portuguese: 
o segundo grupo de 4 bits especifica um endereço ou um registrador
No endereço de memória 0 nós temos 0010 1110
Novamente, esses primeiros 4 bits são o nosso opcode que corresponde a instrução LOAD_A
Essa instrução lê um dado de uma posição de memória especificada nos últimos 4 bits
da instrução e salva esse valor no Registrador A. Nesse caso 1110, ou 14 em decimal
Então não vamos pensar nesse endereço de memória 0 como 0010 1110
mas sim como a instrução LOAD_A 14
Assim fica muito mais fácil para ler, entender e para eu dizer
E nós podemos fazer o mesmo para o resto dos dados na memória
Nosso programa tem apenas 4 instruções e nós colocamos alguns números na memória também, 3 e 14
Agora vamos avançar nesse programa Primeira instrução: LOAD_A 14
que pega o valor no endereço 14, que é igual ao número 3 e o coloca no registrador A
Depois temos a instrução LOAD_B 15 que pega o valor da posição 15 de memória, que é o número 14
e o armazena no registrador B. Ok. Bem fácil.

Spanish: 
El segundo conjunto de 4 bits especifican una dirección o registros
En la dirección de memoria cero tenemos 00101110
De nuevo, esos cuatro bits son nuestro código de operación que corresponden a la instrucción "LOAD_A".
Esta instrucción lee datos desde una ubicación de memoria especificada en estos últimos cuatro bits
de la instrucción  y lo guarda en el registro A. En este caso, 1110, o 14 en decimal
Así que ya no pensemos en la dirección de memoria 0 como "0010 1110", si no como la instrucción
"LOAD_A 14"
Es mucho mas fácil de leer y entender!
y para mi decirlo!
Podemos hacer lo mismo para el resto de datos en memoria
En este caso, nuestro programa consiste en 4 instrucciones, y ya hemos puestos algunos número en memoria
también, 3 y 14
Ahora vayamos paso a paso en este programa
Primero esta "LOAD_A 14" que toma el valor de la dirección 14 que es el numero 3 y lo
guarda en el registro A
Luego tenemos una instrucción" LOAD_B 15" que toma el valor en la ubicación de memoria 15
que es el número 14, y lo almacena en el Registro B
Okay
Bastante Facil

Arabic: 
حددت المجموعة الثانية المكونة من أربع بتات عنوانا أو سجلات.
في عنوان الذاكرة رقم صفر نحن لدينا 0010 1110.
مرة أخرى، تلك البتات الأربعة الأولى هي أوب كود الذي يتوافق مع تعليمات "LOAD_A".
هذه التعليمات تقرأ البيانات من موقع الذاكرة المحددة في تلك الأربع بتات الأخيرة
من التعليمات وتحفظه في التسجيل A. في هذه الحالة، 1110، أو 14 في التمثيل العشري.
لذلك دعونا لا نفكر في  عنوان الذاكرة 0 باسم "0010 1110"، ولكن بدلا من التعليمات
“LOAD_A 14”.
هذا أسهل للقراءة و الفهم!
و أسهل لي لأقولها!
يمكننا أن نفعل الشيء نفسه لبقية البيانات في الذاكرة.
في هذه الحالة، برنامجنا هو مجرد أربعة تعليمات
 و قد وضعنا بعض الأرقام أيضا في الذاكرة
3 و 14.
لذلك دعونا الآن نخطو خطوة من خلال هذا البرنامج:
الأمر الأول هو LOAD_A 14، الذي يأخذ القيمة في العنوان 14، وهو رقم 3، و
يخزنها في سجل A.
ثم لدينا الأمر "LOAD_B 15"، الذي يأخذ القيمة في موقع الذاكرة 15،
وهو الرقم 14، ويحفظه في السجل B.
حسناً.
سهل إلى الآن.

Korean: 
다음 4비트는 메모리 주소나 레지스터를 나타냅니다.
메모리의 0번지에 0010 1110이 있습니다.
다시 설명하면, opcode인 첫번째 4비트는 
"LOAD_A" 명령어라는 뜻입니다.
이 명령어는 다음 4비트에 적혀 있는 메모리 주소에서 데이터를 읽어와서
Register A에 저장하는 것입니다. 여기서 메모리 주소는 1110 (십진수 14)입니다.
이제 메모리 0번지에 "0010 1110"이 있다고 하지 말고, "LOAD_A 14" 명령어가 있다고 합시다.
이제 메모리 0번지에 "0010 1110"이 있다고 하지 말고, "LOAD_A 14" 명령어가 있다고 합시다.
이게 훨씬 읽기도 쉽고, 이해하기도 쉽습니다.
제가 말하기도 편하고요.
메모리의 나머지 데이터 들도 똑같이 바꿀 수 있습니다.
이 경우에, 우리 프로그램은 명령어가 4개 밖에 없습니다. 그리고 숫자 3과 14도 메모리에 넣었습니다.
이 경우에, 우리 프로그램은 명령어가 4개 밖에 없습니다. 그리고 숫자 3과 14도 메모리에 넣었습니다.
자 이제 순서대로 프로그램을 진행해 봅시다.
첫번째는 "LOAD_A 14"입니다. 이 것은 14번지에 저장된 숫자 3을 가져다가 Register A에 저장하는 것입니다.
첫번째는 "LOAD_A 14"입니다. 이 것은 14번지에 저장된 숫자 3을 가져다가 Register A에 저장하는 것입니다.
다음은 "LOAD_B 15", 메모리의 15번지에 저장된 
숫자 14를 Register B에 저장합니다.
다음은 "LOAD_B 15", 메모리의 15번지에 저장된 
숫자 14를 Register B에 저장합니다.
됬어요.
쉽죠.

English: 
But now we have an “ADD” instruction.
This tells the processor to use the ALU to
add two registers together, in this case,
B and A are specified.
The ordering is important, because the resulting sum is saved into the second register that’s specified.
So in this case, the resulting sum is saved
into Register A.
And finally, our last instruction is “STORE_A
13”, which instructs the CPU to write whatever
value is in Register A into memory location
13.
Yesss!
Our program adds two numbers together.
That’s about as exciting as it gets when
we only have four instructions to play with.
So let’s add some more!
Now we’ve got a subtract function, which
like ADD, specifies two registers to operate on.
We’ve also got a fancy new instruction called
JUMP.
As the name implies, this causes the program
to “jump” to a new location.
This is useful if we want to change the order
of instructions, or choose to skip some instructions.
For example, a JUMP 0, would cause the program
to go back to the beginning.
At a low level, this is done by writing the
value specified in the last four bits into
the instruction address register, overwriting
the current value.

Korean: 
이제 "ADD" 명령어 차례입니다.
이 명령어는 프로세서가 ALU를 사용해서 2개의 register의 값을 서로 더하라는 것입니다.
여기서는 A와 B를 더하는 거예요.
순서가 중요합니다. 왜냐하면 더하기의 결과가 두번째로 적혀있는 레지스터에 저장되기 때문입니다.
여기서는, 더하기 결과는 Register A에 저장됩니다.
마지막으로, "SOTRE_A 13"은 CPU가 Register A의 값을
메모리 13번지 위치에 쓰라고 명령하는 것입니다.
예~~쓰~~~
우리 프로그램이 숫자 2개를 더했습니다.
명령어 4개로 놀기에 이것 보다 흥미로운 건 없겠지요.
몇 개를 더 추가해 보죠.
더하기(ADD)와 비슷하게 두 개의 레지스터 값을
 연산하는 빼기(subtract) 기능
또 JUMP라는 근사한 새 명령어를 넣읍시다.
이름에서 알 수 있듯이, 이 명령어는 
프로그램을 새 위치로 "점프" 시키는 것입니다.
이 것은 명령어 처리 순서를 바꾸거나, 명령어 몇개를 
건너뛰고 싶을 때 유용하게 사용됩니다.
예를 들어 "JUMP 0"은 프로그램을 
처음으로 되돌아가게 할 수 있습니다.
세부 동작은 명령어의 뒤 4비트가 가리키는 값을 명령어 주소 (instruction address) 레지스터의 현재 값에 덮어쓰는 것입니다.
세부 동작은 명령어의 뒤 4비트가 가리키는 값을 명령어 주소 (instruction address) 레지스터의 현재 값에 덮어쓰는 것입니다.

Portuguese: 
Agora temos uma instrução ADD (adiciona)
Ela diz ao processador para usar a ALU  para adicionar dois registros
que nesse caso são o B e o A
A ordem é importante por que o resultado é armazenado no segundo registrador especificado
Então, nesse caso a soma resultante é armazenada no registrador A
E finalmente, nossa última instrução é STORE_A 13
que instrui a CPU a gravar o valor que está no registrador A na posição de memória 13
Nosso programa adicionou dois números
Isso é o máximo de diversão que dá para ter com 4 instruções
Então vamos colocar mais
Agora nós temos uma função de subtração, que como a função ADD, especifica em quais registros ela deve operar.
Nós temos também uma função bem legal chamada JUMP (pular)
Como o nome indica ela faz com que o programa pule para uma nova posição (na memória)
Isso é útil se nós queremos mudar a ordem das instruções ou se quisermos pular algumas instruções
Por exemplo, um JUMP 0, fará com que o programa volte para o início.
Em um nível bem básico isso é feito escrevendo o valor desejado nos últimos 4 bits
no registrador de endereço de instrução, sobrescrevendo o valor atual

Arabic: 
ولكن الآن لدينا أمر "ADD". ( إضافة)
هذا يقول للمعالج أن يستخدم ALU 
لإضافة اثنين من السجلات معا، في هذه الحالة،
B و A محددتان
الترتيب مهم، لأن المبلغ الناتج يتم حفظه في السجل الثاني المحدد.
لذلك في هذه الحالة، يتم حفظ الرقم الناتج في السجل A.
وأخيرا، لدينا التعليمات الأخيرة هي "STORE_A 13"، الذي يوجه وحدة المعالجة المركزية لكتابة
القيمة في التسجيل A في موقع الذاكرة 13.
أجللل!
برنامجنا يضيف رقمين معا.
هذا مثير للإهتمام كما يحصل عندما يكون لدينا فقط أربعة تعليمات للعب معه.
لذلك دعونا نضيف البعض أكثر قليلاً!
الآن لدينا أمر طرح، والتي هي مثل ADD، تحدد اثنين من السجلات للعمل عليها.
لدينا أيضا أمر جديد يدعى JUMP.
وكما يوحي الاسم، يؤدي هذا البرنامج إلى "القفز" إلى موقع جديد.
وهذا مفيد إذا أردنا تغيير ترتيب الأوامر، أو تخطي بعض الأوامر.
على سبيل المثال، JUMP 0، سيسبب البرنامج للعودة إلى البداية.
على مستوى منخفض، يتم ذلك عن طريق كتابة القيمة المحددة في البتات الأربع الأخيرة في
سجل عنوان التعليمات، إعادة الكتابة فوق القيمة الحالية.

Spanish: 
Pero ahora tenemos una instrucción "ADD"
Esto le dice al procesador que use el ALU para agregar 2 registros juntos, en este caso,
B y A especificamente
El orden es importante, porque el resultado de la suma es guardado en el segundo registro especificado
En este caso, la suma resultante es guardada en el registro A
Y finalmente, nuestra última instrucción es "STORE_A 13" el cual ordena al CPU para escribir cualquier
valor que esté en el registro A a la locación de memoria 13
Siiii!
Nuestro programa suma 2 números juntos
Eso es casi tan emocionando como se pone cuando tenemos solo 4 instrucciones para usar
Así que agreguemos algunas más!
Ahora tenemos la función de sustracción la cual como "ADD", especifica 2 registro sobre los que operar
Tenemos también una elegante nueva instrucción llamada "JUMP"
Como el nombre dice, esta produce que el programa "salte" a una nueva ubicación
Esto es útil si queremos cambiar el orden de las instrucciones, o saltarnos algunas instrucciones
Por ejemplo, un "JUMP 0" provocará que el programa vuelva al inicio
A bajo nivel, esto es hecho escribiendo el valor especificado en los últimos 4 bits
en el registro de dirección de la instrucción, sobreescribiendo el valor actual

Chinese: 
但是，现在我们有一个“添加”指令。
这告诉处理器使用ALU来
把两个寄存器添加在一起，此时
B和A已经被指定了。
排序是非常重要的，因为相加的结果被保存到指定的第二个寄存器。
所以此时，相加的结果被保存
到寄存器A.
最后，我们的最后一个指令是“STORE_A
13” ，它指示CPU将所有
在寄存器A中的值写入存储器位置
13。
YESSS！
我们的程序把两个数字加起来了。
当我们只有四个指令来操作时，这是十分令人兴奋的。
因此，让我们来添加更多的指令！
现在，我们已经有了一个减函数，
就像ADD一样，它指定两个寄存器进行操作。
我们也得到了一个花哨的新指令，被称为JUMP.
顾名思义，这导致程序
“跳”到新的位置。
如果我们想改变程序的顺序，或选择跳过一些指令，这将非常有用。
例如，指令JUMP 0会导致程序
回到开头。
从较低水平来看，当这个指令完成时，后四位指定的值
会被写入到指令地址寄存器，覆盖当前指令。

English: 
We’ve also added a special version of JUMP
called JUMP_NEGATIVE.
This only jumps the program if the ALU’s
negative flag is set to true.
As we talked about in Episode 5, the negative
flag is only set when the result of an arithmetic
operation is negative.
If the result of the arithmetic was zero or
positive, the negative flag would not be set.
So the JUMP NEGATIVE won’t jump anywhere, and the CPU will just continue on to the next instruction.
And finally, computers need to be told when
to stop processing, so we need a HALT instruction.
Our previous program really should have looked
like this to be correct, otherwise the CPU
would have just continued on after the STORE
instruction, processing all those 0’s.
But there is no instruction with an opcode
of 0, and so the computer would have crashed!
It’s important to point out here that we’re
storing both instructions and data in the
same memory.
There is no difference fundamentally -- it’s
all just binary numbers.
So the HALT instruction is really important
because it allows us to separate the two.
Okay, so let’s make our program a bit more
interesting, by adding a JUMP.
We’ll also modify our two starting values
in memory to 1 and 1.
Lets step through this program just as our
CPU would.

Arabic: 
لقد أضفنا أيضا إصدارا خاصا من JUMP يسمى JUMP_NEGATIVE.
هذا فقط يقفز البرنامج إذا تغييرت
قيمة العلم السلبي الخاص ب ALU إلى صحيح
كما تحدثنا في الحلقة 5، يتم وضع العلم السلبي فقط عندما تكون نتيجة الحساب
العملية سلبية.
إذا كانت نتيجة الحساب صفر أو موجبة،
لن يأخذ العلم السلبي قيمة صحيح.
وبالتالي فإن JUMPNEGATIVE لا تقفز في أي مكان، وسوف تستمر وحدة المعالجة المركزية في تكملة باقي الأوامر.
وأخيرا، أجهزة الكمبيوتر تحتاج إلى أن تعرف متى ستتوقف العملية، لذلك نحن بحاجة إلى الأمر HALT.
برنامجنا السابق حقا يجب أن يبدو مثل هذا ليكون صحيحا،
وإلا وحدة المعالجة المركزية
سوف تستمر بعد الأمر STORE،
وتؤدي الأوامر على كل تلك الأصفار
ولكن لا يوجد أمر بـ أوبكود = 0،
 وبالتالي فإن الكمبيوتر سيتحطم!
من المهم الإشارة هنا إلى أننا نخزن كلا من التعليمات والبيانات في
نفس الذاكرة.
ليس هناك فرق جوهري - انها فقط أرقام ثنائية.
وبالتالي فإن تعليمات HALT مهمة حقا لأنها تسمح لنا بفصلهما.
حسنا،  دعونا نجعل برنامجنا أكثر إثارة قليلا، عن طريق إضافة JUMP.
سنقوم أيضا بتعديل قيمتي البدء في الذاكرة إلى 1 و1.
تتيح خطوة من خلال هذا البرنامج تماما كما وحدة المعالجة المركزية الخاصة بنا.

Portuguese: 
Nós também incluímos uma versão especial de JUMP chamada JUMP_NEGATIVE
Essa instrução salta somente se o indicador de negativo da ALU estiver ligado
Como nós dissemos no episódio 5, o indicador de negativo só é ativado
quando o resultado de uma operação aritmética é negativo
Se o resultado aritmético é zero ou positivo, o indicador de negativo não é ativado.
Assim o JUMP_NEGATIVE não vai a lugar nenhum e a CPU continua normalmente para a próxima instrução
E finalmente, os computadores precisam saber quando parar de processar
então precisamos de uma instrução HALT (parar, suspender)
Nosso programa anterior deveria estar desse jeito para estar correto, senão a CPU
continuaria depois da instrução STORE (armazena) processando todos esses zeros
Mas não há instrução com opcode zero, então o computador iria travar!
É importante lembrar que nós estamos armazenando tanto as instruções quanto os dados na mesma memória
Não há nenhuma diferença fundamental – Tudo são números binários
Por isso a instrução HALT é bem importante por que nos permite separar os dois
Ok, vamos deixar nosso programa mais interessante acrescentando um JUMP
além disso vamos modificar nossos valores iniciais na memória para 1 e 1
Vamos continuar percorrendo o programa da mesma forma que a CPU faria

Korean: 
JUMP의 스페셜 버전인 JUMP_NEGATIVE도 
추가해 봅시다.
이 명령어는 ALU의  음수(negative) 플래그가 true로 설정될 때만 점프하는 것입니다.
에피소드 5에서 산술 연산 결과가 음수(negative)가 되면 음수(negative) 플래그가 설정된다고 배웠습니다.
에피소드 5에서 산술 연산 결과가 음수(negative)가 되면 음수(negative) 플래그가 설정된다고 배웠습니다.
연산 결과가 0이거나 양수이면, 
음수 플래그는 설정되지 않습니다.
그래서 JUMP_NEGATIVE에 의한 점프는 일어나지 않고, 
CPU 바로 다음 명령어를 처리할 것입니다.
마지막으로 컴퓨터가 처리를 언제 끝낼지 알려줄 필요가 있습니다. 그래서 HALT(중단) 명령어가 필요합니다.
우리가 만든 이전 프로그램은 
이렇게 정정되었어야 해요, 그렇지 않으면
CPU는 STORE 명령어 이후에도 
계속 0을 읽어서 수행을 하게 됩니다.
그런데, opcode가 0인 명령어가 없기 때문에 
컴퓨터는 추락했을 거에요.
명령어와 데이터가 같은 메모리에
저장되어 있다는 것을 유념하세요.
명령어와 데이터가 같은 메모리에 저장되어 있다는 것을 유념하세요.
명령어와 데이터는 모두 이진수이기 때문에 근본적인 차이가 없습니다.
그래서 HALT 명령어는 진짜 중요합니다. 명령어와 데이터 부분을 구분해 줄 수 있으니까요.
Okay. 이제 JUMP를 추가 해서 프로그램을 좀 더 재미있게 만들어 봅시다.
두 개의 시작 값을 메모리에 1로 바꿔보지요.
CPU가 하듯이 프로그램 수행을 단계별로 알아봅시다.

Spanish: 
Además agregamos una versión especial de "JUMP" llamada "JUMP_NEGATIVE"
Esto solo salta el programa si el negativo de la bandera del ALU es verdadero
Como hablamos en el capítulo 5, la bandera negativa solo es establecida cuando el resultado de la operación
aritmética es negativa
Si el resultado de la aritmética fuera cero o positiva, la bandera negativa no sería establecida
Por lo que el "JUMP NEGATIVE" no saltaría, y el CPU simplemente continuaría con la siguiente instrucción
Y finalmente, los computadores necesitan que les indiquen cuando dejar de procesar, por lo que necesitamos una instrucción"HALT"
Nuestro programa anterior debió haber visto como esto para estar correcto, de lo contrario la CPU
habría continuado después de la instrucción "STORE", procesando todos esos ceros
Pero no hay ninguna instrucción con un código de operación de 0, por lo que el computador habria cracheado
Es importante mencionar que estamos guardando las instrucciones y los datos en
misma memoria
Básicamente no hay diferencia -- son solo numeros binarios
Por lo que la instrucción "HALT" es muy importante porque permite que separemos las dos
Okay, hagamos nuestro programa un poco más interesante, agregando un "JUMP"
También modificaremos nuestros 2 valores iniciales en memoria a 1 a 1
Veamos paso a paso nuestro programa como lo haría nuestra CPU

Chinese: 
我们还添加了JUMP的一个特殊版本，即所谓JUMP_NEGATIVE。
只有当ALU的
负标志被设置为true时，它才会越过程序。
正如我们在第5集中讲到的，只有当运算操作的结果为负时，
负标志才会被设置
如果计算的结果是零或
正，负标志不会被设置。
所以JUMP NEGATIVE不会跳到任何地方，CPU将只是继续到下一个指令。
最后，计算机需要被告知
何时停止处理，所以我们需要一个HALT指令。
我们之前的程序本应该像
这样才是正确的，否则在STORE 指令后，CPU
将会继续
指令，处理所有那些0指令。
但并不存在一个操作码
0的指令，所以电脑会崩溃！
这里指出这一点很重要，就是
我们将指令和数据存储在
相同的内存。
这在根本上没有区别 - 这是
一切都只是二进制数。
所以HALT指令是非常重要的，
因为它可以让我们把这两个分开。
好了，现在我们通过添加JUMP，把程序变得有趣一点。
我们也将改变在内存中的两个起始值
，将其改为1和1。
就像CPU 一样，让我们来逐步运行一下这个程序。

Arabic: 
أولا، LOAD_A 14 يحمل القيمة 1 في تسجيل A.
بعد ذلك، LOAD_B 15 تقوم بتحميل القيمة 1 في تسجيل B.
كما كان من قبل، نحن ADD تسجيل B و A معا، مع مجموع الذهاب إلى سجل A. 1 + 1 = 2،
و الآن سجل A لديه قيمة 2 في ذلك (المخزنة في ثنائي بالطبع)
ثم تعليمات STORE تحفظ ذلك في مكان الذاكرة 13.
الآن نحن نضرب تعليمات "JUMP 2".
يؤدي هذا المعالج إلى الكتابة فوق القيمة في سجل عنوان التعليمات،
وهو حاليا 4، مع القيمة الجديدة، 2.
الآن، على دورة الجلب المقبلة للمعالج، نحن لا نجلب HALT، بدلا من ذلك نحن نجلب
تعليمات في موقع الذاكرة 2، وهو ADD B A.
لقد قفزنا!
تسجيل A يحتوي على القيمة 2، والتسجيل B يحتوي على القيمة 1.
لذلك 1 + 2 = 3، لذلك الآن سجل A قيمته 3.
نحن سنخزن ذلك في الذاكرة.
ولقد قمنا بضرب JUMP مرة أخرى، والعودة إلى ADD B A.
1+3 = 4.
لذلك الآن التسجيل A لديه قيمة 4.
انظر ماذا يحدث هنا؟
كل حلقة، نحن نضيف واحدة.
انها تعد تصاعدياً!
جميييييل!
ولكن لاحظ أنه لا توجد وسيلة للهرب من أي وقت مضى.

English: 
First, LOAD_A 14 loads the value 1 into Register A.
Next, LOAD_B 15 loads the value 1 into Register B.
As before, we ADD registers B and A together,
with the sum going into Register A. 1+1 = 2,
so now Register A has the value 2 in it (stored
in binary of course)
Then the STORE instruction saves that into
memory location 13.
Now we hit a “JUMP 2” instruction.
This causes the processor to overwrite the
value in the instruction address register,
which is currently 4, with the new value, 2.
Now, on the processor’s next fetch cycle,
we don’t fetch HALT, instead we fetch the
instruction at memory location 2, which is
ADD B A.
We’ve jumped!
Register A contains the value 2, and register
B contains the value 1.
So 1+2 = 3, so now Register A has the value 3.
We store that into memory.
And we’ve hit the JUMP again, back to ADD
B A.
1+3 = 4.
So now register A has the value 4.
See what's happening here?
Every loop, we’re adding one.
Its counting up!
Cooooool.
But notice there’s no way to ever escape.

Korean: 
제일 먼저, "LOAD_A 14"는 Register A에 값 1을 옮깁니다.
다음 "LOAD_B 15"는 Register B에 값 1을 옮기고요.
Register B와 A의 값을 합지고, 
결과는 Register A로 가게됩니다.
1+1=2니까 Register A의 값은 2가 됩니다. 
(물론 이진수로 저장되지요.)
그리고 나서, STORE 명령어로 메모리 13번지에 저장을 합니다.
이제 "JUMP 2" 명령어가 나왔습니다.
이 명령어는 프로세서가 명령어 주소 레지스터 (instruction address register)의 값을 덮어쓰게 만듭니다.
현재값 4가 새로운 값 2로 덮어 써집니다.
그러면, 프로세서는 다음 fetch 사이클에 
HALT를 가져오지 않고
메모리 2번지에 있는 "ADD B A"를 가져옵니다.
이렇게 점프 하는 것이지요.
Register A의 값은 2이고, Register B는 1이니까,
1+2=3, 즉 Register A는 3이라는 값을 갖게 됩니다.
이것을 메모리로 저장하고요.
또 "JUMP"를 만나서 "ADD B A" 로 돌아갑니다.
1+3 = 4.
Register A는 4가 되고요.
무슨 일이 일어나는지 알겠나요?
반복 할 때마다, 1씩 더하는 겁니다.
차례로 숫자를 세는 것이지요.
쿠우우우우우울.
그런데, 빠져나갈 방법이 없네요.

Spanish: 
Primero, "LOAD_A 14" carga el valor 1 en el registro A
Después, "LOAD_B 15" carga el valor 1 en el registro B
Como antes, aplicamos "ADD" en el registro B y A, con la suma yendo en el registro A. 1+1=2
por lo que ahora el registro A tiene el valor 2 en él (guardado en binario por supuesto)
Luego la instrucción "STORE" guarda eso en la localización de memoria 13
Ahora hacemos la instrucción "JUMP 2"
Esto causa que el procesador sobreescriba el valor en el registro de dirección de instrucciones
que es actualmente 4, con el nuevo valor 2
Ahora, en el siguiente ciclo de recuperación del procesador, no buscamos "HALT", en cambio buscamos la
instrucción en la dirección de memoria 2, la cual es "ADD" B A
Saltamos!
El registro A contiene el valor 2, y el registro B contiene el valor 1
Entonces 1+2=3, ahora el registro A tiene el valor 3
Guardamos eso en memoria.
Llegamos al salto otra vez, de vuelta a "ADD" B A
1+3=4
Ahora el registro A tiene el valor 4
Ves lo que está pasando aquí?
Cada loop, estamos sumando 1
Está contando!
Cooool.
Pero nadie notó que no hay forma de terminar

Portuguese: 
Primeiro, LOAD_A 14 carrega o valor 1 no registrador A
Depois, LOAD_B 15 carrega o valor 1 no registrador B
Como antes, nós adicionamos os registradores B e A e a soma vai para o registrador A. 1+1=2
Então agora o registrador A tem o valor 2 (armazenado em binário, claro)
Depois a instrução STORE salva esse valor no endereço de memória 13
Agora nós chegamos em uma instrução JUMP 2
Ela faz com que o processador sobrescreva o valor no registrador de endereço de instrução
que no momento é 4, com o novo valor, 2
Agora, no próximo ciclo de busca nós não chegaremos na instrução HALT
e sim buscamos a instrução na posição 2 de memória
que é ADD B A. Nós saltamos!
O registrador A contém o valor 2 e o registrador B contém o valor 1
Então 1+2 = 3, então agora o registrador A tem o valor 3
Guardamos o valor na memória e chegamos à instrução JUMP novamente, de volta a ADD B A. 1+3 = 4
Agora o registrador A tem o valor 4. Percebeu o que está acontecendo? A cada repetição somamos 1
É uma contagem! Legal. Mas veja que não tem jeito de sair

Chinese: 
首先，LOAD_A 14负载值1到寄存器A.
接下来，LOAD_B 15负载值1到寄存器B.
与以前一样，我们把寄存器B和A添加在一起，把总和写入寄存器A. 即1 + 1 = 2，
所以现在寄存器A有一个值2（以二进制存储）
然后STORE指令将其保存到
存储位置13。
现在，我们触发了一个“JUMP 2”指令。
这使得处理器去覆盖
指令地址寄存器中的值，
也就是用新的值2去覆盖当前的4。
现在，在处理器的下一个提取周期，
我们不取暂停，相反，我们取
在存储器位置2的指令，其指示
将B加入A.
我们已经跳跃了！
寄存器A中有值2，
寄存器B中有值1。
所以1 + 2 = 3，所以现在寄存器A的值是3。
我们把它存储到内存中。
我们再JUMP一次，在执行一次ADD B A操作
1 + 3 = 4。
所以，现在寄存器A得到一个值4。
看这期间发生了什么？
每一个循环，我们都增加一个。
它不断地计数！
这太酷了
但是请注意，这时没出跳出（循环）的出口。

Portuguese: 
Desse jeito nunca vamos chegar na instrução HALT, por que nós sempre vamos chegar naquele JUMP (salto)
Isso é chamado de laço infinito – um programa que roda para sempre, sempre, sempre, sempre
Para parar a repetição, nós precisamos de um salto condicional
Um salto que só acontece se uma certa condição for satisfeita
Nosso JUMP_NEGATIVE é um exemplo de salto condicional
mas os computadores tem outros, como saltar se igual e saltar se maior
Então vamos tornar nosso código mais legal e percorrê-lo
Como antes, o programa começa carregando valores da memória nos registradores A e B
Nesse exemplo, o número 11 é carregado no registrador A e 5 é carregado no registrador B
Agora subtraímos o registrador B do registrador A, ou seja, 11 menos 5, que é 6
e então o valor 6 é guardado no registrador A
Assim atigimos nosso JUMP NEGATIVE. O último resultado da ALU foi 6
É um número positivo, então o sinalizador de negativo está desligado (false)
isso faz com que o processador não salte
Então continuamos para a próxima instrução que é JUMP 2
Não há condição nessa, então saltamos para a instrução 2 direto

Spanish: 
Nosotros nunca vamos a llegar a esa instrucción "HALT", porque siempre vamos a
llegar a ese "JUMP"
Esto es llamado loop infinito - un programa que corre siempre... siempre... siempre...
siempre
Para terminar el loop, necesitamos un "JUMP" condicional
un "JUMP" que solo ocurre si cierta condición ocurre
Nuestro "JUMP_NEGATIVE" es un ejemplo de jump condicional, pero los computadores tienen además otros tipos - como
"JUMP IF EQUAL" y "JUMP IF GREATER"
Hagamos nuestro código un poco más elegante y demos otro paso.
Igual que antes, el programa empieza cargando valores de memoria en los registros A y B
En este ejemplo, el número 11 se carga en el registro A, y el 5 se carga en el registro B.
Ahora restamos el registro B desde el registro A. Eso es 11-5=6, por lo que
6 se guarda en el registro A
Ahora llegamos a nuestro jump negativo
El último resultado de ALU fue 6
Este es un número positivo, por lo que la bandera negativa queda en "false"
Eso significa que el procesador no salta
Continuemos con la siguiente instrucción...
La cual es "JUMP 2"
No hay condicional en esta, por lo que saltamos a la instrucción 2 sin importar qué

Chinese: 
我们永远永远.. ..不会得到
暂停指令，因为我们总是会
触发JUMP。
这就是所谓的无限循环 - 一个程序
将永远地运行下去...永远永远......永远... ...
永远
为了打破循环，我们需要一个条件跳转。
这个跳转只有当某个条件满足时，才会发生。
我们的JUMP_NEGATIVE是条件跳转的一个例子，但计算机也有其他类型，例如
JUMP IF EQUAL以及JUMP IF GREATER。
现在把我们的代码变得更花哨，然后逐步运行他。
和以前一样，通过从存储器加载值到寄存器A和B，程序开始运行.
在这个例子中，数字11被加载
到寄存器A，5被加载到寄存器B.
现在，我们从寄存器A中减去寄存器B，也就是11-5，得到6，于是
6被保存到寄存器A.
现在，我们触发JUMP NEGATIVE。
最后的ALU结果是6。
这是一个正数，所以负
标志是假的。
这意味着该处理器不会跳跃。
因此，我们继续下一个指令......
......也就是一个JUMP 2。
这一个不需要条件，所以不管是什么，我们都跳到指令2。

Korean: 
항상 JUMP를 만나기 때문에 
절대로 HALT 명령어까지 갈 수가 없습니다.
항상 JUMP를 만나기 때문에 절대로 HALT 명령어까지 갈 수가 없습니다.
이런 걸 무한 루프(infinite loop)라고 합니다. 프로그램이 영원히 도는 거지요. 영원히.. 영원히... 영원히... 영원히...
 
반복 루프를 빠져나오려면, 조건부 점프가 필요합니다.
특정 상태가 되어야만 점프가 일어나는 것을 얘기 합니다.
우리 JUMP_NEGATIVE 명령어가 
조건부 점프의 한 예입니다. 다른 타입들도 있지요.
JUMP_IF_EQUAL과 JUMP_IF_GREATER
좀 더 코드를 멋지게 만들어 보고
 한 단계 한단계 살펴봅시다.
이전처럼 프로그램은 메모리에서 Register A와 B에 값을 옮기는 것으로 시작합니다.
예를 들어 Register A에 숫자 11을 
Register B에 숫자 5를 옮겼습니다.
이제 Register A에서 Register B를 뺍니다. 11 빼기 5는 6, 그래서 Register A에 6이 저장됩니다.
이제 Register A에서 Register B를 뺍니다. 11 빼기 5는 6, 그래서 Register A에 6이 저장됩니다.
이제 "JUMP_NEGATIVE"가 나왔습니다.
이전 ALU 결과는 6이었습니다.
양수니까 음수(negative) 플래그는 false입니다.
즉, 프로세서는 점프하지 않는다는 뜻입니다.
그래서 다음 명령어를 계속 진행하지요.
"JUMP 2"
이번 것은 조건이 없습니다. 그래서 바로 명령어 2번으로 점프합니다.

English: 
We’re never.. ever.. going to get to that
halt instruction, because we’re always going
to hit that JUMP.
This is called an infinite loop – a program
that runs forever… ever… ever… ever…
ever
To break the loop, we need a conditional jump.
A jump that only happens if a certain condition is met.
Our JUMP_NEGATIVE is one example of a conditional
jump, but computers have other types too - like
JUMP IF EQUAL and JUMP IF GREATER.
So let’s make our code a little fancier
and step through it.
Just like before, the program starts by loading
values from memory into registers A and B.
In this example, the number 11 gets loaded
into Register A, and 5 gets loaded into Register B.
Now we subtract register B from register A.
That’s 11 minus 5, which is 6, and so 6
gets saved into Register A.
Now we hit our JUMP NEGATIVE.
The last ALU result was 6.
That’s a positive number, so the the negative
flag is false.
That means the processor does not jump.
So we continue on to the next instruction...
...which is a JUMP 2.
No conditional on this one, so we jump to
instruction 2 no matter what.

Arabic: 
نحن أبدا لم .. وأبداً لن .. نذهب إلى الحصول على تعليمات HALT، لأننا دائماً سوف
نضرب تلك الـJUMP.
وهذا ما يسمى حلقة لانهائية - وهو البرنامج الذي يمتد إلى الأبد ... الأبد... الأبد ... الأبد ...
الأبدين
لكسر الحلقة، نحن بحاجة إلى قفزة مشروطة.
القفزة التي تحدث فقط إذا تم استيفاء شرط معين.
لدينا JUMP_NEGATIVE هو مثال واحد من القفزة الشرطية، ولكن أجهزة الكمبيوتر لديها أنواع أخرى أيضا - مثل
JUMP IF EQUAL و JUMP IF GREATER.
لذلك دعونا نجعل رمزنا مربي قليلاً و نخطو من خلال ذلك.
تماما كما سبق، يبدأ البرنامج عن طريق تحميل القيم من الذاكرة إلى السجلات A و B.
في هذا المثال، يتم تحميل الرقم 11 في تسجيل A، و 5 يتم تحميلها في تسجيل B.
الآن نحن سنقوم بطرح سجل B من سجل A. الذي هو 11 ناقص 5، وهو 6، وهكذا 6
يتم حفظها في التسجيل A.
الأن نحن سنقوم بضرب JUMP NEGATIVE الخاصة بنا.
وكانت النتيجة الأخيرة ALU 6.
هذا رقم إيجابي، وبالتالي فإن العلم السلبي غير صحيح.
وهذا يعني أن المعالج لا يقفز.
لذا نواصل التوجيهات التالية ...
التي هي JUMP 2 .....
لا مشروط على هذا ، لذلك نحن سنقفز إلى تعليمات 2 بغض النظر عن هذه المسألة.

Chinese: 
好了，我们回到SUBTRACT，
从寄存器A中减去寄存器B. 6 B减5等于1。
因此1被保存到寄存器A.
下一步指令。
我们再次回到JUMP NEGATIVE。
1也是一个正数，所以CPU继续
运行到JUMP 2，再次返回循环
到减法指令。
然而这一次有些不同。
1减去5为负4。
这样一来，ALU首次将其负标志设置为true
。
现在，当我们前进到下一个指令，
JUMP_NEGATIVE 5，CPU执行跳跃，转到存储器位置5。
我们从无限循环退出！
现在我们得到一个添加 B到A的指令，负4加5为正1，我们将其保存到寄存器A.
接下来我们得到一个 STORE 指令，它把寄存器A存到内存地址13。
最后，我们触发HALT指令，
电脑便停止。
因此，即使这个程序只有7指令
长，CPU却最终执行了13条指令，
这是因为它内部循环了两次。
此代码计算出了余数，如果我们用
11除以5，得到的就是1。

Arabic: 
جيد، لذلك نحن سنعود في طرح تسجيل B من تسجيل A 
6 ناقص 5 = 1
لذلك يتم حفظ 1 في السجل A.
التعليمات التالية.
نحن نعود مرة أخرى في JUMP NEGATIVE الخاصة بنا.
1 هو أيضا رقم موجب، وبالتالي فإن وحدة المعالجة المركزية تستمر إلى JUMP 2، الحلقات تعود مرة أخرى
إلى التعليمات المطروحة.
هذه المرة مختلفة على الرغم من.
1 ناقص 5 يساوي سالب 4.
وبالتالي فإن ALU تضع علمها السلبي إلى  شكل صحيح لأول مرة.
الآن، عندما نتقدم إلى التعليمات التالية،
JUMP_NEGATIVE 5، وحدة المعالجة المركزية تنفذ الانتقال إلى موقع الذاكرة 5.
نحن خارج الحلقة لانهائية!
الآن لدينا إضافة B إلى A. سالب 4 زائد 5، هو موجب 1، ونحن نحفظ ذلك في تسجيل A.
التالي لدينا تعليمات STORE التي تحفظ تسجيل A في عنوان الذاكرة 13.
وأخيرا، سنقوم بضرب تعليمات HALT وموقع الكومبيوتر.
لذلك على الرغم من أن هذا البرنامج هو فقط 7 تعليمات طويلة، انتهت وحدة المعالجة المركزية بتنفيذ 13 تعليمات،
وهذا هو لأنه دار مرتين داخليا.
هذا الرمز هو المتبقي إذا نحن نقسم 5 في 11، وهو الواحد.

Portuguese: 
Ok, voltamos para nossa SUBTRACT registrador B do registrador A. 6 menos 5 igual 1
Então 1 é armazenado no registrador A
Próxima instrução. Voltamos para o JUMP NEGATIVE
1 é um número positivo, então a CPU continua para o JUMP 2, repetindo novamente a instrução SUBTRACT
Mas dessa vez há uma diferença 1 menos 5 é 4 negativo
Então a ALU liga o sinalizador de negativo pela primeira vez
Agora quando vamos para a próxima instrução JUMP_NEGATIVE 5
a CPU executa o salto para a posição de memória 5. Saímos da repetição infinita!
Agora temos um ADD B para A. 4 negativo mais 5 é 1 positivo e nós salvamos esse valor no registrador A
Agora temos uma instrução STORE que salva o valor do registrador A na posição de memória 13
Finalmente chegamos à nossa instrução HALT e o computador para
Então mesmo com esse programa tendo apenas 7 instruções a CPU acabou executando 13 instruções
por que nós saltamos internamente 2 vezes
Esse código calcula o resto da divisão de 11 por 5 que é um

Spanish: 
Ok, entonces estamos devuelta en nuestra sustracción del registro B desde el registro A. 6-5=1
Así que 1 se guarda en el registro A
Siguiente instrucción
Estamos devuelta denuevo en nuestro "JUMP NEGATIVE"
1 es además un numero positivo, por lo que la CPU continua al "JUMP 2", en un ciclo devuelta
a la instrucción de restar
Esta vez sin embargo es diferente.
1 menos 5 es 4 negativo
Así que el ALU establece su bandera negativa a verdadero por primera vez
Ahora, avanzamos a la siguiente instrucción,
"JUMP_NEGATIVE 5", la CPU ejecuta el salto a la dirección de memoria 5.
Estamos en un loop infinito!
Ahora tenemos un "ADD" B a A. 4 negativo mas 5 es 1 positivo, y lo guardamos en el registro A
Después tenemos la instrucción "STORE" que guarda el registro A en la dirección de memoria 13.
Finalmente, llegamos a la instrucción "HALT" y el computador descansa
Así que aunque este programa tiene solo 7 instrucciones, la CPU termina ejecutando 13 instrucciones
y eso es porque hace un ciclo dos veces internamente
Este código calculó el resto si dividimos 5 entre 11, el cual es 1

English: 
Ok, so we’re back at our SUBTRACT Register
B from Register A. 6 minus 5 equals 1.
So 1 gets saved into register A.
Next instruction.
We’re back again at our JUMP NEGATIVE.
1 is also a positive number, so the CPU continues
on to the JUMP 2, looping back around again
to the SUBTRACT instruction.
This time is different though.
1 minus 5 is negative 4.
And so the ALU sets its negative flag to true
for the first time.
Now, when we advance to the next instruction,
JUMP_NEGATIVE 5, the CPU executes the jump
to memory location 5.
We’re out of the infinite loop!
Now we have a ADD B to A. Negative 4 plus
5, is positive 1, and we save that into Register A.
Next we have a STORE instruction that saves
Register A into memory address 13.
Lastly, we hit our HALT instruction and the
computer rests.
So even though this program is only 7 instructions
long, the CPU ended up executing 13 instructions,
and that's because it looped twice internally.
This code calculated the remainder if we divide
5 into 11, which is one.

Korean: 
넵. Register A에서 Register B를 빼는 것으로 돌아갔네요.
6-5=1. Register A에 1이 저장됩니다.
다음 명령어.
"JUMP NEGATIVE"로 다시 왔네요.
1은 여전히 양수니까, CPU는 "JUMP 2"를 실행하고, 다시 루프를 거슬러 올라가 "SUBTRACT" 명령어가 반복되요.
1은 여전히 양수니까, CPU는 "JUMP 2"를 실행하고, 다시 루프를 거슬러 올라가 "SUBTRACT" 명령어가 반복되요.
이번에는 좀 다릅니다.
1 - 5 = -4.
처음으로 ALU가 음수(negative) 플래그를 
true로 설정합니다.
이제 다음 명령어 "JUMP_NEGATIVE 5" 를 진행할 때,
CPU는 "메모리 5번지로 점프"를 수행하게 됩니다.
무한 루프에서 빠져나왔습니다.
이제 "ADD B A"를 실행해서, 
-4 + 5 = 1을 Register A에 저장합니다.
STORE명령어로 Register A의 값을 
메모리 13번지로 저장합니다.
마지막으로 "HALT" 명령어를 만나
컴퓨터는 휴식을 취하게 됩니다.
이 프로그램은 7개의 명령어로 이루어졌지만, 
CPU는 총 13개의 명령어를 실행했습니다.
내부적으로 2번 루프를 돌았기 때문이지요.
이 코드는 11을 5로 나누었을 때 
나머지를 계산하는 것입니다. 결과는 1이지요.

Korean: 
코드에 몇 줄 더 추가해서 
루프를 몇 번 돌았는지 셀 수 있습니다.
즉, 5가 11에 몇 번 들어가는가?
루프를 2번 돌았으니까 5는 11에 2번 들어가 있는 거죠 (11을 5로 나누면 몫이 2라는 것이지요.)
나머지는 1이고요.
이 코드는 메모리의 저장한 수를 바꾸면 
어떤 수라도 연산이 가능합니다.
7과 81, 18과 54 어떤 것이든지요. 
이게 software의 파워입니다.
7과 81, 18과 54 어떤 것이든지요. 
이게 소프트웨어의 힘입니다.
소프트웨어는 우리 하드웨어가 할 수 없는 일도 
할 수 있게 해줍니다.
기억해보세요. 
ALU는 나누기를 하는 기능은 없었습니다.
프로그램이 이 기능을 할 수 있게 만든 것이지요.
그리고 다른 프로그램은 이 나누기 프로그램을 사용해서 더 멋있는 일을 할 수도 있겠지요.
이게 무슨 뜻인지 알겁니다.
새로운 추상화 레벨!
우리가 만든 CPU는 매우 기초적인 것입니다. 모든 명령어는 8비트이고, opcode는 처음 4비트만 차지합니다.
우리가 만든 CPU는 매우 기초적인 것입니다. 모든 명령어는 8비트이고, opcode는 처음 4비트만 차지합니다.
그래서 4비트의 모든 조합을 사용해도 CPU는 최대 16개의 명령어만 지원할 수 있습니다.
그래서 4비트의 모든 조합을 사용해도 CPU는 최대 16개의 명령어만 지원할 수 있습니다.

English: 
With a few extra lines of code, we could also
keep track of how many loops we did, the count
of which would be how many times 5 went into
11… we did two loops, so that means 5 goes
into 11 two times... with a remainder of 1.
And of course this code could work for any
two numbers, which we can just change in memory
to whatever we want: 7 and 81, 18 and 54,
it doesn’t matter -- that’s the power
of software!
Software also allowed us to do something our
hardware could not.
Remember, our ALU didn’t have the functionality
to divide two numbers, instead it’s the
program we made that gave us that functionality.
And then other programs can use our divide
program to do even fancier things.
And you know what that means.
New levels of abstraction!
So, our hypothetical CPU is very basic – all
of its instructions are 8 bits long, with
the opcode occupying only the first four bits.
So even if we used every combination of 4
bits, our CPU would only be able to support
a maximum of 16 different instructions.

Chinese: 
随着一些额外代码行数的增加，我们也可以跟踪我们进行了多少次循环，
这将计算5进入11，进行了多少次。
 ...我们做了两个循环，这意味着5进
入11两次，还有一个余数1。
当然，这个代码可以适用于任何
两个数字，我们可以在内存中改变
以获得我们想要的一切：7和81，18和54，这并不影响 - 这就是力量
的软件！
软件也让我们做一些
硬件不能做的事。
请记住，我们的ALU不具备
两个数字相除的功能，相反，是
我们编写的程序给了我们该功能。
然后，其他程序可以使用我们的相除
程序做更炫的事情。
你知道这意味着什么。
我们将上升到一个抽象的新高度！
因此，我们假设的CPU是非常基本的 - 其所有指令是8位长，其中
操作码仅占前四位。
所以，即使我们使用了这4位的每一种组合，我们的CPU只能够支持
最多16个不同的指令。

Portuguese: 
Com algumas linhas adicionais de código, nós poderíamos contar quantas repetições fizemos, o contador
seria quantas vezes 5 ocorre em 11
fizemos 2 repetições então isso quer dizer que 11 dividido por 5 é igual a 2 e o resto é 1
E é claro esse código funcionaria para quaisquer dois números
basta mudar a memória para o que quisermos: 7 e 81, 18 e 54, não importa
Essa é a força do software
O software nos permite fazer algo que nosso hardware não poderia
Lembre-se nossa ALU não tinha a funcionalidade de dividir dois números, ao invés disso
o programa que fizemos nos forneceu essa funcionalidade
e outros programas podem usar nosso programa para fazer coisas ainda mais legais
E você sabe o que isso significa: Novos níveis de abstração!
Então, nossa CPU hipotética é bem básica – Todas as instruções tem 8 bits de tamanho
com o opcode ocupando os primeiros 4 bits
Mesmo se usássemos todas combinações de 4 bits nossa CPU teria apenas 16 instruções

Spanish: 
Con unas cuantas lineas extras de código, podríamos haber rastreado cuantos loops hizo, el conteo
sería cuantas veces 5 cabe en 11... hicimos 2 loops, eso significa que 5 cabe
en 11 dos veces... con un resto de 1
Y por su puesto este código funcionaría para 2 números cualquiera, los cuales podemos cambiar en memoria
a cualquiera que queramos: 7 y 81, 18 y 54, no importa cuales - ese es el poder
del software!
el software además nos permite realizar algo que el hardware no podría
Recuerda, nuestro ALU no tiene la funcionalidad para dividir 2 números, en cambio es el
programa que hicimos el que nos da esta funcionalidad
Y luego otros programas pueden usar nuestro programa de división para hacer cosas más elegantes
Y tú sabes lo que eso significa.
Nuevos niveles de abstracción
Entonces, nuestra CPU hipotética es muy básica - todas sus instrucciones son de 8 bits de largo, con
el código de operación ocupando solo los primeros 4 bits
Entonces, incluso si usamos cada combinación de 4 bits, nuestro CPU solo sería capaz de soportar
un máximo de 16 diferentes instrucciones

Arabic: 
مع عدد قليل من خطوط إضافية من التعليمات البرمجية، يمكننا أيضا تتبع عدد الحلقات سوف نقوم بالعد
منها سيكون عدد المرات 5 ذهبت إلى 11 ...قمنا باثنين من الحلقات، وهذا يعني 5 تذهب
في 11 مرتين ... مع ما تبقى من 1.
وبالطبع هذا الرمز يمكن أن يعمل على أي رقمين، والتي يمكننا فقط التغيير في الذاكرة
إلى كل ما نريد: 7 و 81 و 18 و 54، لا يهم -هذا يعتمد على قوة
البرمجيات!
البرمجيات أيضاً تسمح لنا لفعل شيء أجهزتنا ليس بوسعها فعله.
تذكر، ALU الخاصة بنا لم يكن لديها وظيفة لتقسيم رقمين، بدلا من ذلك
البرنامج الذي عملناه  أعطانا تلك الوظائف.
وحينئذ البرامج الأخرى تستطيع إستخدام البرنامج المقسم الخاص بنا لعمل حتى أشياء مربية
وأنت تعلم ماذا يعني ذلك.
مستويات جديدة من التجريد!
لذلك،  وحدة المعالجة المركزية الافتراضية الخاصة بنا هي أساسية جدا - كل من تعليماتها 8 بت طويلة، مع
فإن الرمز الشريطي لا يشغل سوى البتات الأربعة الأولى.
لذلك حتى لو استخدمنا كل مزيج من 4 بت، وحدة المعالجة المركزية الخاصة بنا سوف تكون قادرة على الدعم فقط
بحد أقصى 16 تعليمات مختلفة.

English: 
On top of that, several of our instructions
used the last 4 bits to specify a memory location.
But again, 4 bits can only encode 16 different
values, meaning we can address a maximum of
16 memory locations - that’s not a lot to work with.
For example, we couldn’t even JUMP to location
17, because we literally can’t fit the number
17 into 4 bits.
For this reason, real, modern CPUs use two
strategies.
The most straightforward approach is just
to have bigger instructions, with more bits,
like 32 or 64 bits.
This is called the instruction length.
Unsurprisingly.
The second approach is to use variable length
instructions.
For example, imagine a CPU that uses 8 bit
opcodes.
When the CPU sees an instruction that needs
no extra values, like the HALT instruction,
it can just execute it immediately.
However, if it sees something like a JUMP
instruction, it knows it must also fetch
the address to jump to, which is saved immediately
behind the JUMP instruction in memory.
This is called, logically enough, an Immediate
Value.
In such processor designs, instructions can
be any number of bytes long, which makes the
fetch cycle of the CPU a tad more complicated.

Korean: 
그것 보다도, 우리 명령어는 메모리 위치를 나타내는 데 
하위 4비트만 사용합니다.
다시 4비트는 16개 값만 표현할 수 있으므로, 최대 16개의 메모리 위치만 가리킬 수 있다는 뜻입니다.
일을 하기에 충분하지 않지요.
예를 들어 17번지로 JUMP할 수 없습니다. 
17을 4비트로 표현할 수 없으니까요.
이런 이유로, 진짜 현대 CPU들은 2가지 전략을 씁니다.
직접적인 방법은 명령어 길이를 늘리는 것입니다.
32나 64비트로요.
이것을 명령어 길이라고 하지요.
별로 놀랍지는 않습니다.
두번째 방법은 명령어 길이를 가변하는 것입니다.
예를 들어 CPU가 8비트 opcode를 사용한다고 해보지요.
추가 정보가 필요 없는 HALT같은 명령어를 만나면,
CPU는 즉시 실행할 수 있습니다.
허나, JUMP와 같은 명령어를 만나면 CPU는 점프할 주소를 또 읽어와야 한다는 것 압니다.
그래서 메모리에서 JUMP 명령어 뒤에 저장된 값을 즉시 읽어옵니다.
이것을 "Immediate Value"라고 합니다.
이런 프로세서를 설계하면, 명령어의 길이는 몇 바이트라도 만들 수 있습니다만,
CPU의 fetch 사이클이 좀 더 복잡해지겠지요.

Portuguese: 
Além disso, muitas das nossas instruções usam os últimos 4 bits para especificar um endereço de memória
Mesma coisa, 4 bits podem codificar apenas 16 valores diferentes, o que quer dizer que nós podemos endereçar no máximo
Mesma coisa, 4 bits podem codificar apenas 16 valores diferentes, o que quer dizer que nós podemos endereçar no máximo
16 endereços de memória, não dá para fazer muita coisa com isso
Nós não podemos nem pular para a posição 17 por que o número 17 não cabe em 4 bits
Por isso, as CPUS reais atuais usam duas estratégias
A abordagem mais direta é simplesmente ter instruções maiores com mais bits, como 32 ou 64 bits
Isso se chama tamanho de instrução, previsível
A segunda abordagem é usar um tamanho de instruções de variável
Por exemplo imagine uma CPU que usa opcodes de 8 bits
Quando a CPU encontra uma instrução que não precisa de valores adicionais
como a instrução HALT, ela pode executar a instrução imediatamente
Porém se a instrução for igual a JUMP, a CPU sabe que deve buscar também o endereço para o qual deve saltar
que é salvo na memória logo depois da instrução JUMP
Isso se chama, bem logicamente, valor imediato
Nesses projetos de processadores, as instruções podem ter qualquer tamanho em bytes, o que faz
ciclo de busca da CPU um pouco mais complicado

Chinese: 
最重要的是，其中一些指令
使用最后4位来指定存储器位置。
但同样，4位只能编码16种不同
值，这意味着我们最多能解决
16个内存位置 - 这不是一个很大的工作。
例如，我们甚至无法跳转到位置
17，因为我们实际上无法将数
17表示为4个比特。
出于这个原因，真正的，现代的CPU使用两个策略。
最直接的方法就是
使其拥有较大的指令，用更多的位，
像32或64位。
这就是所谓的指令长度。
不出所料。
第二种方法是使用可变长度
指令。
例如，假设有一个使用8位
操作码的CPU，
当CPU看到指令
不需要多余的值，比如HALT指令，
它只需要立即执行。
但是，如果它看到一个类似JUMP
的指令，它知道它必须获取
地址来跳转，在JUMP 指令后，它会被立即保存在内存中。
在逻辑上这就是所谓的立即
值。
在这样的处理器设计中，指令可以
是任何长度的字节，这使得
CPU的获取周期变为稍微更复杂的循环。

Spanish: 
Además de eso, varias de nuestras instrucciones usaron los últimos 4 bits para especificar una dirección de memoria
Pero de nuevo, 4 bits solo pueden codificar 16 diferentes valores, lo que significa que podemos ingresar un máximo de
16 direcciones de memoria - eso no es mucho con lo que trabajar.
Por ejemplo, no podríamos ni siquiera saltar a la ubicación 17, porque literalmente no cabe el número
17 en 4 bits.
Por esta razón la modernas y reales CPUs usan 2 estrategias
La forma más directo es solo tener instrucciones más grandes, con más bits,
como 32 o 64 bits.
Esto es llamado el largo de la instrucción
Como era de esperar.
La segunda forma es usar instrucciones de largo variable.
Por ejemplo, imagina una CPU que usa solo códigos de operacion de 8 bits.
Cuando la CPU ve una instrución que no necesita valores extra, como una instrucción "HALT"
puede ejecutarse inmediatamente.
Sin embargo, si ve algo como una instrucción "JUMP", sabe que debe además agregar
la dirección donde saltar, la cual es guardada inmediatamente detrás de la instrucción "JUMP" en memoria.
Esto es llamado un valor inmediato.
En ese diseño de procesador, las instrucciones pueden ser cualquier cantidad de bytes de largo, lo que hace que el
ciclo de recuperación de la CPU un poco más complicado

Arabic: 
وعلاوة على ذلك، استخدمت العديد من الإرشادات الخاصة بنا آخر 4 بتات لتحديد موقع الذاكرة.
ولكن مرة أخرى، 4 بت يمكن فقط ترميز 16 قيم مختلفة، وهذا يعني أننا يمكن أن نعالج بحد أقصى
من 16 موقع للذاكرة - وهذا ليس الكثير للعمل به.
على سبيل المثال، لا يمكننا حتى القفز إلى الموقع 17، لأننا حرفيا لا يمكننا أن نصلح الرقم
17 إلى 4 بت.
لهذا السبب، وحدات المعالجة المركزية الحقيقية والحديثة تستخدم استراتيجيتين.
النهج الأكثر مباشرة هي مجرد الحصول على تعليمات أكبر، مع المزيد من بتات،
مثل 32 أو 64 بت.
وهذا ما يسمى طول التعليمات.
ليس من المستغرب.
النهج الثاني هو استخدام تعليمات الطول المتغير.
على سبيل المثال، تخيل وحدة المعالجة المركزية التي تستخدم 8 بت أوب كودز.
عندما ترى وحدة المعالجة المركزية تعليمات لا تحتاج إلى قيم إضافية، مثل تعليمات HALT،
فإنه يمكنها فقط تنفيذها على الفور.
ومع ذلك، إذا رأيت شيئا مثل تعليمات JUMP، فإنها تعرف أنه يجب أيضا جلب
العنوان للقفز إليه ، الذي يتم حفظه مباشرة وراء تعليمات JUMP في الذاكرة.
وهذا ما يسمى، منطقيا بما فيه الكفاية، قيمة فورية.
في مثل هذه التصاميم المعالجة، يمكن أن تحمل التعليمات أي عدد من بايت طويلة، الأمر الذي يجعل
جلب دورة من وحدة المعالجة المركزية بادي أكثر تعقيدا.

Arabic: 
الآن، لدينا مثال وحدة المعالجة المركزية ومجموعة التعليمات افتراضية، تهدف إلى توضيح العمل الرئيسي
مبدئياً.
لذلك أريد أن أترككم مع مثال وحدة المعالجة المركزية الحقيقي.
في عام 1971، أصدرت إنتل معالج 4004.
كان أول وحدة المعالجة المركزية وضع كل شيء في رقاقة واحدة ومهدت الطريق إلى معالجات إنتل
ونحن نعلم ونحب اليوم.
وأيدت 46 تعليمات، كما هو موضح هنا.
وهو ما يكفي لبناء جهاز كمبيوتر يعمل بكامله.
واستخدمت العديد من التعليمات التي تحدثنا عنها مثل JUMP ADD SUBTRACT وLOAD.
كما أنه يستخدم القيم الفورية 8 بت، كما تحدثنا فقط عنه، لأشياء مثل JUMPs،
من أجل معالجة المزيد من الذاكرة.
وقد قطعت المعالجات شوطا طويلا منذ عام 1971.
معالج الكمبيوتر الحديث، مثل إنتل كور i7، لديه الآلاف من التعليمات المختلفة
وتعليمات مختلفة، تتراوح بين واحد إلى خمسة عشر بايت طويلة.
على سبيل المثال، هناك أكثر من عشرات أوب كودز مختلفة فقط لمتغيرات ADD!
وهذا النمو الهائل في حجم مجموعة التعليمات يرجع في جزء كبير منه إلى أجراس وصفارات إضافية
التي تمت إضافتها إلى تصاميم المعالج العمل الإضافي، والتي سوف نتحدث عنها الحلقة القادمة.
اراكم الاسبوع القادم!

English: 
Now, our example CPU and instruction set is hypothetical, designed to illustrate key working
principles.
So I want to leave you with a real CPU example.
In 1971, Intel released the 4004 processor.
It was the first CPU put all into a single
chip and paved the path to the intel processors
we know and love today.
It supported 46 instructions, shown here.
Which was enough to build an entire working
computer.
And it used many of the instructions we’ve
talked about like JUMP ADD SUBTRACT and LOAD.
It also uses 8-bit immediate values, like
we just talked about, for things like JUMPs,
in order to address more memory.
And processors have come a long way since 1971.
A modern computer processor, like an Intel
Core i7, has thousands of different instructions
and instruction variants, ranging from one
to fifteen bytes long.
For example, there’s over a dozens different
opcodes just for variants of ADD!
And this huge growth in instruction set size
is due in large part to extra bells and whistles
that have been added to processor designs
overtime, which we’ll talk about next episode.
See you next week!

Spanish: 
Ahora, nuestro CPU de ejemplo y set de instrucciones es hipotético, diseñado para ilustrar los trabajos
claves
Así que quiero dejarte con un ejemplo de una CPU real.
En 1971, Intel lanzó el procesador 4004.
Fue la primera CPU en poner todo en un solo chip y pavimentó el camino hacia los procesadores intel
que conocemos y amamos hoy en día.
Soportaba 46 instrucciones, mostradas aquí.
Lo cual era suficiente para hacer un computador funcional completo
Y usaba varias de las instrucciones de las que hemos hablado como "JUMP", "ADD", "SUBSTRACT" y "LOAD"
Usa además valores inmediatos de 8 bits, como acabamos de hablar, para cosas como "JUMPs",
a fin de abordar más memoria.
Y los procesadores han recorrido un largo camino desde 1971.
Un procesador de computador moderno, como un Intel Core i7, tiene miles de instrucciones diferentes
y variantes de instrucciones, que varían de uno a quince bytes de longitud.
Por ejemplo, hay más de una docena de códigos de operación diferentes solo para las variantes de "ADD".
Y este gran crecimiento en el tamaño del conjunto de instrucciones se debe en gran parte a las campanas y silbatos adicionales
que han sido agregadas al diseño de los procesadores con el paso del tiempo, hablaremos de ellos en el siguiente episodio.
Nos vemos la próxima semana!

Chinese: 
现在，我们的例子中CPU和指令集是假设性的，旨在说明关键工作
原则。
所以我想留给你一个真实的CPU的例子。
1971年，Intel发布了4004处理器。
这是首次CPU把所有指令放入一个单一的芯片中，为我们今天熟悉和喜爱的英特尔处理器
铺平了道路。
它支持46种指令，在如图所示。
这足以建立一个完整的工作
电脑。
它使用了许多，我们已经
谈到的像JUMP ADD SUBTRACT and LOAD。
它还使用8位立即值，比如
刚才我们谈到，对于像跳跃，
为了解决更多的内存。
而自1971年以来，处理器已经走过了很长的路。
现代计算机处理器，如英特尔
酷睿i7，有数以千计的不同指令
和指令变量，从一字节长
到十五个字节长。
例如，ADD的指令变量就有有超过几十个不同的操作码！
而指令集规模的巨大增长
在很大程度上是由于部分额外的花俏功能
已添加到处理器设计
中，我们将在下一集中讨论。
下周见！

Korean: 
우리의 예제 CPU와 명령어 집합은 가상적이지만 주요한 기본 원칙을 설명할 수 있도록 설계 되었습니다.
우리의 예제 CPU와 명령어 집합은 가상적이지만 주요한 기본 원칙을 설명할 수 있도록 설계 되었습니다.
이제 실제 CPU의 예제를 살펴보겠습니다.
1971년에 Intel은 4004 프로세서를 출시했습니다.
이것은 모든 기능을 단일 칩에 넣은 최초의 CPU이고
오늘날 우리가 알고 있고 사랑하고 있는
 Intel 프로세서의 기반을 닦은 칩입니다.
여기 보이듯이 46개의 명령어를 지원하고,
이것은 컴퓨터가 하는 모든 일들을 만드는데 충분합니다.
우리가 지금까지 설명한, JUMP, ADD, SUBTRACT, LOAD같인 명령어가 많이 사용됩니다.
이 CPU는 좀 전에 말했던 것 처럼, 많은 메모리 주소를 가리킬 수 있도록 JUMP같은 명령어에 8비트 immediate value를 사용합니다.
이 CPU는 좀 전에 말했던 것 처럼, 많은 메모리 주소를 가리킬 수 있도록 JUMP같은 명령어에 8비트 immediate value를 사용합니다.
프로세서는 1971년 이후로 긴 여정을 거쳐왔습니다.
Intel Core i7과 같은 현대 컴퓨터 프로세서는 수천개의 서로 다른 명령어 와 명령어의 변형형태를 갖고 있습니다.
길이의 범위도 1바이트에서 15바이트에 이릅니다.
예를 들어 ADD의 변형형태로 10여개 이상의 서로 다른 opcode를 갖고 있습니다.
이렇게 명령어 집합 크기가 거대하게 커짐으로 해서 많은 부가 부속품들이 사용됩니다.
이로 인해 프로세서를 설계하는 데 시간이 오래 걸리게 됐지요. 이 건 다음 에피소드에서 얘기하지요.
다음 주에 봐요.

Portuguese: 
Nosso exemplo de CPU e conjunto de instruções é fictício
pensado para ilustrar os princípios básicos de funcionamento
Então vou mostrar para vocês um exemplo de CPU de verdade. Em 1971 a Intel lançou o processador 4004
Foi a primeira CPU a colocar tudo em um único chip
e preparou o caminho para os processadores Intel que conhecemos e amamos hoje
Ela aceitava 46 instruções, mostradas aqui
Que eram suficientes para construir um computador completo e funcional
E usava muitas das instruções que nós falamos aqui, como JUMP, ADD, SUBTRACT e LOAD
Ela usava também valores imediatos de 8 bits, como os que falamos para coisas como JUMPs
para endereçar mais memória
E os processadores evoluíram bastante desde 1971
Um processador de computador moderno, como um Intel Core I7 possui milhares de instruções diferentes
e variações de instruções variantes indo de um a 15 bytes de tamanho
Por exemplo há mais de uma dúzia de opcodes para as diferentes formas de ADD!
E esse enorme crescimento no tamanho do conjunto de instruções se deve em grande parte a detalhes
que foram sendo adicionados ao projeto dos processadores ao longo do tempo
falaremos sobre eles no próximo episódio
Nos vemos semana que vem
