Machine (Assembly) Language

Building a Modern Computer From First Principles

www.nand2tetris.org

Elements of Computing Systems, Nisan & Schocken, MIT Press, www.nand2tetris.org , Chapter 4: Machine Language slide 1
Where we are at:

Human Abstract design Software

abstract interface
Thought hierarchy
Chapters 9, 12
H.L. Language Compiler
& abstract interface
Chapters 10 - 11
Operating Sys.
Virtual VM Translator
abstract interface
Machine Chapters 7 - 8

Assembly
Language

Assembler

Chapter 6

abstract interface
Computer
Machine Architecture
abstract interface
Language
Chapters 4 - 5
Hardware Gate Logic
abstract interface
Platform Chapters 1 - 3 Electrical
Chips & Engineering
Hardware Physics
Logic Gates
hierarchy

Elements of Computing Systems, Nisan & Schocken, MIT Press, www.nand2tetris.org , Chapter 4: Machine Language slide 2
Machine language

Abstraction – implementation duality:

◼ Machine language ( = instruction set) can be viewed as a programmer-

oriented abstraction of the hardware platform

◼ The hardware platform can be viewed as a physical means for realizing

the machine language abstraction

Elements of Computing Systems, Nisan & Schocken, MIT Press, www.nand2tetris.org , Chapter 4: Machine Language slide 3
Machine language

Abstraction – implementation duality:

◼ Machine language ( = instruction set) can be viewed as a programmer-

oriented abstraction of the hardware platform

◼ The hardware platform can be viewed as a physical means for realizing

the machine language abstraction

Another duality:

◼ Binary version: 0001 0001 0010 0011 (machine code)

◼ Symbolic version ADD R1, R2, R3 (assembly)

Elements of Computing Systems, Nisan & Schocken, MIT Press, www.nand2tetris.org , Chapter 4: Machine Language slide 4
Machine language

Abstraction – implementation duality:

◼ Machine language ( = instruction set) can be viewed as a programmer-

oriented abstraction of the hardware platform

◼ The hardware platform can be viewed as a physical means for realizing

the machine language abstraction

Another duality: ALU

combinational

◼ Binary version

◼ Symbolic version
Memory
Loose definition: state

◼ Machine language = an agreed-upon formalism for manipulating

a memory using a processor and a set of registers

◼ Same spirit but different syntax across different hardware platforms.

Elements of Computing Systems, Nisan & Schocken, MIT Press, www.nand2tetris.org , Chapter 4: Machine Language slide 5
Lecture plan

◼ Machine languages at a glance

◼ The Hack machine language:

⚫ Symbolic version

⚫ Binary version

◼ Perspective

(The assembler will be covered in chapter 6).

Elements of Computing Systems, Nisan & Schocken, MIT Press, www.nand2tetris.org , Chapter 4: Machine Language slide 6
Typical machine language commands (3 types)

◼ ALU operations
◼ Memory access operations
(addressing mode: how to specify operands)
⚫ Immediate addressing, LDA R1, 67 // R1=67
⚫ Direct addressing, LD R1, 67 // R1=M[67]
⚫ Indirect addressing, LDI R1, R2 // R1=M[R2]
◼ Flow control operations

Elements of Computing Systems, Nisan & Schocken, MIT Press, www.nand2tetris.org , Chapter 4: Machine Language slide 7
Typical machine language commands (a small sample)

// In what follows R1,R2,R3 are registers, PC is program counter,

// and addr is some value.

ADD R1,R2,R3 // R1  R2 + R3

ADDI R1,R2,addr // R1  R2 + addr

AND R1,R1,R2 // R1  R1 and R2 (bit-wise)

JMP addr // PC  addr

JEQ R1,R2,addr // IF R1 == R2 THEN PC  addr ELSE PC++

LOAD R1, addr // R1  RAM[addr]

STORE R1, addr // RAM[addr]  R1

NOP // Do nothing

// Etc. – some 50-300 command variants

Elements of Computing Systems, Nisan & Schocken, MIT Press, www.nand2tetris.org , Chapter 4: Machine Language slide 8
The Hack computer
A 16-bit machine consisting of the following elements:

reset Screen
Computer

Keyboard

Elements of Computing Systems, Nisan & Schocken, MIT Press, www.nand2tetris.org , Chapter 4: Machine Language slide 9
The Hack computer

◼ The ROM is loaded with a Hack program

◼ The reset button is pushed
◼ The program starts running

Elements of Computing Systems, Nisan & Schocken, MIT Press, www.nand2tetris.org , Chapter 4: Machine Language slide 10
The Hack computer
A 16-bit machine consisting of the following elements:

inM

writeM
Instruction outM Data
instruction

CPU
Memory Memory
addressM
(ROM32K) (Memory)
pc

reset

Both memory chips are 16-bit wide and have 15-bit address space.

Elements of Computing Systems, Nisan & Schocken, MIT Press, www.nand2tetris.org , Chapter 4: Machine Language slide 11
The Hack computer (CPU)
A 16-bit machine consisting of the following elements:

ALU output

C C
C

D
D
C C
decode
outM

ALU
C
A
Mux

A
C
instruction A/M

Mux
M
inM
C writeM
A
addressM
C
reset

A
PC pc

Elements of Computing Systems, Nisan & Schocken, MIT Press, www.nand2tetris.org , Chapter 4: Machine Language slide 12
The Hack computer
A 16-bit machine consisting of the following elements:

Data memory: RAM – an addressable sequence of registers

Instruction memory: ROM – an addressable sequence of registers

Registers: D, A, M, where M stands for RAM[A]

Processing: ALU, capable of computing various functions

Program counter: PC, holding an address

Control: The ROM is loaded with a sequence of 16-bit instructions, one per memory
location, beginning at address 0. Fetch-execute cycle: later

Instruction set: Two instructions: A-instruction, C-instruction.

Elements of Computing Systems, Nisan & Schocken, MIT Press, www.nand2tetris.org , Chapter 4: Machine Language slide 13
The A-instruction

@value // A  value

Where value is either a number or a symbol referring to some number.

Why A-instruction?
In TOY, we store address in the instruction (fmt #2). But, it is impossible
to pack a 15-bit address into a 16-bit instruction. So, we have the A-
instruction for setting addresses if needed.

Example: @21

Effect:

◼ Sets the A register to 21

◼ RAM[21] becomes the selected RAM register M

Elements of Computing Systems, Nisan & Schocken, MIT Press, www.nand2tetris.org , Chapter 4: Machine Language slide 14
The A-instruction

@value // A  value

Used for: Coding example:

◼ Entering a constant value

( A = value) @17 // A = 17
D = A // D = 17

◼ Selecting a RAM location @17 // A = 17

( register = RAM[A]) D = M // D = RAM[17]
M = -1 // RAM[17]=-1

◼ Selecting a ROM location @17 // A = 17

( PC = A ) JMP // fetch the instruction
// stored in ROM[17]

Elements of Computing Systems, Nisan & Schocken, MIT Press, www.nand2tetris.org , Chapter 4: Machine Language slide 15
The C-instruction

dest = comp ; jump

Both dest and jump are optional.

First, we compute something.
Next, optionally, we can store the result, or use it to jump to somewhere to
continue the program execution.

comp:

0, 1, -1, D, A, !D, !A, -D, -A, D+1, A+1, D-1, A-1, D+A, D-A, A-D, D&A, D|A
M, !M, -M, M+1, M-1, D+M, D-M, M-D, D&M, D|M

dest: null, A, D, M, MD, AM, AD, AMD

Compare to zero. If the

jump: null, JGT, JEQ, JLT, JGE, JNE, JLE, JMP condition holds, jump to
ROM[A]
Elements of Computing Systems, Nisan & Schocken, MIT Press, www.nand2tetris.org , Chapter 4: Machine Language slide 16
The C-instruction

dest = comp ; jump

◼ Computes the value of comp

◼ Stores the result in dest
◼ If (the condition jump compares to zero is true), goto the instruction at
ROM[A].

Elements of Computing Systems, Nisan & Schocken, MIT Press, www.nand2tetris.org , Chapter 4: Machine Language slide 17
The C-instruction

dest = comp ; jump

comp:
0, 1, -1, D, A, !D, !A, -D, -A, D+1, A+1, D-1, A-1, D+A, D-A, A-D, D&A, D|A
M, !M, -M, M+1, M-1, D+M, D-M, M-D, D&M, D|M

dest: null, A, D, M, MD, AM, AD, AMD

jump: null, JGT, JEQ, JLT, JGE, JNE, JLE, JMP

Example: set the D register to -1

D = -1
Example: set RAM[300] to the value of the D register minus 1
@300
M = D-1
Example: if ((D-1) == 0) goto ROM[56]
@56
D-1; JEQ
Elements of Computing Systems, Nisan & Schocken, MIT Press, www.nand2tetris.org , Chapter 4: Machine Language slide 18
Hack programming reference card

Hack commands:
A-command: @value // set A to value
C-command: dest = comp ; jump // dest = and ;jump
// are optional
Where:
comp =
0 , 1 , -1 , D , A , !D , !A , -D , -A , D+1 , A+1 , D-1, A-1 , D+A , D-A , A-D , D&A , D|A,
M, !M , -M , M+1, M-1 , D+M, D-M, M-D, D&M, D|M
dest = M, D, A, MD, AM, AD, AMD, or null
jump = JGT , JEQ , JGE , JLT , JNE , JLE , JMP, or null
In the command dest = comp; jump, the jump materialzes if (comp
jump 0) is true. For example, in D=D+1,JLT, we jump if D+1 < 0.

Elements of Computing Systems, Nisan & Schocken, MIT Press, www.nand2tetris.org , Chapter 4: Machine Language slide 19
The Hack machine language

Two ways to express the same semantics:

◼Binary code (machine language)
◼Symbolic language (assembly)

symbolic binary
@17 0000 0000 0001 0001
translate
D+1; JLE 1110 0111 1100 0110

execute

hardware

Elements of Computing Systems, Nisan & Schocken, MIT Press, www.nand2tetris.org , Chapter 4: Machine Language slide 20
The A-instruction

symbolic binary
@value 0value
◼ value is a non-negative decimal ◼ value is a 15-bit binary number
number <= 215-1 or

◼ A symbol referring to such a

constant

Example

@21 0000 0000 0001 0101

Elements of Computing Systems, Nisan & Schocken, MIT Press, www.nand2tetris.org , Chapter 4: Machine Language slide 21
The C-instruction

symbolic binary
dest = comp ; jump 111A C1C2C3C4 C5C6 D1D2 D3J1J2J3

]
comp dest jump
not used
opcode

Elements of Computing Systems, Nisan & Schocken, MIT Press, www.nand2tetris.org , Chapter 4: Machine Language slide 22
The C-instruction
111A C1C2C3C4 C5C6 D1D2 D3J1J2J3

comp dest jump

Elements of Computing Systems, Nisan & Schocken, MIT Press, www.nand2tetris.org , Chapter 4: Machine Language slide 23
The C-instruction
111A C1C2C3C4 C5C6 D1D2 D3J1J2J3

comp dest jump

A D M

dest d d d effect: the value is stored in:

null 0 0 0 the value is not stored
M 0 0 1 RAM[A]
D 0 1 0 D register
DM 0 1 1 D register and RAM[A]
A 1 0 0 A register
AM 1 0 1 A register and RAM[A]
AD 1 1 0 A register and D register
ADM 1 1 1 A register, D register, and RAM[A]

Elements of Computing Systems, Nisan & Schocken, MIT Press, www.nand2tetris.org , Chapter 4: Machine Language slide 24
The C-instruction
111A C1C2C3C4 C5C6 D1D2 D3J1J2J3

comp dest jump

< = >
jump j j j effect:
null 0 0 0 no jump
JGT 0 0 1 if comp > 0 jump
JEQ 0 1 0 if comp = 0 jump
JGE 0 1 1 if comp ≥ 0 jump
JLT 1 0 0 if comp < 0 jump
JNE 1 0 1 if comp ≠ 0 jump
JLE 1 1 0 if comp ≤ 0 jump
JMP 1 1 1 Unconditional jump

Elements of Computing Systems, Nisan & Schocken, MIT Press, www.nand2tetris.org , Chapter 4: Machine Language slide 25
Hack assembly/machine language
Source code (example) Target code
// Computes 1+...+RAM[0] 0000000000010000
// And stored the sum in RAM[1] 1110111111001000
@i 0000000000010001
M=1 // i = 1 1110101010001000
@sum 0000000000010000
M=0 // sum = 0 1111110000010000
(LOOP) 0000000000000000
@i // if i>RAM[0] goto WRITE 1111010011010000
D=M 0000000000010010
@R0 1110001100000001
D=D-M 0000000000010000
@WRITE 1111110000010000
D;JGT assemble 0000000000010001
@i // sum += i 1111000010001000
D=M 0000000000010000
@sum Hack assembler 1111110111001000
M=D+M 0000000000000100
@i // i++ or CPU emulator 1110101010000111
M=M+1 0000000000010001
@LOOP // goto LOOP 1111110000010000
0;JMP 0000000000000001
(WRITE) 1110001100001000
@sum 0000000000010110
D=M 1110101010000111
@R1
M=D // RAM[1] = the sum
(END)
@END We will focus on writing the assembly code.
0;JMP

Elements of Computing Systems, Nisan & Schocken, MIT Press, www.nand2tetris.org , Chapter 4: Machine Language slide 26
Working with registers and memory

◼ D: data register
◼ A: address/data register
◼ M: the currently selected memory cell, M=RAM[A]

Data memory Instruction memory

0 0
1 1
2 2
... ...
RAM ROM

address out address out

M instruction
... ...
32766 32766
32767 32767

Address register Data register

A D

Elements of Computing Systems, Nisan & Schocken, MIT Press, www.nand2tetris.org , Chapter 4: Machine Language slide 27
Hack programming exercises

Exercise: Implement the following tasks

using Hack commands:

1. Set D to A-1

2. Set both A and D to A + 1

3. Set D to 19

4. D++

5. D=RAM[17]

6. Set RAM[5034] to D - 1

7. Set RAM[53] to 171

8. Add 1 to RAM[7],
and store the result in D.

Elements of Computing Systems, Nisan & Schocken, MIT Press, www.nand2tetris.org , Chapter 4: Machine Language slide 28
Hack programming exercises

Exercise: Implement the following tasks 1. D = A-1

using Hack commands:
2. AD=A+1
1. Set D to A-1 3. @19
D=A
2. Set both A and D to A + 1
4. D=D+1
3. Set D to 19 5. @17
D=M
4. D++
6. @5034
5. D=RAM[17] M=D-1
7. @171
6. Set RAM[5034] to D - 1
D=A
7. Set RAM[53] to 171 @53
M=D
8. Add 1 to RAM[7],
and store the result in D. 8. @7
D=M+1
Elements of Computing Systems, Nisan & Schocken, MIT Press, www.nand2tetris.org , Chapter 4: Machine Language slide 29
A simple program: add two numbers (demo)

Binary
Add.asm (example)
0000000000000000
// Computes: RAM[2] = RAM[0] + RAM[1]
1000010010001101
// D = RAM[0] 0000000000000001
@0 1010011001100001
D=M Load into the 0000000000000010 Execute
// D = D + RAM[1] CPU emulator 1110010010010011
@1
D=D+M
// RAM[2] = D
@2
M=D When loading a symbolic program
into the CPU emulator, the
emulator translates it into binary
code (using a built-in assembler)

Elements of Computing Systems, Nisan & Schocken, MIT Press, www.nand2tetris.org , Chapter 4: Machine Language slide 30
Terminate properly

◼ To avoid malicious code, you could terminate your program with an

infinite loop, such as

00: @0
@6
01: D=M
0; JMP 02: @1
03: D=D+M
04: @2
05: M=D

Elements of Computing Systems, Nisan & Schocken, MIT Press, www.nand2tetris.org , Chapter 4: Machine Language slide 31
Built-in symbols

symbol value symbol value

R0 0 SP 0
R1 1 LCL 1
R2 2 ARG 2
… … THIS 3
R15 15 THAT 4
SCREEN 16384
KBD 24576

◼ R0, R1, …, R15 : virtual registers

◼ SCREEN and KBD : base address of I/O memory maps
◼ Others: used in the implementation of the Hack Virtual Machine
◼ Note that Hack assembler is case-sensitive, R5 != r5

Elements of Computing Systems, Nisan & Schocken, MIT Press, www.nand2tetris.org , Chapter 4: Machine Language slide 32
Branching
// Program: branch.asm
// if R0>0
// R1=1
// else
// R1=0

Elements of Computing Systems, Nisan & Schocken, MIT Press, www.nand2tetris.org , Chapter 4: Machine Language slide 33
Branching
// Program: branch.asm
// if R0>0
// R1=1
// else
// R1=0

@R0
D=M // D=RAM[0]

@8
D; JGT // If R0>0 goto 8

@R1
M=0 // R1=0
@10
0; JMP // go to end

@R1
M=1 // R1=1

@10
0; JMP

Elements of Computing Systems, Nisan & Schocken, MIT Press, www.nand2tetris.org , Chapter 4: Machine Language slide 34
Branching
// Program: branch.asm
// if R0>0
// R1=1
// else
// R1=0

@R0
D=M // D=RAM[0]

@8
D; JGT // If R0>0 goto 8

@R1
M=0 // R1=0
@10
0; JMP // go to end

@R1
M=1 // R1=1

@10
0; JMP

Elements of Computing Systems, Nisan & Schocken, MIT Press, www.nand2tetris.org , Chapter 4: Machine Language slide 35
Branching with labels
// Program: branch.asm 0 @0
// if R0>0
// R1=1
1 D=M
// else 2 @8
// R1=0 3 D;JGT
4 @1
@R0 5 M=0
D=M // D=RAM[0] 6 @10
@POSTIVE refer a label 7
0;JMP
D; JGT // If R0>0 goto 8 8
@1
9
@R1 10 M=1
M=0 // R1=0
11 @10
@END
0; JMP // go to end 12 0; JMP
(POSTIVE)
declare a label 13
@R1
M=1 // R1=1
14
(END) 15
@10 16
0; JMP

Elements of Computing Systems, Nisan & Schocken, MIT Press, www.nand2tetris.org , Chapter 4: Machine Language slide 36
IF logic – Hack style

High level: Hack:

if condition { D  condition
code block 1 @IF_TRUE
} else { D;JEQ
code block 2
code block 2
}
@END
code block 3
0;JMP

Hack convention: (IF_TRUE)

code block 1
❑ True is represented by -1
(END)
❑ False is represented by 0 code block 3

Elements of Computing Systems, Nisan & Schocken, MIT Press, www.nand2tetris.org , Chapter 4: Machine Language slide 37
Coding examples (practice)

Exercise: Implement the following

tasks using Hack commands:

1. goto 50

2. if D==0 goto 112

3. if D<9 goto 507

4. if RAM[12] > 0 goto 50

5. if sum>0 goto END

6. if x[i]<=0 goto NEXT.

Elements of Computing Systems, Nisan & Schocken, MIT Press, www.nand2tetris.org , Chapter 4: Machine Language slide 38
Coding examples (practice)

Exercise: Implement the following

tasks using Hack commands:

1. goto 50 1. @50 5. @sum

0; JMP D=M
2. if D==0 goto 112
2. @112 @END
3. if D<9 goto 507 D; JEQ D: JGT
3. @9 6. @i
4. if RAM[12] > 0 goto 50 D=D-A D=M
@507 @x
if sum>0 goto END
A=D+M
5.
D; JLT
6. if x[i]<=0 goto NEXT. 4. @12 D=M
D=M @NEXT
@50 D; JLE
D; JGT

Elements of Computing Systems, Nisan & Schocken, MIT Press, www.nand2tetris.org , Chapter 4: Machine Language slide 39
variables
// Program: swap.asm
// temp = R1
// R1 = R0
// R0 = temp

Elements of Computing Systems, Nisan & Schocken, MIT Press, www.nand2tetris.org , Chapter 4: Machine Language slide 40
variables
// Program: swap.asm
// temp = R1 ◼ When a symbol is encountered,
// R1 = R0 the assembler looks up a symbol
// R0 = temp
table
@R1
◼ If it is a new label, assign a
D=M
@temp number (address of the next
M=D // temp = R1 available memory cell) to it.
@R0 ◼ For this example, temp is
D=M assigned with 16.
@R1
M=D // R1 = R0 ◼ If the symbol exists, replace it
with the number recorded in
@temp
D=M the table.
@R0
M=D // R0 = temp

(END) ◼ With symbols and labels, the

@END program is easier to read and
0;JMP debug. Also, it can be relocated.
Elements of Computing Systems, Nisan & Schocken, MIT Press, www.nand2tetris.org , Chapter 4: Machine Language slide 41
Hack program (exercise)
Exercise: Implement the following tasks
using Hack commands:

1. sum = 0

2. j = j + 1

3. q = sum + 12 – j

4. arr[3] = -1

5. arr[j] = 0

6. arr[j] = 17

Elements of Computing Systems, Nisan & Schocken, MIT Press, www.nand2tetris.org , Chapter 4: Machine Language slide 42
Hack program (exercise)
Exercise: Implement the following tasks
using Hack commands:
1. @sum 4. @arr 6. @j
1. sum = 0
M=0 D=M D=M
2. j = j + 1 2. @j @3 @arr
M=M+1 A=D+A D=D+M
3. q = sum + 12 – j
3. @sum M=-1 @ptr
4. arr[3] = -1 D=M 5. @j M=D
5. arr[j] = 0
@12 D=M @17
D=D+A @arr D=A
6. arr[j] = 17
@j A=D+M @ptr
D=D-M M=0 A=M
@q M=D
M=D

Elements of Computing Systems, Nisan & Schocken, MIT Press, www.nand2tetris.org , Chapter 4: Machine Language slide 43
WHILE logic – Hack style

High level: Hack:

while condition { (LOOP)

code block 1 D  condition
} @END
Code block 2
D;JNE
code block 1
@LOOP
0;JMP
Hack convention:
(END)
❑ True is represented by -1 code block 2

❑ False is represented by 0

Elements of Computing Systems, Nisan & Schocken, MIT Press, www.nand2tetris.org , Chapter 4: Machine Language slide 44
Complete program example
C language code:
// Adds 1+...+100.
int i = 1;
int sum = 0;
while (i <= 100){
sum += i;
i++;
}

Hack assembly convention:

❑ Variables: lower-case

❑ Labels: upper-case

❑ Commands: upper-case

Elements of Computing Systems, Nisan & Schocken, MIT Press, www.nand2tetris.org , Chapter 4: Machine Language slide 45
Complete program example
Pseudo code: Hack assembly code:

i = 1; // Adds 1+...+100.
sum = 0; @i // i refers to some RAM location
M=1 // i=1
LOOP:
@sum // sum refers to some RAM location
if (i>100) goto END
M=0 // sum=0
sum += i; (LOOP)
i++; @i
goto LOOP D=M // D = i
END: @100
D=D-A // D = i - 100
Hack assembly convention: @END
D;JGT // If (i-100) > 0 goto END
❑ Variables: lower-case @i
D=M // D = i
❑ Labels: upper-case @sum
M=D+M // sum += i
❑ Commands: upper-case @i
M=M+1 // i++
@LOOP
0;JMP // Got LOOP
Demo
(END)
CPU emulator
@END
0;JMP // Infinite loop
Elements of Computing Systems, Nisan & Schocken, MIT Press, www.nand2tetris.org , Chapter 4: Machine Language slide 46
Example
// for (i=0; i<n; i++) Pseudo code:
// arr[i] = -1;

Elements of Computing Systems, Nisan & Schocken, MIT Press, www.nand2tetris.org , Chapter 4: Machine Language slide 47
Example
// for (i=0; i<n; i++) Pseudo code:
// arr[i] = -1;
i = 0

(LOOP)
if (i-n)>=0 goto END
arr[i] = -1
i++
goto LOOP
(END)

Elements of Computing Systems, Nisan & Schocken, MIT Press, www.nand2tetris.org , Chapter 4: Machine Language slide 48
Example
// for (i=0; i<n; i++) Pseudo code:
// arr[i] = -1;
@i i = 0
M=0
(LOOP) (LOOP)
@i if (i-n)>=0 goto END
D=M arr[i] = -1
@n i++
D=D-M goto LOOP
@END (END)
D; JGE

@arr
D=M
@i
A=D+M
M=-1

@i
M=M+1

@LOOP
0; JMP
(END)
Elements of Computing Systems, Nisan & Schocken, MIT Press, www.nand2tetris.org , Chapter 4: Machine Language slide 49
Perspective

◼ Hack is a simple machine language

◼ User friendly syntax: D=D+A instead of ADD D,D,A

◼ Hack is a “½-address machine”: any operation that needs to operate on the

RAM must be specified using two commands: an A-command to address the
RAM, and a subsequent C-command to operate on it

◼ A Macro-language can be easily developed

⚫ D=D+M[XXX] => @XXX followed by D=D+M
⚫ GOTO YYY => @YYY followed by 0; JMP

◼ A Hack assembler is needed and will be discusses and developed later in

the course.

Elements of Computing Systems, Nisan & Schocken, MIT Press, www.nand2tetris.org , Chapter 4: Machine Language slide 50