Q]Draw flag register of 8086 and explain any four flags.
Conditional /Status Flags
C-Carry Flag : It is set when carry/borrow is generated out of MSB of result.
(i.e D7 bit for 8-bit operation, D15 bit for a 16 bit operation).
P-Parity Flag: This flag is set to 1 if the lower byte of the result contains even
number of 1’s otherwise it is reset.
AC-Auxiliary Carry Flag: This is set if a carry is generated out of the lower
nibble, (i.e. From D3 to D4 bit)to the higher nibble
Z-Zero Flag: This flag is set if the result is zero after performing ALU
operations. Otherwise it is reset.
S-Sign Flag: This flag is set if the MSB of the result is equal to 1 after
performing ALU operation , otherwise it is reset.
O-Overflow Flag: This flag is set if an overflow occurs, i.e. if the result of a
signed operation is large enough to be accommodated in destination register.
Control Flags
T-Trap Flag: If this flag is set ,the processor enters the single step execution
mode.
I-Interrupt Flag: it is used to mask(disable) or unmask(enable)the INTR
interrupt. When this flag is set,8086 recognizes interrupt INTR. When it is reset
INTR is masked.
D-Direction Flag: It selects either increment or decrement mode for DI &/or SI
register during string instructions
Q]Explain assembly language program development steps. 4M
1. Defining the problem: The first step in writing program is to think very
carefully about the problem that the program must solve.
2. Algorithm: The formula or sequence of operations to be performed by the
program can be specified as a step in general English is called algorithm.
3. Flowchart: The flowchart is a graphically representation of the program
operation or task.
4. Initialization checklist: Initialization task is to make the checklist of entire
variables, constants, all the registers, flags and programmable ports
5. Choosing instructions: Choose those instructions that make program smaller
in size and more importantly efficient in execution.
6. Converting algorithms to assembly language program: Every step in the
algorithm is converted into program statement using correct and efficient
instructions or group of instructions.
Q]Explain logical instructions of 8086.(Any Four) 4M
1) AND- Logical AND
Syntax : AND destination, source
Operation:Destination ←destination AND source
Flags Affected :CF=0,OF=0,PF,SF,ZF
This instruction AND’s each bit in a source byte or word with the same number
bit in a destination byte or word. The result is put in destination.
Example: AND AX, BX
• AND AL,BL
• AL 1111 1100
• BL 0000 0011
---------------------
• AL0000 0000 (AND AL,BL)
2) OR – Logical OR
Syntax :OR destination, source
Operation:Destination OR source
Flags Affected :CF=0,OF=0,PF,SF,ZF
This instruction OR’s each bit in a source byte or word with the corresponding
bit in a destination byte or word. The result is put in a specified destination.
Example :
• OR AL,BL
• AL 1111 1100
• BL 0000 0011
---------------------
• AL1111 1111
3) NOT – Logical Invert
Syntax : NOT destination
Operation: Destination NOT destination
Flags Affected :None
The NOT instruction inverts each bit of the byte or words at the specified
destination.
Example
NOT BL
BL = 0000 0011
NOT BL gives 1111 1100
4) XOR – Logical Exclusive OR
Syntax : XOR destination, source
Operation : Destination Destination XOR source
Flags Affected :CF=0,OF=0,PF,SF,ZF
This instruction exclusive, OR’s each bit in a source byte or word with the
same number bit in a destination byte or word.
Q]What is pipelining? How it improves the processing speed.
In 8086, pipelining is the technique of overlapping instruction fetch and
execution mechanism.
To speed up program execution, the BIU fetches as many as six instruction
bytes ahead of time from memory. The size of instruction prefetching queue in
8086 is 6 bytes.
While executing one instruction other instruction can be fetched. Thus it
avoids the waiting time for execution unit to receive other instruction.
BIU stores the fetched instructions in a 6 level deep FIFO . The BIU can be
fetching instructions bytes while the EU is decoding an instruction or executing
an instruction which does not require use of the buses.
When the EU is ready for its next instruction, it simply reads the instruction
from the queue in the BIU.
This is much faster than sending out an address to the system memory and
waiting for memory to send back the next instruction byte or bytes.
This improves overall speed of the processor
Advantages of pipelining:
The execution unit always reads the next instruction byte from the
queue in BIU. This is faster than sending out an address to the memory
and waiting for the next instruction byte to come.
More efficient use of processor.
Quicker time of execution of large number of instruction.
Q]Define logical and effective address. Describe physical address
generation process in 8086.
A logical address is the address at which an item (memory cell, storage element)
appears to reside from the perspective of an executing application program. A
logical address may be different from the physical address due to the operation
of an address translator or mapping function.
Effective Address or Offset Address: The offset for a memory operand is
called the operand's effective address or EA. It is an unassigned 16 bit number
that expresses the operand's distance in bytes from the beginning of the segment
in which it resides. In 8086 we have base registers and index registers.
Generation of 20 bit physical address in 8086:-
1. Segment registers carry 16 bit data, which is also known as base address.
2. BIU appends four 0 bits to LSB of the base address. This address becomes
20-bit address.
3. Any base/pointer or index register carries 16 bit offset.
4. Offset address is added into 20-bit base address which finally forms 20 bit
physical address of memory location
Q]Explain the use of assembler directives. 1) DW 2) EQU 3) ASSUME 4)
OFFSET 5) SEGMENT 6) EVEN
DW (DEFINE WORD)
The DW directive is used to tell the assembler to define a variable of type word
or to reserve storage locations of type word in memory. The statement
MULTIPLIER DW 437AH, for example, declares a variable of type word
named MULTIPLIER, and initialized with the value 437AH when the program
is loaded into memory to be run.
EQU (EQUATE):EQU is used to give a name to some value or symbol. Each
time the assembler finds the given name in the program, it replaces the name
with the value or symbol you equated with that name.
Example
Data SEGMENT
Num1 EQU 50H
Num2 EQU 66H
Data ENDS
Numeric value 50H and 66H are assigned to Num1 and Num2.
ASSUME
ASSUME tells the assembler what names have been chosen for Code, Data
Extra and Stack segments. Informs the assembler that the register CS is to be
initialized with the address allotted by the loader to the label CODE and DS is
similarly initialized with the address of label DATA.
OFFSET
OFFSET is an operator, which tells the assembler to determine the offset or
displacement of a named data item (variable), a procedure from the start of the
segment, which contains it.
Example
MOV BX;
OFFSET PRICES;
It will determine the offset of the variable PRICES from the start of the segment
in which PRICES is defined and will load this value into BX.
SEGMENT
The SEGMENT directive is used to indicate the start of a logical segment.
Preceding the SEGMENT directive is the name you want to give the segment.
For example, the statement CODE SEGMENT indicates to the assembler
the start of a logical segment called CODE. The SEGMENT and ENDS
directive are used to “bracket” a logical segment containing code of data
EVEN (ALIGN ON EVEN MEMORY ADDRESS):As an assembler
assembles a section of data declaration or instruction statements, it uses a
location counter to keep track of how many bytes it is from the start of a
segment at any time. The EVEN directive tells the assembler to increment the
location counter to the next even address, if it is not already at an even address.
A NOP instruction will be inserted in the location incremented over.
Q]Describe any 6 addressing modes of 8086 with one example each. 6M
1. Immediate addressing mode: An instruction in which 8-bit or 16-bit
operand (data) is specified in the instruction, then the addressing mode of such
instruction is known as Immediate addressing mode.
Example:
MOV AX,67D3H
2. Register addressing mode:An instruction in which an operand (data) is
specified in general purposeregisters, then the addressing mode is known as
register addressing mode.
Example:
MOV AX,CX
3. Direct addressing mode:An instruction in which 16 bit effective address of
an operand is specified in the instruction, then the addressing mode of such
instruction is known as direct addressing mode.
Example:
MOV CL,[2000H]
4. Register Indirect addressing mode :An instruction in which address of an
operand is specified in pointer register
or in index register or in BX, then the addressing mode is known as register
indirect addressing mode.
Example:
MOV AX, [BX]
5. Indexed addressing mode:An instruction in which the offset address of an
operand is stored in index registers (SI or DI) then the addressing mode of such
instruction is known as indexed addressing mode.
DS is the default segment for SI and DI.
For string instructions DS and ES are the default segments for SI and DI resp.
this is a special case of register indirect addressing mode.
Example:
MOV AX,[SI]
6. Based Indexed addressing mode::An instruction in which the address of an
operand is obtained by adding the content of base register (BX or BP) to the
content of an index register (SI or DI) The default segment register may be DS
or ES
Example:
MOV AX, [BX][SI]
7. Register relative addressing mode: An instruction in which the address
of the operand is obtained by adding the displacement (8-bit or 16 bit) with
the contents of base registers or index registers (BX, BP, SI, DI). The default
segment register is DS or ES.
Example:
MOV AX, 50H[BX]
Q]Illustrate the use of any three branching instructions. 6 M
BRANCH INSTRUCTIONS
Branch instruction transfers the flow of execution of the program to a new
address specified in the instruction directly or indirectly. When this type of
instruction is executed, the CS and IP registers get loaded with new values of
CS and IP corresponding to the location to be transferred.
Unconditional Branch Instructions :
1. CALL : Unconditional Call
The CALL instruction is used to transfer execution to a subprogram or
procedure by storing return address on stack There are two types ofcallsNEAR
(Inter-segment) and FAR(Intra-segment call). Near call refers to a procedure
call which is in the same code segment as the call instruction and far call refers
to a procedure call which is in different code segment from that of
the call instruction.
Syntax: CALL procedure_name
2. RET: Return from the Procedure.
At the end of the procedure, the RET instruction must be executed. When it is
executed, the previously stored content of IP and CS along with Flags are
retrieved into the CS, IP and Flag registers from the stack and execution of the
main program continues further.
Syntax :RET
3. JMP: Unconditional Jump
This instruction unconditionally transfers the control of execution to the
specified address using an 8-bit or 16-bit displacement. No Flags are affected by
this instruction.
Syntax : JMP Label
4. IRET: Return from ISR
When it is executed, the values of IP, CS and Flags are retrieved from the stack
to continue the execution of the main program.
Syntax: IRET
Q]Explain memory segmentation in 8086 and list its advantages.(any two)
Memory Segmentation:
In 8086 available memory space is 1MByte.
This memory is divided into different logical segments and each segment has
its own base address and size of 64 KB.
It can be addressed by one of the segment registers.
There are four segments.
Advantages of Segmentation:
The size of address bus of 8086 is 20 and is able to address 1 Mbytes ( ) of
physical memory.
The compete 1 Mbytes memory can be divided into 16 segments, each of 64
Kbytes size.
It allows memory addressing capability to be 1 MB.
The offset values are from 00000H to FFFFFH
Q]With neat sketches demonstrate the use of re-entrant and recursive
procedure.
Reentrant Procedure:
A reentrant procedure is one in which a single copy of the program code can be
shared by multiple users during the same period of time. Re-entrance has two
key aspects: The program code cannot modify itself and the local data for each
user must be stored separately.
Recursive procedures:
An active procedure that is invoked from within itself or from within another
active procedure is a recursive procedure. Such an invocation is called
recursion. A procedure that is invoked recursively must have the RECURSIVE
attribute specified in the PROCEDURE statement.
Q]Describe register organization of 8086 microprocessor. 4 M
Register Organization of 8086
1. AX (Accumulator) - Accumulator register consists of two 8-bit registers AL
and AH, which can be combined together and used as a 16- bit register AX. AL
in this case contains the low-order byte of the word, and AH contains the high-
order byte. Accumulator can be used for I/O operations, rotate and string
manipulation.
2. BX –This register is mainly used as a base register. It holds the starting base
location of a memory region within a data segment. It is used as offset storage
forforming physical address in case of certain addressing mode.
3. CX – It is used as default counter or count register in case of string and loop
instructions.
4. DX – Data register can be used as a port number in I/O operations and
implicitoperand or destination in case of few instructions. In integer 32-bit
multiply and divideinstruction the DX register contains high-order word of the
initial or resulting number.
5. CS – Code Segment – holds base address for all executable instructions in a
program
Q]Describe mechanism for generation of physical address in 8086 with
suitable example.
Fig.: Mechanism used to calculate physical address in 8086
As all registers in 8086 are of 16 bit and the physical address will be in 20 bits.
For this reason the above mechanism is helpful.
Logical Address is specified as segment: offset
Physical address is obtained by shifting the segment address 4 bits to the left
and adding the offset address.
Thus the physical address of the logical address A4FB:4872 is:
A4FB0
+ 4872
---------------
A9822
Q]What are the functions of CALL and RET instructions? Describe in
brief.
CALL Instruction: It is used to transfer program control to the sub-program or
subroutine. The CALL can be NEAR, where the procedure is in the same
segment whereas in FAR CALL, procedure is in a different segment.
Syntax: CALL procedure name (direct/indirect)
Operation: Steps executed during CALL
Example:
1) For Near CALL
SP ←SP - 2
Save IP on stack
IP address of procedure
2) For Far call
SP ← SP-2
Save CS on stack
CS New segment base containing procedure
SP←SP-2
Save IP on stack
IP Starting address of called procedure
RET instruction: it is used to transfer program execution control from a
procedure to the next instruction immediate after the CALL instruction in the
calling program.
Syntax: RET
Operation: Steps executed during RET
Example:
1) For Near Return
IP Content from top of stack
SP ←SP + 2
2) For Far Return
IP Contents from top of stack
SP ←SP+2
CS Contents of top of stack
SP←SP+2
Q]Addition of two 16 bit numbers
data segment
num1 dw 1111h
num2 dw 2222h
sum dw ?
data endS
code segment
assume cs:code,ds:data
start:
mov ax,data
mov ds,ax
mov ax,num1
mov bx,num2
add ax,bx
mov sum,ax
mov ah,4ch
int 21h
code ends
end start
Q]Write an ALP to find length of string. 4M
Data Segment
STRG DB 'GOOD MORNING$'
LEN DB ?
DATA ENDS
CODE SEGMENT
START:
ASSUME CS: CODE, DS : DATA
MOV DX, DATA
MOV DS,DX
LEA SI, STRG
MOV CL,00H
MOV AL,'$'
NEXT: CMP AL,[SI]
JZ EXIT
ADD CL,01H
INC SI
JMP
NEXT EXIT: MOV LEN,CL
MOV AH,4CH
INT 21H
CODE ENDS
Q]Write an ALP to count no.of 0’s in 16 bit number. 4M
DATA SEGMENT
N DB 1237H
Z DB 0
DATA ENDS
CODE SEGMENT
ASSUME DS:DATA, CS:CODE
START:
MOV DX,DATA
MOV DS,DX
MOV AX, N
MOV CL,08
NEXT: ROL AX,01
JC ONE
INC Z
ONE: LOOP NEXT
HLT
CODE ENDS
END START
Q]Write an ALP to find largest number in array of elements 10H, 24H,
02H, 05H, 17H.
DATA SEGMENT
ARRAY DB 10H,24H,02H,05H,17H
LARGEST DB 00H
DATA ENDS
CODE SEGMENT
START:
ASSUME CS:CODE,DS:DATA
MOV DX,DATA
MOV DS,DX
MOV CX,04H
MOV SI ,OFFSET
ARRAY MOV AL,[SI]
UP: INC SI
CMP AL,[SI]
JNC NEXT
MOV AL,[SI]
NEXT: DEC CX
JNZ UP
MOV LARGEST,AL
MOV AX,4C00H
INT 21H
CODE ENDS
END START
Q]Write an ALP for addition of series of 8-bit number using procedure.
DATA SEGMENT
NUM1 DB 10H,20H,30H,40H,50H
RESULT DB 0H
CARRY DB 0H
DATA ENDS
CODE SEGMENT
ASSUME CS:CODE, DS:DATA
START: MOV DX,DATA
MOV DS, DX
MOV CL,05H
MOV SI, OFFSET NUM1
UP: CALL SUM
INC SI
LOOP UP
MOV AH,4CH
INT 21H
SUM PROC;
MOV AL,[SI]
ADD RESULT, AL
JNC NEXT
INC CARRY
NEXT: RET
SUM ENDP
CODE ENDS
END START
Q]Write an ALP to arrange numbers in array in descending order. 6 M
DATA SEGMENT
ARRAY DB 15H,05H,08H,78H,56H
DATA ENDS
CODE SEGMENT
START:ASSUME CS:CODE,DS:DATA
MOV DX,DATA
MOV DS,DX
MOV BL,05H
STEP1: MOV SI,OFFSET ARRAY
MOV CL,04H
STEP: MOV AL,[SI]
CMP AL,[SI+1]
JNC DOWN
XCHG AL,[SI+1]
XCHG AL,[SI]
DOWN:ADD SI,1
LOOP STEP
DEC BL
JNZ STEP1
MOV AH,4CH
INT 21H
CODE ENDS
END START
Q]Write an ALP to reverse a string. Also draw flowchart for same.
DATA SEGMENT
STRB DB 'GOOD MORNING$'
REV DB 0FH DUP(?)
DATA ENDS
CODE SEGMENT
START:ASSUME CS:CODE,DS:DATA
MOV DX,DATA
MOV DS,DX
LEA SI,STRB
MOV CL,0FH
LEA DI,REV
ADD DI,0FH
UP:MOV AL,[SI]
MOV [DI],AL
INC SI
DEC DI
LOOP UP
MOV AH,4CH
INT 21H
CODE ENDS
END START
Q]Write an ALP to count the number of positive and negative numbers in
array.
CODE SEGMENT
ASSUME CS:CODE,DS:DATA
START: MOV AX,DATA
MOV DS,AX
MOV DX,0000H
MOV CX,COUNT
MOV SI, OFFSET ARRAY
NEXT: MOV AX,[SI]
ROR AX,01H
JC NEGATIVE
INC DL
JMP COUNT_IT
NEGATIVE: INC DH
COUNT_IT: INC SI
INC SI
LOOP NEXT
MOV NEG_COUNT,DL
MOV POS_COUNT,DH
MOV AH,4CH
INT 21H
CODE ENDS
DATA SEGMENT
ARRAY DW F423H,6523H,B658H,7612H, 2300H,1559H
COUNT DW 06H
POS_COUNT DB ?
NEG_COUNT DB ?
DATA ENDS
END START
Q]Write an ALP to find the sum of series. Assume series of 10 numbers.
CODE SEGMENT
ASSUME CS:CODE,DS:DATA
START: MOV AX,DATA
MOV DS,AX
LEA SI,DATABLOCK
MOV CL,0AH
UP:MOV AL,[SI]
ADD RESULT_LSB,[SI]
JNC DOWN
INC REULT_MSB
DOWN:INC SI
LOOP UP
CODE ENDS
DATA SEGMENT
DATABLOCK DB 45H,02H,88H,29H,05H,45H,78H, 95H,62H,30H
RESULT_LSB DB 0
RESULT_MSB DB 0
DATA ENDS
END
Q]Write ALP to perform block transfer operation of 10 numbers. 4 M
CODE SEGMENT
ASSUME CS:CODE,DS:DATA,ES:EXTRA
MOV AX,DATA
MOV DS,AX
MOV AX,EXTRA
MOV ES,AX
MOV CX,000AH
LEA SI,BLOCK1
LEA DI,ES:BLOCK2
CLD
REPNZ MOVSW
MOV AX,4C00H
INT 21H
CODE ENDS
DATA SEGMENT
BLOCK1 DW 1001H,4003H,6005H,2307H,4569H, 6123H,
1865H, 2345H,4000H,8888H
DATA ENDS
EXTRA SEGMENT
BLOCK2 DW ?
EXTRA EN DS
END
Q]Write ALP to count ODD and EVEN numbers in an array. 4 M
CODE SEGMENT
ASSUME CS:CODE,DS:DATA
START: MOV AX,DATA
MOV DS,AX
MOV DX,0000H
MOV CX,COUNT
MOV SI, OFFSET ARRAY1
NEXT: MOV AX,[SI]
ROR AX,01H
JC ODD_1
INC DL
JMP COUNT_IT
ODD_1 : INC DH
COUNT_IT: INC SI
INC SI
LOOP NEXT
MOV ODD_COUNT,DH
MOV EVENCNT,DL
MOV AH,4CH
INT 21H
CODE ENDS
DATA SEGMENT
ARRAY1 DW F423H, 6523H, B658H, 7612H, 9875H,
2300H, 1559H, 1000H, 4357H, 2981H
COUNT DW 0AH
ODD_COUNT DB ?
EVENCNT DB ?
DATA ENDS
END START
Q]Write ALP using macro to perform multiplication of two 8 Bit Unsigned
numbers.
PRODUCT MACRO FIRST,SECOND
MOV AL,FIRST
MOV BL,SECOND
MUL BL
PRODUCT ENDM
DATA SEGMENT
NO1 DB 05H
NO2 DB 04H
MULTIPLE DW ?
DATA ENDS
CODE SEGMENT
ASSUME CS: CODE,DS:DATA
START:MOV AX,DATA
MOV DS,AX
PRODUCT NO1,NO2
MOV MULTIPLE, AX
MOV AH,4CH
INT 21H
CODE ENDS
END
Q]Write an assembly language program to add BCD numbers in an array
of 10 numbers. Assume suitable array. Store the result at the end of the
array.
.MODEL SMALL
.STACK 100
.DATA
ARRAY DB 1,2,3,4,5,6,7,8,9,10
SUM_LSB DB 0
SUM_MSB DB 0
.CODE
MOV AX , @DATA
MOV DS , AX
MOV CX , 10
MOV SI , OFFSET ARRAY
UP:
MOV AL , [SI]
ADD SUM_LSB , AL
DAA
JNC NEXT
INC SUM_MSB
NEXT:
INC SI
LOOP UP
MOV DL , SUM_MSB
MOV AH , 2
INT 21H
MOV DL , SUM_LSB
MOV AH , 2
INT 21H
MOV AH , 4CH
INT 21H
END
Q]Write a procedure to find factorial of given number. 4 M
DATA SEGMENT
NUM DB 04H
DATA ENDS
CODE SEGMENT
START: ASSUME CS:CODE, DS:DATA
MOV AX,DATA
MOV DS,AX
CALL FACTORIAL
MOV AH,4CH
INT 21H
PROC FACTORIAL
MOV BL,NUM ; TAKE NO IN BL REGISTER
MOV CL,BL ;TAKE CL AS COUNTER
DEC CL ;DECREMENT CL BY 1
MOV AL,BL
UP: DEC BL ;DECREMENT BL TO GET N-1
MUL BL ;MULTIPLY CONTENT OF N BY N-1
DEC CL ;DECREMENT COUNTER
JNZ UP ;REPEAT TILL ZERO
RET
FACTORIAL ENDP
CODE ENDS
END START
Q] Write an assembly language program to arrange the numbers in
ascending order (Assume suitable data).
DATA SEGMENT
ARRAY DB 15h,05h,08h,78h,56h, 60h, 54h, 35h, 24h, 67h
DATA ENDS
CODE SEGMENT
START: ASSUME CS: CODE, DS:DATA
MOV DX, DATA
MOV DS, DX
MOV BL,0AH
step1: MOV SI,OFFSET ARRAY
MOV CL,09H
step: MOV AL,[SI]
CMP AL,[SI+1]
JC Down
XCHG AL,[SI+1]
XCHG AL,[SI]
Down : ADD SI,1
LOOP step
DEC BL
JNZ step1
MOV AH,4CH
INT 21H
CODE ENDS
END START
Q]Write an assembly language program to Count No. of 1's in a 16-bit
number.
MODEL SMALL
.DATA
NUM DW 0008H
ONES DB 00H
.CODE
START:
MOV AX,@DATA
MOV DS,AX
MOV CX, 10H
MOV BX, NUM
UP: ROR BX, 1
JNC DN
INC ONES
DN: LOOP UP
MOV CX, ONES
MOV AH, 4CH
INT 21H
ENDS
END
Q]Write an assembly language program using MACRO to perform
following operation.X = (A +B) * (C +D)
.Model small
add_no1 macro a,b,res_add1
mov al,a
add al,b
mov res_add1,al
endm
add_no2 macro c,d,res_add2
mov al,c
add al,d
mov res_add2,al
endm
multiply_num macro res_add1,res_add2
mov al,res_add1
mul res_add2
endm
.Data
a db 02h
b db 03h
c db 04h
d db 05h
res_add1 db ?
res_add2 db ?
ends
.Code
start :
mov ax,@data
mov ds,ax
mov al,a
mov bl,b
mov cl,c
mov dl,d
add al,bl
add cl,dl
mov res_add1,al
mov res_add2,cl
multiply_num res_add1,res_add2
mov ah,4ch
int 21h
ends
end
Q]Draw architectural block diagram of 8086 and describe its register
organization.
Register Organization of 8086
1. AX (Accumulator) – Used to store the result for arithmetic / logical
operations
2. BX – Base – used to hold the offset address or data
3. CX – acts as a counter for repeating or looping instructions.
4. DX – holds the high 16 bits of the product in multiply (also handles divide
operations)
6. SS - Base address of the stack
7. DS – Data Segment – default base address for variables
