LAB 10

MUHAMMAD REHAN KHAN

21K-3172
BCS-3A
INSTRUCTOR: Engr. Muhammad Kariz Kamal
 LAB 10

TASK 1
• In the following task I used stack parameter method to pass parameters to function.
And in BubbleSort Function I used to nested loops to sort array.

INCLUDE irvine32.inc
.data
array DWORD 8,5,1,3,6
.code
main PROC
push offset array
push lengthof array
call BubbleSort
exit
main ENDP
BubbleSort PROC
push ebp
mov ebp,esp
mov ecx,[ebp+8]
mov ebx,0
dec ecx
l1:
mov esi,[ebp+12]
mov edx,ecx
mov ecx,[ebp+8]
dec ecx
l2:
mov eax,[esi]
add esi,4
mov ebx,[esi]
cmp eax,ebx
JG swap
continue:
loop l2
mov ecx,edx
loop l1
JMP print
swap:
mov edi,esi
mov [edi],eax
sub edi,4
mov [edi],ebx
JMP continue
print:
mov ecx,[ebp+8]
mov esi,[ebp+12]
l3:
mov eax,[esi]
call writedec
add esi,4
call crlf
loop l3
pop ebp
ret
BubbleSort ENDP
 LAB 10

END main

OUTPUT:
 LAB 10

TASK 2
• In the following task I did function call within another function and I used an array and
conditional jumps for calculation whether inputted numbers are Armstrong numbers or
not.

INCLUDE Irvine32.inc
.data
elements dword ?
array DWORD 100 DUP(?)
msg3 byte "Enter Number of Elments to Enter: ",0
sum DWORD 0
msg byte "Enter Numbers: ",0
msg1 byte "Entered Numbers are Armstrong ",0
msg2 byte "Entered Numbers are not Armstrong ",0
.code
main PROC
call Takeinput
exit
main ENDP
Takeinput PROC
mov edx,offset msg3
call writestring
call readdec
mov elements,eax
mov ecx,eax
mov esi,offset array
l1:
mov edx,offset msg
call writestring
call readdec
mov [esi],eax
add esi,type array
loop l1
call DumpRegs
call Armstrong
ret
Takeinput ENDP
Armstrong PROC
call DumpRegs
mov esi,offset array
mov ecx,elements
l1:
mov eax, [esi]
mov ebx,ecx
mov ecx,elements
dec ecx
l2:
mul DWORD PTR [esi]
loop l2
mov ecx,ebx
add esi,type array
add sum, eax
loop l1
mov esi,offset array
 LAB 10

mov ebx,10
mov ecx,elements
dec ecx
mov eax,[esi]
l3:
mul ebx
add esi,4
add eax,[esi]
loop l3
cmp eax,sum
JNE _else
mov edx,offset msg1
call writestring
jmp _end
_else:
mov edx,offset msg2
call writestring
_end:
ret
Armstrong ENDP
END main

OUTPUT:
 LAB 10

TASK 3
• In the following task I used recursion for reversing string by using the concept of
reversing array (high index and low index)

INCLUDE Irvine32.inc
.data
string byte "Muhammad Rehan Khan",0
.code
main PROC
mov edx,offset string
call writestring
call crlf
mov eax,0
mov ebx,lengthof string - type string
call Reverse
call crlf
mov esi,offset string
mov ecx,lengthof string
l1:
mov eax,[esi]
call writechar
inc esi

loop l1

exit
main ENDP
Reverse PROC
cmp eax,ebx
JAE _end
mov dl,string[eax]
mov cl,string[ebx]
xchg dl,cl
mov string[eax],dl
mov string[ebx],cl
inc eax
dec ebx
call Reverse
_end:
ret
Reverse ENDP
END main
 LAB 10

OUTPUT:
 LAB 10

TASK 4
• In the following task I used local directive for finding square

INCLUDE Irvine32.inc
.data
msg byte "Enter a Number: ",0
.code
main PROC
call LocalSquare
exit
main ENDP
LocalSquare PROC
Local temp:DWORD
enter 4,0
mov edx,offset msg
call writestring
call readdec
mov temp,eax
mul temp
call writedec
leave
ret
LocalSquare ENDP

END main

OUTPUT:
 LAB 10

TASK 5
• In the following task I used recursion for calculating factorial by moving the inputted
number into ebx and multiplying it with eax after decrementing it beforehand.

Include Irvine32.inc
.data
prompt BYTE "Enter a Number: ",0
.code
Main PROC
Mov edx,offset prompt
Call writestring
Call readint
Mov ebx,eax
Call crlf
Call Fact
Call crlf
Call writedec
Exit
Main ENDP
Fact PROC
Cmp ebx,1
Jbe endproc
Dec ebx
Mul ebx
Call Fact
Endproc:
Ret
Fact ENDP
END MAIN

OUTPUT:
 LAB 10

TASK 6
• In the following task I used invoke and proto to for function call and parameters and I
used conditional jumps for checking prime and printing the largest prime number

INCLUDE Irvine32.inc
.data
var1 DWORD ?
var2 DWORD ?
var3 DWORD ?
var4 DWORD ?
flag DWORD 0
msg byte "Numbers are Not Prime",0
msg1 byte "Numbers are Prime",0
msg3 byte "Largest Prime: ",0
.code
CheckPrime PROTO a:DWORD
LargestPrime PROTO p:DWORD,q:DWORD,r:DWORD,s:DWORD
main PROC
call readdec
mov var1,eax
call readdec
mov var2,eax
call readdec
mov var3,eax
call readdec
mov var4,eax
Invoke CheckPrime, var1
Invoke CheckPrime, var2
Invoke CheckPrime, var3
Invoke CheckPrime, var4
cmp flag,0
jne _notprime
mov edx,offset msg1
call writestring
call crlf
Invoke LargestPrime, var1,var2,var3,var4
jmp _exit
_notprime:
mov edx,offset msg
call writestring
_exit:
exit
main ENDP
CheckPrime PROC a:DWORD
LOCAL count:DWORD
mov count,0
mov ecx,1
L1:
cmp ecx,a
JG _end
mov eax,a
mov edx,0
div ecx
 LAB 10

cmp edx,0
jne _inc
inc count
_inc:
inc ecx
jmp L1
_end:
;mov eax,count
;call writedec
;call crlf
cmp count,2
JG _notprime
jmp _ret
_notprime:
mov flag,1
_ret:
ret
CheckPrime ENDP
LargestPrime PROC p,q,r,s
mov eax,p
mov ebx,q
mov ecx,r
mov edx,s
cmp eax,ebx
jb _var2
cmp eax,ecx
jb _var2
cmp eax,edx
jb _var2
mov edx,offset msg3
call writestring
mov eax,var1
call writedec
jmp _end
_var2:
cmp ebx,eax
jb _var3
cmp ebx,ecx
jb _var3
cmp ebx,edx
jb _var3
mov edx,offset msg3
call writestring
mov eax,var2
call writedec
jmp _end
_var3:
cmp ecx,eax
jb _var4
cmp ecx,ebx
jb _var4
cmp ecx,edx
jb _var4
mov edx,offset msg3
call writestring
mov eax,var3
call writedec
jmp _end
 LAB 10

_var4:
mov edx,offset msg3
call writestring
mov eax,var4
call writedec
_end:
ret
LargestPrime ENDP
END MAIN

OUTPUT: