Programming the basic computer

Programming The Basic
Computer

Introduction
• A computer system includes both hardware
and software. The designer should be familiar
with both of them.
• This chapter introduces some basic
programming concepts and shows their
relation to the hardware representation of
instructions.
• A program may be : dependent or
independent on the computer that runs it.

Instruction Set of the Basic Computer
Symbol Hex code Description
AND 0 or 8 AND M to AC
ADD 1 or 9 Add M to AC, carry to E
LDA 2 or A Load AC from M
STA 3 or B Store AC in M
BUN 4 or C Branch unconditionally to m
BSA 5 or D Save return address in m and branch to m+1
ISZ 6 or E Increment M and skip if zero
CLA 7800 Clear AC
CLE 7400 Clear E
CMA 7200 Complement AC
CME 7100 Complement E
CIR 7080 Circulate right E and AC
CIL 7040 Circulate left E and AC
INC 7020 Increment AC, carry to E
SPA 7010 Skip if AC is positive
SNA 7008 Skip if AC is negative
SZA 7004 Skip if AC is zero
SZE 7002 Skip if E is zero
HLT 7001 Halt computer
INP F800 Input information and clear flag
OUT F400 Output information and clear flag
SKI F200 Skip if input flag is on
SKO F100 Skip if output flag is on
ION F080 Turn interrupt on
IOF F040 Turn interrupt off

Machine Language
• Program: A list of instructions that direct the computer
to perform a data processing task.
• Many programming languages (C++, JAVA). However,
the computer executes programs when they are
represented internally in binary form.
• Binary code: a binary representation of instructions
and operands as they appear in computer memory.
• Octal or hexadecimal code: translation of binary code to
octal or hexadecimal representation.

Hierarchy of programming languages
• The user uses symbols (Letter, numerals, or special
characters) for the operation, address and other parts
of the instruction code (Symbolic code).
• symbolic code  binary coded instruction
• The translation is done by a special program called an
assembler
• High-level programming language:
C++ : used to write procedures to solve a problem or
implement a task.
• Assembly language: concerned with the computer
hardware behavior.

Binary/Hex Code
0 0010 0000 0000 0100
1 0001 0000 0000 0101
10 0011 0000 0000 0110
11 0111 0000 0000 0001
100 0000 0000 0101 0011
101 1111 1111 1110 1001
110 0000 0000 0000 0000
Binary code
Location Instruction Code
• Binary Program to Add Two Numbers:
•It is hard to understand the task of the program
 symbolic code
Location Instruction
000 2004
001 1005
002 3006
003 7001
004 0053
005 FFE9
006 0000
Hexadecimal code

Symbolic OP-Code
000 LDA 004 Load 1st operand into AC
001 ADD 005 Add 2nd operand to AC
002 STA 006 Store sum in location 006
003 HLT Halt computer
004 0053 1st operand
005 FFE9 2nd operand (negative)
006 0000 Store sum here
Location Instruction Comments
• Symbolic names of instructions instead of binary or
hexadecimal code.
• The address part of memory-reference and operands
 remain hexadecimal.
• Symbolic programs are easier to handle.

Assembly-Language Program
ORG 0 /Origin of program is location 0
LDA A /Load operand from location A
ADD B /Add operand from location B
STA C /Store sum in location C
HLT /Halt computer
A, DEC 83 /Decimal operand
B, DEC -23 /Decimal operand
C, DEC 0 /Sum stored in location C
END /End of symbolic program

Assembly Language
• Following the rules of the language  the
programs will be translated correctly.
• Almost every commercial computer has its
own particular assembly language.

Rules of the Language
• Each line of an assembly language program is
arranged in three columns called fields:
1- The Label field: May be empty or specify a
symbolic address.
2- The Instruction field: Specifies a machine instruction or
pseudo instruction.
3- The Comment field: May be empty or it may include a
comment.
– Example:
ORG Lab
Lab, ADD op1 / this is an add operation.
Label Instruction comment
Note that Lab is a symbolic address.

Cont’
• Symbolic address: Consists of one, two, or three
(maximum) alphanumeric characters.
• The first character must be a letter, the next two
may be letters or numerals.
• A symbolic address in the label field is
terminated by a comma so that it will be
recognized as a label by the assembler.
• Examples: Which of the following is a valid
symbolic address: r2 : Yes; Sum5: No
tmp : Yes.

Instruction field
• The instruction field contains:
1- Memory-Reference Instruction (MRI)
2- A register-reference or I/O instruction (non-
MRI)
3- A pseudo instruction with or without an
operand. Ex: ORG, DEC 83

1-Memory-Reference Inst.
• Occupies two or three symbols separated by
spaces.
• The first must be a three-letter symbol
defining an MRI operation code. (ADD)
• The second is a symbolic address.
Ex: ADD OPR direct address MRI
• The third (optional)-Letter I to denote an
indirect address instruction
Ex: ADD OPR I Indirect address MRI

Memory-Reference Inst. / cont.
• A symbolic address in the instruction field specifies
the memory location of the operand.
• This location MUST be defined somewhere in the
program by appearing again as a label in the first
column. Ex: LDA X1
X1, HEX 40
2-Non-Memory-Reference Inst.
• Does not have an address part.
• It is recognized in the instruction field by one of the
three-letter symbols (CLA, INC, CLE,..).

Pseudo instruction
• Not a machine instruction
• It is an instruction to the assembler giving
information about some phase of the
translation
Ex:
ORG N
Hexadecimal number N is the memory loc. for the instruction or
operand listed in the following line
END
Denotes the end of symbolic program
DEC N
Signed decimal number N to be converted to binary
HEX N
Hexadecimal number N to be converted to binary

Comment Field
• A line of code may or may not have a
comment. (Ex: STA A0 / storing at A0)
• A comment must be preceded by a slash for
the assembler to recognize the beginning of
the comment field.

Example:
• An assembly language program to subtract
two numbers
ORG 100
LDA SUB
CMA
INC
ADD MIN
STA DIF
HLT
DEC 83
DEC -23
HEX 0
END
Instruction
/ Origin of program is location 100
/ Load subtrahend to AC
/ Complement AC
/ Increment AC
/ Add minuend to AC
/ Store difference
/ Halt computer
/ Minuend
/ Subtrahend
/ Difference stored here
/ End of symbolic program
comment
MIN,
SUB,
DIF,
Label

TRANSLATION TO BINARY
ORG 100
LDA SUB
CMA
INC
ADD MIN
STA DIF
HLT
DEC 83
DEC -23
HEX 0
END
MIN,
SUB,
DIF,
100 2107
101 7200
102 7020
103 1106
104 3108
105 7001
106 0053
107 FFE9
108 0000
Symbolic Program
Location Content
Hexadecimal Code

Address Symbol Table
• The translation process can be simplified if we
scan the entire symbolic program twice.
• No translation is done during the first scan.
We just assign a memory location to each
instruction and operand.
• Such assignment defines the address value of
labels and facilitates the translation during the
second scan.

• ORG & END are not assigned a numerical
location because they do not represent an
instruction or operand.
Address symbol Hex Address
MIN 106
SUB 107
DIF 108

Example
LDA SUB
Address mode: direct  I=0
Instruction: LDA  010
Address : SUB  107
Instruction 0 010 107  2107

The Assembler
• An Assembler is a program that accepts a symbolic
language and produces its binary machine language
equivalent.
• The input symbolic program :Source program.
• The resulting binary program: Object program.
• Prior to assembly, the program must be stored in the
memory.
• A line of code is stored in consecutive memory
locations with two characters in each location. (each
character 8 bits) memory word 16 bits

Programming the basic computer

Example: storing the symbolic program in Memory
• PL3, LDA SUB I
• By referring to the ASCII code table, we get:
Memory
word
Symbol Hex code
1 P L 50 4C
2 3 , 33 2C
3 L D 4C 44
4 A 41 20
5 S U 53 55
6 B 42 20
7 I CR 49 0D

First Pass
• The assembler scans the symbolic program twice.
• First pass: generates an “Address Symbol Table”
that connects all user-defined address symbols
with their binary equivalent value.
• Second Pass: Binary translation

First Pass /cont.
• To keep track of instruction locations: the
assembler uses a memory word called a
location counter (LC).
• LC stores the value of the memory location
assigned to the instruction or operand
presently being processed.
• LC is initialized to the first location using the
ORG pseudo instruction. If there is no ORG
LC = 0.

Second Pass
• Machine instructions are translated in this
pass by means of a table lookup procedure.
• A search of table entries is performed to
determine whether a specific item matches
one of the items stored in the table.

Assembler Tables
• Four tables are used:
– Pseudoinstruction table. (ORG, DEC, HEX, END)
– MRI table. (7 symbols for memory reference and
3-bit opcode equivalent)
– Non-MRI table. (18 Reg. & I/O instruction and
16-bit binary code equivalent)
– Address symbol table. (Generated during first pass)

Second Pass/ cont.
Second pass
LC <- 0
Scan next line of code
Set LC
yes
yes
ORG
Pseudo
instr.
yes
END
no
Done
yes
MRI
no
Valid
non-MRI
instr.
no
Convert
operand
to binary
and store
in location
given by LC
no
DEC or
HEX
Error in
line of
code
Store binary
equivalent of
instruction
in location
given by LC
yes
no
Get operation code
and set bits 2-4
Search address-
symbol table for
binary equivalent
of symbol address
and set bits 5-16
I
Set
first
bit to 0
Set
first
bit to 1
yes no
Assemble all parts of
binary instruction and
store in location given by LC
Increment LC

Error Diagnostics
• One important task of the assembler is to
check for possible errors in the symbolic
program.
Example:
– Invalid machine code symbol.
– A symbolic address that did not appear as
a label.

Program Loops
• A sequence of instructions that are executed
many times, each time with a different set of
data.

Program Loops/ cont.
ORG 100
LDA ADS
STA PTR
LDA NBR
STA CTR
CLA
ADD PTR I
ISZ PTR
ISZ CTR
BUN LOP
STA SUM
HLT
HEX 150
HEX 0
DEC -100
HEX 0
HEX 0
ORG 150
DEC 75
.
.
DEC 23
END
/ Origin of program is HEX 100
/ Load first address of operand
/ Store in pointer
/ Load -100
/ Store in counter
/ Clear AC
/ Add an operand to AC
/ Increment pointer
/ Increment counter
/ Repeat loop again
/ Store sum
/ Halt
/ First address of operands
/ Reserved for a pointer
/ Initial value for a counter
/ Reserved for a counter
/ Sum is stored here
/ Origin of operands is HEX 150
/ First operand
/ Last operand
/ End of symbolic program
LOP,
ADS,
PTR,
NBR,
CTR,
SUM,

Programming Arithmetic & Logic
Operations
• Software Implementation
- Implementation of an operation with a program
using machine instruction set
- Usually used: when the operation is not included
in the instruction set
• Hardware Implementation
- Implementation of an operation in a computer
with one machine instruction

Multiplication
• We will develop a program to multiply two
numbers.
• Assume positive numbers and neglect the sign
bit for simplicity.
• Also, assume that the two numbers have no
more than 8 significant bits  16-bit product.

Multiplication / cont.
Example with four significant digits
0000 1111
0000 1011 0000 0000
0000 1111 0000 1111
0001 1110 0010 1101
0000 0000 0010 1101
0111 1000 1010 0101
1010 0101
X =
Y = X holds the multiplicand
Y holds the multiplier
P holds the product
P

cil
CTR  - 8
P  0
E  0
AC  Y
Y  AC
cir EAC
E
P  P + X
E  0
AC  X
cil EAC
X  AC
CTR  CTR + 1
=1
=0
CTR
=0
Stop
 0
Example with four significant digits
0000 1111
0000 1011 0000 0000
0000 1111 0000 1111
0001 1110 0010 1101
0000 0000 0010 1101
0111 1000 1010 0101
1010 0101
X =
Y = X holds the multiplicand
Y holds the multiplier
P holds the product
P

ORG 100
CLE
LDA Y
CIR
STA Y
SZE
BUN ONE
BUN ZRO
LDA X
ADD P
STA P
CLE
LDA X
CIL
STA X
ISZ CTR
BUN LOP
HLT
DEC -8
HEX 000F
HEX 000B
HEX 0
END
/ Clear E
/ Load multiplier
/ Transfer multiplier bit to E
/ Store shifted multiplier
/ Check if bit is zero
/ Bit is one; goto ONE
/ Bit is zero; goto ZRO
/ Load multiplicand
/ Add to partial product
/ Store partial product
/ Clear E
/ Load multiplicand
/ Shift left
/ Store shifted multiplicand
/ Increment counter
/ Counter not zero; repeat loop
/ Counter is zero; halt
/ This location serves as a counter
/ Multiplicand stored here
/ Multiplier stored here
/ Product formed here
LOP,
ONE,
ZRO,
CTR,
X,
Y,
P,

Double Precision Addition
• When two 16-bit unsigned numbers are multiplied,
the result is a 32-bit product that must be stored in
two memory words.
• A number stored in two memory words is said to
have double precision.
• When a partial product is computed, it is necessary
to add a double-precision number to the shifted
multiplicand, which is also double-precision.
• This provides better accuracy

Double Precision Addition / cont.
• One of the double precision numbers is stored in two
consecutive memory locations, AL & AH. The other
number is placed in BL & BH.
• The two low-order portions are added and the carry
is transferred to E. The AC is cleared and E is
circulated into the LSB of AC.
• The two high-order portions are added and the sum
is stored in CL & CH.

Double Precision Addition / cont.
LDA AL
ADD BL
STA CL
CLA
CIL
ADD AH
ADD BH
STA CH
HLT
AL, _____
AH, _____
BL, _____
BH, _____
CL, _____
CH, _____
/ Load A low
/ Add B low, carry in E
/ Store in C low
/ Clear AC
/ Circulate to bring carry into AC(16)
/ Add A high and carry
/ Add B high
/ Store in C high
/ Location of operands

Logic Operations
• All 16 logic operations can be implemented using
the AND & complement operations.
• Example: OR : x + y = (x’.y’)’ Demorgan’s Law
/ Load 1st operand
/ Complement to get A’
/ Store in a temporary location
/ Load 2nd operand B
/ Complement to get B’
/ AND with A’ to get A’ AND B’
/ Complement again to get A OR B
LDA A
CMA
STA TMP
LDA B
CMA
AND TMP
CMA

Shift Operations
• The circular shift operations are machine
instructions in the basic computer.
• Logical and Arithmetic shifts can be
programmed with a small number of
instructions.

Logical Shift Operations
• Logical shift right
CLE
CIR
• Logical shift left
CLE
CIL

Arithmetic Shift Operations
• Arithmetic shift right: it is necessary that the sign bit in
the leftmost position remain unchanged. But the sign bit
itself is shifted into the high-order bit position of the
number.
CLE / Clear E to 0
SPA / Skip if AC is positive, E remains 0
CME / AC is negative, set E to 1
CIR / Circulate E and AC

Arithmetic Shift Operations /cont.
• Arithmetic shift left: it is necessary that the
added bit in the LSB be 0.
CLE
CIL
• The sign bit must not change during this shift.
• With a circulate instruction, the sign bit moves
into E.

Arithmetic Shift Operations /cont.
• The sign bit has to be compared with E after
the operation to detect overflow.
• If the two values are equal  No overflow.
• If the two values are not equal  Overflow.

Subroutines
• The same piece of code might be written again in
many different parts of a program.
• Write the common code only once.
• Subroutines :A set of common instructions that
can be used in a program many times
• Each time a subroutine is used in the main
program, a branch is made to the beginning of
the subroutine. The branch can be made from
any part of the main program.

Subroutines /cont.
• After executing the subroutine, a branch is
made back to the main program.
• It is necessary to store the return address
somewhere in the computer for the
subroutine to know where to return.
• In the basic computer, the link between the
main program and a subroutine is the BSA
instruction.

Subroutines example- (CIL 4 times)
ORG 100
LDA X
BSA SH4
STA X
LDA Y
BSA SH4
STA Y
HLT
HEX 1234
HEX 4321
HEX 0
CIL
CIL
CIL
CIL
AND MSK
BUN SH4 I
HEX FFF0
END
/ Main program
/ Load X
/ Branch to subroutine
/ Store shifted number
/ Load Y
/ Branch to subroutine again
/ Store shifted number
/ Subroutine to shift left 4 times
/ Store return address here
/ Circulate left once
/ Circulate left fourth time
/ Set AC(13-16) to zero
/ Return to main program
/ Mask operand
X,
Y,
SH4,
MSK,
100
101
102
103
104
105
106
107
108
109
10A
10B
10C
10D
10E
10F
110
Loc.

Subroutines /cont.
• The first memory location of each subroutine
serves as a link between the main program and
the subroutine.
• The procedure for branching to a subroutine and
returning to the main program is referred to as a
subroutine linkage.
• The BSA instruction performs the call.
• The BUN instruction performs the return.

Subroutine Parameters and Data Linkage
• When a subroutine is called, the main
program must transfer the data it wishes the
subroutine to work with.
• It is necessary for the subroutine to have
access to data from the calling program and to
return results to that program.
• The accumulator can be used for a single input
parameter and a single output parameter.

/cont.
• In computers with multiple processor registers, more
parameters can be transferred this way.
• Another way to transfer data to a subroutine is
through the memory.
• Data are often placed in memory locations following
the call.

Parameter Linkage(OR-ING)
ORG 200
LDA X
BSA OR
HEX 3AF6
STA Y
HLT
HEX 7B95
HEX 0
HEX 0
CMA
STA TMP
LDA OR I
CMA
AND TMP
CMA
ISZ OR
BUN OR I
HEX 0
END
/ Load 1st operand into AC
/ Branch to subroutine OR
/ 2nd operand stored here
/ Subroutine returns here
/ 1st operand stored here
/ Result stored here
/ Subroutine OR
/ Complement 1st operand
/ Store in temporary location
/ Load 2nd operand
/ Complement 2nd operand
/ AND complemented 1st operand
/ Complement again to get OR
/ Increment return address
/ Temporary storage
X,
Y,
OR,
TMP,
200
201
202
203
204
205
206
207
208
209
20A
20B
20C
20D
20E
20F
210
Loc.

/cont.
• It is possible to have more than one operand
following the BSA instruction.
• The subroutine must increment the return
address stored in its first location for each
operand that it extracts from the calling
program.

Data Transfer
• If there is a large amount of data to be
transferred, the data can be placed in a block
of storage and the address of the first item in
the block is then used as the linking
parameter.

Data transfer
BSA MVE
HEX 100
HEX 200
DEC -16
HLT
HEX 0
LDA MVE I
STA PT1
ISZ MVE
LDA MVE I
STA PT2
ISZ MVE
LDA MVE I
STA CTR
ISZ MVE
LDA PT1 I
STA PT2 I
ISZ PT1
ISZ PT2
ISZ CTR
BUN LOP
BUN MVE I
--
--
--
/ Main program
/ Branch to subroutine
/ 1st address of source data
/ 1st address of destination data
/ Number of items to move
/ Subroutine MVE
/ Bring address of source
/ Store in 1st pointer
/ Bring address of destination
/ Store in 2nd pointer
/ Bring number of items
/ Store in counter
/ Load source item
/ Store in destination
/ Increment source pointer
/ Increment destination pointer
/ Increment counter
/ Repeat 16 times
MVE,
LOP,
PT1,
PT2,
CTR,

Input-Output Programming
• Users of the computer write programs with
symbols that are defined by the programming
language used.
• The symbols are strings of characters and each
character is assigned an 8-bit code so that it
can be stored in a computer memory.

Input-Output Programming /cont.
• A binary coded character enters the computer
when an INP instruction is executed.
• A binary coded character is transferred to the
output device when an OUT instruction is
executed.

Character Input
Program to Input one Character(Byte)
SKI
BUN CIF
INP
OUT
STA CHR
HLT
--
/ Check input flag
/ Flag=0, branch to check again
/ Flag=1, input character
/ Display to ensure correctness
/ Store character
/ Store character here
CIF,
CHR,

Character Output
LDA CHR
SKO
BUN COF
OUT
HLT
HEX 0057
/ Load character into AC
/ Check output flag
/ Flag=0, branch to check again
/ Flag=1, output character
/ Character is "W"
COF,
CHR,
Program to Output a Character

Character Manipulation
• The binary coded characters that represent
symbols can be manipulated by computer
instructions to achieve various data-
processing tasks.
• One such task may be to pack two characters
in one word.
• This is convenient because each character
occupies 8 bits and a memory word contains
16 bits.

--
SKI
BUN FST
INP
OUT
BSA SH4
BSA SH4
SKI
BUN SCD
INP
OUT
BUN IN2 I
/ Subroutine entry
/ Input 1st character
/ Logical Shift left 4 bits
/ 4 more bits
/ Input 2nd character
/ Return
IN2,
FST,
SCD,
Subroutine to Input 2 Characters and pack into a word

Buffer
• The symbolic program is stored in a section of the
memory called the buffer.
• A buffer is a set of consecutive memory locations
that stores data entered via the input device. Ex:
store input characteres in a buffer
LDA ADS
STA PTR
BSA IN2
STA PTR I
ISZ PTR
BUN LOP
HLT
HEX 500
HEX 0
/ Load first address of buffer
/ Initialize pointer
/Go to subroutine IN2
/ Store double character word in buffer
/ Increment pointer
/ Branch to input more characters
/ First address of buffer
/ Location for pointer
LOP,
ADS,
PTR,

Table lookup
• A two pass assembler performs the table lookup in
the second pass.
• This is an operation that searches a table to find out
if it contains a given symbol.
• The search may be done by comparing the given
symbol with each of the symbols stored in the table.

Table lookup /cont.
• The search terminates when a match occurs or
if none of the symbols match.
• The comparison is done by forming the 2’s
complement of a word and arithmetically
adding it to the second word.
• If the result is zero, the two words are equal
and a match occurs. Else, the words are not
the same.

Table Lookup / cont.
LDA WD1
CMA
INC
ADD WD2
SZA
BUN UEQ
BUN EQL
---
---
/ Load first word
/ Form 2’s complement
/ Add second word
/ Skip if AC is zero
/ Branch to “unequal” routine
/ Branch to “equal” routine
WD1,
WD2,
Comparing two words:

Program Interrupt
• The running time of input and output programs
is made up primarily of the time spent by the
computer in waiting for the external device to set
its flag.
• The wait loop that checks the flags wastes a large
amount of time.
• Use interrupt facility to notify the computer
when a flag is set  eliminates waiting time.

Program Interrupt /cont.
• Data transfer starts upon request from the
external device.
• Only one program can be executed at any
given time.
• Running program: is the program currently
being executed
• The interrupt facility allows the running
program to proceed until the input or output
device sets its ready flag

Program Interrupt /cont.
• When a flag is set to 1: the computer completes
the execution of the instruction in progress and
then acknowledges the interrupt.
• The return address is stored in location 0.
• The instruction in location 1 is performed: this
initiates a service routine for the input or output
transfer.
• The service routine can be stored anywhere in
memory provided a branch to the start of the
routine is stored in location 1.

Service Routine
• Must have instructions to perform:
– Save contents of processor registers.
– Check which flag is set.
– Service the device whose flag is set.
– Restore contents of processor registers
– Turn the interrupt facility on.
– Return to the running program.

Service Routine /cont.
• The contents of processor registers before and
after the interrupt must be the same.
• Since the registers may be used by the service
routine, it is necessary to save their contents
at the beginning of the routine and restore
them at the end.

• The sequence by which flags are checked
dictates the priority assigned to each device.
• The device with higher priority is serviced
first.
• Even though two or more flags may be set at
the same time, the devices are serviced on at
a time.

• The occurrence of an interrupt disables the facility
from further interrupts.
• The service routine must turn the interrupt on before
the return to the running program.
• The interrupt facility should not be turned on until
after the return address is inserted into the program
counter.

Interrupt Service Program
-
BUN SRV
CLA
ION
LDA X
ADD Y
STA Z
STA SAC
CIL
STA SE
SKI
BUN NXT
INP
OUT
STA PT1 I
ISZ PT1
SKO
BUN EXT
LDA PT2 I
OUT
ISZ PT2
LDA SE
CIR
LDA SAC
ION
BUN ZRO I
-
-
-
-
/ Return address stored here
/ Branch to service routine
/ Portion of running program
/ Turn on interrupt facility
/ Interrupt occurs here
/ Program returns here after interrupt
/ Interrupt service routine
/ Store content of AC
/ Move E into AC(1)
/ Store content of E
/ Check input flag
/ Flag is off, check next flag
/ Flag is on, input character
/ Print character
/ Store it in input buffer
/ Increment input pointer
/ Check output flag
/ Flag is off, exit
/ Load character from output buffer
/ Output character
/ Increment output pointer
/ Restore value of AC(1)
/ Shift it to E
/ Restore content of AC
/ Turn interrupt on
/ Return to running program
/ AC is stored here
/ E is stored here
/ Pointer of input buffer
/ Pointer of output buffer
ZRO,
SRV,
NXT,
EXT,
SAC,
SE,
PT1,
PT2,
0
1
100
101
102
103
104
200
Loc.

Programming the basic computer

More Related Content

What's hot (20)

Similar to Programming the basic computer (20)

More from Kamal Acharya (20)

Recently uploaded (20)

Programming the basic computer