8086 Microprocessor All Programs

16 BIT ADDITION (DIRECT END START

ADDERESSING MODE):
ASSUME CS: CODE, DS :DATA
DATA SEGMENT
NUM DW 1232H 16 BIT ADDITION (IMMEDIATE
DATA ENDS ADDERESSING MODE):
CODE SEGMENT
START: ASSUME CS:CODE
MOV AX ,DATA CODE SEGMENT
MOV DS, AX START:
MOV AX,4562H MOV BX,5678H
ADD AX,NUM ADD AX,1234H
INT 03H INT 03H
CODE ENDS CODE ENDS
END START

16 BIT ADDITION
(INDIRECTADDERESSING MODE):
ASSUME CS:CODE,DS:DATA
DATA SEGMENT 16 BIT ADDITION
NUM DW 02H (REGISTERADDERESSING MODE):
DATA ENDS
CODE SEGMENT ASSUME CS:CODE
START: CODE SEGMENT
MOV AX,DATA START:
MOV DS,AX MOV BX,5678H
MOV AX,4444H MOV AX,1234H
MOV BX,OFFSET NUM ADD AX,BX
ADD AX,[BX] INT 03H
INT 03H CODE ENDS
CODE ENDS END START
END START

B) SUBTRACTION: END START

i) 16 BIT SUBTRACTION (DIRECT
ADDRESSING MODE):
ASSUME CS:CODE,DS:DATA
DATA SEGMENT ii) 16 BIT SUBTRACTION
NUM DW 1232H
DATA ENDS (IMMEDIATE ADDRESSING MODE):
CODE SEGMENT
SSUME CS:CODE
START:
CODE SEGMENT
MOV AX,DATA
START:
MOV DS,AX
MOV AX,5678H
MOV AX,4562H
SUB AX,1234H
SUB AX,NUM
INT 03H
INT 03H
CODE ENDS
CODE ENDS
END START

iii) 16 BIT SUBTRACTION ASSUME CS:CODE,DS:DATA

DATA SEGMENT
(INDIRECTADDRESSING MODE): NUM DW 02H
DATA ENDS
CODE SEGMENT
START: iv) 16 BIT SUBTRACTION
MOV AX,DATA
MOV DS,AX (REGISTERADDRESSING MODE):
MOV AX,4444H
ASSUME CS:CODE
MOV BX,OFFSET NUM
CODE SEGMENT
SUB AX,[BX]
START:
INT 03H
MOV BX,5678H
CODE ENDS
MOV AX,1234H
END START
SUB AX,BX
INT 03H
CODE ENDS
END START

MULTIPLICATION:
i) 16 BIT MULTIPLICATION
(DIRECT ADDERESSING MODE):
AIM: - To write an assembly language program
for multiplication of two 16-bit numbers.
PROGRAM: ii) 16 BIT MULTIPLICATION
ASSUME CS:CODE,DS:DATA
DATA SEGMENT (REGISTER ADDERESSING MODE):
X DB 02H AIM: - To write an assembly language program
DATA ENDS for multiplication of two 16-bit numbers.
CODE SEGMENT ASSUME CS:CODE
START: CODE SEGMENT
MOV AX,DATA START:
MOV DS,AX MOV BX,1234H
MOV AX,0002H MOV AX,1234H
MUL X MUL BX
INT 03H INT 03H
CODE ENDS CODE ENDS
END START END STAR

DIVISION:
i) 16 BIT DIVISION (DIRECT ADDRESSING MODE):
AIM: - To write an assembly language program for multiplication of two 16-bit numbers
PROGRAM:
ASSUME CS:CODE,DS:DATA START:
DATA SEGMENT MOV AX,DATA
NUM DW 02H MOV DS,AX
DATA ENDS MOV AX,4444H
CODE SEGMENT DIV NUM
INT 03H
CODE ENDS
END START

ii) 16 BIT DIVISION (REGISTER ADDRESSING MODE):

AIM: - To write an assembly language program for multiplication of two 16-bit numbers
ASSUME CS:CODE
CODE SEGMENT
START:
MOV BX,0022H
MOV AX,4444H
DIV BX
INT 03H
CODE ENDS
END START

PROGRAM FOR SORTING AN ARRAY FOR 8086

A) ASCENDING ORDER
AIM:-Program to sort the given numbers in ascending order
PROGRAM:
ASSUME CS:CODE,DS:DATA L2:MOV AX,[SI]
DATA SEGMENT CMP AX,[SI+2]
LIST DW 55H,67H,23H,45H JL L3
COUNT EQU 04H XCHG [SI+2],AX
DATA ENDS XCHG [SI],AX
CODE SEGMENT L3:ADD SI,02
START: LOOP L2
MOV AX,DATA DEC DX
MOV DS,AX JNZ L1
MOV DX,COUNT-1 INT 03H
L1:MOV CX,DX CODE ENDS
MOV SI,OFFSET LIST END START

B) DECENDING ORDER
AIM:-Program to sort the given numbers in descending order
PROGRAM:
ASSUME CS:CODE,DS:DATA L2:MOV AX,[SI]
DATA SEGMENT CMP AX,[SI+2]
LIST DW 55H,67H,23H,45H JA L3
COUNT EQU 04H XCHG [SI+2],AX
DATA ENDS XCHG [SI],AX
CODE SEGMENT L3:ADD SI,02
START: LOOP L2
MOV AX,DATA DEC DX
MOV DS,AX JNZ L1
MOV DX,COUNT-1 INT 03H
L1:MOV CX,DX CODE ENDS
MOV SI,OFFSET LIST END START

SERCHING OF AN ARRAY:
AIM: Write an alp program for to search a number or character from an array
PROGRAM: SEARCHING AN ARRAY CASE: EQUAL
ASSUME CS: CODE, DS: DATA
DATA SEGMENT
ARRAY DB 27H, 0A9H, 82H, 4DH, 36H
N1 DB 82H
N2 DB 25H
COUNT DB 05H
DATA ENDS
CODE SEGMENT
START:
MOV AX, DATA
MOV DS, AX
MOV CL, COUNT
MOV BX, OFFSET ARRAY
LEA BX, ARRAY
MOV DL, N1
BACK: CMP DL,[BX]
JE EXIT
INC BX
LOOP BACK
MOV AX, 0FFFFH
INT 03H
EXIT: MOV AX, 00H
INT 03H
CODE ENDS
END START

SEARCHING AN ARRAY CASE: NOT EQUAL

ASSUME CS: CODE, DS: DATA LEA BX, ARRAY
DATA SEGMENT MOV DL, N2
ARRAY DB 27H, 0A9H, 82H, 4DH, 36H BACK: CMP DL, [BX]
N1 DB 82H JE EXIT
N2 DB 25H INC BX
COUNT DB 05H LOOP BACK
DATA ENDS MOV AX, 0FFFFH
CODE SEGMENT INT 03H
START: EXIT: MOV AX, 00H
MOV AX, DATA INT 03H
MOV DS, AX CODE ENDS
MOV CL, COUNT END START
MOV BX, OFFSET ARRAY

PROGRAM FOR STRING MANIPULATIONS FOR 8086.

Aim: To write an alp for transfer block of data from one memory location to another memory location.
PROGRAM:
ASSUME CS:CODE,DS:DATA,ES:EXTRA MOV AX,EXTRA
DATA SEGMENT MOV ES,AX
STG1 DB "ELECTRONICS" CLD
DATA ENDS LEA SI,STG1
EXTRA SEGMENT LEA DI,STG2
STG2 DB 11 DUP(?) MOV CX,11
EXTRA ENDS REP MOVSB
CODE SEGMENT INT 03H
START: CODE ENDS
MOV AX,DATA END START
MOV DS,AX

INSERT A STRING
PROGRAM
ASSUME CS:CODE,DS:DATA,ES:DATA DATA SEGMENT
S1 DB "ANURAGLEGE" MOV CX,04H
S2 DB "COL" REP MOVSB
S3 DB 0DH DUP(?) LEA SI,[S2+2]
DATA ENDS MOV CX,3
CODE SEGMENT REP MOVSB
START: LEA SI,[S1+5]
MOV AX,DATA MOV CX,6
MOV DS,AX REP MOVSB
MOV ES,AX INT 03H
STD CODE ENDS
LEA SI,[S1+09H] END START
LEA DI,[S3+0CH]

REVERSING A STRING
PROGRAM
ASSUME CS: CODE, DS: DATA ,ES: DATA LEA DI,[S2+8]
DATA SEGMENT MOV CX,9
S1 DB "KNOWLEDGE" BACK:CLD
S2 DB 09H DUP (?) LODSB
DATA ENDS STD
CODE SEGMENT STOSB
START: DEC CX
MOV AX,DATA JNZ BACK
MOV DS,AX INT 03H
MOV ES,AX CODE ENDS
LEA SI,[S1]
END START

STRING LENGTH
PROGRAM
ASSUME CS:CODE,ES:DATA CLD
DATA SEGMENT LEA DI,STG
STG DB "ANURAG#" MOV AL,CHAR
CHAR DB "#" MOV CX,14
LEN DW 00H REPNE SCASB
DATA ENDS MOV LEN,DI
CODE SEGMENT INT 03H
START: CODE ENDS
MOV AX,DATA END START
MOV ES,AX

STRING COMPARISION
CASE: STRINGS ARE EQUAL
ASSUME CS:CODE, DS: DATA, ES: DATA DATA SEGMENT
S1 DB "ELECTRONICS $" MOV CX,11
S2 DB "ELECTRONICS $" CLD
S3 DB "COMPUTER $" REP CMPSB
MSG1 DB "STRINGS ARE EQUAL $" JNZ ABC
MSG2 DB "STRINGS ARE NOT EQUAL $" LEA DX,MSG1
DATA ENDS LAST:MOV AH,09H
CODE SEGMENT INT 21H
START: MOV AH,4CH
MOV AX,DATA INT 21H
MOV DS,AX ABC:LEA DX,MSG2
MOV ES,AX JMP LAST
LEA SI,S1 CODE ENDS
LEA DI,S2 END START

CASE: STRINGS ARE NOT EQUAL

COMPARE STRINGS
ASSUME CS: CODE, DS:DATA,ES:DATA LEA DI,S3
DATA SEGMENT MOV CX,11
S1 DB "ELECTRONICS $" CLD
S2 DB "ELECTRONICS $" REP CMPSB
S3 DB "COMPUTER $" JNZ ABC
MSG1 DB "STRINGS ARE EQUAL $" LEA DX,MSG1
MSG2 DB "STRINGS ARE NOT EQUAL $" LAST:MOV AH,09H
DATA ENDS INT 21H
CODE SEGMENT MOV AH,4CH
START: INT 21H
MOV AX,DATA ABC:LEA DX,MSG2
MOV DS,AX JMP LAST
MOV ES,AX CODE ENDS
LEA SI,S1 END START

Binary to BCD code conversion

DATA SEGMENT MOV AL,AH
BIN DW 01A9H MOV AH,00H
BCD DB 2 DUP(0) MOV CL,0AH
DATA ENDS DIV CL
CODE SEGMENT MOV CL,04
ASSUME CS:CODE,DS:DATA ROR AL,CL
START: MOV AX,DATA ADD AL,AH
MOV DS,AX MOV AH,4CH
MOV AX,BIN INT 21H
MOV CL,64H CODE ENDS
DIV CL END START
MOV BCD+1,AL

Input: binary--------01A9
Output: bcd------------425

BCD to Binary code conversion

DATA SEGMENT
BCD DW 27H
BIN DW ?
DATA ENDS
CODE SEGMENT
ASSUME CS:CODE,DS:DATA
START: MOV AX,DATA
MOV DS,AX
MOV AX,BCD
AND AX,07H
MOV BX,AX
MOV AX,BCD
AND AX,0F0H
MOV CX,0AH
MUL CX
ADD AX,BX
MOV BIN,AX
MOV AH,4CH
INT 21H
CODE ENDS
END START

Input: BCD-------------27
Output:------------------1B

Arithmetic programs to find square, cube, LCM, GCD and factorial

i) Program to find square and cube of a number
DATA SEGMENT MOV BX,X
X DW 04H MUL BX
SQUARE DW ? MOV SQUARE,AX
CUBE DW ? MUL BX
DATA ENDS MOV CUBE,AX
CODE SEGMENT MOV AH,4CH
ASSUME CS:CODE,DS:DATA INT 21H
START: MOV AX,DATA CODE ENDS
MOV DS,AX END START
MOV AX,X
Input: x ----------- 4h
Output: Square ---------10h
Cube -----------40h

ii)Program to find LCM of a given number

DATA SEGMENT CMP DX,0
NUM DW 05,04 JE EXIT
LCM DW 2 DUP(0) POP DX
DATA ENDS POP AX
CODE SEGMENT ADD AX,NUM
ASSUME CS:CODE,DS:DATA JNC DOWN
START: MOV AX,DATA INC DX
MOV DS,AX DOWN: JMP UP
MOV DX,0H EXIT: POP LCM+2
MOV AX,NUM POP LCM
MOV BX,NUM+2 MOV AH,4CH
UP: PUSH AX INT 21H
PUSH DX CODE ENDS
DIV BX END START

Input: 0A, 04
Output: 02

Program to find factorial of a given number

DATA SEGMENT X DW 06H
FACT DW ? UP: MUL CX
DATA ENDS LOOP UP
CODE SEGMENT MOV FACT,AX
ASSUME CS:CODE,DS:DATA MOV AH,4CH
START: MOV AX,DATA INT 21H
MOV DS,AX CODE ENDS
MOV AX,01H END START
MOV CX,X
Input: 06
Output: 2D0H

If given data is positive or negative

DATA SEGMENT JC NEGAMOV
NUM DB 12H
MES1 DB 10,13,'DATA IS POSITIVE $' DX,OFFSET MES1.
MES2 DB 10,13,'DATA IS NEGATIVE $' JMP EXIT
DATA ENDS
CODE SEGMENT NEGA: MOV DX,OFFSET MES2
ASSUME CS:CODE,DS:DATA EXIT: MOV AH,09H
START: MOV AX,DATA INT 21H
MOV DS,AX MOV AH,4CH
MOV AL,NUM INT 21H
ROL AL,1
CODE ENDS
END START
Output: Data is positive
Positive Numbers: 00-7F
Negative numbers: 80-FF
If given data is odd or even
DATA SEGMENT LEA DX,MSG1
X DW 27H MOV AH,09H
MSG1 DB 19,13,'NUMBER IS EVEN$' INT 21H
MSG2 DB 10,13,'NUMBER IS ODD$' JMP LAST
DATA ENDS
CODE SEGMENT EXIT: LEA DX,MSG2
ASSUME CS:CODE,DS:DATA MOV AH,09H
START: MOV AX,DATA INT 21H
MOV DS,AX LAST: MOV AH,4CH
MOV AX,X INT 21H
TEST AX,01H CODE ENDS
JNZ EXIT END START

Logical ones and zeros in a given data

DATA SEGMENT
X DB 0AAH
ONE DB ?
ZERO DB ?
DATA ENDS
CODE SEGMENT
ASSUME CS: CODE,DS:DATA
START: MOV AX,DATA
MOV DS,AX
MOV AH,X
MOV BL,8
MOV CL,1
UP: ROR AH,CL
JNC DOWN
INC ONE
JMP DOWN1
DOWN: INC ZERO
DOWN1: DEC BL
JNZ UP
MOV AH,4CH
INT 21H
CODE ENDS
END START

Output: Ones--------04
Zeros--------04

PROGRAMS TO FIND LARGEST AND SMALLEST NUMBER

PROGRAM TO FIND LARGEST NUMBER AMONG THE SERIES

DATA SEGMENT UP: CMP AX,[SI+2]

X DW 0010H,52H,30H,40H,50H JA CONTINUE
LAR DW ? MOV AX,[SI+2]
DATA ENDS CONTINUE:ADD SI,2
CODE SEGMENT DEC CX
ASSUME CS:CODE,DS:DATA JNZ UP
START: MOV AX,DATA MOV LAR,AX
MOV DS,AX MOV AH,4CH
MOV CX,05H INT 21H
LEA SI,X CODE ENDS
MOV AX,[SI] END START
DEC CX

PROGRAM TO REVERSE A STRING

DATA SEGMENT LEA SI,STR1
STR1 DB 'HELLO' LEA DI,STR2+LEN-1
LEN EQU $-STR1 MOV CX,LEN
STR2 DB 20 DUP(0) UP: CLD
LODSB
DATA ENDS STD
CODE SEGMENT STOSB
ASSUME CS:CODE,DS:DATA,ES:DATA LOOP UP
START: MOV AX,DATA MOV AH,4CH
MOV DS,AX INT 21H
MOV ES,AX CODE ENDS
END START
OUTPUT: OLLEH