
Portuguese: 
Oi, Eu sou Carrie Anne e esse é o Crash Course de Ciência da Computação e hoje vamos falar sobre processadores
Vou avisar logo – Esse é provavelmente o episódio mais complicado de todos
Então depois que entender esse o resto é moleza
Nós já fizemos uma unidade aritmética e lógica, que pega números binários e executa
cálculos e já fizemos dois tipos de memória: Registradores – Pequenos pedaços de memória
linear, úteis para armazenar um único valor – e também já aumentamos e fizemos um pouco de
RAM, um banco de memória bem maior que pode armazenar vários números localizados em endereços diferentes
Agora é hora de juntar tudo e construir o coração de qualquer computador
mas sem nada da bagagem emocional que vem com os corações humanos
Para computadores esse coração é a Unidade Central de Processamento, comumente chamada de CPU (Sigla em Inglês)
INTRODUÇÃO
O trabalho de uma CPU é executar programas
Programas, como o Microsoft Office, Safari, ou sua amada cópia de Half Life 2, são feitos

Indonesian: 
Hai, saya Carrie Anne, ini Crash Course Computer Science, dan hari ini, kita berbicara tentang prosesor.
Hanya peringatan - ini
mungkin adalah episode paling rumit dalam seri ini.
Jadi begitu Anda mendapatkan ini, Anda emas.
Kami sudah membuat Aritmatika dan Logika
Unit, yang mengambil angka biner dan berkinerja
perhitungan, dan kami telah membuat dua jenis
memori komputer: Register - kecil, linier
potongan memori, berguna untuk menyimpan nilai tunggal - dan kemudian kami ditingkatkan, dan membuat beberapa
RAM, bank memori yang lebih besar yang dapat menyimpan banyak nomor yang terletak di alamat yang berbeda.
Sekarang saatnya untuk menyatukan semuanya dan
membangun sendiri jantung dari komputer mana pun,
tetapi tanpa beban emosional apa pun yang datang dengan hati manusia.
Untuk komputer, ini adalah Unit Pemrosesan Pusat, paling sering disebut CPU.
INTRO
Tugas CPU adalah menjalankan program.
Program, seperti Microsoft Office, Safari, atau salinan Half Life: 2 yang Anda cintai, dibuat

English: 
Hi, I’m Carrie Anne, this is Crash Course Computer Science, and today, we’re talking about processors.
Just a warning though - this
is probably the most complicated episode in the series.
So once you get this, you’re golden.
We’ve already made a Arithmetic and Logic
Unit, which takes in binary numbers and performs
calculations, and we’ve made two types of
computer memory: Registers -- small, linear
chunks of memory, useful for storing a single value -- and then we scaled up, and made some
RAM, a larger bank of memory that can store a lot of numbers located at different addresses.
Now it’s time to put it all together and
build ourselves the heart of any computer,
but without any of the emotional baggage that comes with human hearts.
For computers, this is the Central Processing Unit, most commonly called the CPU.
INTRO
A CPU’s job is to execute programs.
Programs, like Microsoft Office, Safari, or your beloved copy of Half Life: 2, are made

iw: 
היי, אני קארי אן זה, קראש קורס במדעי המחשב, והיום אנחנו נדבר על מעבדים.
אזהרה לפני שנתחיל - זה כנראה הפרק הכי מסובך בסדרה.
אז ברגע שתבינו את זה, אתם מעולים
כבר הכנו את יחידה אריתמטית ולוגית, שלוקחת מספרים בינריים ומבצעת
חישובים, והכנו שני סוגים של זיכרון ממוחשב: רג'יסטרים - חתיכות קטנות
של זיכרון בשורה, שימושיים לאחסון ערך יחיד - ואז עלינו בגודל והכנו קצת
RAM, בנק גדול יותר של זיכרון שיכול להכיל הרבה מספרים הממוקמים בכתובות שונות.
עכשיו הגיע הזמן לחבר הכל ביחד ולבנות לעצמינו את הלב של כל מחשב,
אבל בלי המטען הרגשי שבא עם לבבות אנושיים.
עבור מחשבים, זאת יחידת העיבוד המרכזית, שנקראת בדרך כלל CPU.
(פתיחה)
העבודה של ה-CPU היא לבצע תכנות.
תכנות, כמו אופיס של מייקרוסופ, דפדפן ספארי או העותק האהוב עליכם של האלף לייף:2, עשויים

Spanish: 
Hola, soy Carrie Anne, esto es Crash Course: Ciencias de la Computación, y hoy vamos a hablar sobre procesadores.
Solo una advertencia: este probablemente sea el episodio más complicado de la serie
por lo que, si entiendes esto, estás de diez.
Ya hemos hecho una Unidad de Aritmética Lógica, que hace cálculos
con números binarios, y hemos hecho dos tipos de memoria de computadora: Registros -pequeños trozos
lineares de memoria, útiles para almacenar un solo valor- y después agrandamos la escala, e hicimos
memoria RAM, un banco de memoria más grande, que puede almacenar una gran cantidad de números ubicados en distintas direcciones.
Ahota, es tiempo de unir todo y construir el corazón de cualquier computadora,
pero sin la carga emocional que tienen los corazones humanos.
Para las computadoras, esto es la Unidad Central de Procesamiento, conocido como CPU.
 
El trabajo de un CPU es ejecutar programas.
Programas como Microsoft Office, Safari, o tu amada copia de Half Life: 2 están constituidos

Chinese: 
嗨，我是 Carrie Anne，欢迎收看计算机科学速成课，今天我们来讨论处理器
提醒下 - 本集可能是本系列最复杂的一集
所以一旦你理解了本集，那么接下来的视频也难不倒你啦！
我们已经做了一个算术逻辑单元（ALU），它会对输入的二进制数执行
计算，我们也做了两种计算机内存：一种是寄存器（线性排列的小内存块，
能存一个值），把寄存器规模扩大后，
就成了另一种内存类型：RAM，它能在不同地址存大量数字
现在是时候把这些放在一起造一个计算机的“心脏”了，
但是个没有人类情感的“心脏”
对计算机来说，它的心脏是中央处理单元，通常叫做“CPU”
# 开场动画
CPU 的工作是执行程序
像 Office，Safari，和你最爱的 Half Life: 2都是程序，

Chinese: 
嗨，我是凱莉安妮，這是電腦科學速成班
今天我們來討論處理器
只是提醒一下
這可能是該系列中最複雜的一節
所以，一旦你搞懂這個
你該感到自豪
我們已經做了一個算術和邏輯單元
它們在二進制裡執行計算
我們做了兩種類型的記憶體：單一容量的暫存器
用於存儲單一數據
然後我們按比例放大，作出 RAM --
一個大容量的記憶體
能存儲大量的數值在其中
是時候把它們放在一起
建造出我們電腦的心
但沒有人心的情感包袱
對電腦而言，中央處理單元，通常被稱為CPU。
 
CPU的工作是執行程序
如Microsoft Office、Safari瀏覽器、
或者你愛玩的戰慄時空2

French: 
Bonjour, je m'appelle Carrie Anne, vous regardez Crash Course informatique, et aujourd'hui, on va parler des processeurs.
Juste pour avertissement, ce sera probablement l'épisode le plus compliqué de la série.
Donc quand vous l'aurez compris, vous serez en or.
On a déjà fabriqué une unité d'arithmétique et de logique (ALU), qui traite les nombres binaires et réalise
des calculs, et on a fait deux types de mémoire d'ordinateur : les registres, blocs de mémoire
petits et linéaires, utiles pour stocker une seule valeur, et ensuite nous avons changé d'échelle et fabriqué
de la RAM, une banque de mémoire plus grande qui peut stocker beaucoup de nombres localisés à différentes adresses.
Maintenant, il est temps de tout mettre ensemble et de construire nous même le cœur de n'importe quel ordinateur,
mais sans le bagage émotionnel que comportent les cœurs humains.
Pour les ordinateurs, c'est l'unité centrale de traitement, plus couramment appelée CPU.
[Générique d'introduction]
Le travail d'un CPU est d’exécuter des programmes.
Des programmes comme Microsoft Office, Safari, ou votre bien aimée copie de Half Life 2 : qui sont composées

Arabic: 
مرحبا، أنا كاري آن، وهذا هو  دورة علوم الكمبيوتر، اليوم، نحن نتحدث عن المعالجات.
مجرد تحذير  - هذه
ربما هي الحلقة الأكثر تعقيدا في هذه السلسلة.
لذا حتى تفهم  هذا،انت ذهبي
لقد قمنا مسبقا بوحدة  الحساب والمنطق
، والتي تستعمل في الأرقام الثنائية وينفذ
الحسابات، ولقد وجدنا نوعين من
ذاكرة الكمبيوتر: تسجيلات - صغيرة، وخطية
قطع من الذاكرة، مفيدة لتخزين قيمة واحدة - ثم مضينا قدما، وتحدثنا عن
RAM، وهو جزء أكبر من الذاكرة الذي يمكننا من تخزين الكثير من الأرقام التي تقع في عناوين مختلفة.
الآن حان الوقت لوضع كل ذلك معا، و
نبني أنفسنا "قلب" أي جهاز كمبيوتر،
ولكن من دون أي من الأمتعة العاطفية التي تأتي مع قلوب البشر.
بالنسبة لأجهزة الكمبيوتر، هذا هو وحدة المعالجة المركزية، وتدعي وحدة المعالجة المركزية.
مقدمة
وظيفة وحدة المعالجة المركزية هي تنفيذ البرامج.
برامج، مثل مايكروسوفت أوفيس، وسفاري، أو نسختك الحبيبة نصف الحياة: 2، مصنوعة

Korean: 
안녕하세요. Carrie Anne입니다. Crash Course 컴퓨터 과학의 오늘 강의는 프로세서에 관한 내용입니다.
걱정스럽게도, 이번 에피소드는 시리즈 중에서 가장 복잡할 것 같습니다.
그래서, 이 내용을 이해하게 되면 특별해질 수 있습니다.
우리는 이미 이진수를 입력받아 계산하는 
Arithmetic and Logic Unit (ALU)를 살펴봤습니다.
그리고, 두 종류의 컴퓨터 메모리에 대해서도 
알아봤어요.
레지스터(Register) - 하나의 값을 저장하는데 사용하는 작은 일렬로 된 메모리 뭉치
그리고 이것들을 확장해서 만드는 RAM - 서로 다른 주소에 수많은 수들을 저장할 수 있는 메모리 저장소.
이제는 이것들을 하나로 모아서 컴퓨터의 심장을 만들어 보겠습니다.
인간의 심장(마음)처럼 감정적인 문제들은 없습니다.
컴퓨터에서 이 심장을 중앙처리장치(Central Processing Unit)이라고 하고 CPU라고 부릅니다.
 
CPU의 일은 프로그램을 실행하는 것입니다.
Microsoft Office, Safari 또는 여러분이 사랑하는 게임인 Half Life:2와 같은 프로그램은

iw: 
מסדרה של פעולות בודדות, הנקראות הוראות, כי הן "מורות"
למחשב מה לעשות.
אם מדובר בהוראות מתמטיות, כמו חיבור או חיסור, ה-CPU ייתן ל-ALU
שלו לעשות את הפעולות המתמטיות.
או שאולי מדובר בהוראה של זיכרון, ובמקרה זה ה-CPU יאמר לזיכרון
לקרוא ולכתוב ערכים.
ישנם הרבה חלקים ב-CPU, אז אנחנו הולכים לבחון כל חתיכה בנפרד, ולבנות
כלפי מעלה תוך כדי.
נתמקד בגושים שימושיים, במקום להראות כל חוט וחוט.
כשאנחנו כן מחברים שני רכיבים בקו, זאת הפשטה לכל החוטים הנצרכים.
הרמה הגבוהה הזאת נקראת מיקרו-ארכיטקטורה.
אוקיי, קודם כל, אנחנו נצטרך קצת זיכרון.
בואו נכניס את רכיב ה-RAM שבנינו בפרק הקודם.
כדי לשמור על פשטות, נניח שיש לו רק 16 מקומות בזיכרון, וכל אחד מהם מכיל 8 ביטים.
בנוסף ניתן למעבד שלנו ארבעה רג'יסטרים של 8-ביט, אותם נסמן ב-A, B, C ו-D, והם
ישמשו לאחסון זמני של ערכים ופעולות עליהם.
אנחנו כבר יודעים שניתן לאחסן את המידע בזיכרון בתור ערכים בינריים,
וכן ניתן לאחסן בזיכרון גם תכנות.
אנחנו יכולים לתת שם לכל הוראה שנתמכת ע"י ה-CPU שלנו

Portuguese: 
de várias operações individuais, chamadas de instruções, por que elas instruem o computador sobre o que fazer
Se essas instruções são matemáticas, como adicionar ou subtrair, a CPU vai configurar a ALU para fazer as operações
Ou talvez seja uma instrução de memória, nesse caso a CPU vai conversar com a memória para ler e escrever valores
Há várias partes na CPU, então vamos olhar parte por parte, juntando aos poucos
Vamos nos focar em blocos funcionais, ao invés de mostrar cada trilha
Quando nós conectamos dois componentes com uma linha isso é uma abstração para todas as trilhas necessárias
Essa visão simplificada é chamada de microarquitetura. Ok, primeiro vamos precisar de um pouco de memória
Vamos pegar o módulo de RAM que criamos no último episódio.
Para simplificar vamos imaginar que ele tem apenas 16 posições de memória, cada uma contendo 8 bits
Vamos dar ao nosso processador 8 registradores de 8 bits, chamados de A, B, C, e D que usaremos para armazenar e manipular valores temporariamente
Nós já sabemos que dados podem ser armazenados na memória como valores binários e programas podem ser armazenados da mesma forma
Nós podemos colocar um Identificador (ID) em cada instrução aceita pela nossa CPU

Arabic: 
من سلسلة من العمليات الفردية، وتدعي تعليمات، لأنها "تعطي اوامر"
للكمبيوتر ما يجب القيام به.
إلذا كانت تلك التعليمات رياضية، مثل الجمع أو طرح، فإن وحدة المعالجة المركزية يمكنها القيام بذلك باعطاء الامر لل ALU
للقيام بتلك  العملية الحسابية.
أو انها قد تكون تعليمات للذاكرة، في هذه الحالة وحدة المعالجة المركزية  ALU سوف نتحدث مع الذاكرة
لقراءة وكتابة القيم
هناك الكثير من قطع الغيار في وحدة المعالجة المركزية، لذلك سوضح ذلك قطعة قطعة،  بناء
حتى نكمل
سنركز على القطع الرئيسية، بدلا
من إظهار كل سلك واحد.
عندما نفعل ربط جهازين مع خط، هذا  فكرة مجردة لجميع الأسلاك اللازمة.
وتسمى هذه النظرة العالية بالمعمارية المصغرة.
حسنا، أولا سنحتاج الى بعض الذاكرة.
يتيح انخفاض في حدة ذاكرة الوصول العشوائي الذي  أنشأنا في الحلقة السابقة.
لابقاء الامور بسيطة، سوف نفترض أن لديها فقط 16 موقعا في الذاكرة، كل منها يحتوي على 8 bits
دعونا أيضا نعطي معالجنا   أربعة، 8 bits
سجلات الذاكرة، و A، B، C و D التي
سوف تستخدم لتخزين مؤقت وتغيير القيم
نحن نعلم من قبل أن البيانات  يمكن تخزينها في الذاكرة كقيمل ثنائية
والبرامج  يمكن تخزينها في الذاكرة أيضا.
يمكننا تعيين ID إلى كل التعليمات التي تدعمها وحدة المعالجة المركزية لدينا.

English: 
up of a series of individual operations, called instructions, because they “instruct”
the computer what to do.
If these are mathematical instructions, like
add or subtract, the CPU will configure its
ALU to do the mathematical operation.
Or it might be a memory instruction, in which case the CPU will talk with memory
to read and write values.
There are a lot of parts in a CPU, so we’re going to lay it out piece by piece, building
up as we go.
We’ll focus on functional blocks, rather
than showing every single wire.
When we do connect two components with a line, this is an abstraction for all of the necessary wires.
This high level view is called the microarchitecture.
OK, first, we’re going to need some memory.
Lets drop in the RAM module we created last episode.
To keep things simple, we’ll assume it only has 16 memory locations, each containing 8 bits.
Let’s also give our processor four, 8-bit
memory registers, labeled A, B, C and D which
will be used to temporarily store and manipulate values.
We already know that data can be stored in memory as binary values
and programs can be stored in memory too.
We can assign an ID to each instruction supported by our CPU.

Indonesian: 
dari serangkaian operasi individu, yang disebut instruksi, karena mereka "menginstruksikan"
komputer apa yang harus dilakukan.
Jika ini adalah instruksi matematika, seperti
menambah atau mengurangi, CPU akan mengkonfigurasi nya
ALU untuk melakukan operasi matematika.
Atau mungkin instruksi memori, dalam hal ini CPU akan berbicara dengan memori
untuk membaca dan menulis nilai.
Ada banyak bagian dalam CPU, jadi kita akan meletakkannya sepotong demi sepotong, membangun
saat kita pergi.
Kami akan fokus pada blok fungsional
dari menunjukkan setiap kawat.
Ketika kita menghubungkan dua komponen dengan sebuah garis, ini adalah abstraksi untuk semua kabel yang diperlukan.
Pandangan tingkat tinggi ini disebut mikroarsitektur.
Oke, pertama, kita akan membutuhkan memori.
Mari kita turun dalam modul RAM yang kita buat episode terakhir.
Untuk mempermudah, kami menganggap itu hanya memiliki 16 lokasi memori, masing-masing berisi 8 bit.
Mari kita beri prosesor kita empat, 8-bit
register memori, berlabel A, B, C dan D yang
akan digunakan untuk menyimpan sementara dan memanipulasi nilai.
Kita sudah tahu bahwa data dapat disimpan dalam memori sebagai nilai biner
dan program dapat disimpan dalam memori juga.
Kami dapat menetapkan ID untuk setiap instruksi yang didukung oleh CPU kami.

French: 
d'une série d'opérations individuelles appelées instructions, parce qu'elles disent
à l'ordinateur ce qu'il doit faire.
Si ce sont des instructions mathématiques, comme additionner ou soustraire, le CPU va configurer son
ALU pour faire l'opération mathématique.
Ou il se pourrait que ce soit une instruction de sauvegarde, dans ce cas le CPU va parler avec la mémoire
pour lire et écrire les valeurs.
Il y a beaucoup d'éléments dans un CPU, donc on va les énoncer un par un, et
le construire au fur et à mesure.
On va se concentrer sur les blocs fonctionnels, plutôt que de montrer chaque câble.
Lorsque l'on connecte deux composants avec une ligne, c'est une abstraction pour tous les câbles nécessaires.
Cette vue d'ensemble est appelée micro-architecture.
OK, tout d'abord, on va avoir besoin de mémoire.
Mettons le module de RAM que l'on a construit au dernier épisode.
Pour garder les choses simple, on suppose qu'il n'a que 16 emplacements, chacun contenant 8 bits.
Donnons également à notre processeur quatre registres de 8 bit, étiquetés A, B, C et D
qui vont être utilisés pour stocker temporairement les valeurs et les manipuler.
On sait déjà que les données peuvent être stockées dans la mémoire sous forme binaire
et les programmes peuvent être stockés dans la mémoire également.
On peut donner une identité à chaque instruction supportée par notre CPU.

Korean: 
instruction(명령어)라고 하는 
개별적인 동작의 연속으로 구성되어 있어요.
컴퓨터가 무엇을 해야하는지 "instruct(명령)"하는 것이기 때문에, instruction(명령어)라고 부릅니다.
더하기(add)나 빼기(subtract)와 같은 수학 명령어라면,
CPU는 ALU에 수학 연산을 하도록 설정할 것입니다.
메모리 관련 명령어라면, CPU는 
메모리와 read와 write동작으로
메모리와 얘기할 것입니다.
CPU에는 많은 부품이 있기 때문에, 조각조각 나눠서 이해하고
다시 합쳐보겠습니다.
모든 선들에 대해서 살펴보기 보다는
 기능을 담당하는 블록들에 초점을 맞춰보죠.
두 부품을 한 선으로 연결하는 것은 
필요한 모든 선을 추상화하는 것입니다.
마이크로아키텍쳐(microarchitecture)라고 하는 
상위 수준의 개념으로 접근해봅시다.
우선 메모리가 필요하겠지요.
지난 에피소드에서 다룬 RAM 모듈을 배치합시다.
간단히 16개의 저장공간이 있고, 각 저장공간에는
 8bit를 저장할 수 있다고 가정합시다.
그리고, 우리 프로세서는 A, B, C, D라고 하는
 4개의 8bit 메모리 register를 갖고 있다고 가정합시다.
이 레지스터들은 값들을 조작하고 
임시로 저장하는데 사용할 것입니다.
data는 메모리에 이진수 형태로 저장이 됩니다.
그리고, 프로그램도 역시 메모리에 저장됩니다.
우리의 CPU가 지원하는 각 명령어(instruction)에 
ID를 부여해 보지요.

Spanish: 
por una serie de operaciones individuales, llamadas instrucciones, porque instruyen
a la computadora qué hacer.
Si estas instrucciones son matemáticas, como sumar o restar, el CPU configura su
Unidad de Aritmética Lógica para que ésta haga la operación matemática.
O puede ser una instrucción de memoria, en cuyo caso el CPU va a hablar con la memoria
para que esta lea y escriba valores.
Hay muchas partes en un CPU, por lo que vamos a ir pieza por pieza, armandolo
mientras progresamos.
Más que mostrar cada cable individual, vamos a concentrarnos en bloques funcionales.
Cuando conectemos dos componentes con una línea, es una abstracción de todos los cables necesarios para poder lograr dicha conexión.
Esta vista de alto nivel se llama microarquitectura.
Bien, primero vamos a necesitar una memoria.
Utilicemos el módulo RAM que creamos en el episodio anterior.
Para simplificar las cosas, vamos a asumir que solo tiene 16 ubicaciones de memoria, y que cada una contiene 8 bits.
Agreguemos a nuestro procesador 4 registros de 8 bits, y llamémoslos A, B, C, y D, que
serán usados para almacenar y manipular valores temporalmente.
Ya sabemos que los datos se pueden guardar en la memoria como valores binarios,
así como los programas también pueden ser guardados en la memoria.
Podemos asignar una identificación a cada instrucción soportada por nuestro CPU.

Chinese: 
这些程序都是由一系列单个操作（指令）组成的，
这些操作之所以叫作“指令”（instruction），因为它们“指示”计算机做什么
如果是数学指令，比如 加/减，
那么CPU会配置它的 ALU 去做数学运算
这些操作还可能是内存指令，这时 CPU 会和内存通信
CPU 中有很多部分，我们将各个部分列出来，
一边讲一边把各个部分组合起来。
我们会专注于功能块，而不是具体一根根线怎么连。
当我们用一条线连接两个组件时，
这条线就表示实际连接的多个线
这种高层次视角叫 “微体系架构”
OK，我们首先需要一些内存
为了理解简单，假设内存只有 16 个地址，每个地址能保存 8-bit
再给处理器加  4 个 8-bit 的寄存器： A，B，C，D
这些寄存器用于临时存储和操作数据
我们知道数据可以作为二进制值存在内存中
程序也可以存在内存中
我们可以给 CPU 支持的每个指令分配 ID

Chinese: 
由一系列的個別運算，被稱為指令，因為它們“指示” --
電腦做什麼。
如果有數學指令，像是加法或減法
CPU就會使用 --
ALU 做數學運算。
或者，它可能是一個內存指令
這樣的話，CPU會對記憶體做 --
讀取或寫入數值。
在CPU中有很多的組件
所以我們要把它拆解開來，按照我們的意思
一塊一塊的組裝起來。
我們將專注於功能模組
而不是每一條單一線路
當我們用線連接兩個組件
把線路抽象化這是有必要的
這種組成被稱為微體系結構。
首先，我們將需要一些記憶體
讓我們使用上一節提到的記憶體模組
為了簡單起見，我們假設它只有 16 個儲存位址
每個位址包含 8 bits
讓我們也給處理器賦予 4 個 8 bits 暫存器
標記為A、B、C、D --
用於暫時存儲要被處理的數據
我們已經知道，數據以二進制形式儲存記憶體中
以及程序也是。
我們可以將所有CPU指令整理作一張表單

Arabic: 
في المثال افتراضي لدينا، ونحن نستخدم أولا
أربعة bits  لتخزين "رمز العملية"،
أو شفرة التشغيل لفترة قصيرة.
أربعة bits النهائية تحدد فيها البيانات عن هذه العملية يجب أن تأتي من -
هذا يمكن أن تكون سجلات أو عنوان في الذاكرة.
نحن بحاجة أيضا الى اثنين من السجلات لاكمال وحدة المعالجة المركزية لدينا .
أولا، نحن بحاجة إلى تسجيل لتتبع ما نحن فيه في البرنامج.
لهذا، نحن نستخدم سجلا لعناوين التعليمات، والتي كما يوحي اسمها، تقوم بتخزين الذاكرة
عنوان التعليمة الحالية.
ثم نحن بحاجة إلى سجل آخر لتخزين التعليمات الحالية، والتي سنقوم باستدعاء سجل التعليمة.
عندما طورنا  الكمبيوترللمرة الاولى ، كل من
 السجلات تبدأ من 0.
وكمثال على ذلك، قمنا تهيئة RAM لدينا مع برنامج كمبيوتر بسيط وهو الذي سنتطرق اليه اليوم
المرحلة الأولى من عملية وحدة المعالجة المركزية هي
استدعاء مرحلة الجلب.
هذا هو المكان الذي جلبنا منه التعليمة الأولى
أولا، نحن لدينا سلك عنوان التعليمات تسجل لدينا وحدة ذاكرة الوصول العشوائي.
قيمة السجل هي 0، وبالتالي فإن عوائد RAM أي قيمة يتم تخزينها في عنوان 0.
في هذه الحالة، 0010 1110.
ثم يتم نسخ هذه القيمة في سجل تعليمنا.
الآن بعد أن قمنا بجلب تعليمات من
الذاكرة، نحن بحاجة لمعرفة ما هذه  التعليمة

iw: 
בדוגמה התאורטית שלנו, אנחנו משתמשים בארבעת הביטים הראשונים כדי לאחסן את "קוד הפעולה"
או בקיצור opcode.
ארבעת הביטים האחרונים מציינים מאיפה המידע עבור הפעולה מגיע.
זה יכול להיות רג'יסטר או כתובת בזיכרון.
אנחנו גם צריכים עוד שני רג'יסטרים כדי לסיים את ה-CPU שלנו.
קודם כל, אנחנו צריכים רג'יסטר כדי לעקוב אחרי המיקום שלנו בתכנה.
בשביל זה, אנחנו משתמשים ברג'יסטר כתובת ההוראה, וכפי שניתן להבין משמו, מאחסן את הכתובת
בזיכרון של ההוראה הנוכחית.
ואז אנחנו צריכים רג'יסטר נוסף כדי לאחסן את ההוראה הנוכחית, לו נקרא רג'יסטר ההוראה.
כשאנחנו מדליקים לראשונה את המחשב שלנו, כל הרג'יסטרים שלנו מתחילים ב-0.
בתור דוגמה, אתחלנו את ה-RAM שלנו עם תוכנת מחשב פשוטה שנעבור עליה היום.
השלב הראשון בפעילות של ה-CPU נקרא שלב המשיכה.
כאן אנחנו שולפים את ההוראה הראשונה שלנו.
קודם כל, אנחנו מחברים את רג'יסטר כתובת ההוראה שלנו לרכיב ה-RAM שלנו
הערך של הרג'יסטר הוא 0, אז ה-RAM מחזיר את ערך כלשהו הנמצא בכתובת 0.
במקרה הזה, 0010 1110.
ואז הערך הזה מועתק לרג'יסטר ההוראה.
עכשיו שמשכנו את ההוראה מהזיכרון, אנחנו צריכים להבין מהי ההוראה הזאת

Spanish: 
En nuestro ejemplo hipotético, usamos los primeros 4 bits para guardar el "código de operación"
también llamado opcode.
Los 4 bits restantes especifican de dónde deben provenir los datos para esa operación:
de los registros, o de una dirección en la memoria.
También necesitamos dos registros adicionales para completar nuestro CPU.
Primero, necesitamos un registro para poder saber dónde estamos en un programa.
Para esto, usamos un registro de dirección de memoria que, como lo sugiere su nombre, almacena la memoria
de la dirección de la instrucción actual.
Luego, necesitamos otro registro para almacenar la instrucción que esta siendo ejecutada, que llamaremos el registro de instrucción.
Cuando arrancamos nuestra computadora, todos nuestros registros comienzan en 0.
Como ejemplo, hemos iniciado nuestra memoria RAM con un programa de computadora simple que vamos a pasar hoy.
La primer fase de la operación de un CPU se llama la fase de búsqueda.
Aquí es cuando obtenemos nuestra primera instrucción.
Primero, conectamos nuestro registro de dirección de memoria a nuestro módulo RAM.
El valor del registro es 0, por lo que el RAM devuelve cualquier valor almacenado en la dirección 0.
En este caso, 0010 1110.
Luego, este valor es copiado a nuestro registro de instrucción.
Ahora que hemos obtenido una instrucción de nuestra memoria, debemos averiguar qué es esa instrucción

Portuguese: 
No nosso exemplo hipotético vamos usar os primeiros quatro bits para armazenar o ‘Código operacionl’ ou Opcode para simplificar
Os últimos quatro bits especificam de onde o dado para essa operação vem. Pode ser um registro ou um endereço de memória
Nós ainda precisamos de mais dois registradores para completar nossa CPU
Primeiro precisamos de um registrador para lembrar de onde estamos no programa
Para isso vamos usar um registrador de endereço de instrução, que como o nome sugere armazena a posição na memória da instrução atual
E então vamos precisar de outro registrador para armazenar a instrução atual que vamos chamar de registrador de instrução
Quando nós ligamos o computador, todos nossos registros começam valendo zero
Como exemplo, nós iniciamos nossa RAM com um programa simples que vamos examinar hoje
A primeira fase da operação da CPU é chamada de fase de busca (fetch)
É aqui que pegamos nossa primeira instrução
Primeiro nós ligamos nosso registrador de endereço de instrução ao nosso módulo RAM.
O valor do registrador é 0, então a RAM retorna o que estiver armazenado no endereço 0
Nesse caso 0010 1110
Assim esse valor é copiado no nosso registrador de instrução
Agora que nós buscamos uma instrução da memória, nós precisamos descobrir o que essa instrução faz

French: 
Dans notre exemple hypothétique, on utilise les quatre premiers bits pour stocker le "code d'opération"
ou "opcode" pour faire plus court.
Les quatre bits finaux disent d'où les données nécessaires à l'opération viennent -
ce pourrait être des registres ou une adresse dans la mémoire.
On a également besoin de deux registres supplémentaires pour compléter notre CPU.
Tout d'abord, on a besoin d'un registre pour savoir où on en est dans le programme.
Pour cela on utilise un registre d'adresse d'instruction, qui, comme le nom le suggère, enregistre
l'adresse de l'instruction en cours.
Et ensuite on a besoin de l'autre registre pour enregistrer l'instruction en cours, on va l'appeler le registre d'instruction.
Lorsque l'on démarre notre ordinateur pour la première fois tous les registres sont à 0.
Par exemple, on a initialisé notre RAM avec un simple programme que l'on va voir aujourd'hui.
La première phase d'une opération d'un CPU est appelée la phase d'extraction.
C'est là que l'on retrouve notre première instruction.
Tout d'abord, on relie notre registre d'adresse d'instruction à notre module de RAM.
La valeur du registre est 0, donc la RAM retourne à la valeur stockée à l'adresse 0.
Dans ce cas, 0010 1110.
Ensuite cette valeur est copiée dans notre registre d'instruction.
Maintenant que l'on a extrait une instruction de la mémoire, on a  besoin de trouver ce qu'est cette instruction

Chinese: 
在这个假设的例子中，我们用前四位存“操作代码”（operation code）
或简称“操作码”（opcode）
后四位代表操作的数据来自哪里：
可以是寄存器或内存地址
我们还需要两个寄存来完整组成我们的 CPU
首先，我们需要一个寄存器去追踪程序运行到哪里了，
我们叫它 “指令地址寄存器”
顾名思义，它存当前指令的内存地址
然后需要另一个寄存器来存当前指令，叫 “指令寄存器”
当启动计算机时，所有寄存器从 0 开始
举个例子，目前 RAM 里存了一个简单的计算机程序，我们会过一遍这个程序
CPU操作的第一阶段叫“取指令”（fetch phase）
也就是获得第一个指令的阶段
首先，将“指令地址寄存器”连到 RAM
寄存器的值为 0，因此 RAM 返回地址 0 处存的值
在这个例子里，地址0存的值是“0010 1110”，
现在我们从内存中获取了一个指令

English: 
In our hypothetical example, we use the first
four bits to store the “operation code”,
or opcode for short.
The final four bits specify where the data for that operation should come from -
this could be registers or an address in memory.
We also need two more registers to complete our CPU.
First, we need a register to keep track of where we are in a program.
For this, we use an instruction address register, which as the name suggests, stores the memory
address of the current instruction.
And then we need the other register to store the current instruction, which we’ll call the instruction register.
When we first boot up our computer, all of
our registers start at 0.
As an example, we’ve initialized our RAM with a simple computer program that we’ll to through today.
The first phase of a CPU’s operation is
called the fetch phase.
This is where we retrieve our first instruction.
First, we wire our Instruction Address Register to our RAM module.
The register’s value is 0, so the RAM returns whatever value is stored in address 0.
In this case, 0010 1110.
Then this value is copied into our instruction register.
Now that we’ve fetched an instruction from
memory, we need to figure out what that instruction is

Indonesian: 
Dalam contoh hipotesis kami, kami menggunakan yang pertama
empat bit untuk menyimpan "kode operasi",
atau singkatnya opcode.
Empat bit terakhir menentukan dari mana data untuk operasi itu harus berasal -
ini bisa berupa register atau alamat di memori.
Kami juga membutuhkan dua register lagi untuk menyelesaikan CPU kami.
Pertama, kita membutuhkan register untuk melacak di mana kita berada dalam suatu program.
Untuk ini, kami menggunakan register alamat instruksi, yang seperti namanya, menyimpan memori
alamat instruksi saat ini.
Dan kemudian kita membutuhkan register lain untuk menyimpan instruksi saat ini, yang akan kita sebut register instruksi.
Ketika kami pertama kali boot komputer kami, semuanya
register kami mulai dari 0.
Sebagai contoh, kami telah menginisialisasi RAM kami dengan program komputer sederhana yang akan kami lalui hari ini.
Fase pertama operasi CPU adalah
disebut fase ambil.
Di sinilah kami mengambil instruksi pertama kami.
Pertama, kami mengirimkan Register Instruksi Alamat kami ke modul RAM kami.
Nilai register adalah 0, sehingga RAM mengembalikan nilai apa pun yang disimpan di alamat 0.
Dalam hal ini, 0010 1110.
Kemudian nilai ini disalin ke dalam register instruksi kami.
Sekarang kami telah mengambil instruksi dari
memori, kita perlu mencari tahu apa instruksi itu

Korean: 
이 예제에서는 첫 4bit는 "operation code" 
(또는 짧게 opcode)를
나타내는 데 사용하겠습니다.
뒤에 4bit는 ㅏ연산에 사용될 data가 어디서 오는 가를 나타냅니다.
이것은 레지스터일 수도 있고, 
메모리의 주소일 수도 있습니다.
CPU 동작을 완성하기 위해서
2개의 레지스터가 더 필요합니다.
첫번째로, 프로그램의 어디에 있는지 추적할 수 있는 레지스터가 필요합니다.
이것을 instruction address (명령어 주소) 레지스터라고 하고,
이름에서 알 수 있듯이 현재 instruction의 메모리 주소를 저장합니다.
그리고, 현재 수행되는 명령어가 
저장되는 레지스터가 필요합니다.
이 레지스터는 명령어(instruction) 레지스터라고 합니다.
처음 컴퓨터가 부팅되면, 
모든 레지스터는 0에서 시작됩니다.
오늘 계속 설명할 간단한 컴퓨터 프로그램이
 RAM에 저장되어 있다고 합시다.
CPU 동작의 첫번째 단계는 
fetch phase(인출 단계)라고 합니다.
instruction을 가져오는 것입니다.
우선, RAM 모듈에 instruction address 레지스터를 연결하겠습니다.
레지스터의 값이 0이기 때문에,
RAM은 0번지에 저장되어 있는 값을 보내줍니다.
이 예제에서는 0010 1110입니다.
이 값은 instruction 레지스터에 복사됩니다.
이제 instruction 하나를 메모리로 부터 fetch했으니,
이 instruction이 무엇인지 알아내야 합니다.

Chinese: 
在我們假設的例子中
前 4 個 bits 當作操作碼（operation code）
或簡稱 opcode
後 4 個 bits 表示操作的數據來自 --
暫存器或記憶體裡的位址
我們還需要兩個暫存器來完成CPU
首先，我們需要標示，了解程序的動態
為此，我們使用的位址暫存器
顧名思義
它存儲當前被執行指令的暫存位址
然後，我們需要另一個暫存器來存儲指令
稱之為指令暫存器
當我們第一次啟動電腦
所有的暫存器從 0 開始
作為例子，我們已經初始化 RAM
我們今天將運行一個簡單的計算機程序
CPU的運行的第一階段稱為獲取階段。
這是我們取得第一個指令的地方。
首先，我們連接位址暫存器到RAM模組。
位址暫存器的值是 0
所以RAM返回任何值存儲在位址都是 0
在這種情況下，0010 1110。
那麼這個值被複製到指令暫存器。
現在，我們已經從記憶體獲取指令
我們需要弄清楚該指令是什麼

Portuguese: 
Para que possamos executá-la, no sentido de rodá-la, não de matá-la
Essa fase é chamada de decodificação. Nesse caso o opcde que são os primeiros 4 bits: 0010
Esse opcode corresponde à instrução ‘LOAD A’ que carrega um valor da RAM para o registrador A
O endereço da RAM são os quatro últimos bits de nossa instrução que são 1110, ou 14 em decimal
Depois as instruções são decodificada e interpretadas pela unidade de controle, como tudo mais que fizemos essa é feita de portas lógicas
Por exemplo, para reconhecer uma instrução LOAD A nós precisamos de um circuito que verifica que o opcode
corresponde a 0010 o que podemos fazer com algumas portas lógicas
Agora que nós sabemos com qual instrução estamos lidando nós podemos continuar e executar
essa instrução, o que é o começo da fase de execução
Usando a saída de nosso circuito de checagem LOAD_A, nós podemos ativar a leitura na RAM e enviar o endereço 14
A memória RAM busca o valor contido nesse endereço que é 00000011 ou 3 em decimal
Agora por que essa é uma instrução LOAD_A nós queremos que esse valor seja guardado no registrador A e apenas nele

iw: 
על מנת לבצע אותה.
כלומר להריץ אותה,
לא להוציא אותה להורג.
זה נקרא שלב הפענוח.
במקרה זה ה-opcode, שהוא ארבעת הביטים הראשונים, הוא 0010.
ה-opcode הזה מתאים להוראה "טען_A", שטוענת ערך מה-RAM
לתוך רג'יסטר A.
כתובת ה-RAM היא ארבעת הביטים האחרונים של ההוראה שלנו, שהם 1110, או 14 בבסיס עשרוני.
לאחר מכן, הוראות מפוענחות ומפורשות על ידי יחידת בקרה.
כמו כל דבר אחר שבנינו, גם היא עשויה משערים לוגיים.
לדוגמה, כדי לזהות הוראה של "טען A", אנחנו צריכים מעגל שבודק אם ה-opcode
מתאים ל-0010, מה שניתן לעשות עם קומץ של שערים לוגיים.
עכשיו שאנחנו יודעים עם איזו הוראה אנחנו מתמודדים, אנחנו יכולים להתקדם הלאה ולבצע
הוראה זו, מה שמתחיל את שלב הביצוע!
באמצעות הפלט של מעגל בדיקת ה"טען_A" שלנו, אנחנו יכולים להפעיל את החוט המאפשר קריאה של ה-RAM
ולשלוח פנימה את כתובת 14.
ה-RAM שולף את הערך הנמצא בכתובת זו, שהוא 00000011, או 3 בבסיס עשרוני.
עכשיו, בגלל שזאת הוראת טען_A, אנחנו רוצים שהערך הזה ישמר רק בתוך רג'יסטר A
ולא לתוך אף רג'יסטר אחר.

Arabic: 
حتى نتمكن من تنفيذه.
أن يتم تشغيله.
ليس قتله
وهذا ما يسمى بمرحلة فك شفرة.
في هذه الحالة شفرة التشغيل، وهوbits الأربعة الأولى، هي: 0010.
هذا شفرة تشغيل يتوافق مع تعليمات "LOAD A"، الذي يحمل قيمة من ذاكرة الوصول العشوائي
إلى التسجيل A.
عنوان RAM هو bits الأربعة الأخيرة من التعليمات لدينا والتي هي 1110، أو 14 في العشرية.
بعد ذلك، يتم فك التعليمات وتفسيرها من قبل وحدة التحكم.
مثل كل شيء آخر  قد بنيناه ، أيضا يتم من البوابات المنطقية.
على سبيل المثال، للتعرف على LOAD في تعليمة، نحن بحاجة إلى الدائرة التي تتحقق إذا كانت شفرة التشغيل
تربط 0010 الذي يمكننا القيام به مع حفنة من البوابات المنطقية.
الآن بعد أن عرفنا ما هي التعليمات التي نتعامل معها، يمكننا المضي قدما وتنفيذ
التعليمة التي هو بداية لمرحلة التنفيذ!
عن طريق إخراج  LOAD_A من دائرة فحص، نحن يمكن أن تغيير قراءة ذاكرة الوصول العشوائي
وترسل في عنوان 14.
ذاكرة الوصول العشوائي تقوم بسترداد قيمة في هذا العنوان، الذي هو 00000011، أو 3 في النظام العشري
الآن، لأن هذا هو تعليم LOAD_A،
نريد أن يتم حفظ هذه القيمة فقط إلى السجيل  A
وليس أي من السجلات الأخرى.

Indonesian: 
jadi kita bisa menjalankannya.
Itu yang menjalankannya.
Bukan membunuhnya.
Ini disebut fase decode.
Dalam hal ini opcode, yang merupakan empat bit pertama, adalah: 0010.
Opcode ini sesuai dengan instruksi "LOAD A", yang memuat nilai dari RAM
ke dalam Daftar A.
Alamat RAM adalah empat bit terakhir dari instruksi kami yang 1110, atau 14 dalam desimal.
Selanjutnya, instruksi diterjemahkan dan ditafsirkan oleh Unit Kontrol.
Seperti semua yang kami bangun, itu juga terbuat dari gerbang logika.
Sebagai contoh, untuk mengenali instruksi LOAD A, kita membutuhkan sirkuit yang memeriksa apakah opcode
cocok dengan 0010 yang bisa kita lakukan dengan beberapa gerbang logika.
Sekarang kita tahu instruksi apa yang sedang kita tangani, kita dapat melanjutkan dan melakukan
instruksi itu yang merupakan awal dari fase eksekusi!
Dengan menggunakan output dari rangkaian pemeriksaan LOAD_A kami, kami dapat mengaktifkan jalur baca aktif RAM
dan kirim alamat 14.
RAM mengambil nilai di alamat itu, yaitu 00000011, atau 3 dalam desimal.
Sekarang, karena ini adalah instruksi LOAD_A,
kami ingin nilai itu hanya disimpan dalam Daftar A
dan tidak ada register lain.

French: 
pour pouvoir l'exécuter.
La lancer.
Pas la tuer.
C'est la phase de décodage.
Dans ce cas là le code d'opération qui est stocké dans les quatre premiers bits, est : 0010.
Ce code d'opération (opcode) correspond à l'instruction "LOAD A", qui charge une donnée de la RAM
dans le registre A.
L'adresse de la RAM se trouve dans les quatre derniers bits de notre instruction, ici 1110, ou 14 en décimal.
Ensuite, les instructions sont décodées et interprétées par une unité de contrôle.
Comme tout ce que nous avons construit, elle est également constituée de portes logiques.
Par exemple, pour reconnaître une instruction "LOAD A", on a besoin d'un circuit qui vérifie si l'opcode
correspond à 0010, ce que l'on peut faire avec de nombreuses portes logiques.
Maintenant que l'on connaît l'instruction à traiter, on peut y aller et exécuter
cette instruction, ce qui constitue le début de la phase d'exécution !
En utilisant la sortie de notre circuit de vérification LOAD_A, on peut mettre en route la ligne permettant la lecture de la RAM
et l'envoyer à l'adresse 14.
La RAM extrait la valeur à cette adresse, qui est 00000011, ou 3 en décimal.
Maintenant, parce qu'il s'agit de l'instruction LOAD_A, on veut que cette ne soit enregistrée que dans le registre A
et dans aucun autre registre.

Korean: 
그래야지 instruction을 실행할 수 있습니다.
실행해야지,
버리면 안되니까요.
이 단계를 decode phase(해독 단계)라고 합니다.
이 경우에 opcode인 첫 4bit는 0010 입니다.
이 opcode는 RAM에 저장된 값을 Register A로 옮겨 오는(load)
"LOAD A"라는 instruction을 나타냅니다.
RAM의 주소는  instruction의 뒤 4bit인 1110, 십진수로 14입니다.
Control Unit은 instruction을 
번역(decode)하고 해석합니다.
다른 것과 마찬가지로, 
이것 또한 논리 게이트로 구성됩니다.
예를 들어, LOAD_A 명령어를 해독하기 위해서는, 
opcode가 0010인지 체크하는 회로가 필요합니다.
이것은 논리 게이트 몇개로 만들 수가 있습니다.
이제 무슨 instruction을 처리해야 하는지 알았으니까,
 이 instruction을 실행하는 단계로 갈 수 있습니다.
이게 실행(execute) phase의 시작입니다.
LOAD_A 검사 회로의 출력으로 
RAM의 read enable을 켤 수가 있습니다.
그리고, 주소 14를 전송합니다.
그럼 RAM에서 00000011 (십진수 3)을 가져 옵니다.
LOAD_A instruction이기 때문에 
이 값은 오직 Register A에 저장되어야 합니다.
다른 레지스터에 저장되면 안되겠지요.

Chinese: 
我们需要先弄清楚指令是什么，然后才能执行（execute）
也就是运行它
不是杀死（kill）它
这个阶段叫“解码”
这个例子里，前四位操作码是：“0010”，
对应“LOAD A”指令，把值从 RAM 加载到寄存器 A 中。
指令的最后四位是 RAM 地址，地址是“1110”，对应十进制的“14”
接下来，指令会由“控制单元”进行解码并执行
就像之前做的东西一样，“控制单元”也是逻辑门组成的
比如，为了识别“LOAD A”指令
需要一个电路检查操作码是否匹配“0010”
这个检查电路可以用很少的逻辑门来实现
现在知道要处理什么指令
我们就可以继续执行该指令了，这就是“执行阶段”开始时的指令！
用“LOAD_A”指令检查电路的输出
使能RAM的 "允许读"线路
然后把地址 14 传过去
RAM 会获取该地址的值，也就是“00000011”，转换成十进制的是“3”
由于当前执行的是 LOAD_A 指令，我们想要该值只存到寄存器 A

English: 
so we can execute it.
That is run it.
Not kill it.
This is called the decode phase.
In this case the opcode, which is the first four bits, is: 0010.
This opcode corresponds to the “LOAD A” instruction, which loads a value from RAM
into Register A.
The RAM address is the last four bits of our instruction which are 1110, or 14 in decimal.
Next, instructions are decoded and interpreted by a Control Unit.
Like everything else we’ve built, it too is made out of logic gates.
For example, to recognize a LOAD A instruction, we need a circuit that checks if the opcode
matches 0010 which we can do with a handful of logic gates.
Now that we know what instruction we’re dealing with, we can go ahead and perform
that instruction which is the beginning of the execute phase!
Using the output of our LOAD_A checking circuit, we can turn on the RAM’s read enable line
and send in address 14.
The RAM retrieves the value at that address, which is 00000011, or 3 in decimal.
Now, because this is a LOAD_A instruction,
we want that value to only be saved into Register A
and not any of the other registers.

Chinese: 
所以我們可以執行它。
即運行它。
不清除它。
這就是所謂的解碼階段。
在這種情況下，操作碼是前 4 個 bits，是：0010。
此操作碼對應於“LOAD A”指令，它讀取RAM中的值。
到暫存器A.
後 4 位 bits 是 RAM 位址
該指令是 1110 也就是十進制的14
接下來，指令通過控制單元解讀
像我們已經建立的其他組件一樣
它也是由邏輯門做出來的
例如，為了識別讀取的指令
我們需要運行操作碼來檢查
符合0010，我們可以用一些邏輯門來做到。
現在，我們知道我們正在處理什麼指令
我們可以繼續執行
那個執行階段開始的指令！
使用LOAD_A檢查電路的輸出
我們可以開啟RAM讀取該線路
並發送位址中的 14。
RAM檢索該地址的值
它是 0000 0011，或 3 的十進制值
現在，因為這是個 LOAD_A 指令
我們希望該值只保存到暫存器 A
而不是任何其它的暫存器。

Spanish: 
para así poder ejecutarla.
"Ejecutar" en el sentido de hacer que funcione.
No de matarlo.
Esto se llama la fase de decodificación.
En este caso el opcode, que es los primeros 4 bits, es 0010.
Este opcode corresponde a la instrucción "CARGAR A", que carga un valor de la memoria RAM
al Registro A.
La dirección RAM es los últimos 4 bits de nuestra instrucción que son 1110, o 14 en decimal.
Luego, nuestras instrucciones son decodificadas e interpretadas por una Unidad de Control.
Como todo lo que hemos construido, la Unidad de Control también está hecha de puertas lógicas.
Por ejemplo, para reconocer la instrucción CARGAR A, necesitamos un circuito que verifique si el opcode
coincide con 0010, cosa que podemos hacer con un puñado de puertas lógicas.
Ahora que sabemos con qué instrucción estamos trabajando, podemos seguir adelante, ¡y hacer funcionar
la instrucción que da comienzo a la fase de ejecución!
Utilizando la salida de nuestro circuito de comprobación LOAD_A, podemos activar la línea de habilitación de lectura de la memoria RAM
y enviar la dirección 14.
La memoria RAM obtiene el valor que se encuetra en ensa dirección, que es 00000011, o 3 en decimal.
Bien, debido a la instrucción CARGAR_A, queremos que ese valor seaalmacenado solo en el Registro A
y no en ninguno de los otros registros.

Spanish: 
Entonces, conectando los cables de datos de la memoria RAM a los cuatro registros de datos, podemos usar nuestro circuito de
comprobación  CARGAR_A para habilitar el activador adecuado, solo para el Registro A.
Y ahí lo tienen: hemos cargado correctamente el valor de la dirección RAM 14 en el Registro A.
Hemos completado esa instrucción,  por lo que podemos apagar todos nuestros cables, y estamos
listos para ira buscar la siguiente instrucción en la memoria.
Par hacer esto, incrementamos el Registro de Dirección de Memoria por 1, completando la fase de ejecución.
CARGAR_A es solo una de varias posibles instrucciones que nuestro CPU puede ejecutar.
Hay diferentes circuitos lógicos que decodifican diferentes instrucciones, configurando los componentes
del CPU para que realicen esa acción.
Ver todos esos circuitos decodificadores individuales es demasiado detalle, y como vimos un ejemplo,
vamos a agrupar a todos como una única Unidad de Control para simplificar las cosas.
Correcto: un nuevo nivel de abstracción.
La Unidad de Control es algo así como el conductor de una orquesta, dirigiendo todas las partes
diferentes del CPU.

Arabic: 
لذلك إذا أردنا ربط الأسلاك البيانات RAM لدينا سجلات البيانات الأربعة، يمكننا استخدام LOAD_A
دائرة الاختيار لتمكين الكتابة تمكين فقط من أجل التسجيل A.
و الان - لقد تم بنجاح تحميل قيمة العنوان RAM 14 إلى التسجيل A.
لقد أكملنا التعليمات، لذلك 
يمكننا أن نحول كل من الأسلاك لدينا حالا، ونحن
على استعداد لجلب التعليمة التالية في الذاكرة.
للقيام بذلك، نقوم بزيادة السجل التعليمات ب (1) الذي يكمل مرحلة التنفيذ.
LOAD_A هي مجرد واحدة من العديد من الإرشادات التي يمكن لوحدة المعالجة المركزية يمكن تنفيذ.
وفك تعليمات مختلفة من قبل دوائر المنطق المختلفة، والتي تكون وحدة المعالجة المركزية
مكونات لتنفيذ هذا الإجراء.
وعند النظر إلى تشفير الذبذبات الفردية فيه الكثير من التفاصيل، لذلك لأننا ننظر في مثال واحد،
نحن سوف كل شيء  نجمع منهم باعتباره وحدة تحكم واحدة لابقاء الامور بسيطة.
هذا صحيح إلى مستوى جديد من التجريد.
وحدة تحكم غير قابلة للمقارنة مع موصل للأوركسترا، وتوجيه مختلف
الأجزاء من وحدة المعالجة المركزية.

Chinese: 
所以如果我们将 RAM 的数据线连到 4 个数据寄存器，
然后用 【“LOAD_A”指令检查电路】去开启寄存器 A 的“允许写入线”
然后就成功把 RAM地址14中保存的值载入到了寄存器 A
既然完成了指令，就可以关掉所有线路。
现在我们可以去内存里读取下一条指令了。
为了做到这个，把“指令地址寄存器”+1，完成“执行阶段”
LOAD_A 只是 CPU 可以执行的指令之一
不同指令由不同逻辑电路解码
这些逻辑电路会配置 CPU 组件来执行它的操作
具体分析这些解码电路太繁琐了
既然我们已经看了 1 个解码电路的例子，
干脆把“解码电路“整个包起来
构成一个控制单元（Control Unit）来保持简洁
没错，这就是新的一层的抽象
控制单元就像管弦乐队的指挥，
“指挥” CPU 的所有组件

French: 
Donc si on connecte les cables de la RAM à nos quatre registres, on peut utiliser notre circuit
de vérification pour ne permettre l'écriture que dans le registre A.
Et voilà -- on a chargé la valeur de l'adresse 14 dans notre registre A avec succès.
On a accompli l'instruction, on peut donc éteindre tous les câbles, et on est prêt
pour extraire la prochaine instruction dans la mémoire.
Pour ce faire, on ajoute 1 dans le registre d'adresse d'instruction ce qui termine la phase d'exécution.
LOAD_A est just l'une des multiples instructions possibles que notre CPU peut exécuter.
Différentes instructions sont décodées par différents circuits logiques, qui configurent les composants
du CPU pour réaliser cette action.
Regarder tous ces circuits de décodage individuellement ferait trop de détails, étant donné qu'on a déjà regardé un exemple,
on va continuer et les regrouper en une seule unité de contrôle pour que ça reste simple.
Oui, c'est un nouveau degrés d'abstraction. [Musique]
L'unité de contrôle est comparable à un chef d'orchestre, dirigeant
les différentes parties du CPU.

English: 
So if we connect the RAM’s data wires to our four data registers, we can use our LOAD_A
check circuit to enable the write enable only for Register A.
And there you have it -- we’ve successfully loaded the value at RAM address 14 into Register A.
We’ve completed the instruction, so we
can turn all of our wires off, and we’’re
ready to fetch the next instruction in memory.
To do this, we increment the Instruction Address Register by 1 which completes the execute phase.
LOAD_A is just one of several possible instructions that our CPU can execute.
Different instructions are decoded by different logic circuits, which configure the CPU’s
components to perform that action.
Looking at all those individual decode circuits is too much detail, so since we looked at one example,
we’re going to go head and package them all up as a single Control Unit to keep things simple.
That’s right a new level of abstraction.
The Control Unit is comparable to the conductor of an orchestra, directing all of the different
parts of the CPU.

Indonesian: 
Jadi jika kita menghubungkan kabel data RAM ke empat register data kita, kita dapat menggunakan LOAD_A kita
periksa sirkuit untuk mengaktifkan fungsi penulisan hanya untuk Register A.
Dan begitulah - kami telah berhasil memuat nilai pada alamat RAM 14 ke dalam Daftar A.
Kami sudah menyelesaikan instruksi, jadi kami
dapat mematikan semua kabel kami, dan kami sudah
siap untuk mengambil instruksi selanjutnya dalam memori.
Untuk melakukan ini, kami menambah Register Alamat Instruksi oleh 1 yang menyelesaikan tahap eksekusi.
LOAD_A hanyalah salah satu dari beberapa instruksi yang mungkin dijalankan oleh CPU kami.
Instruksi yang berbeda didekodekan oleh sirkuit logika yang berbeda, yang mengkonfigurasi CPU
komponen untuk melakukan tindakan itu.
Melihat semua sirkuit dekode individu itu terlalu detail, jadi karena kami melihat satu contoh,
kita akan pergi dan mengemas semuanya sebagai Unit Kontrol tunggal untuk menjaga hal-hal sederhana.
Itu benar level baru abstraksi.
Unit Kontrol dapat dibandingkan dengan konduktor orkestra, mengarahkan semua yang berbeda
bagian dari CPU.

iw: 
אז אם אנחנו מחברים את חוטי המידע של ה-RAM אל ארבעת הרגי'סטרים של המידע, אנחנו יכולים להשתמש במעגל בדיקת
הטען_A שלנו כדי לאפשר כתיבה רק לרג'יסטר A.
והנה יש לכם את זה - טענו בהצלחה את הערך בכתובת 14 של ה-RAM לתוך רג'יסטר A.
השלמנו את ההוראה, אז אנחנו יכולים לכבות את כל החוטים, ואנחנו
מוכנים למשוך את ההוראה הבאה בזיכרון.
כדי לעשות זאת, אנחנו מגדילים את רג'יסטר כתובת ההוראה ב-1, מה שמשלים את שלב הביצוע.
טען_A היא רק אפשרות אחת מתוך מגוון הוראות שה-CPU שלנו יכול לבצע.
הוראות שונות מפוענחות על ידי מעגלים לוגיים שונים, שמגדירים לרכיבים
של ה-CPU לבצע את אותה פעולה.
להסתכל על כל מעגל פענוח בפני עצמו דורש פירוט רב מדי, אז מכיוון שהסתכלנו על דוגמה אחת,
אנחנו נתקדם הלאה ונאחד אותם לתוך יחידת בקרה אחת כדי לשמור על פשטות.
בדיוק - רמת הפשטה חדשה
ניתן להשוות את יחידת הבקרה למנצח של מקהלה, המכוון את כל החלקים
השונים של ה-CPU.

Portuguese: 
Então se conectarmos as trilhas da RAM aos nossos 4 registradores nós podemos usar nosso circuito de checagem LOAD_A
para habilitar a escrita somente no registrador A
E aí está – nós conseguimos carregar o valor do endereço 14 da RAM no registrador A
Nós completamos a instrução então podemos desligar todas as nossas trilhas e estamos próximos para buscar a próxima instrução na memória
Para fazer isso nós incrementamos o registrador de endereço de instrução em 1 o que completa a fase de execução
LOAD_A é apenas uma de várias instruções possíveis que nossa CPU pode executar
Diferentes instruções são decodificadas por diferentes circuitos lógicos
que configuram os componentes da CPU para executar aquela ação
Examinar todos esses circuitos de decodificação seria muito detalhado, então já que examinamos um exemplo
vamos em frente e empacotamos todos eles como uma Unidade Única de Controle para manter as coisas simples
Você acertou esse é mais um nível de abstração
A Unidade de controle funciona como o maestro de uma orquesta, orientando todas as partes da CPU

Korean: 
RAM의 data를 4개 레지스터에 전부 연결했더라도, LOAD_A 검사 회로는
Register A의 write enable만 활성화합니다.
그래서 RAM의 주소 14번지의 값이 성공적으로 Register A로 load될 수가 있는 것입니다.
하나의 instruction이 완성됐으므로 모든 연결선을 끄고,
메모리에서 다음 instruction을
fetch할 수 있도록 준비합니다.
이를 위해, instruction address 레지스터를 1 증가시키고, execute phase를 종료합니다.
LOAD_A는 우리의 CPU가 수행할 수 있는 
여러 instruction 중에 하나입니다.
다른 instruction은 다른 논리 회로를 통해 decode되고, 
해당 동작을 수행할 수 있도록
CPU 구성 요소들을 설정합니다.
각각의 decode 회로를 살펴 보는 것은 너무 상세합니다.
이미 하나의 예제를 살펴보았기 때문에, 
다른 것들은 Control Unit으로 묶어서 단순화 하겠습니다.
새로운 추상화 레벨입니다.
Control unit은 오케스트라의 지휘자와 같습니다. CPU의 다른 모든 파트를 지휘하기 때문입니다.
 

Chinese: 
因此，如果RAM的數據線連接到我們的四個數據暫存器
我們可以用 LOAD_A
檢查電路，使寫入只能針對暫存器A。
有了它 -- 
我們已經成功地讀取在RAM位址 14 的值到暫存器A.
我們已經完成了指令，
所以我們可以把所有的線路復原，並且
準備獲取記憶體中的下一個指令。
要做到這一點
我們使指令位址暫存器遞增 1 來結束執行階段
LOAD_A 只是CPU可以執行的多個指令其中之一。
不同的指令解讀是由不同的邏輯電路
其配置CPU的
組件來執行該操作。
縱觀所有這樣的個體解碼電路有太多細節
所以我們看一個例子
我們將它們全部包裝為一個控制單元
讓事情變得簡單
這是一個新的抽象層次。
控制單元相當於一個管弦樂隊的指揮，指揮所有
CPU不同的部分。

Chinese: 
剛才完成一個完整的獲取/解碼/執行循環
我們準備從頭再來一次
從獲取階段開始。
指令地址暫存器現在它的值為 1 
所以RAM給我們的值
儲存在位址 1 ，這是0001 1111。
接著到譯碼階段！
0001 是“LOAD B”指令
該指令移動RAM的值到暫存器B
儲存器位址這時是 1111，它是15 的十進制值。
現在到了執行階段！
控制單元用RAM讀取位址 15 
以及用暫存器B接收數據。
賓果，我們保存的值 0000 1110 或是稱為十進制數的 14
存入到暫存器B
最後要做的是使指令地址暫存器遞增 1
我們完成了另一個循環
我們的下一個指令有一點不同。
讓我們獲取它瞧瞧。
1000 0100。
該操作碼 1000 是ADD指令。
代替 4-bit 的RAM位址，這個指令採用兩組 2-bit。

Portuguese: 
Uma vez que completamos um ciclo completo busca/decodificação/execução estamos prontos para começar tudo de novo a partir da fase de busca
O Registrador de endereço de Instrução agora tem o valor 1 armazenado, então a RAM nos entrega o valor contido no endereço 1 que é 0001 1111
Na fase de decodificação 0001 é a instrução LOAD B que move um valor da RAM para o registrador B,
o endereço dessa vez é 1111 que é 15 em decimal
Agora vamos a execução. A Unidade de controle configura a RAM para ler o endereço 15 e configura o registrador B para receber o dado
Bingo, nós salvamos o valor 00001110, ou seja 14 em decimal no registrador B
A última coisa a fazer é incrementar nosso endereço de instrução em 1 e assim terminamos outro ciclo
A próxima instrução é um pouco diferente, vamos buscá-la 1000 0100
O opcode 1000 é uma instrução ADD (adicionar) ao invés de um endereço de RAM de 4 bits essa instrução usa dois conjuntos de 2 bits

Spanish: 
Habiendo completado un ciclo de búsqueda/decodificación/ejecución, estamos listos para empezar todo devuelta,
comenzando con la fase de búsqueda.
El Registro de Dirección de Memoria ahora tiene el valor 1 en él, por lo que la memoria RAM nos da el valor
almacenado en la dirección 1, que es 0001 1111.
Ahora, ¡a la fase de decodificación!
0001 es la instrucción "CARGAR_B", que mueve un valor de la memoria RAM al Registro B.
La ubicación de la memoria actualmente es 1111, que es 15 en decimal.
¡A la fase de ejecución!
La Unidad de Control configura la memoria RAM para que lea la dirección 15, y configura al Registro B para recibir los datos.
¡Bingo! Hemos guardado el valor 00001110 -el número 14 en decimal- en el Registro B.
Lo último que debemos hace es incrementar el registro de dirección de memoria por 1, y hemos terminado con otro ciclo.
Nuestra próxima instrucción es un poco diferente.
Vamos a buscarla.
1000 01 00.
El opcode 1000 es una instrucción ADD.
Esta instrucción usa dos sets de 2 bits en lugar de una dirección de memoria RAM de 4 bits.

Chinese: 
完成一个 “取指令 -> 解码 -> 执行” 周期后
我们准备好了再来一次，从“取指令”开始
“指令地址寄存器”现在值为1
所以 RAM 返回地址 1 的值，即“0001 1111”
再到“解码”阶段！
“0001”是“LOAD B”指令，将一个值从 RAM 移到寄存器 B
这次内存位置是“1111”，十进制的“15”
现在到“执行”阶段！
“控制单元”操作 RAM 读取地址 15，并配置寄存器 B 接收数据
成功了，我们把值“00001110”，也就是十进制的“14”存到了寄存器 B
最后一件事是将“指令地址寄存器”+1
我们又完成了另一个循环
我们的下一条指令有点不同
来取它吧
“1000 0100”
操作码“1000”是个“ADD”指令
这个指令后面的 4-bit 不再是RAM 地址，
而是 2-bit 一组，构成两组
记住 2 bit 可以表示 4 个值
所以 2 个 bit 足以选择 4 个寄存器的其中一个

Arabic: 
وبعد الانتهاء من واحدة كاملة جلب / تشفير / تنفيذ دورة، نحن على استعداد للبدء من جديد،
بدءا من مرحلة الجلب.
سجل التعليمات عنوان يحتوي الآن القيمة 1 في ذلك، وبالتالي فإن RAM يعطينا قيمة
تم تخزينها في عنوان 1، وهو 0001 1111.
إلى مرحلة التشفير!
0001 هو "LOAD B" التعليمات التي
تغير القيمة من ذاكرة الوصول العشوائي الي السجل B.
موقع الذاكرة هذه المرة هو 1111، وهو 15 في النظام العشري.
الآن إلى مرحلة التنفيذ!
وحدة تحكم بتكوين RAM لقراءة عنوان 15 وتكوين السجل B لتلقي البيانات.
بنغو، نحن فقط حفظ قيمة 00001110، أو رقم ال 14 في العشرية إلى التسجيل B.
آخر شيء يجب فعله هو زيادة عنوان تعليمات  السجل بمقدار 1، وننتهي مع دورة أخرى.
تعليمتنا المقبلة مختلفة قليلا
دعونا نجلبها
1000 01 00.
أن شفرة تشغيل 1000 هو تعليم ADD.
بدلا من عنوان RAM 4bits ، يستخدم هذه التعليمات مجموعتين من 2 bits

English: 
Having completed one full fetch/decode/execute cycle, we’re ready to start all over again,
beginning with the fetch phase.
The Instruction Address Register now has the value 1 in it, so the RAM gives us the value
stored at address 1, which is 0001 1111.
On to the decode phase!
0001 is the “LOAD B” instruction, which
moves a value from RAM into Register B.
The memory location this time is 1111, which is 15 in decimal.
Now to the execute phase!
The Control Unit configures the RAM to read address 15 and configures Register B to receive the data.
Bingo, we just saved the value 00001110, or the number 14 in decimal, into Register B.
Last thing to do is increment our instruction address register by 1, and we’re done with another cycle.
Our next instruction is a bit different.
Let’s fetch it.
1000 01 00.
That opcode 1000 is an ADD instruction.
Instead of an 4-bit RAM address, this instruction uses two sets of 2 bits.

iw: 
אחרי שסיימנו מעגל שלם של משיכה/פענוח/ביצוע, אנחנו מוכנים להתחיל הכל מחדש
ולהתחיל עם שלב המשיכה.
להוראה כתובת הרג'יסטר מכילה עכשיו את הערך 1, אז ה-RAM מביא לנו את הערך
המאחוסן בכתוב 1, שהוא 0001 1111.
קדימה לשלב הפענוח!
0001 זה ההוראה "טען_B", המזיזה ערך מה-RAM לרג'יסטר B.
המיקום בזיכרון הפעם הוא 1111, כלומר 15 בבסיס עשרוני.
עכשיו לשלב הביצוע!
יחידת הבקרה מגדירה ל-RAM לקרוא את כתובת 15 ולרג'יסטר B לקבל את המידע.
בינגו, בדיוק שמרנו את הערך 00001110, או 14 בבסיס עשרוני, לתוך רג'יסטר B.
הדבר האחרון שנשאר הוא להגדיר את רג'יסטר כתובת ההוראה ב-1, וסיימנו עם מעגל נוסף.
ההוראה הבאה שלנו היא קצת שונה.
בואו נמשוך אותה.
1000 01 00.
ה-opcode של 1000 הוא הוראת חיבור.
במקום כתובת RAM של 4 ביטים, ההוראה משתמשת בשני זוגות של 2 ביטים.

Korean: 
인출/해독/실행의 전체 사이클이 한번 끝났으니, 
이 모든 것을 다시 시작할 준비가 되었습니다.
fetch phase부터 시작합니다.
instruction address 레지스터는 1을 갖고 있고,
 RAM은 주소 1번지에 저장된
0001 1111을 보냅니다.
decode phase에서,
0001은 "LOAD_B" instruction이고, 이것은 RAM에서 값을 Register B로 이동시키는 것입니다.
이번에 메모리 위치는 1111, 십진수로 15번지 입니다.
이제 excute phase 입니다.
Control unit은 RAM의 15번지를 read할 수 있도록 설정하고, Register B는 data를 받을 수 있도록 설정합니다.
빙고, 이제 막 00001110 (십진수 14)를 
Register B에 저장했습니다.
마지막으로 할 일은 instruction address 레지스터를 1 증가시키고, 또 하나의 사이클을 완료합니다..
다음 instruction은 조금 다릅니다.
우선 fetch 해 봅시다.
1000 0100
opcode 1000은 ADD instruction입니다.
이 instruction은 4bit RAM 주소 대신 
2bit 짜리 2개 셋트를 사용합니다.

Indonesian: 
Setelah menyelesaikan satu siklus pengambilan / dekode / eksekusi penuh, kami siap memulai dari awal lagi,
dimulai dengan fase pengambilan.
Instruction Address Register sekarang memiliki nilai 1 di dalamnya, sehingga RAM memberi kita nilai
disimpan di alamat 1, yaitu 0001 1111.
Aktif ke fase decode!
0001 adalah instruksi "LOAD B", yang
memindahkan nilai dari RAM ke dalam Register B.
Lokasi memori kali ini adalah 1111, yaitu 15 dalam desimal.
Sekarang ke tahap eksekusi!
Unit Kontrol mengkonfigurasi RAM untuk membaca alamat 15 dan mengkonfigurasi Register B untuk menerima data.
Bingo, kami baru saja menyimpan nilai 00001110, atau angka 14 dalam desimal, ke dalam Register B.
Hal terakhir yang harus dilakukan adalah menambah daftar alamat instruksi kami dengan 1, dan kami selesai dengan siklus lainnya.
Instruksi kami berikutnya agak berbeda.
Mari kita ambil.
1000 01 00.
Opcode 1000 itu adalah instruksi ADD.
Alih-alih alamat RAM 4-bit, instruksi ini menggunakan dua set 2 bit.

French: 
Ayant complété un cycle complet extraction/décodage/exécution, on est prêt pour tout recommencer,
en commencant par la phase d'extraction.
Le registre d'adresse d'instruction a maintenant la valeur 1, donc la RAM nous donne la valeur
enregistrée à l'adresse 1, qui est 0001 1111.
Maintenant, phase de décodage !
0001 constitue l'instruction "LOAD B", qui transfère une valeur de la RAM vers le registre B.
L'emplacement dans la mémoire est 1111 cette fois ci, c'est à dire 15 en décimal.
Maintenant, phase d'exécution !
L'unité de contrôle configure la RAM pour lire l'adresse 15 et configure le registre B pour recevoir les données.
Bingo, on vient de sauvegarder la valeur 00001110, ou le nombre 14 en décimal, dans le registre B.
Dernière chose à faire, ajouter 1 à notre registre d'adresse d'instruction et on peut commencer un nouveau cycle.
Notre prochaine instruction est un peu différente.
Allons l'extraire.
1000 01 00.
Cet opcode 1000 est une instruction d'addition.
Au lieu d'une adresse de RAM de 4 bits, cette instruction utilise deux lots d'adresses de 2 bits.

Spanish: 
Recuerden que 2 bits pueden codificar 4 valores, por lo que 2 bits son suficiente para seleccionar cualquiera de nuestros 4 registros.
El primer set de 2 bits es 01, que en este caso corresponde al Registro B, y 00, que es el Registro A.
Por lo que "1000 01 00" es la instrucción para sumar el valor del Registro B dentro del valor del Registro A.
Para ejecutar esta instrucción, necesitamos integrar la Unidad Aritmética Lógica que creamos en el episodio 5 a nuestro CPU.
La Unidad de Control es la responsable de seleccionar los registros correctos para pasar como entradas,
y configurar la Unidad Aritmética Lógica para realizar la operación adecuada.
Para esta instrucción ADD, la Unidad de Control habilita el Registro B y envía su valor a
la primer entrada de la Unidad Aritmética Lógica.
También habilita el Registro A, enviando su valor a la segunda entrada de la ALU.
Como ya hemos dicho, la ALU puede realiar varias operaciones, por lo que
la Unidad de Control debe configurarla para realizar una operación ADD enviándole el opcode ADD.
Por último, la salida debe ser guardada en el Registro A. Pero no puede ser escrita allí directamente
porque el valor nuevo sería enviado al ALU y se sumaría a si mismo una y otra vez.

Indonesian: 
Ingatlah bahwa 2 bit dapat mengkodekan 4 nilai, jadi 2 bit sudah cukup untuk memilih salah satu dari 4 register kami.
Set 2 bit pertama adalah 01, yang dalam hal ini sesuai dengan Register B, dan 00, yaitu Register A.
Jadi "1000 01 00" adalah instruksi untuk menambahkan nilai dalam Register B ke dalam nilai dalam register A.
Jadi untuk menjalankan instruksi ini, kita perlu mengintegrasikan ALU yang kita buat di Episode 5 ke dalam CPU kita.
Unit Kontrol bertanggung jawab untuk memilih register yang tepat untuk dimasukkan sebagai input,
dan mengkonfigurasi ALU untuk melakukan operasi yang benar.
Untuk instruksi ADD ini, Unit Kontrol
memungkinkan Daftar B dan memasukkan nilainya ke
input pertama ALU.
Ini juga memungkinkan Register A dan memasukkannya ke input ALU kedua.
Seperti yang sudah kita bahas, ALU itu sendiri bisa
melakukan beberapa operasi berbeda, jadi
Unit Kontrol harus mengkonfigurasinya untuk melakukan
operasi ADD dengan meneruskan opcode ADD.
Akhirnya, hasilnya harus disimpan ke dalam Register A. Tetapi tidak dapat ditulis secara langsung
karena nilai baru akan beriak kembali ke ALU dan kemudian terus menambahkannya.

iw: 
תזכרו ש-2 ביטים יכולים לקודד 4 ערכים, אז 2 ביטים מספיקים כדי לבחור כל אחד מ-4 הרג'יסטרים שלנו.
הזוג הראשון של 2 ביטים הוא 01, שמתאים במקרה זה לרג'יסטר B, ו-00, שמתאים לרג'יסטר A.
אז “1000 01 00” היא ההוראה להוסיף את הערך ברג'יסטר B לתוך הערך ברג'יסטר A.
אז כדי לבצע הוראה זו, אנחנו צריכים לשלב את ה-ALU שהכנו בפרק 5 לתוך ה-CPU שלנו.
יחידת הבקרה אחראית לבחור את הרג'יסטרים הנכונים להעביר כקלטים,
ולהגדיר ל-ALU לבצע את הפעולה הנכונה.
עבור הוראת החיבור הזאת, יחידת הבקרה מאפשרת את Register B ומזינה את הערך שלו לתוך
הקלט הראשון של ה-ALU.
היא גם מאפשרת את רג'יסטר A ומזינה אותו לתוך הקלט השני של ה-ALU.
כפי שכבר אמרנו, ה-ALU עצמו יכול לבצע מספר פעולות שונות,
כך שיחידת הבקרה חייבת להגדיר לו לבצע את פעולת החיבור עלי ידי העברת opcode החיבור.
לבסוף, הפלט אמור להישמר לתוך רג'יסטר A. אבל לא ניתן לכתוב אותו ישירות,
כי הערך החדש יזרום מחדש לתוך ה-ALU ואז ימשיך להתווסף לעצמו.

English: 
Remember that 2 bits can encode 4 values, so 2 bits is enough to select any one of our 4 registers.
The first set of 2 bits is 01, which in this case corresponds to Register B, and 00, which is Register A.
So “1000 01 00” is the instruction for adding the value in Register B into the value in register A.
So to execute this instruction, we need to integrate the ALU we made in Episode 5 into our CPU.
The Control Unit is responsible for selecting the right registers to pass in as inputs,
and configuring the ALU to perform the right operation.
For this ADD instruction, the Control Unit
enables Register B and feeds its value into
the first input of the ALU.
It also enables Register A and feeds it into the second ALU input.
As we already discussed, the ALU itself can
perform several different operations, so the
Control Unit must configure it to perform
an ADD operation by passing in the ADD opcode.
Finally, the output should be saved into Register A. But it can’t be written directly
because the new value would ripple back into the ALU and then keep adding to itself.

Portuguese: 
Lembre-se que 2 bits podem ser armazenar 4 valores, então 2 bits é o suficiente para selecionar qualquer um dos nossos 4 registradores
O primeiro conjunto de 2 bits é 01 que nesse caso corresponde ao registrador B e 00 que é o registrador A
Então 1000 01 00 é a instrução para adicionar o valor no Registrador B com  valor no registrador A
Então para executar essa instrução nós precisamos integrar a ALU que nós fizemos no episódio 5 à nossa CPU
A unidade de controle é responsável por selecionar os registradores corretos e passar seus valores como entrada e configurar a ALU para executar a operação
Para essa instrução ADD a unidade controle habilita o registrador B e passa seu valor como primeira entrada para a ALU
Ela também habilita o registrador A e passa seu valor como segunda entrada para a ALU
Como nós já dissemos a ALU pode executar várias operações diferentes, assim a
Unidade de controle deve prepará-la para executar uma operação ADD passando o opcode ADD
Finalmente a saída deve ser salva no Registrador A. Mas ele não pode ser modificado diretamente
por que o novo valor voltaria à ALU e seria adicionado novamente

Korean: 
2 bit는 4개의 값을 표현할 수 있으니까, 우리 4개의 레지스터중에 하나를 선택할 수 있습니다.
첫번째 세트는 01이고, Register B를 나타냅니다. 다음은 00으로 Register A를 나타냅니다.
따라서, "1000 01 00"은 Register B의 값을 Register A의 값에 더하라는 instruction입니다.
이 instruction을 수행하기 위해서, 
5강에서 배운 ALU를 합치겠습니다.
Control unit은 올바른 레지스터를 선택해서 입력해 주고,
올바른 연산이 수행되도록 ALU를 설정해야합니다.
이 ADD instruction을 위해서 
Control unit은 Register B를 enable하고,
저장된 값을 ALU의 첫번째 입력으로 보냅니다.
또한 Register A를 활성화 하여
ALU의 두번째 입력으로 보냅니다.
앞서 말한 것처럼 ALU는 
몇개의 다른 연산을 수행할 수 있습니다.
따라서, Control unit은 ADD opcode 를 전달해서
ADD 연산이 수행되도록 설정해야만 합니다.
마지막으로, 연산 결과가 Register A에 저장되야 합니다. 
하지만 바로 저장할 수는 없습니다.
이 value가 ALU로 되돌아 와서 
다시 더해질 수 있기 때문입니다.

Arabic: 
تذكر أن 2 بت يمكن ترميز 4 قيم، لذلك 2 bits كافية لتحديد أي واحد من 4 السجلات.
أول مجموعة من 2bits هو 01، وهو في هذه الحالة يتوافق مع تسجيل B، و00، وهو سجل A.
حتى "1000 01 00" هو تعليمات لإضافة قيمة في التسجيل B إلى القيمة في السجل A.
وذلك لتنفيذ هذه التعليمات، نحن بحاجة إلى دمج ALU التي قطعناها على أنفسنا في الحلقة 5 في وحدة المعالجة المركزية
وحدة تحكم هي المسؤولة عن اختيار السجلات الصحيحة لتمرير كمدخلات،
وتكوين ALU لتنفيذ العملية الصحيحة.
لهذه التعليمة "add"، وحدة تحكم
تمكن التسجيل B ويغذي قيمتها إلى
إدخال الأول من ALU.
كما يتيح تسجيل ويتغذى عليه في إدخال ALU الثاني.
كما ناقشنا سابقا، فإن ALU نفسها يمكن
تنفيذ العديد من عمليات مختلفة، وبالتالي فإن
وحدة تحكم تكونه لأداء
عملية "add' عن طريق تمرير في شفرة تشغيل ADD.
وأخيرا، يجب حفظ الإخراج إلى التسجيل A. ولكن لا يمكن أن يكتب مباشرة
لان  القيمة الجديدة مرة أخرى في ALU وبعدها يطلع مشيرا إلى نفسها.

Chinese: 
第一组 2 位地址是“01”，对应寄存器B
第二组 2 位地址是“00”，对应寄存器A
因此，“1000 01 00”指令，意思是把寄存器 B 的值加到寄存器 A 里
为了执行这个指令，我们需要第 5 集的 ALU 放到 CPU 里
“控制单元”负责选择正确的寄存器作为ALU的输入
并配置 ALU 执行正确的操作
对于“ADD”指令，“控制单元”启用寄存器 B
将B中存放的值输到 ALU 的第一个输入
它还启用寄存器 A，将值输到 ALU 的第二个输入
正如之前讨论过的，ALU 可以执行不同的操作
所以控制单元必须传递“ADD”操作码，配置它执行“ADD”
最后，输出应存在寄存器 A
但不能直接写入寄存器 A
因为新值会重复进入 ALU ，然后和自己相加

Chinese: 
請記住，2-bit 可以編譯4個值
因此 2-bit 就足以選擇我們的4個暫存器中的任何一個
第一組的 2-bit 是 01，在這種情況下，對應暫存器B
而 00，對應暫存器A
因此，“1000 01 00”是用來添加暫存器B的值
到暫存器A的指令
因此，要執行這個指令
我們需要在第5集所製作，CPU裡面的ALU來整合
控制單元負責選擇正確的暫存器作為輸入。
並經由ALU來進行正確的操作。
該添加指令，
控制單元使暫存器B和它的值寫入
ALU的第一輸入端。
同時也使暫存器A寫入，並將其送入第二ALU輸入。
正如我們已經討論的
ALU本身可以執行不同的操作，所以
控制單元必須將其配置為執行
透過ADD操作碼的ADD操作
最後，輸出應該被保存到暫存器A
但它不能直接寫入
因為新的值將回傳ALU，然後不斷加入到自身。

French: 
Retenez que 2 bits peuvent encoder 4 valeurs, donc deux bits suffisent pour encoder nos 4 registres.
Le premier lot de 2 bits est 01, qui correspond dans ce cas au registre B, et 00, le registre A.
Donc "1000 01 00" est l'instruction pour ajouter la valeur du registre B à celle du registre A.
Pour exécuter cette instruction, on a donc besoin d'intégrer l'ALU fabriquée à l'épisode 5 dans notre CPU.
L'unité de contrôle est responsable de la sélection des bons registres, les rentrer dans l'ALU,
et configurer l'ALU pour qu'elle réalise la bonne opération.
Pour cette instruction d'addition, l'unité de contrôle permet la lecture du registre B et rentre sa valeur
dans la première entrée de l'ALU.
Elle permet également la lecture du registre A et rentre sa valeur dans la seconde entrée de l'ALU.
Comme on l'a déjà dit, l'ALU elle-même peut réaliser de nombreuses opérations différentes,
donc l'unité de contrôle doit la configurer pour qu'elle réalise une addition en passant par l'opcode ADD.
Finalement, la sortie devrait être sauvegardée dans le registre A. Mais elle ne peut être écrite directement car
la nouvelle valeur retournerait dans l'ALU et continuerait de s'additionner à elle-même.

Portuguese: 
Então a Unidade de controle usa um registrador interno para salvar o resultado temporariamente, desliga
a ALU e então grava o valor no registrador de destino
Nesse caso nossas entradas eram 3 e 14, a soma é 17, ou 0001 0001 em binário
Que agora está no registrador A. Como antes, a última coisa a fazer é incrementar nosso endereço de instrução em 1 e completamos outro ciclo
Ok, agora vamos buscar outra instrução 0100-1101
Quando nós a decodificamos vemos que 0100 é a instrução STORE_A com um endereço de memória RAM de 13
Como de costume nós passamos o endereço para o módulo de RAM, mas ao invés de ativar a leitura nós ativamos a escrita
ao mesmo tempo nós habilitamos a leitura no Registrador A. Isso nos permite usar o fluxo de dados para passar o valor armazenado no Registrador A
Parabéns, rodamos nosso primeiro programa de computador
Ele carrega dois valores da memória, soma eles e então salva seu valor de volta na memória

Spanish: 
Por eso, la Unidad de Control utiliza un registro interno para guardar la salida de datos temporalmente, apagar el
ALU, y luego escribir el valor en el registro de destino adecuado.
En este caso, nuestra salida de datos fue 3 y 14, que sumados dan 17, o 00010001 en binario,
que ahora está en el Registro A. Nuevamente, lo último que hacemos es incrementar el registro de dirección
de memoria por 1, y ya hemos completado otro ciclo.
Okay, busquemos una última instrucción: 01001101.
Cuando la decodificamos vemos que 0100 es una instrucción ALMACENAR_A, con una dirección de memoria RAM de 13.
Como siempre, enviamos la dirección al módulo RAM , pero en lugar de habilitar la memoria para lectura, la habilitamos para escritura.
Al mismo tiempo, habilitamos al Registro A para lectura. Esto nos permite usar la línea de datos para
pasar los valores escritos en A.
¡Felicitaciones! ¡Acabamos de ejecutar nuestro primer programa de computadora!
Cargó dos valores de la memoria, los sumó, y luego guardó esa suma en la memoria.

Arabic: 
لذلك وحدة تحكم  تستخدم  في السجل الداخلي
للحفظ مؤقتا الإخراج، إيقاف
ALU، ومن ثم كتابة القيمة في السجل جهة السليم.
في هذه الحالة، كانت المدخلات لدينا 3 و 14، و
وبالتالي فإن المبلغ هو 17 أو 00010001 في  النظام الثنائي،
المسجل في السجيل A. كما كان من قبل، وآخر شيء نفعله هو زيادة عنوان التعليمة
بمقدار 1، ودورة أخرى اكتملت
حسنا، لذلك دعونا نجلب التعليمة الاخيرة: 01001101.
عندما كنا نشفر ذلك نرى أن 0100 هو تعليم STORE_A، مع عنوان RAM 13.
وكما جرت العادة، نمرر عنوان إلى وحدة ذاكرة الوصول العشوائي، ولكن بدلا من القراءة تمكين الذاكرة، ونحن نكتب تمكينه.
وفي الوقت نفسه، نقرأ تمكين التسجيل A. وهذا يسمح لنا باستخدام خط البيانات ل
تمر في القيمة المخزنة في السجل A.
تهاني،  تم بنجاح اول برنامج كمبيوتر!
انها تحمل قيمتين من الذاكرة، مجموعين مع بعضهم البعض، ومن ثم حفظ هذا المجموع مرة أخرى إلى الذاكرة.

French: 
Donc l'unité de contrôle utilise un registre interne pour stocker temporairement la sortie, éteindre l'ALU,
et ensuite écrire la valeur dans le bon registre destinataire.
Dans ce cas nos entrées étaient 3 et 14, et la somme 17, ou 00010001 en binaire,
qui se trouve maintenant dans le registre A. Comme avant, la dernière chose à faire est d'ajouter 1 à notre registre d'adresse d'instruction
et un autre cycle est terminé.
D'accord, donc exécutons une dernière instruction: 01001101.
Lorsqu'on la décode on voit que 0100 est une instruction STORE_A, avec une adresse de RAM de 13.
Comme d'habitude, on transmet l'adresse au module de RAM mais au lieu de la lire, on en permet l'écriture.
En même temps, on lit le registre A. Ce qui nous permet d'utiliser la ligne de données qu'il contient
et de la transmettre.
Bravo, on vient de faire fonctionner notre premier programme informatique.
Il a chargé deux valeurs de la mémoire, les a additionné, et a enregistré cette somme dans la mémoire.

English: 
So the Control Unit uses an internal register
to temporarily save the output, turn off the
ALU, and then write the value into the proper destination register.
In this case, our inputs were 3 and 14, and
so the sum is 17, or 00010001 in binary,
which is now sitting in Register A. As before, the last thing to do is increment our instruction
address by 1, and another cycle is complete.
Okay, so let’s fetch one last instruction: 01001101.
When we decode it we see that 0100 is a STORE_A instruction, with a RAM address of 13.
As usual, we pass the address to the RAM module, but instead of read-enabling the memory, we write-enable it.
At the same time, we read-enable Register A. This allows us to use the data line to
pass in the value stored in register A.
Congrats, we just ran our first computer program!
It loaded two values from memory, added them together, and then saved that sum back into memory.

Chinese: 
因此，控制單元使用內部的暫存器暫時保存輸出，
接著關閉
ALU，然後將值寫入正確目的地的暫存器。
在這種情況下，我們輸入的值分別為3和14
所以總和為 17 或二進制的 00010001
現在儲存在暫存器A，和以前一樣
最後一件事是使指令位址遞增 1
另一個循環結束。
很好，讓我們獲取最後一個指令：01001101。
當我們對其進行解讀，我們看到
0100是一個 STORE_A 指令，在RAM的位址 13
像往常一樣，我們通過位址到暫存模組
但不是啟用讀取暫存，而是啟用寫入它
與此同時，我們讀取暫存器A。
經由數據線
儲存在暫存器A中的值
恭喜，我們剛剛完成我們的第一個電腦程序！
它載入兩個值從記憶體，加在一起，
然後再保存該總和傳回記憶體。

iw: 
אז יחידת הבקרה משתמש ברג'יסטר זמני כדי לשמור את הפלט, לכבות
את ה-ALU, ואז לכתוב את הערך לתוך רג'יסטר היעד המתאים.
במקרה זה, הקלטים שלנו היו 3 ו-14, ולכן הסכום הוא 17, או 00010001 בבינרית
שעכשיו יושב ברג'יסטר A. כמו קודם, הדבר האחרון לעשות הוא להגדיל את כתובת
ההוראה ב-1, ומעגל נוסף הושלם.
אוקיי, אז בואו נמשוך הוראה אחת אחרונה: 01001101.
כשאנחנו מפענחים אותה אנחנו רואים ש-0100 היא הוראת אחסן_A, עם כתובת RAM של 13.
כרגיל, אנחנו מעבירים את הכתובת לתוך יחידת ה-RAM, אבל במקום לאפשר קריאה של הזיכרון אנחנו מאפשרים כתיבה לתוכו.
באותו הזמן, אנחנו מאפשרים לקרוא מרג'יסטר A. זה מאפשר לנו להשתמש בקו המידע
כדי להעביר פנימה את הערך המאוחסן ברג'יסטר A.
כל הכבוד, סיימנו להריץ את תכנת המחשב הראשונה שלנו!
היא טענה שני ערכים מהזיכרון, חיברה אותם ביחד, ואז שמרה את הסכום הזה בחזרה לזיכרון.

Indonesian: 
Jadi Unit Kontrol menggunakan register internal
untuk menyimpan sementara output, matikan
ALU, dan kemudian tulis nilainya ke dalam register tujuan yang tepat.
Dalam hal ini, input kami adalah 3 dan 14, dan
jadi jumlahnya adalah 17, atau 00010001 dalam biner,
yang sekarang duduk di Register A. Seperti sebelumnya, hal terakhir yang harus dilakukan adalah menambah instruksi kami
alamat dengan 1, dan siklus lain selesai.
Oke, jadi mari kita ambil satu instruksi terakhir: 01001101.
Ketika kami mendekodekannya, kami melihat bahwa 0100 adalah instruksi STORE_A, dengan alamat RAM 13.
Seperti biasa, kami meneruskan alamat ke modul RAM, tetapi alih-alih membaca-mengaktifkan memori, kami menulis-mengaktifkannya.
Pada saat yang sama, kami membaca-aktifkan Register A. Ini memungkinkan kami untuk menggunakan jalur data
masukkan nilai yang disimpan dalam register A.
Selamat, kami baru saja menjalankan program komputer pertama kami!
Ini memuat dua nilai dari memori, menambahkannya bersama-sama, dan kemudian menyimpan jumlah itu kembali ke memori.

Chinese: 
因此，控制单元用内部寄存器暂时保存输出
关闭 ALU，然后将该值写入正确的目标寄存器
在这个例子里，3 + 14 = 17，或二进制的“0001 0001”
现在存在寄存器 A
和之前一样，最后一件事是把指令地址 + 1
这样就又完成了一个循环
好，来看最后一个指令例子：“0100 1101”
当解码时，看到“0100”是 STORE_A 指令，RAM 地址是 13
像往常一样，把地址传给 RAM
但这次不是“允许读取”，而是“允许写入”
同时，打开寄存器 A 的“允许读取”
这样数据线会把数据传 RAM 里。
恭喜，我们刚运行了第一个电脑程序！
它从内存中加载两个值，相加，然后把结果放回内存。
当然，通过讲述每一个单独的步骤

Korean: 
그래서, Control unit을 내부 레지스터에
연산결과를 임시로 저장하고,
ALU를 끈 다음, 목적지 레지스터에 값을 저장합니다.
이 경우에, 입력은 3과 14이므로 합은 17, 
이진수로 00010001입니다.
이 값은 현재 Register A에 있습니다. 
지난번과 마찬가지로 마지막 할 일은
instruction address 레지스터를 1 증가 시키는 것입니다. 또 하나의 cycle이 완성되었습니다.
자, 이제 마지막 instruction 01001101을 fetch합시다.
해독해보면, 0100은 STORE_A instruction이고, 
RAM 주소는 13입니다.
마찬가지로 RAM 모듈에 address를 전달하지만,
 read enable 대신에 write enable을 합니다.
같은 시간에 Register A도 read enable하여
data 선에 Register A에 저장된 값이 통과하게 됩니다.
축하합니다. 지금 막 우리는 
첫 컴퓨터 프로그램을 실행했습니다.
메모리로부터 2개의 값을 옮겨와서, 서로 합친 후에 
결과를 메모리로 다시 저장하는 프로그램이었습니다.

Korean: 
물론 제가 fetch, decode, execute phase의 
각 단계를 설명하면서
CPU를 수동으로 전환하고 있었습니다.
하지만, 모든 컴퓨터 속에 
mini Carrie Anne이 들어가 있을 수는 없겠죠.
그래서 CPU를 착착 작동시킬 수 있게
 clock 이라고 하는 부품을 추가하겠습니다.
이름에서 알 수 있 듯이, clock은 
정확하고 규칙적인 시간에 전기 신호를 발생합니다.
이 신호는 Control Unit이 CPU의 내부 동작을 완벽하게 발 맞춰 진행시킬 수 있게 해줍니다.
마치 로마 갤리선의 앞에서 
리드미컬하게 북을 치는 사람 처럼요.
그럼, 모든 노 젓는 사람이 
동시에 박자를 맞출 수가 있지요.
물론 무작정 빨리 갈 수는 없습니다. 아무리 전자라도 
전선을 통과해서 신호가 안정될 때까지
시간이 필요하니까요.
CPU가 fetch-decode-execute 사이클의 각 단계를 
수행하는 속도를 Clock speed라고 합니다.
이 speed는 주파수 단위인 헤르츠(Hz)로 표시합니다.
1 헤르츠(Hz)는 1초에 1 cycle이라는 의미입니다.
제가 LOAD, LOAD, ADD, STORE 4개의 instruction에 대해서 설명하는데 대략 6분정도 걸렸습니다.
이 말은, 저의 실제적인 clock speed는 
대략 0.03Hz라는 것이지요.
제가 뛰어난 컴퓨터는 아니라는 걸 인정하지만,
수학에 재능있는 사람은

Spanish: 
Claro, guiándolos verbalmente por cada uno de los pasos era como si yo manualmente hicera que el CPU
transicione por sus fases de búsqueda, decodificación, y ejecución.
Pero no hay una pequeña Carrie Anne dentro de cada computadora,
por lo que la responsabilidad de mantener al CPU funcionando recae sobre un componente llamado el reloj.
Como su nombre sugiere, el reloj dispara una señal eléctrica en intervalos precisos y regulares.
Su señal es utilizada por la Unidad de Control para avanzar las operaciones internas del CPU,
manteniendo todo a paso continuo -como el sujeto en la proa de una Galera romana, tamborileando rítmicamente
manteniendo todos los remeros sincronizados... o un metrónomo.
Claro que no puedes ir demasiado rápido, porque a la electricidad también le lleva un determinado tiempo viajar
por los cables y para que la señal se establezca.
La velocidad con la que un CPU puede ejecutar cada paso del ciclo búsqueda-decodificación-ejecución se llama Velocidad de Rejoj.
Esta velocidad se mide en Hertz -una unidad de frecuencia.
Un Hertz significa un ciclo por segundo.
Dado que me llevó aproximadamente 6 minutos para verbalmente realizar als 4 instrucciones -CARGA, CARGA,
ADD, ALMACENAR- eso significa que tengo una Velocidad de Reloj  efectva de unos .03 Hertz.
Siendo honesta, no soy una buena computadora, pero aún alguien muy bueno en matemática

French: 
Bien sûr, avec moi vous parlant à chaque étape, je faisait les transitions du CPU manuellement
à travers ses phases d'extraction, décodage et exécution.
Mais il n'y a pas de mini Carrie Anne dans chaque ordinateur.
Donc la responsabilité de conserver la cadence revient à un composant appelé l'horloge.
Comme son nom le suggère, l'horloge déclenche un signal électrique à un intervalle précis et régulier.
Ce signal est utilisé par l'unité de contrôle pour faire avancer l'opération interne du CPU,
en gardant tout en "lock-step" (j'ai pas compris...) - comme le type sur une galère romaine faisant du tambour en rythme
au front, gardant les rameurs synchronisés... ou un métronome.
Bien sûr vous ne pouvez pas aller trop vite, parce que même l'électricité prend du temps pour voyager
dans les câbles et pour que le signal s'installe.
La vitesse à laquelle un CPU peut effectuer chaque étape du cycle extraction/décodage/exécution est appelée sa "clock speed" (vitesse d'horloge).
Cette vitesse se mesure en Hertz - une unité de fréquence.
1 Hertz veut dire un cycle par seconde.
Sachant que ça m'a pris 6 minutes pour vous présenter 4 instructions -- LOAD, LOAD,
ADD et STORE -- ça veut dire que j'ai une vitesse d'horloge d'à peut près 0.3 Hertz.
Certes, je ne suis pas un super ordinateur mais même quelqu'un de doué en maths

Portuguese: 
Claro comigo falando os passos individuais eu estava passando a CPU através das fases de busca, decodificação e execução
Mas não há uma mini Carrie Anne dentro de cada computador
Então a responsabilidade de manter a CPU sincronizada é de um componente chamado clock (relógio)
Como o nome sugere, o clock dispara um sinal elétrico em um intervalo preciso e regular
esse sinal é usado pela Unidade de Controle para avançar a operação interna da CPU
mantendo tudo sincronizado – como o cara do tambor em um barco romano batendo o tambor no ritmo correto
mantendo os remadores sincronizados, ou um metrônomo (usado em música)
Claro que você não pode ir muito rápido, por que até a eletricidade leva tempo para passar pelas trilhas e para o sinal ser interpretado
A velocidade que uma CPU pode executar cada fase do ciclo de busca-decodificação-execução é chamada de frequência de clock
Essa velocidade é medida em Hertz – uma unidade de frequência, um Hertz significa um ciclo por segundo
Como eu levei 6 minutos para passarmos 4 instruções – Carregar, Carregar,
Adicionar e Armazenar – podemos dizer que tenho uma frequência de clock de 0.03 Hertz
Eu admito, não sou grande coisa como computador mas mesmo alguém que faça cálculos mais rápido

English: 
Of course, by me talking you through the individual steps, I was manually transitioning the CPU
through its fetch, decode and execute phases.
But there isn’t a mini Carrie Anne inside of every computer.
So the responsibility of keeping the CPU ticking along falls to a component called the clock.
As it’s name suggests, the clock triggers an electrical signal at a precise and regular interval.
Its signal is used by the Control Unit to advance the internal operation of the CPU,
keeping everything in lock-step - like the dude on a Roman galley drumming rhythmically
at the front, keeping all the rowers synchronized... or a metronome.
Of course you can’t go too fast, because even electricity takes some time to travel
down wires and for the signal to settle.
The speed at which a CPU can carry out each step of the fetch-decode-execute cycle is called its Clock Speed.
This speed is measured in Hertz - a unit of frequency.
One Hertz means one cycle per second.
Given that it took me about 6 minutes to talk you through 4 instructions -- LOAD, LOAD,
ADD and STORE -- that means I have an effective clock speed of roughly .03 Hertz.
Admittedly, I’m not a great computer but even someone handy with math

iw: 
בוודאי, כשאני אמרתי לכם מה קורה בכל צעד, העברתי ידנית את ה-CPU
דרך שלב המשיכה, שלב הפענוח ושלב הביצוע.
אבל לא קיימת קארי אן קטנה בתוך כל מחשב.
אז האחריות לשמור שה-CPU ממשיך לעבוד נופלת על הרכיב הנקרא "שעון".
כפי שניתן להבין משמו, השעון מפעיל אות חשמלי ברווחים קבועים ומדויקים.
האות שלו משמש את יחידת הבקרה כדי לקדם את הפעילות הפנימית של ה-CPU,
ולשמור על הכל בקצב אחיד, כמו הבחור בחזית ספינה רומית המתופף
לפי המקצב, ושומר את כל החותרים מסונכרנים... או כמו מטרונום.
ברור שאתם לא יכולים להתקדם מהר מדי, כי אפילו לחשמל לוקח זמן לעבור
בין החוטים ולאות לוקח זמן להתייצב.
המהירות בה ב-CPU יכול ל כל צעד במעגל המשיכה-פענוח-ביצוע נקראת מהירות השעון שלו.
המהירות הזאת נמדדת ב"הרץ" - יחידה של תדירות.
הרץ אחד אומר מעגל אחד לשנייה.
בהנתן שלקח לי בערך 6 דקות להסביר לכם 4 הוראות - טען, טען,
חבר ואחסן - זה אומר שיש לי בפועל מהירות שעון של בערך 0.03 הרץ.
יש להודות, אני לא מחשב מדהים, אבל אפילו מישהו זריז במתמטיקה

Chinese: 
我们人工切换 CPU 的状态“取指令 -> 解码 -> 执行“
但不是每台电脑里都有一个迷你 Carrie Anne
所以负责 CPU 到下一个阶段的责任，落在一个叫“时钟”（clock）的组件上
顾名思义，时钟以精确和固定的间隔，触发电信号
其信号被控制单元用于推进 CPU 的内部操作
保持一切操作同步
- 就像罗马帆船前面有个人有规律地击鼓
让所有划船者同步... 就像节拍器一样
当然不能走太快
因为即使是电也需要一些时间传输
CPU 执行 “取指令 -> 解码 -> 执行” 的速度，叫“时钟速度”（时钟频率）
该速度以赫兹为单位测量
一赫兹表示每秒一个周期
鉴于我花了大约 6 分钟给你讲了 4 条指令：
读取 -> 读取 -> 相加 -> 存储
意味着我的有效时钟速度大约为 0.03 赫兹
我承认，我不是一个好电脑

Chinese: 
當然，通過我說話你完成的各個步驟
我是手動轉換的CPU
通過它的獲取，解碼和執行階段。
但是，每一台計算機內沒有一個迷你的安妮凱莉。
因此保持CPU滴答作響的責任落在一個叫時鐘的組件上。
就像它的名字所暗示的
時鐘以精確且有規律的間隔觸發電信號
其信號被控制單元用來推進CPU的內部操作
把所有東西鎖在一起 - 
就像羅馬帆船裡的花花公子，在前面有節奏地打鼓
保持所有的划船同步...或像一個節拍器。
當然，你不能走得太快
因為即使是電也需要一段時間
才可以通過線路並讓信號設置。
CPU進行獲取 - 解碼 - 執行週期的速度被稱為時脈速度。
這個速度以赫茲為單位測量一個頻率。
一赫茲意味著每秒一個循環週期。
鑑於我花了大約6分鐘時間
跟大家介紹4個指令 --LOAD、LOAD、
ADD 和 STORE -- 這意味著
我大約有0.03赫茲的有效時脈速度
不可否認，我不是一個偉大的電腦
但即使是擅長數學能力的人

Arabic: 
بالطبع، و انا اشرح لكم الخطوات الفردية، كنت انتقل من وحدة المعالجة المركزية يدويا
لجلب، تشفير وتنفيذ مراحل.
ولكن ليس هناك مصغرة" كاري آن "مصغرة داخل كل جهاز كمبيوتر.
وبالتالي فإن مسؤولية الحفاظ على وحدة المعالجة المركزية موقوتة على طول تقع على عاتق مكون يسمى  الساعة.
كما يوحي اسمه، تشغل  الساعة  إشارة كهربائية في فاصل زمني دقيق ومنتظم.
يستخدم إشارة من قبل وحدة تحكم للمضي قدما في العملية الداخلية من وحدة المعالجة المركزية،
حفظ كل شيء في قفل خطوة - مثل المتأنق على الطبول المطبخ الروماني بشكل متوازن
في الجبهة، متزامنة الحفاظ على جميع مجدفين ... أو المسرع.
بالطبع لا يمكنك الذهاب بسرعة كبيرة، لأنه حتى الكهرباء يأخذ بعض الوقت للتنقل
أسفل الأسلاك وللإشارة إلى تسوية.
السرعة التي تنفيذها وحدة المعالجة المركزية كل خطوة من دورة جلب-تشفير-تنفيذ يسمى سرعة ساعة .
يتم قياس هذه السرعة في هيرتز - وحدة من التردد.
واحد هيرتز يعني دورة واحدة في الثانية الواحدة.
وبالنظر إلى أن الأمر استغرق مني حوالي 6 دقائق للحديث لك من خلال 4 تعليمات - LOAD، LOAD،
ADD وSTORE - وهذا يعني لدي سرعة الساعة فعالة ما يقرب من 0.03 هيرتز.
وباعتراف الجميع، أنا لست كمبيوتر رائع و
لست حتى شخص مفيد مع الرياضيات

Indonesian: 
Tentu saja, dengan saya berbicara Anda melalui langkah-langkah individu, saya secara manual mentransisikan CPU
melalui mengambil, mendekode dan menjalankan fase.
Tetapi tidak ada Carrie Anne mini di dalam setiap komputer.
Jadi tanggung jawab menjaga agar CPU terus berdetak jatuh ke komponen yang disebut jam.
Seperti namanya, jam memicu sinyal listrik pada interval yang tepat dan teratur.
Sinyal digunakan oleh Unit Kontrol untuk memajukan operasi internal CPU,
menjaga segala sesuatu dalam langkah-langkah - seperti dude pada dapur Romawi drum yang berirama
di depan, menjaga semua pendayung disinkronkan ... atau metronom.
Tentu saja Anda tidak dapat pergi terlalu cepat, karena bahkan listrik membutuhkan waktu untuk melakukan perjalanan
kabel dan untuk sinyal untuk menetap.
Kecepatan di mana CPU dapat melakukan setiap langkah dari siklus fetch-decode-execute disebut Clock Speed-nya.
Kecepatan ini diukur dalam Hertz - unit frekuensi.
Satu Hertz berarti satu siklus per detik.
Mengingat bahwa butuh sekitar 6 menit untuk berbicara dengan Anda melalui 4 instruksi - LOAD, LOAD,
TAMBAH dan MENYIMPAN - itu berarti saya memiliki kecepatan clock efektif sekitar 0,03 Hertz.
Harus diakui, saya bukan komputer yang hebat tetapi bahkan seseorang yang ahli dalam matematika

Chinese: 
但即使有人数学很好，也只能一秒一次，或 1 赫兹
第一个单芯片 CPU 是“英特尔 4004”，1971 年发布的 4-bit CPU
它的微架构其实非常类似我们举例用的 CPU
尽管是第一个单芯片处理器
它的时钟速度达到了 740 千赫兹 - 每秒 74 万次
你可能觉得很快
但和如今的处理器相比不值一提
一兆赫兹是每秒 100 万个时钟周期
而你看这个视频的计算机甚至手机肯定是几千兆赫兹
- 这可是每秒数十亿次 CPU 周期
另外，你可能听过有人超频电脑
意思就是修改时钟以加快 CPU 的速度
- 就像罗马帆船需要撞另一艘船时鼓手会加快速度一样
芯片制造商经常给 CPU 设计一点宽容度来忍受一点超频
但过度超频可能使 CPU 过热
或信号跟不上时钟，产生乱码

Korean: 
머리 속으로 1초에 계산 하나씩 할 수 있을거에요.
 1 Hz의 속도로.
최초의 단일칩 CPU는 1971년에 출시된
 Intel 4004라는 4 bit CPU입니다.
이 CPU의 마이크로아키텍쳐는 우리가 예제로 사용하고 있는 것과 상당히 비슷합니다.
최초의 프로세서임에도 불구하고, 
놀랍게도 740kHz로 작동했습니다.
1초에 74만 사이클이 수행된다는 것이죠.
엄청 빠르다고 생각할 수 있지만, 요즘 우리가 사용하는 프로세서와 비교하면 아무것도 아닙니다.
1 메가헤르츠(MHz)는 1초에 백만 clock 사이클이고,
이 비디오를 보고 있는 컴퓨터나 스마트폰은 
몇 기가헤르츠(GHz)로 작동합니다.
매 1초마다 수십억개의 CPU 사이클이 작동하는 거지요.
혹시 컴퓨터를 overclocking해서 사용한다고 
들은 적이 있을지도 모릅니다.
clock 속도를 올리면, CPU의 속도를 올릴 수 있죠. 
마치 로마 갤리선의 북치는 사람이
다른 배와 충돌하기 위해서 속도를 올리는 것 처럼요.
칩 제조사는 약간의 overclocking이 가능하도록
 CPU를 설계합니다.
하지만, 너무 많이 하면 CPU가 과열되거나 
신호가 안정되는 속도보다 clock이 빨라질 수 있습니다.

French: 
ne doit pas être capable de faire un calcul dans sa tête chaque seconde ou à un rythme d'un Hertz.
Le premier CPU en une puce était l'Intel 4004, un CPU à 4 bit présenté en 1971.
Sa micro-architecture est assez similaire à notre exemple d'aujourd'hui.
Bien qu'il soit le premier processeur de sa sorte, il avait une incroyable vitesse d'horloge de 740 kiloHertz --
c'est 740 000 cycles par secondes.
Vous devez vous dire que c'est rapide, mais ce n'est rien comparé aux processeurs que l'on utilise aujourd'hui.
Un megaHertz est 1 millions de cycles d'horloge par seconde, et l'ordinateur ou même le téléphone
avec lequel vous regardez cette vidéo en ce moment a sans doute quelques gigaHertz --
c'est un milliard de cycles de CPU chaque...seconde
Aussi, vous devez avoir déjà entendu parlé de personnes qui "overclock" leur ordinateur.
C'est lorsque vous modifiez l'horloge pour accélérer le tempo du CPU -- comme lorsque celui qui joue du tambour
accélère quand la galère doit poursuivre un autre navire.
Les fabricants de puces design souvent les CPU avec assez de marge pour supporter un peu d' "overclocking",
mais trop, peut, soit faire surchauffer le CPU, soit produire des charabia car les signaux arrivent après l'horloge.

Spanish: 
podría ser capaz de hacer un solo calculo mentalmente cada segundo, o 1 Hertz.
El primer CPU de 1 chip fue el Intel 4004, un CPU de 4 bits lanzado en 1971.
Su microarquitectura  es realmente bastante similar a la de nuestro ejemplo de un CPU.
A pesar de ser el primer procesador de su tipo, tenía una sorprendente Velocidad de Reloj de 740 Kilohertz
-eso es 740 ciclos por segundo.
Puedes pensar "¡eso es rápido!", pero no es nada compardo con los procesadores que utilizamos hoy en día.
Un megahertz es un millón de ciclos de reloj por segundo, y la computadora o hasta el teléfono
en el que estás mirando este video sin duda tenga un par de gigahertz -eso es
MIL MILLONES de ciclos de CPU cada segundo.
También, puedes haber escuchado de gente que le hace overclocking a sus computadoras.
Eso es cunado modificas la Velocidad de Reloj para hacer más veloz el tempo del CPU -como cuando el tamborilero
sube la velocidad cuando la Galera romana necesita chocar contra otra nave.
Los manufactureros de chips muchas veces diseñan los CPUs con suficiente tolerancia como par soportar un poco de overclocking,
pero demasiado puede o sobrecalentar el CPU, o producir gobbledygook a medida que las señales van quedando atrás del tempo del reloj.

Arabic: 
قد تكون قادرة على القيام حساب واحد في رؤوسهم كل ثانية أو 1 هيرتز فقط.
كانت أول  رقاقة واحدة وحدة المعالجة المركزية إنتل
4004، وحدة المعالجة المركزية 4 بت صدر في عام 1971.
انها المعمارية المصغرة هي في الواقع مشابهة جدا لمثال وحدة المعالجة المركزية.
على الرغم من كونه المعالج الأول من نوعه،
كان لديها سرعة الساعة العقل تهب من 740 الكيلوهيرتز
- هذا هو 740،000 دورة في الثانية.
قد تعتقد أن هذا هو سريع، ولكن لا شيء مقارنة مع المعالجات التي نستخدمها اليوم.
واحد ميغا هرتز هو واحد مليون دورة في الثانية الواحدة على مدار الساعة، والكمبيوتر، أو حتى الهاتف
إن كنت تشاهد هذا الفيديو في الوقت الحالي مما لا شك فيه عدد قليل جيجاهيرتز - وهذا
مليارات دورات CPU كل ... واحد ... الثانية.
أيضا، كنت قد سمعت من الناس رفع تردد التشغيل أجهزة الكمبيوتر الخاصة بهم.
هذا عند تعديل على مدار الساعة لتسريع وتيرة وحدة المعالجة المركزية - مثل عندما الطبال
يسرع عندما يحتاج الروماني مخزن لرام سفينة أخرى.
شركات صناعة الرقائق الالكترونية في كثير من الأحيان تصميم وحدات المعالجة المركزية مع ما يكفي من التسامح للتعامل مع قليلا من رفع تردد التشغيل،
ولكن الكثير إما أن ارتفاع درجة حرارة وحدة المعالجة المركزية، أو إنتاج الهراء مع انخفاض الإشارات وراء مدار الساعة.

iw: 
יכול אולי לחשב אולי חישוב אחד בראש בכל שנייה, או 1 הרץ.
ה-CPU הראשון מצ'יפ בודד היה האינטל 4004, CPU של 4 ביט, שוחרר ב-1971.
המיקרו-אריכיטקטוקה שלו למעשה די דומה לדוגמה של ה-CPU שלנו.
למרות שהוא היה המעבד הראשון מסוגו, הייתה לו מהירות שעון מדהימה של 740 קילוהרץ.
זה 740 אלף מעגלים לשנייה!
אתם אולי חושבים שזה מהיר, אבל זה כלום לעומת המעבדים שאנחנו משתמשים בהם היום.
מגה-הרץ אחד זה מיליון מעגלי שעון בשנייה, ולמחשב או אפילו לטלפון
שאתם אתם צופים בסרטון הזה עכשיו יש ללא ספק כמה ג'יגה-הרץ - זה
מיליארדים של מעגלים של CPU - בכל שנייה ושנייה.
כמו כן, אולי שמעתם על אנשים שממהרים את השעון של המחשב שלהם.
זה קורה כאשר מתאימים את השעון כדי להגביר את הקצב של ה-CPU - בדומה לכך שהמתופף
מגביר את המהירות כשהספינה הרומית צריכה להתנגש בספינה אחרת.
יצרנים של צ'יפים בדרך כלל מעצבים את ה-CPU שלהם עם מספיק סבלנות כדי לסבול קצת המהרה,
אבל יותר מדי יכול לחמם יותר מדי את ה-CPU, או להפיק ג'יבריש כשהאותות לא עומדים בקצב של השעון.

Portuguese: 
vai conseguir fazer um cálculo por segundo de cabeça ou 1 Hertz
A primeira CPU de um único chip foi a Intel 4004, uma CPU de 4 bits lançada em 1971
cuja microarquitetura era bem parecida com a CPU do nosso exemplo
Apesar de ser a primeira do seu tipo, ela já tinha uma velocidade impressionante de 740 quilohertz, ou seja 740 mil ciclos por segundo
Olhando assim parece rápido, mas não é nada comprado aos processadores que usamos hoje
Um mega-hertz é um milhão de ciclos por segundo e o computador ou celular que você está usando agora
para assistir esse vídeo quase certamente tem uma velocidade de alguns giga-hertz ou seja, bilhões de ciclos de CPU, por SEGUNDO
Além disso, você talvez já tenha ouvido falar de pessoas que fazem overclock dos seus computadores
Isto é: modificam a velocidade de clock para aumentar o ritmo da CPU, como quando o cara do tambor acelera o galeão romano para perseguir outro navio
Os fabricantes de chip geralmente fabricam chips que permitem um pouco de overclock
mas exageros podem sobreaquecer a CPU ou produzir efeitos indesejáveis a medida que os outros sinais ficam mais lentos que a CPU

Chinese: 
也只能每秒鐘或1赫茲進行一次計算。
最早的單芯片CPU是 Intel 4004
在1971年發布是第一個 4-bit CPU
它的微架構與我們例子中的CPU非常相似。
儘管是同類產品中的第一款處理器
它擁有740千赫驚人的時脈速度
-- 這是每秒74萬次循環。
你可能認為這很快
但它沒有什麼比得過我們今天所使用的處理器
一兆赫茲是每秒一百萬個時脈週期，
而你現在正在觀看這個視頻的電腦甚至電話
無疑是幾千兆赫 --
這就是每秒...數十億個CPU循環。
此外，您可能聽過人們超頻自己的電腦。
這是當你修改時脈來加快CPU的速度 --
就像羅馬帆船需要衝撞另一艘船時鼓手加速。
芯片製造商通常設計的CPU
有足夠的容忍度來操作一點超頻
但過多使用會使CPU過熱，或者由於信號落後於時脈
而產生gobbledygook(不知所云、沒有意義的雜訊)

Indonesian: 
mungkin hanya bisa melakukan satu perhitungan di kepala mereka setiap detik atau 1 Hertz.
CPU chip tunggal yang pertama adalah Intel
4004, CPU 4-bit dirilis pada tahun 1971.
Arsitektur mikro sebenarnya sangat mirip dengan contoh CPU kami.
Meskipun merupakan prosesor pertama dari jenisnya,
itu memiliki kecepatan clock 740 Kilohertz yang mengejutkan
- 740 ribu siklus per detik.
Anda mungkin berpikir itu cepat, tetapi tidak seberapa dibandingkan dengan prosesor yang kami gunakan saat ini.
Satu megahertz adalah satu juta siklus clock per detik, dan komputer atau bahkan telepon
Anda menonton video ini sekarang tidak diragukan lagi beberapa gigahertz - itu
MILIARAN siklus CPU setiap ... satu ... detik.
Juga, Anda mungkin pernah mendengar tentang orang yang melakukan overclocking komputer mereka.
Ini adalah saat Anda memodifikasi jam untuk mempercepat tempo CPU - seperti saat drummer
mempercepat ketika Galley Romawi perlu menabrak kapal lain.
Pembuat chip sering merancang CPU dengan toleransi yang cukup untuk menangani sedikit overclocking,
tetapi terlalu banyak dapat menjadi terlalu panas CPU, atau menghasilkan gobbledygook sebagai sinyal jatuh di belakang jam.

English: 
might only be able to do one calculation in their head every second or 1 Hertz.
The very first, single-chip CPU was the Intel
4004, a 4-bit CPU released in 1971.
It’s microarchitecture is actually pretty similar to our example CPU.
Despite being the first processor of its kind,
it had a mind-blowing clock speed of 740 Kilohertz
-- that’s 740 thousand cycles per second.
You might think that’s fast, but it’s nothing compared to the processors that we use today.
One megahertz is one million clock cycles per second, and the computer or even phone
that you are watching this video on right now is no doubt a few gigahertz -- that's
BILLIONs of CPU cycles every… single... second.
Also, you may have heard of people overclocking their computers.
This is when you modify the clock to speed up the tempo of the CPU -- like when the drummer
speeds up when the Roman Galley needs to ram another ship.
Chip makers often design CPUs with enough tolerance to handle a little bit of overclocking,
but too much can either overheat the CPU, or produce gobbledygook as the signals fall behind the clock.

French: 
Et bien que vous n'entendiez pas souvent parler d' "underclocking", c'est super utile.
Parfois ce n'est pas nécessaire de faire fonctionner son processeur à pleine vitesse...
car l'utilisateur s'est éloigné, ou juste parce qu'il n'utilise pas un programme exigeant.
En ralentissant le CPU, vous pouvez économiser beaucoup de puissance, ce qui est important pour les ordinateurs
qui manquent de batterie, comme les ordinateurs portables ou les smartphones.
Pour répondre à ces besoins, beaucoup d'ordinateurs modernes peuvent augmenter ou diminuer leur vitesse d'horloge
selon la demande, c'est ce que l'on appelle "dynamic frequency scaling" (Graduation de fréquence dynamique).
Donc, avec l'ajout d'une horloge, notre CPU est complet.
On peut maintenant le mettre dans une boîte, et en faire un composant à part entière.
Yep.
Un nouveau degrés d'abstraction ! [Musique]
La RAM, comme je vous l'ai montré à l'épisode précédent, se situe en dehors du CPU comme un composant à part entière, et ils communiquent
ensemble en utilisant des adresses, des données et les câbles disponibles.
Bien que le CPU que l'on a construit aujourd'hui soit un exemple simplifié, la plupart des mécaniques décrites
sont celles que l'on trouve dans les ordinateurs modernes.
Au prochain épisode, on va étoffer notre CPU, en l'élargissant avec plus d'instructions
en faisant nos premiers pas vers les logiciels.

Indonesian: 
Dan meskipun Anda tidak banyak mendengar tentang underclocking, ini sebenarnya sangat berguna.
Terkadang tidak perlu menjalankan prosesor dengan kecepatan penuh ...
mungkin pengguna telah menjauh, atau tidak menjalankan program yang sangat menuntut.
Dengan memperlambat CPU, Anda dapat menghemat banyak daya, yang penting untuk komputer
yang beroperasi pada baterai, seperti laptop dan smartphone.
Untuk memenuhi kebutuhan ini, banyak prosesor modern dapat menambah atau mengurangi kecepatan clock mereka
berdasarkan permintaan, yang disebut penskalaan frekuensi dinamis.
Jadi, dengan tambahan jam, CPU kami
selesai.
Kita sekarang dapat meletakkan kotak di sekitarnya, dan menjadikannya komponen sendiri.
Ya.
Tingkat abstraksi baru!
RAM, seperti yang saya tunjukkan pada Anda episode terakhir, terletak di luar CPU sebagai komponennya sendiri, dan mereka berkomunikasi
satu sama lain menggunakan alamat, data, dan memungkinkan kabel.
Meskipun CPU yang kami rancang hari ini adalah contoh yang disederhanakan, banyak mekanisme dasar yang kami diskusikan
masih ditemukan di prosesor modern.
Episode berikutnya, kita akan menambah CPU kita, memperluasnya dengan instruksi lebih lanjut
kami mengambil langkah kecil pertama kami ke dalam perangkat lunak.

English: 
And although you don’t hear very much about underclocking, it’s actually super useful.
Sometimes it’s not necessary to run the processor at full speed...
maybe the user has stepped away, or just not running a particularly demanding program.
By slowing the CPU down, you can save a lot of power, which is important for computers
that run on batteries, like laptops and smartphones.
To meet these needs, many modern processors can increase or decrease their clock speed
based on demand, which is called dynamic frequency scaling.
So, with the addition of a clock, our CPU
is complete.
We can now put a box around it, and make it its own component.
Yup.
A new level of abstraction!
RAM, as I showed you last episode, lies outside the CPU as its own component, and they communicate
with each other using address, data and enable wires.
Although the CPU we designed today is a simplified example, many of the basic mechanics we discussed
are still found in modern processors.
Next episode, we’re going to beef up our CPU, extending it with more instructions as
we take our first baby steps into software.

iw: 
ולמרות שלא שומעים יותר מדי על האטה של השעון, למעשה זה מאד שימושי.
לפעמים זה לא נצרף להריץ את המעבד במהירות מלאה...
אולי המשתמש עזב את המחשב, או שפשוט הוא לא מריץ תכנה תובענית במיוחד.
על ידי האטת ה-CPU, אתם יכולים לחסוך הרבה חשמל, שחשוב למחשבים
שעובדים על בטריות, כמו לפטופים וטלפונים ניידים.
כדי לספק את הצרכים האלו, הרבה מעבדים מודרניים יכולים להגדיל או להקטין את מהירות השעון שלהם
לפי הביקוש, מה שנקרא דירוג תדירות דינמי.
אז, עם הוספה של שעון, ה-CPU שלנו שלם.
אנחנו יכולים לכסות אותו בקופסה, ולהפוך אותה לרכיב בפני עצמו.
יאפ.
שלב חדש של הפשטה!
כפי שהראיתי בפרק הקודם, ה-RAM יושב מחוץ ל-CPU בתור רכיב בפני עצמו, והם מתקשרים
אחד עם השני באמצעות חוטים של כתובת, מידע ואפשור.
למרות שה-CPU שעיצבנו היום הוא רק דוגמה פשוטה, הרבה מהעקרונות שדנו בהם
עדיין קיימים במעבדים מודרניים.
בפרק הבא, אנחנו הולכים לתגבר את ה-CPU שלנו, ולהרחיב אותו עם עוד הוראות
כשאנחנו צועדים את צעדי התינוק הראשונים שלנו לתוך תכנות.

Chinese: 
儘管你沒有聽說關於降頻的事情
但實際上它是非常有用的
有時候沒有必要全速運行處理器...
也許用戶已經走開了
或者沒有運行一個特別苛刻的程序
通過減慢CPU速度
可以節省大量的電力，這對電腦很重要
使用電池運行，如筆記本電腦和智能手機。
為了滿足這些需求
許多現代的處理器可以增加或減少它們的時脈速度
根據需求，這就是所謂的動態頻率調整。
因此，加上一個時鐘，我們的CPU就完成了。
現在我們可以在它周圍放一個盒子
並把它作為自己的組件
對。
一個新的抽象層次！
RAM -- 就像我上次演示的那樣，作為組件位於CPU之外
並且它們使用位址、數據，使能連線相互傳遞資訊。
雖然我們今天設計的CPU是一個簡單的範例
但是我們討論的許多基本機制
在現代處理器中仍然存在。
下一集，我們將加強我們的CPU，並擴展更多的指令
把我們的第一個心血逐漸打造成軟體。

Spanish: 
Y aunque no se hable mucho del underclocking, es en verdad muy útil.
A veces no es necesario ejecutar el procesador a máxima velocidad...
por ahí el usuario no está utilizando el dispositivo, o sólo esta ejecutando un programa particularmente exigente.
Al bajar la velocidad del CPU, se puede conservar mucha energía, algo que resulta importante para computadoras
que utilizan baterías, como las laptops o los smartphones.
Para poder cumplir con estas necesidades, muchos procesadores modernos pueden aumentar o disminuir su Velocidad de Reloj
en base a la demanda, lo que se llama escala de frecuencia dinámica.
Así, agregando el reloj, nuestro CPU está completo.
Ahora podemos ponerle una caja alrededor, y hacerlo su propio componente.
Así es,
¡un nuevo nivel de abstracción!
La memoria RAM, como les mostré en el episodio anterior, está por fuera del CPU como un componente individual, y se
comiunican utilizando direcciones, datos, y cables de habilitacion
Aunque el CPU que diseñamos hoy es un ejemplo simplificado, muchas de las mecánicas básicas que discutimos
todavía se encuentran en procesadores modernos.
En el episodio siguiente, vamos a reforzar nuestro CPU, añadiendo más instrucciones y
dando nuestros primeros pasos pequeños hacia el software.

Portuguese: 
E apesar de ser menos falado o underclok também é muito importante
As vezes não é necessário que o processador esteja na velocidade máxima
talvez o usuário tenha se afastado ou o programa que está rodando não é muito pesado
Reduzindo a frequência da CPU pode-se economizar bastante energia o que é importante para um computador
que funciona com baterias, como laptops ou smartphones
Para atender a essas necessidades, a maioria dos processadores modernos pode aumentar ou diminuir a frequência de funcionamento
conforme a demanda o que é chamado de escalonamento dinâmico de frequência
Assim, com a adição de um clock nossa CPU está completa
Nós podemos colocá-la em uma caixa e fazer um novo componente. Sim, um novo nível de abstração
a memória RAM, como mostramos no último episódio, fica fora da CPU em seu próprio componente e ela se comunica com a CPU
usando trilhas de endereço, dados e ativação
Apesar de a CPU que projetamos hoje ser bem simples a maioria dos sistemas básicos dos quais falamos hoje ainda são usados nos processadores modernos
No próximo episódio nós vamos melhorá-la com mais algumas instruções à medida que daremos os primeiros passos no software

Chinese: 
虽然你很少听人说降频
但降频实际上超级有用
有时没必要全速运行处理器...
也许用户已经离开了，或在跑一个性能要求不高的程序
通过减慢 CPU，可以节省大量的电力，
这对用电池的设备
（比如笔记本电脑和智能手机）非常重要
为了满足这些需求
许多现代处理器可以根据需求增加或减少其时钟速度
叫做“动态时钟频率调整”
所以加上时钟后，CPU 才是完整的。
现在可以放到盒子里，变成一个独立组件
对
一层新的抽象！
RAM，正如上集展示的那样，是在 CPU 之外的独立组件
CPU 和 RAM 之间用“地址线”“数据线”和“允许读/写线”进行通信
虽然今天设计的 CPU 是个简化的例子
但许多基本概念在现代处理器中仍然存在
下一集，我们要加强这个 CPU
一边开始讲软件方面，一边扩展更多指令

Korean: 
underclocking에 대해서 많이 들어 보진 못했을 것 
같지만, 이것도 매우 유용합니다.
때때로 프로세서가 최고 속도로 
작동할 필요가 없을 때가 있습니다.
사용자가 자리를 떠났거나, 
별다른 프로그램일 실행하지 않는 경우
CPU 속도를 느리게 해서, 
전력 소비를 많이 줄일 수가 있습니다.
이것은 배터리로 동작하는 노트북이나 스마트폰에서는 아주 중요한 일이죠.
이런 요구사항을 만족하기 위해, 많은 요즘 프로세서들은 상황에 맞게 clock speed를 높이거나 낮출 수가 있습니다.
이 것을 dynamic frequency scaling 
(동적 주파수 스케일링) 이라고 합니다.
자 이제 clock을 추가해서
 우리의 CPU가 완성되었씁니다.
이제 이것들을 상자에 넣고, 하나의 부품으로 만들어 봅시다.
얍.
새로운 추상화 레벨!
지난 강의에서 살펴본 RAM은 
CPU 바깥에 별도 부품으로 위치합니다.
두 부품은 서로 address, data, enable 선들을 통해서 
통신합니다.
오늘 설계한 CPU는 하나의 간단한 예제이긴 하지만, 
우리가 알아본 많은 기본 원리들은 여전히
현대 프로세서에서 찾아 볼 수 있습니다.
다음 에피소드에서 몇 가지 instruction을 추가해서 
우리의 CPU를 강화해 보겠습니다.
이것을 가지고 소프트웨어의 첫 걸음마를 떼어봅시다.

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

Indonesian: 
Sampai jumpa minggu depan.

Korean: 
다음 주에 봐요.

Chinese: 
下周见

Portuguese: 
Vejo vocês semana que vem

French: 
A la semaine prochaine.

Chinese: 
我們下週見。

iw: 
להתראות שבוע הבא.

English: 
I’ll see you next week.

Arabic: 
سوف اراك الاسبوع المقبل.

Spanish: 
Los veré la semana que viene.
