MAP notes

Chapter 5: 8086 Assembly Language programming Part 2

Programming using Assembler:

Write an assembly language program to add two 8 bit numbers

Program:
assume cs : code
assume ds : data

data segment
a db 25h
b db 34h
sum db ?
data ends

code segment
start:
mov ax,data
mov ds,ax
mov ax,0000h

mov al,a
mov bl,b
add al,bl
mov sum,al
int 3
code ends
end start

Write an assembly language program to add two 16 bit numbers

Program:

assume cs : code
assume ds : data

data segment
a dw 1191h
b dw 2272h
sum dw ?
data ends

code segment
start:
mov ax,data
mov ds,ax
mov ax,0000h

mov ax,a
mov bx,b
add ax,bx
mov sum,ax

int 3
code ends
end start

Write an assembly language program to subtract two 16 bit numbers

Program:
assume cs : code
assume ds : data

data segment
a dw 3400h
b dw 2500h
dif dw ?
data ends

code segment
start:
mov ax,data
mov ds,ax
mov ax,0000h

mov bx,a
mov ax,b
sub bx,ax
mov dif,bx

int 3
code ends
end start

Write an assembly language program to find the sum of series of n numbers.

Program:
assume cs : code
assume ds : data

data segment
series db 10h,20h,40h,90h,87h
res dw ?
data ends

code segment
start:
mov ax,data
mov ds,ax
mov ax,0000h

lea si,series
mov al,[si]
mov cl,04

up: inc si
mov bl,[si]
add al,bl
jc down

up1: dec cl
jnz up
jmp exit

down: inc ah
jmp up1

exit: mov res,ax

int 3
code ends
end start

Write an assembly language program to multiply two 8 bit unsigned numbers

Program:
assume cs : code
assume ds : data

data segment
a db 25h
b db 40h
result dw ?
data ends

code segment
start:
mov ax,data
mov ds,ax
mov ax,0000h

mov al,a
mov bl,b
mul bl
mov result,ax

int 3
code ends
end start
Write an assembly language program to multiply two 16 bit unsigned numbers
Program:

assume cs : code
assume ds : data

data segment
a dw 2525h
b dw 4040h
result dd ?

data ends

code segment
start:
mov ax,data
mov ds,ax
mov ax,0000h

mov ax,a
mov bx,b
mul bx
lea si,result
mov [si],dh
inc si
mov [si],dl
inc si
mov [si],ah
inc si
mov [si],al

int 3
code ends
end start
Write an assembly language program to multiply two 8 bit signed numbers
Program:
assume cs : code
assume ds : data

data segment
a db 15h
b db -18h

result dw ?
data ends

code segment
start:
mov ax, data
mov ds, ax
mov ax,0000h

mov al,a
mov bl,b
imul bl
mov result, ax
int 3
code ends
end start
Write an assembly language program to multiply two 16 bit signed numbers
Program:

assume cs : code
assume ds : data

data segment
a dw 1000h
b dw -2000h
result dd ?
data ends

code segment
start:
mov ax,data

mov ds,ax
mov ax,0000h

mov ax,a
mov bx,b
imul bx
lea si,result
mov [si],dh
inc si
mov [si],dl
inc si
mov [si],ah
inc si
mov [si],al

int 3
code ends
end start
Write an assembly language program to divide two unsigned numbers (8bits/8bits)
Program:
assume cs : code
assume ds : data

data segment
a db 64h
b db 31h
quo db ?
rem db ?
data ends

code segment

start:
mov ax,data
mov ds,ax
mov ax,0000h
mov al,a
mov bl,b
div bl
mov quo,al
mov rem,ah

int 3
code ends
end start
Write an assembly language program to divide two unsigned numbers (16bits/8bits)
Program:
assume cs : code
assume ds : data

data segment
a dw 1200h
b db 89h
quo db ?
rem db ?
data ends

code segment
start:
mov ax,data
mov ds,ax
mov ax,0000h
mov ax,a

mov bl,b
div bl
mov quo,al
mov rem,ah

int 3
code ends
end start
Write an assembly language program to divide two unsigned numbers (16bits/16bits)
Program:
assume cs : code
assume ds : data

data segment
a dw 1200h
b dw 1678h
quo dw ?
rem dw ?
data ends

code segment
start:
mov ax,data
mov ds,ax
mov ax,0000h
mov dx,0000h

mov ax,a
mov bx,b
div bx
mov quo,ax

mov rem, dx

int 3
code ends
end start
Write an assembly language program to divide two unsigned numbers (32bits/16bits)
Program:

assume cs : code
assume ds : data

data segment
a dd 10000000h
b dw 9000h
quo dw ?
rem dw ?
data ends

code segment
start:
mov ax,data
mov ds,ax
mov ax,0000h

lea si,a
mov al,[si]
mov ah,[si+1]
mov dl, [si+2]
mov dh, [si+3]
mov bx,b
div bx

mov quo, ax
mov rem, dx
int 3
code ends
end start
Note: For signed division only instruction will change from div to idiv and if either
dividend or divisor is negative, quotient will also be negative and remainder will be
positive. If both dividend and divisor are negative then remainder and quotient both are
positive.
Write an assembly language program to find the smallest number from a given array of n
numbers
Program:

assume cs : code
assume ds : data

data segment
array db 09,10,8,12
smallest db ?
data ends

code segment
start:
mov ax,data
mov ds,ax
mov ax,0000h

lea si,array
mov al,[si]
mov cl,03

up: inc si
mov bl, [si]
cmp al, bl
jc down
mov al, bl

down: dec cl
jnz up
mov smallest,al

int 3
code ends
end start
Write an assembly language program to find the largest number from array of n numbers.
Program:

assume cs : code
assume ds : data

data segment
array db 09,10,11,12
largest db ?
data ends

code segment
start:
mov ax,data
mov ds,ax
mov ax,0000h

lea si,array

mov al,[si]
mov cl,03

up: inc si
mov bl, [si]
cmp al, bl
jnc down
mov al,[si]

down: dec cl
jnz up
mov largest,al

int 3
code ends
end start
Write an assembly language program to arrange n numbers in an array in ascending order
Program:

assume cs : code
assume ds : data

data segment
array db 10h,15h,9h,7h,4h
data ends

code segment
start:
mov ax,data
mov ds,ax
mov ax,0000h

mov cl,04
up2:

mov ch,04
lea si,array

up1:

mov al,[si]
inc si
cmp al,[si]

jc down
xchg [si],al
dec si
xchg [si],al
inc si
down:

dec ch
jnz up1

dec cl
jnz up2

int 3
code ends
end start
Write an assembly language programming to arrange an array of n numbers in descending
order
assume cs : code
assume ds : data

data segment
array db 1h,5h,9h,7h,4h
data ends

code segment
start:
mov ax,data
mov ds,ax
mov ax,0000h

mov cl,04
up2: mov ch,04
lea si,array
up1: mov al,[si]
inc si
cmp al,[si]

jnc down
mov dl,[si]
mov [si],al
dec si
mov [si],dl
inc si

down: dec ch
jnz up1

dec cl
jnz up2

int 3
code ends
end start

Write a program in assembly language to perform block transfer of data without using
string instructions
Program:
assume cs : code
assume ds : data

data segment

block1 db 10h,20h,30h,40h,50h
block2 db 5 dup(0)
data ends

code segment
start:
mov ax,data
mov ds,ax
mov ax,0000h

lea si,block1
lea di,block2
mov cl,5

up: mov al,[si]

mov [di],al
inc si
inc di
dec cl
jnz up

int 3
code ends
end start

Write a program in assembly language to perform block transfer of data using string
instructions
Program:
assume cs : code
assume ds : data

data segment
block1 db 10h,20h,30h,40h,01010000b
data ends

extra segment
block2 db 5 dup(?)
extra ends

code segment
start:
mov ax,data
mov bx,extra
mov ds,ax

mov es,bx
mov ax,0000h

lea si,block1
lea di, block2
cld
mov cl, 05h
repz movsb
int 3
code ends
end start
Write an assembly language program to compare two strings without using string
instructions and display the result accordingly
Program:
assume cs : code
assume ds : data

data segment
string1 db "abcde$"
string2 db "abcde$"
msg1 db "Both the strings are same$"
msg2 db "Both the strings are not same$"
data ends

code segment
start:
mov ax,data
mov ds,ax
mov ax,0000h

lea si,string1

lea di,string2

up: mov al,[si]

cmp al,[di]
jne down
inc si
inc di
cmp al,'$'
jne up
lea dx,msg1
mov ah,09
int 21h
jmp exit

down: lea dx,msg2

mov ah,09
int 21h

exit:

mov ah,4ch
int 21h
code ends
end start

Write an assembly language program to compare two strings using string instructions and
display the result accordingly.
Program:
assume cs : code
assume ds : data
assume es : extra

data segment
string1 db "vbcde$"

msg1 db "Both the strings are same$"

msg2 db "Both the strings are not same$"
data ends

extra segment
string2 db "vwxyz$"
extra ends

code segment
start:
mov ax,data
mov ds,ax
mov ax,extra
mov es,ax
mov ax,0000h
mov cl,5
cld
lea si,string1
lea di,string2
repz cmpsb
jz msg
lea dx,msg2
mov ah,09
int 21h
jmp exit
msg: lea dx,msg1
mov ah,09
int 21h
exit: mov ah,4ch
int 21h
code ends

end start
Write a program in assembly language to calculate the length of the string
Program:
assume cs : code
assume ds : data

data segment
string db "xyz$"
strlength db ?
data ends

code segment
start:
mov ax,data
mov ds,ax
mov ax,0000h

lea si,string
mov cl,00h
up: mov al,[si]
cmp al,'$'
je down
inc si
inc cl
jmp up

down: mov strlength, cl

int 3
code ends
end start
Write an assembly language program to display string in reverse order

Program:
assume cs : code
assume ds : data

data segment
string db MAHARASHTRA$"
stringreverse db 100 dup(?)
msg db "The reverse of the string is: $"
data ends

code segment
start:
mov ax,data
mov ds,ax
mov ax,0000h
lea si,string
up: mov al,[si]
cmp al,'$'
je down
inc si
jmp up

down: lea di,stringreverse

mov cx,si
up1:

dec si
mov al,[si]
mov [di],al
inc di
dec cx
jnz up1
mov al,'$'
mov [di],al

lea dx,msg
mov ah,09
int 21h
lea dx,stringreverse
mov ah,09
int 21h
mov ah,4ch
int 21h
code ends
end start
Write an assembly language program to concatenate two strings (two words)
assume cs : code
assume ds : data

data segment
msg1 db "The two strings are :$"
string1 db 10,13, "If you don't study $"
string2 db 10,13, "You will fail in MAP $"
msg2 db 10,13, "After concatenation the strings are as follows :$"
data ends

code segment
start:
mov ax,data
mov ds,ax
mov ax,0000h
;a general msg is printed to show which are the two strings

lea dx,msg1
mov ah,09
int 21h

lea dx,string1
mov ah,09
int 21h
lea dx,string2
mov ah,09
int 21h
;from here the concatenation procedure starts

lea si,string1
lea di,string2

up: inc si
mov al,[si]
cmp al,'$'
jne up

up1: mov al,[di+2]

mov [si],al
inc si
inc di
cmp al,'$'
jne up1
lea dx,msg2
mov ah,09
int 21h

lea dx,string1
mov ah,09
int 21h

mov ah,4ch

int 21h
code ends
end start
Write an assembly language program to add two BCD numbers
Program:
assume cs : code
assume ds : data

data segment
a db 10010110b
b db 00000111b
result dw ?
data ends

code segment
start:
mov ax,data
mov ds,ax
mov ax,0000h

mov al,a
mov bl,b
add al,bl
daa
jc down
mov result,ax
jmp exit
down: inc ah
mov result,ax
exit:

int 3
code ends

end start
Write an assembly language program to subtract two BCD numbers
Program:
assume cs : code
assume ds : data

data segment
a db 00110010b
b db 00010111b
result db ?
data ends

code segment
start:
mov ax,data
mov ds,ax
mov ax,0000h
mov al,a
mov bl,b
sub al,bl
das
mov result,al
int 3
code ends
end start
Write an assembly language program to multiply two BCD numbers
Program:
assume cs : code
assume ds : data

data segment
a db 04
b db 06
result dw ?
data ends

code segment
start:
mov ax,data
mov ds,ax
mov ax,0000h
mov al,a
mov bl,b
mul bl
aam
mov result, ax
int 3
code ends
end start
Write an assembly language program to divide two BCD numbers
Program:
assume cs : code
assume ds : data

data segment
a dw 0600h
b db 04
quo db ?

rem db ?
data ends

code segment
start:
mov ax,data
mov ds,ax
mov ax,0000h
mov ax,a
mov bl,b
aad
div bl
daa
int 3
code ends
end start
Write an assembly language program to convert a decimal number to hexadecimal
number.
Program:
assume cs : code
assume ds : data

data segment
deci db 45h
hexi db ?
data ends

code segment
start:
mov ax,data

mov ds,ax
mov ax,0000h

mov al,deci
and al,0fh
mov dl,al
mov al,deci
and al,0f0h
mov cl,04h
rol al,cl
mov dh,0ah
mul dh
add al,dl
mov hexi,al

int 3
code ends
end start
Write an assembly language program to find odd and even numbers in an array
assume cs:code
assume ds:data
data segment
array db 45h,47h,76h,77h
oddarray db 4 dup(?)
evenarray db 4 dup(?)
data ends
code segment
start:

mov ax,data
mov ds,ax
mov ax,0000h
mov dl,02h
mov cl,04
lea si,array
lea di,evenarray
lea bx,oddarray
up: mov al,[si]
div dl
cmp ah,01
jz ODD
mov al,[si]
mov [di],al
inc di
inc si
dec cl
jnz up
jmp exit
ODD:
mov al,[si]
mov [bx],al
mov ah,00h
inc bx

inc si
dec cl
jnz up
exit: int 3
code ends
end start
Write an assembly language program to find positive and negative numbers in an array
assume ds:data
assume cs:code

data segment
array db 4,-4,5,-5,6,-6
posarray db 6 dup(?)
negarray db 6 dup(?)
data ends

code segment
start:
mov ax,data
mov ds,ax
mov ax,0000h

mov cl,06
lea si,array

lea di,posarray
lea bx,negarray

up:

mov al,[si]
neg al

js positive
mov dl,[si]
mov [bx],dl
inc bx
inc si
dec cl
jnz up
jmp exit

positive:
mov dl,[si]
mov [di],dl
inc di
inc si
dec cl
jnz up

exit: int 3

code ends
end start
Write an assembly language program to find the number of ones and zeroes in a number
assume cs:code
assume ds:data

data segment
number db 10011011b
ones dw ?
zeroes dw ?
data ends

code segment
start:
mov ax,data
mov ds,ax
mov ax,0000h

mov al,number
mov cl,08

up:

ror al,1
jc one
inc di

dec cl
jnz up
one:

inc si
dec cl
jnz up
mov ones, si
mov zeroes, di

exit:

int 3
code ends
end start