Assembly Programming Report Page 1

Contents
1 Program 1: Hello World 3
1.1 Problem Statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.2 Code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
1.3 Output . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3

2 Program 2: Two Number Addition 4

2.1 Problem Statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
2.2 Code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 4
2.3 Sample Input . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
2.4 Sample Output . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6

3 Program 3: Average Calculator with Decimal Precision 7

3.1 Problem Statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
3.2 Code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
3.3 Sample Input . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
3.4 Sample Output . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12

4 Program 4: Number Comparison 12

4.1 Problem Statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
4.2 Code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
4.3 Sample Input . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
4.4 Sample Output . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14

5 Program 5: Number Swapping 15

5.1 Problem Statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
5.2 Code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
5.3 Sample Input . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
5.4 Sample Output . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17

6 Program 6: Prime Number Checker 17

6.1 Problem Statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
6.2 Code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 18
6.3 Sample Input . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19
6.4 Sample Output . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 19

7 Program 7: Fibonacci Series Generator 20

7.1 Problem Statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
7.2 Code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
7.3 Sample Input . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
7.4 Sample Output . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23

8 Program 8: Factorial Calculator 24

8.1 Problem Statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
8.2 Code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
8.3 Sample Input . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
8.4 Sample Output . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29

9 Program 9: GCD Calculator 29

9.1 Problem Statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
9.2 Code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 29
9.3 Sample Input . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
9.4 Sample Output . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
Assembly Programming Report Page 2

10 Program 10: LCM Calculator 31

10.1 Problem Statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
10.2 Code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 31
10.3 Sample Input . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
10.4 Sample Output . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33

11 Program 11: Left Triangle Pattern 33

11.1 Problem Statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
11.2 Code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
11.3 Sample Input . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
11.4 Sample Output . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35

12 Program 12: Star Pyramid Pattern 35

12.1 Problem Statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 35
12.2 Code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
12.3 Sample Input . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
12.4 Sample Output . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37

13 Program 13: Matrix Addition 37

13.1 Problem Statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
13.2 Code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
13.3 Sample Input . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
13.4 Sample Output . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43

14 Program 14: Matrix Subtraction 43

14.1 Problem Statement . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
14.2 Code . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
14.3 Sample Input . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
14.4 Sample Output . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 50
Assembly Programming Report Page 3

1 Program 1: Hello World

1.1 Problem Statement
Write an assembly language program that displays "Hello World!" to the console and exits gracefully.

1.2 Code

1 section .data
2 msg db " Hello World ! " , 0 xA
3 len equ $ - msg
4
5 section .text
6 global _start
7
8 _start :
9 mov rax , 1 ; syscall : write
10 mov rdi , 1 ; stdout ( file descriptor 1)
11 mov rsi , msg ; address of our message
12 mov rdx , len ; length of message
13 syscall
14
15 mov rax , 60 ; syscall : exit
16 xor rdi , rdi ; return code 0
17 syscall

1.3 Output

1 Hello World !
Assembly Programming Report Page 4

2 Program 2: Two Number Addition

2.1 Problem Statement
Write an assembly language program that prompts the user to enter two integers, calculates their sum, and
displays the result.

2.2 Code

1 section .data
2 prompt1 db " Enter first number : " , 0
3 prompt1_len equ $ - prompt1
4 prompt2 db " Enter second number : " , 0
5 prompt2_len equ $ - prompt2
6 result_msg db " The sum is : " , 0
7 result_msg_len equ $ - result_msg
8 newline db 10 , 0
9
10 section .bss
11 num1 resq 1 ; Reserve 8 bytes for first number
12 num2 resq 1 ; Reserve 8 bytes for second number
13 sum resq 1 ; Reserve 8 bytes for sum
14 buffer resb 20 ; Buffer for input string
15 result_str resb 20 ; Buffer for result string
16
17 section .text
18 global _start
19
20 _start :
21 ; Print first prompt
22 mov rax , 1 ; sys_write
23 mov rdi , 1 ; stdout
24 mov rsi , prompt1
25 mov rdx , prompt1_len
26 syscall
27
28 ; Read first number
29 call read_number
30 mov [ num1 ] , rax
31
32 ; Print second prompt
33 mov rax , 1
34 mov rdi , 1
35 mov rsi , prompt2
36 mov rdx , prompt2_len
37 syscall
38
39 ; Read second number
40 call read_number
41 mov [ num2 ] , rax
42
43 ; Calculate sum
44 mov rax , [ num1 ]
45 add rax , [ num2 ]
46 mov [ sum ] , rax
47
48 ; Print result message
49 mov rax , 1
50 mov rdi , 1
51 mov rsi , result_msg
52 mov rdx , result_msg_len
53 syscall
54
55 ; Convert sum to string and print
56 mov rax , [ sum ]
Assembly Programming Report Page 5

57 call print_number
58
59 ; Print newline
60 mov rax , 1
61 mov rdi , 1
62 mov rsi , newline
63 mov rdx , 1
64 syscall
65
66 ; Exit program
67 mov rax , 60 ; sys_exit
68 mov rdi , 0 ; exit status
69 syscall
70
71 ; Function to read a number from stdin
72 read_number :
73 push rbp
74 mov rbp , rsp
75
76 ; Read string input
77 mov rax , 0 ; sys_read
78 mov rdi , 0 ; stdin
79 mov rsi , buffer
80 mov rdx , 20
81 syscall
82
83 ; Convert string to integer
84 mov rsi , buffer
85 xor rax , rax ; Clear result
86 xor rcx , rcx ; Clear digit counter
87 mov rbx , 10 ; Base 10
88
89 convert_loop :
90 movzx rdx , byte [ rsi + rcx ]
91 cmp dl , 10 ; Check for newline
92 je convert_done
93 cmp dl , 0 ; Check for null terminator
94 je convert_done
95 cmp dl , ’0 ’
96 jl convert_done
97 cmp dl , ’9 ’
98 jg convert_done
99 sub dl , ’0 ’ ; Convert ASCII to digit
100 imul rax , rbx ; Multiply current result by 10
101 add rax , rdx ; Add new digit
102 inc rcx
103 jmp convert_loop
104
105 convert_done :
106 pop rbp
107 ret
108
109 ; Function to print a number
110 print_number :
111 push rbp
112 mov rbp , rsp
113 push rbx
114 push rcx
115 push rdx
116
117 mov rbx , 10 ; Divisor
118 mov rcx , 0 ; Digit counter
119 mov rsi , result_str
120 add rsi , 19 ; Point to end of buffer
121 mov byte [ rsi ] , 0 ; Null terminate
122
Assembly Programming Report Page 6

123 ; Handle zero case

124 test rax , rax
125 jnz divide_loop
126 dec rsi
127 mov byte [ rsi ] , ’0 ’
128 inc rcx
129 jmp print_digits
130
131 divide_loop :
132 xor rdx , rdx ; Clear remainder
133 div rbx ; Divide by 10
134 add dl , ’0 ’ ; Convert remainder to ASCII
135 dec rsi
136 mov [ rsi ] , dl
137 inc rcx
138 test rax , rax
139 jnz divide_loop
140
141 print_digits :
142 mov rax , 1 ; sys_write
143 mov rdi , 1 ; stdout
144 mov rdx , rcx ; Number of digits
145 syscall
146
147 pop rdx
148 pop rcx
149 pop rbx
150 pop rbp
151 ret

2.3 Sample Input

1 Enter first number : 25

2 Enter second number : 37

2.4 Sample Output

1 The sum is : 62
Assembly Programming Report Page 7

3 Program 3: Average Calculator with Decimal Precision

3.1 Problem Statement
Write an assembly language program that calculates the average of multiple user-provided integers with two
decimal places precision and includes input validation for minimum 2 numbers.

3.2 Code

1 section .data
2 prompt_count db " How many numbers do you want to enter? " , 0
3 prompt_count_len equ $ - prompt_count
4 prompt_num db " Enter number " , 0
5 prompt_num_len equ $ - prompt_num
6 colon db " : " , 0
7 result_msg db " The average is : " , 0
8 result_msg_len equ $ - result_msg
9 decimal_point db " . " , 0
10 newline db 10 , 0
11 error_msg db " Error : Please enter at least 2 numbers ! " , 10 , 0
12 error_msg_len equ $ - error_msg
13
14 section .bss
15 count resq 1 ; Number of values to input
16 sum resq 1 ; Sum of all numbers
17 average resq 1 ; Integer part of average
18 remainder resq 1 ; Remainder for decimal calculation
19 counter resq 1 ; Loop counter
20 buffer resb 20 ; Input buffer
21 result_str resb 20 ; Result string buffer
22 num_str resb 5 ; For printing current number position
23
24 section .text
25 global _start
26
27 _start :
28 ; Print prompt for count
29 mov rax , 1 ; sys_write
30 mov rdi , 1 ; stdout
31 mov rsi , prompt_count
32 mov rdx , prompt_count_len
33 syscall
34
35 ; Read number of values
36 call read_number
37 mov [ count ] , rax
38
39 ; Validate input ( must be >= 2)
40 cmp rax , 2
41 jl error_exit
42
43 ; Initialize variables
44 mov qword [ sum ] , 0
45 mov qword [ counter ] , 1
46
47 input_loop :
48 ; Check if we ’ ve read all numbers
49 mov rax , [ counter ]
50 cmp rax , [ count ]
51 jg calcu late_average
52
53 ; Print prompt for current number
54 mov rax , 1
55 mov rdi , 1
56 mov rsi , prompt_num
Assembly Programming Report Page 8

57 mov rdx , prompt_num_len

58 syscall
59
60 ; Print current number position
61 mov rax , [ counter ]
62 call p r i nt_number_inline
63
64 ; Print colon
65 mov rax , 1
66 mov rdi , 1
67 mov rsi , colon
68 mov rdx , 2
69 syscall
70
71 ; Read number
72 call read_number
73
74 ; Add to sum
75 add [ sum ] , rax
76
77 ; Increment counter
78 inc qword [ counter ]
79 jmp input_loop
80
81 calcu late_average :
82 ; Calculate average : sum / count
83 mov rax , [ sum ]
84 mov rbx , [ count ]
85
86 ; Save original values for remainder calculation
87 mov rcx , rax ; Save sum
88 mov rdx , rbx ; Save count
89
90 ; Integer division
91 xor rdx , rdx ; Clear remainder
92 div rbx
93 mov [ average ] , rax
94 mov [ remainder ] , rdx
95
96 ; Print result message
97 mov rax , 1
98 mov rdi , 1
99 mov rsi , result_msg
100 mov rdx , result_msg_len
101 syscall
102
103 ; Print integer part of average
104 mov rax , [ average ]
105 call print_number
106
107 ; Print decimal point
108 mov rax , 1
109 mov rdi , 1
110 mov rsi , decimal_point
111 mov rdx , 1
112 syscall
113
114 ; Calculate and print first two decimal places
115 mov rax , [ remainder ]
116 mov rbx , 10
117 mul rbx ; remainder * 10
118 xor rdx , rdx
119 div qword [ count ] ; ( remainder * 10) / count
120 call p rint_single_digit
121
122 ; Calculate second decimal place
Assembly Programming Report Page 9

123 mov rax , rdx ; Use remainder from previous division

124 mov rbx , 10
125 mul rbx
126 xor rdx , rdx
127 div qword [ count ]
128 call p rint_single_digit
129
130 ; Print newline
131 mov rax , 1
132 mov rdi , 1
133 mov rsi , newline
134 mov rdx , 1
135 syscall
136
137 ; Exit program
138 mov rax , 60 ; sys_exit
139 mov rdi , 0 ; exit status
140 syscall
141
142 error_exit :
143 ; Print error message
144 mov rax , 1
145 mov rdi , 1
146 mov rsi , error_msg
147 mov rdx , error_msg_len
148 syscall
149
150 ; Exit with error code
151 mov rax , 60
152 mov rdi , 1
153 syscall
154
155 ; Function to read a number from stdin
156 read_number :
157 push rbp
158 mov rbp , rsp
159 push rbx
160 push rcx
161 push rdx
162 push rsi
163
164 ; Read string input
165 mov rax , 0 ; sys_read
166 mov rdi , 0 ; stdin
167 mov rsi , buffer
168 mov rdx , 20
169 syscall
170
171 ; Convert string to integer
172 mov rsi , buffer
173 xor rax , rax ; Clear result
174 xor rcx , rcx ; Clear digit counter
175 mov rbx , 10 ; Base 10
176
177 convert_loop :
178 movzx rdx , byte [ rsi + rcx ]
179 cmp dl , 10 ; Check for newline
180 je convert_done
181 cmp dl , 0 ; Check for null terminator
182 je convert_done
183 cmp dl , ’0 ’
184 jl convert_done
185 cmp dl , ’9 ’
186 jg convert_done
187
188 sub dl , ’0 ’ ; Convert ASCII to digit
Assembly Programming Report Page 10

189 imul rax , rbx ; Multiply current result by 10

190 add rax , rdx ; Add new digit
191 inc rcx
192 jmp convert_loop
193
194 convert_done :
195 pop rsi
196 pop rdx
197 pop rcx
198 pop rbx
199 pop rbp
200 ret
201
202 ; Function to print a number
203 print_number :
204 push rbp
205 mov rbp , rsp
206 push rax
207 push rbx
208 push rcx
209 push rdx
210 push rsi
211
212 mov rbx , 10 ; Divisor
213 mov rcx , 0 ; Digit counter
214 mov rsi , result_str
215 add rsi , 19 ; Point to end of buffer
216 mov byte [ rsi ] , 0 ; Null terminate
217
218 ; Handle zero case
219 test rax , rax
220 jnz divide_loop
221 dec rsi
222 mov byte [ rsi ] , ’0 ’
223 inc rcx
224 jmp print_digits
225
226 divide_loop :
227 xor rdx , rdx ; Clear remainder
228 div rbx ; Divide by 10
229 add dl , ’0 ’ ; Convert remainder to ASCII
230 dec rsi
231 mov [ rsi ] , dl
232 inc rcx
233 test rax , rax
234 jnz divide_loop
235
236 print_digits :
237 mov rax , 1 ; sys_write
238 mov rdi , 1 ; stdout
239 mov rdx , rcx ; Number of digits
240 syscall
241
242 pop rsi
243 pop rdx
244 pop rcx
245 pop rbx
246 pop rax
247 pop rbp
248 ret
249
250 ; Function to print a number inline ( for prompts )
251 pri n t _n u mb e r_inline :
252 push rbp
253 mov rbp , rsp
254 push rax
Assembly Programming Report Page 11

255 push rbx

256 push rcx
257 push rdx
258 push rsi
259
260 mov rbx , 10
261 mov rcx , 0
262 mov rsi , num_str
263 add rsi , 4
264 mov byte [ rsi ] , 0
265
266 test rax , rax
267 jnz d iv ide_loop_inline
268 dec rsi
269 mov byte [ rsi ] , ’0 ’
270 inc rcx
271 jmp pr i nt_digits_inline
272
273 di vi de _lo op _inline :
274 xor rdx , rdx
275 div rbx
276 add dl , ’0 ’
277 dec rsi
278 mov [ rsi ] , dl
279 inc rcx
280 test rax , rax
281 jnz d iv ide_loop_inline
282
283 pri n t _d i gi t s_inline :
284 mov rax , 1
285 mov rdi , 1
286 mov rdx , rcx
287 syscall
288
289 pop rsi
290 pop rdx
291 pop rcx
292 pop rbx
293 pop rax
294 pop rbp
295 ret
296
297 ; Function to print a single digit
298 pr in t_ sin gl e_digit :
299 push rbp
300 mov rbp , rsp
301 push rax
302 push rbx
303 push rdi
304 push rsi
305 push rdx
306
307 add al , ’0 ’ ; Convert to ASCII
308 mov [ result_str ] , al
309 mov byte [ result_str + 1] , 0
310
311 mov rax , 1 ; sys_write
312 mov rdi , 1 ; stdout
313 mov rsi , result_str
314 mov rdx , 1
315 syscall
316
317 pop rdx
318 pop rsi
319 pop rdi
320 pop rbx
Assembly Programming Report Page 12

321 pop rax

322 pop rbp
323 ret

3.3 Sample Input

1 How many numbers do you want to enter ? 4

2 Enter number 1: 10
3 Enter number 2: 20
4 Enter number 3: 30
5 Enter number 4: 40

3.4 Sample Output

1 The average is : 25.00

4 Program 4: Number Comparison

4.1 Problem Statement
Write an assembly language program that prompts the user to enter two integers, compares them, and
displays whether the first number is greater, the second number is greater, or both numbers are equal.

4.2 Code

1 section .data
2 prompt1 db " Enter first number : " , 0
3 prompt2 db " Enter second number : " , 0
4 result1 db " First number is greater " , 10 , 0
5 result2 db " Second number is greater " , 10 , 0
6 result_eq db " Both numbers are equal " , 10 , 0
7
8 section .bss
9 input1 resb 20
10 input2 resb 20
11 num1 resq 1
12 num2 resq 1
13
14 section .text
15 global _start
16
17 ; ---------------------------
18 ; _start ( entry point )
19 ; ---------------------------
20 _start :
21 ; Prompt and read first number
22 mov rdi , prompt1
23 call print_string
24 mov rsi , input1
25 call read_input
26 mov rsi , input1
27 call atoi
28 mov [ num1 ] , rax
29
30 ; Prompt and read second number
31 mov rdi , prompt2
32 call print_string
33 mov rsi , input2
34 call read_input
Assembly Programming Report Page 13

35 mov rsi , input2

36 call atoi
37 mov [ num2 ] , rax
38
39 ; Compare numbers
40 mov rax , [ num1 ]
41 mov rbx , [ num2 ]
42 cmp rax , rbx
43 je equal
44 ja first
45 jb second
46
47 first :
48 mov rdi , result1
49 call print_string
50 jmp exit
51
52 second :
53 mov rdi , result2
54 call print_string
55 jmp exit
56
57 equal :
58 mov rdi , result_eq
59 call print_string
60
61 exit :
62 mov rax , 60 ; syscall : exit
63 xor rdi , rdi ; exit code 0
64 syscall
65
66 ; ---------------------------
67 ; print_string : rdi = address of null - terminated string
68 ; ---------------------------
69 print_string :
70 push rsi
71 push rdx
72 mov rsi , rdi
73 xor rax , rax
74 xor rcx , rcx
75
76 .find_len :
77 cmp byte [ rsi + rcx ] , 0
78 je .done_len
79 inc rcx
80 jmp .find_len
81
82 .done_len :
83 mov rdx , rcx ; rdx = length
84 mov rax , 1 ; syscall : write
85 mov rdi , 1 ; stdout
86 syscall
87 pop rdx
88 pop rsi
89 ret
90
91 ; ---------------------------
92 ; read_input : rsi = buffer
93 ; ---------------------------
94 read_input :
95 mov rax , 0 ; syscall : read
96 mov rdi , 0 ; stdin
97 mov rdx , 20 ; max bytes
98 syscall
99 ; remove newline
100 mov rcx , rsi
Assembly Programming Report Page 14

101
102 .strip :
103 cmp byte [ rcx ] , 10
104 je .newline_found
105 cmp byte [ rcx ] , 0
106 je .done
107 inc rcx
108 jmp .strip
109
110 .newline_found :
111 mov byte [ rcx ] , 0
112
113 .done :
114 ret
115
116 ; ---------------------------
117 ; atoi : convert string to integer
118 ; input : rsi = address of string
119 ; output : rax = integer
120 ; ---------------------------
121 atoi :
122 xor rax , rax ; result
123 xor rbx , rbx ; digit
124
125 .next_char :
126 mov bl , [ rsi ]
127 cmp bl , 0
128 je .done
129 sub bl , ’0 ’
130 imul rax , rax , 10
131 add rax , rbx
132 inc rsi
133 jmp .next_char
134
135 .done :
136 ret

4.3 Sample Input

1 Test Case 1:
2 Enter first number : 25
3 Enter second number : 15
4 -------------
5 Test Case 2:
6 Enter first number : 10
7 Enter second number : 20
8 -------------
9 Test Case 3:
10 Enter first number : 30
11 Enter second number : 30

4.4 Sample Output

1 Test Case 1 Output :

2 First number is greater
3 --------------------------
4 Test Case 2 Output :
5 Second number is greater
6 ---------------------------
7 Test Case 3 Output :
8 Both numbers are equal
Assembly Programming Report Page 15

5 Program 5: Number Swapping

5.1 Problem Statement
Write an assembly language program that prompts the user to enter two integers, swaps their values, and
displays both numbers after the swapping operation.

5.2 Code

1 section .bss
2 num1 : resb 32 ; buffer for first number
3 num2 : resb 32 ; buffer for second number
4 int1 : resq 1 ; storage for integer 1
5 int2 : resq 1 ; storage for integer 2
6 outbuf : resb 32 ; buffer for output string
7
8 section .data
9 prompt1 : db " Enter first number : " ,0
10 prompt1_len : equ $ - prompt1
11 prompt2 : db " Enter second number : " ,0
12 prompt2_len : equ $ - prompt2
13 msg : db " After swapping : " ,10 ,0
14 msg_len : equ $ - msg
15 newline : db 10 ,0
16
17 section .text
18 global _start
19
20 _start :
21 ; Prompt for first number
22 mov rax , 1
23 mov rdi , 1
24 mov rsi , prompt1
25 mov rdx , prompt1_len
26 syscall
27
28 ; Read first number
29 mov rax , 0
30 mov rdi , 0
31 mov rsi , num1
32 mov rdx , 32
33 syscall
34
35 ; Convert string num1 --> integer in int1
36 mov rsi , num1
37 call str_to_int
38 mov [ int1 ] , rax
39
40 ; Prompt for second number
41 mov rax , 1
42 mov rdi , 1
43 mov rsi , prompt2
44 mov rdx , prompt2_len
45 syscall
46
47 ; Read second number
48 mov rax , 0
49 mov rdi , 0
50 mov rsi , num2
51 mov rdx , 32
52 syscall
53
54 ; Convert string num2 --> integer in int2
55 mov rsi , num2
56 call str_to_int
Assembly Programming Report Page 16

57 mov [ int2 ] , rax

58
59 ; -------- SWAP int1 and int2 --------
60 mov rax , [ int1 ]
61 mov rbx , [ int2 ]
62 mov rcx , rax
63 mov rax , rbx
64 mov rbx , rcx
65 mov [ int1 ] , rax
66 mov [ int2 ] , rbx
67
68 ; Print result message
69 mov rax , 1
70 mov rdi , 1
71 mov rsi , msg
72 mov rdx , msg_len
73 syscall
74
75 ; Print int1
76 mov rax , [ int1 ]
77 mov rsi , outbuf
78 call int_to_str
79 mov rax , 1
80 mov rdi , 1
81 mov rsi , outbuf
82 mov rdx , rbx ; length returned in rbx
83 syscall
84
85 ; Print newline
86 mov rax , 1
87 mov rdi , 1
88 mov rsi , newline
89 mov rdx , 1
90 syscall
91
92 ; Print int2
93 mov rax , [ int2 ]
94 mov rsi , outbuf
95 call int_to_str
96 mov rax , 1
97 mov rdi , 1
98 mov rsi , outbuf
99 mov rdx , rbx
100 syscall
101
102 ; Print newline
103 mov rax , 1
104 mov rdi , 1
105 mov rsi , newline
106 mov rdx , 1
107 syscall
108
109 ; Exit
110 mov rax , 60
111 xor rdi , rdi
112 syscall
113
114 ; -------------------------------------------
115 ; str_to_int ( RSI points to string , return RAX = integer )
116 ; -------------------------------------------
117 str_to_int :
118 xor rax , rax
119 xor rcx , rcx
120
121 .next_digit :
122 mov bl , byte [ rsi + rcx ]
Assembly Programming Report Page 17

123 cmp bl , 10 ; newline?

124 je .done
125 cmp bl , 0
126 je .done
127 sub bl , ’0 ’
128 imul rax , rax , 10
129 add rax , rbx
130 inc rcx
131 jmp .next_digit
132
133 .done :
134 ret
135
136 ; -------------------------------------------
137 ; int_to_str ( RAX = integer , RSI = buffer )
138 ; returns : buffer filled with string , RBX = length
139 ; -------------------------------------------
140 int_to_str :
141 mov rcx , 0
142 mov rbx , 10
143
144 .convert :
145 xor rdx , rdx
146 div rbx ; divide RAX by 10
147 add dl , ’0 ’
148 push rdx
149 inc rcx
150 test rax , rax
151 jnz .convert
152
153 mov rbx , rcx ; length
154 mov rdi , rsi
155
156 .print_loop :
157 pop rdx
158 mov [ rdi ] , dl
159 inc rdi
160 loop .print_loop
161 ret

5.3 Sample Input

1 Enter first number : 15

2 Enter second number : 25

5.4 Sample Output

1 After swapping :
2 25
3 15

6 Program 6: Prime Number Checker

6.1 Problem Statement
Write an assembly language program that prompts the user to enter a number, checks whether the number
is prime or not, and displays an appropriate message indicating the result.
Assembly Programming Report Page 18

6.2 Code

1 section .bss
2 num resb 32 ; buffer for input
3 value resq 1 ; integer storage
4 outbuf resb 32 ; buffer for integer to string ( not needed here , but useful )
5
6 section .data
7 prompt db " Enter a number : " ,0
8 prompt_len equ $ - prompt
9 prime_msg db " It is a Prime number " ,10 ,0
10 prime_len equ $ - prime_msg
11 notprime_msg db " It is NOT a Prime number " ,10 ,0
12 notprime_len equ $ - notprime_msg
13
14 section .text
15 global _start
16
17 _start :
18 ; Print prompt
19 mov rax , 1
20 mov rdi , 1
21 mov rsi , prompt
22 mov rdx , prompt_len
23 syscall
24
25 ; Read number string
26 mov rax , 0
27 mov rdi , 0
28 mov rsi , num
29 mov rdx , 32
30 syscall
31
32 ; Convert string to integer
33 mov rsi , num
34 call str_to_int
35 mov [ value ] , rax ; store input number
36
37 ; Check if number < 2 --> Not prime
38 cmp rax , 2
39 jl not_prime
40
41 ; Check divisibility
42 mov rcx , 2 ; divisor = 2
43
44 check_loop :
45 mov rbx , rcx
46 mov rdx , 0
47 mov rax , [ value ]
48 div rbx ; rax / rbx --> quotient , remainder in rdx
49 cmp rdx , 0
50 je not_prime ; divisible --> not prime
51
52 inc rcx
53 mov rax , rcx
54 mov rbx , rcx
55 imul rbx , rbx ; rcx ^2
56 cmp rbx , [ value ]
57 jle check_loop
58 jmp is_prime
59
60 ; ---------------------------------
61 is_prime :
62 mov rax , 1
63 mov rdi , 1
64 mov rsi , prime_msg
Assembly Programming Report Page 19

65 mov rdx , prime_len

66 syscall
67 jmp exit
68
69 not_prime :
70 mov rax , 1
71 mov rdi , 1
72 mov rsi , notprime_msg
73 mov rdx , notprime_len
74 syscall
75 jmp exit
76
77 ; ---------------------------------
78 ; str_to_int ( convert string --> integer )
79 ; RSI points to string , result in RAX
80 ; ---------------------------------
81 str_to_int :
82 xor rax , rax
83 xor rcx , rcx
84
85 .next_digit :
86 mov bl , byte [ rsi + rcx ]
87 cmp bl , 10 ; newline?
88 je .done
89 cmp bl , 0
90 je .done
91 sub bl , ’0 ’
92 imul rax , rax , 10
93 add rax , rbx
94 inc rcx
95 jmp .next_digit
96
97 .done :
98 ret
99
100 ; ---------------------------------
101 exit :
102 mov rax , 60
103 xor rdi , rdi
104 syscall

6.3 Sample Input

1 Test Case 1:
2 Enter a number : 7
3 -------------
4 Test Case 2:
5 Enter a number : 12
6 -------------
7 Test Case 3:
8 Enter a number : 1

6.4 Sample Output

1 Test Case 1 Output :

2 It is a Prime number
3 --------------------------
4 Test Case 2 Output :
5 It is NOT a Prime number
6 ---------------------------
7 Test Case 3 Output :
8 It is NOT a Prime number
Assembly Programming Report Page 20

7 Program 7: Fibonacci Series Generator

7.1 Problem Statement
Write an assembly language program that prompts the user to enter the number of Fibonacci terms to
generate, validates the input to ensure it’s a positive number, and displays the Fibonacci series up to the
specified number of terms with proper formatting.

7.2 Code

1 section .data
2 prompt db " Enter number of Fibonacci terms to generate : " , 0
3 prompt_len equ $ - prompt
4 series_msg db " Fibonacci Series : " , 10 , 0
5 series_msg_len equ $ - series_msg
6 space db " " , 0
7 newline db 10 , 0
8 error_msg db " Error : Please enter a positive number ! " , 10 , 0
9 error_msg_len equ $ - error_msg
10
11 section .bss
12 n resq 1 ; Number of terms to generate
13 fib1 resq 1 ; First Fibonacci number
14 fib2 resq 1 ; Second Fibonacci number
15 temp resq 1 ; Temporary storage
16 counter resq 1 ; Loop counter
17 buffer resb 20 ; Input buffer
18 result_str resb 20 ; Result string buffer
19
20 section .text
21 global _start
22
23 _start :
24 ; Print prompt
25 mov rax , 1 ; sys_write
26 mov rdi , 1 ; stdout
27 mov rsi , prompt
28 mov rdx , prompt_len
29 syscall
30
31 ; Read number of terms
32 call read_number
33 mov [ n ] , rax
34
35 ; Check if input is valid ( > 0)
36 cmp rax , 0
37 jle error_exit
38
39 ; Print series message
40 mov rax , 1
41 mov rdi , 1
42 mov rsi , series_msg
43 mov rdx , series_msg_len
44 syscall
45
46 ; Initialize Fibonacci sequence
47 mov qword [ fib1 ] , 0 ; First Fibonacci number
48 mov qword [ fib2 ] , 1 ; Second Fibonacci number
49 mov qword [ counter ] , 0 ; Initialize counter
50
51 ; Handle special cases
52 mov rax , [ n ]
53 cmp rax , 1
54 je print_first_only
55 cmp rax , 2
Assembly Programming Report Page 21

56 je print_first_two
57
58 ; Print first number (0)
59 mov rax , [ fib1 ]
60 call print_number
61 call print_space
62
63 ; Print second number (1)
64 mov rax , [ fib2 ]
65 call print_number
66 call print_space
67
68 ; Set counter to 2 ( already printed 2 numbers )
69 mov qword [ counter ] , 2
70
71 fibonacci_loop :
72 mov rax , [ counter ]
73 cmp rax , [ n ]
74 jge done
75
76 ; Calculate next Fibonacci number : temp = fib1 + fib2
77 mov rax , [ fib1 ]
78 add rax , [ fib2 ]
79 mov [ temp ] , rax
80
81 ; Print the new Fibonacci number
82 call print_number
83 call print_space
84
85 ; Update for next iteration : fib1 = fib2 , fib2 = temp
86 mov rax , [ fib2 ]
87 mov [ fib1 ] , rax
88 mov rax , [ temp ]
89 mov [ fib2 ] , rax
90
91 ; Increment counter
92 inc qword [ counter ]
93 jmp fibonacci_loop
94
95 print_first_only :
96 mov rax , [ fib1 ]
97 call print_number
98 jmp done
99
100 print_first_two :
101 mov rax , [ fib1 ]
102 call print_number
103 call print_space
104 mov rax , [ fib2 ]
105 call print_number
106 jmp done
107
108 done :
109 ; Print newline
110 mov rax , 1
111 mov rdi , 1
112 mov rsi , newline
113 mov rdx , 1
114 syscall
115
116 ; Exit program
117 mov rax , 60 ; sys_exit
118 mov rdi , 0 ; exit status
119 syscall
120
121 error_exit :
Assembly Programming Report Page 22

122 ; Print error message

123 mov rax , 1
124 mov rdi , 1
125 mov rsi , error_msg
126 mov rdx , error_msg_len
127 syscall
128
129 ; Exit with error code
130 mov rax , 60
131 mov rdi , 1
132 syscall
133
134 ; Function to read a number from stdin
135 read_number :
136 push rbp
137 mov rbp , rsp
138
139 ; Read string input
140 mov rax , 0 ; sys_read
141 mov rdi , 0 ; stdin
142 mov rsi , buffer
143 mov rdx , 20
144 syscall
145
146 ; Convert string to integer
147 mov rsi , buffer
148 xor rax , rax ; Clear result
149 xor rcx , rcx ; Clear digit counter
150 mov rbx , 10 ; Base 10
151
152 convert_loop :
153 movzx rdx , byte [ rsi + rcx ]
154 cmp dl , 10 ; Check for newline
155 je convert_done
156 cmp dl , 0 ; Check for null terminator
157 je convert_done
158 cmp dl , ’0 ’
159 jl convert_done
160 cmp dl , ’9 ’
161 jg convert_done
162
163 sub dl , ’0 ’ ; Convert ASCII to digit
164 imul rax , rbx ; Multiply current result by 10
165 add rax , rdx ; Add new digit
166 inc rcx
167 jmp convert_loop
168
169 convert_done :
170 pop rbp
171 ret
172
173 ; Function to print a number
174 print_number :
175 push rbp
176 mov rbp , rsp
177 push rax
178 push rbx
179 push rcx
180 push rdx
181 push rsi
182
183 mov rbx , 10 ; Divisor
184 mov rcx , 0 ; Digit counter
185 mov rsi , result_str
186 add rsi , 19 ; Point to end of buffer
187 mov byte [ rsi ] , 0 ; Null terminate
Assembly Programming Report Page 23

188
189 ; Handle zero case
190 test rax , rax
191 jnz divide_loop
192 dec rsi
193 mov byte [ rsi ] , ’0 ’
194 inc rcx
195 jmp print_digits
196
197 divide_loop :
198 xor rdx , rdx ; Clear remainder
199 div rbx ; Divide by 10
200 add dl , ’0 ’ ; Convert remainder to ASCII
201 dec rsi
202 mov [ rsi ] , dl
203 inc rcx
204 test rax , rax
205 jnz divide_loop
206
207 print_digits :
208 mov rax , 1 ; sys_write
209 mov rdi , 1 ; stdout
210 mov rdx , rcx ; Number of digits
211 syscall
212
213 pop rsi
214 pop rdx
215 pop rcx
216 pop rbx
217 pop rax
218 pop rbp
219 ret
220
221 ; Function to print a space
222 print_space :
223 push rbp
224 mov rbp , rsp
225 push rax
226 push rdi
227 push rsi
228 push rdx
229
230 mov rax , 1 ; sys_write
231 mov rdi , 1 ; stdout
232 mov rsi , space
233 mov rdx , 1
234 syscall
235
236 pop rdx
237 pop rsi
238 pop rdi
239 pop rax
240 pop rbp
241 ret

7.3 Sample Input

1 Enter number of Fibonacci terms to generate : 8

7.4 Sample Output

1 Fibonacci Series :
2 0 1 1 2 3 5 8 13
Assembly Programming Report Page 24

8 Program 8: Factorial Calculator

8.1 Problem Statement
Write a program that prompts the user to enter a non-negative integer, calculates its factorial, and displays
the result with proper error handling for negative numbers and overflow conditions.

8.2 Code

1 section .data
2 prompt db " Enter a number to calculate factorial : " , 0
3 prompt_len equ $ - prompt
4 result_msg db " Factorial of " , 0
5 result_msg_len equ $ - result_msg
6 equals db " is : " , 0
7 equals_len equ $ - equals
8 newline db 10 , 0
9 error_msg db " Error : Please enter a non - negative number ! " , 10 , 0
10 error_msg_len equ $ - error_msg
11 overflow_msg db " Error : Number too large ( factorial overflow ) ! " , 10 , 0
12 overflow_msg_len equ $ - overflow_msg
13 ze ro _f actorial_msg db " 1 " , 10 , 0 ; 0! = 1
14
15 section .bss
16 input_num resq 1 ; Input number
17 factorial resq 1 ; Result factorial
18 counter resq 1 ; Loop counter
19 buffer resb 20 ; Input buffer
20 result_str resb 25 ; Result string buffer ( larger for big numbers )
21
22 section .text
23 global _start
24
25 _start :
26 ; Print prompt
27 mov rax , 1 ; sys_write
28 mov rdi , 1 ; stdout
29 mov rsi , prompt
30 mov rdx , prompt_len
31 syscall
32
33 ; Read input number
34 call read_number
35 mov [ input_num ] , rax
36
37 ; Check for negative numbers
38 test rax , rax
39 js error_exit
40
41 ; Check for overflow potential ( factorial grows very quickly )
42 ; 20! is the largest factorial that fits in 64 - bit
43 cmp rax , 20
44 jg overflow_exit
45
46 ; Handle special case : 0! = 1
47 cmp rax , 0
48 je zero_factorial
49
50 ; Print result message part 1
51 mov rax , 1
52 mov rdi , 1
53 mov rsi , result_msg
54 mov rdx , result_msg_len
55 syscall
56
Assembly Programming Report Page 25

57 ; Print the input number

58 mov rax , [ input_num ]
59 call print_number
60
61 ; Print equals part
62 mov rax , 1
63 mov rdi , 1
64 mov rsi , equals
65 mov rdx , equals_len
66 syscall
67
68 ; Calculate factorial
69 call c a l culate_factorial
70
71 ; Print factorial result
72 mov rax , [ factorial ]
73 call print_number
74
75 ; Print newline
76 mov rax , 1
77 mov rdi , 1
78 mov rsi , newline
79 mov rdx , 1
80 syscall
81
82 ; Exit program
83 mov rax , 60 ; sys_exit
84 mov rdi , 0 ; exit status
85 syscall
86
87 zero_factorial :
88 ; Print result message part 1
89 mov rax , 1
90 mov rdi , 1
91 mov rsi , result_msg
92 mov rdx , result_msg_len
93 syscall
94
95 ; Print "0"
96 mov rax , 0
97 call print_number
98
99 ; Print equals part
100 mov rax , 1
101 mov rdi , 1
102 mov rsi , equals
103 mov rdx , equals_len
104 syscall
105
106 ; Print "1" for 0!
107 mov rax , 1
108 call print_number
109
110 ; Print newline and exit
111 mov rax , 1
112 mov rdi , 1
113 mov rsi , newline
114 mov rdx , 1
115 syscall
116
117 mov rax , 60
118 mov rdi , 0
119 syscall
120
121 error_exit :
122 ; Print error message
Assembly Programming Report Page 26

123 mov rax , 1

124 mov rdi , 1
125 mov rsi , error_msg
126 mov rdx , error_msg_len
127 syscall
128
129 ; Exit with error code
130 mov rax , 60
131 mov rdi , 1
132 syscall
133
134 overflow_exit :
135 ; Print overflow message
136 mov rax , 1
137 mov rdi , 1
138 mov rsi , overflow_msg
139 mov rdx , overflow_msg_len
140 syscall
141
142 ; Exit with error code
143 mov rax , 60
144 mov rdi , 1
145 syscall
146
147 ; Function to calculate factorial
148 cal c u la t e_ f actorial :
149 push rbp
150 mov rbp , rsp
151 push rbx
152 push rcx
153 push rdx
154
155 mov rax , [ input_num ]
156 mov rbx , rax ; Store input number
157 mov rcx , rax ; Counter for loop
158 mov rax , 1 ; Initialize result to 1
159
160 ; Handle case where input is 1
161 cmp rbx , 1
162 je factorial_done
163
164 factorial_loop :
165 cmp rcx , 1
166 jle factorial_done
167
168 ; Check for overflow before multiplication
169 ; Simple overflow check : if rax > (2^64 - 1) / rcx , we ’ ll overflow
170 push rax
171 push rcx
172 mov rdx , 0
173 mov rbx , rcx
174 ; We ’ ll skip complex overflow check for simplicity in this example
175 ; In production code , you ’d want more sophisticated overflow detection
176 pop rcx
177 pop rax
178
179 mul rcx ; rax = rax * rcx
180 dec rcx
181 jmp factorial_loop
182
183 factorial_done :
184 mov [ factorial ] , rax
185
186 pop rdx
187 pop rcx
188 pop rbx
Assembly Programming Report Page 27

189 pop rbp

190 ret
191
192 ; Function to read a number from stdin
193 read_number :
194 push rbp
195 mov rbp , rsp
196 push rbx
197 push rcx
198 push rdx
199 push rsi
200
201 ; Read string input
202 mov rax , 0 ; sys_read
203 mov rdi , 0 ; stdin
204 mov rsi , buffer
205 mov rdx , 20
206 syscall
207
208 ; Convert string to integer
209 mov rsi , buffer
210 xor rax , rax ; Clear result
211 xor rcx , rcx ; Clear digit counter
212 mov rbx , 10 ; Base 10
213 xor r8 , r8 ; Sign flag (0 = positive , 1 = negative )
214
215 ; Check for negative sign
216 movzx rdx , byte [ rsi ]
217 cmp dl , ’ - ’
218 jne convert_loop
219 mov r8 , 1 ; Set negative flag
220 inc rsi ; Skip the minus sign
221
222 convert_loop :
223 movzx rdx , byte [ rsi + rcx ]
224 cmp dl , 10 ; Check for newline
225 je convert_done
226 cmp dl , 0 ; Check for null terminator
227 je convert_done
228 cmp dl , ’0 ’
229 jl convert_done
230 cmp dl , ’9 ’
231 jg convert_done
232
233 sub dl , ’0 ’ ; Convert ASCII to digit
234 imul rax , rbx ; Multiply current result by 10
235 add rax , rdx ; Add new digit
236 inc rcx
237 jmp convert_loop
238
239 convert_done :
240 ; Apply sign
241 test r8 , r8
242 jz positive_result
243 neg rax
244
245 positive_result :
246 pop rsi
247 pop rdx
248 pop rcx
249 pop rbx
250 pop rbp
251 ret
252
253 ; Function to print a number
254 print_number :
Assembly Programming Report Page 28

255 push rbp

256 mov rbp , rsp
257 push rax
258 push rbx
259 push rcx
260 push rdx
261 push rsi
262 push r8
263
264 ; Handle negative numbers
265 test rax , rax
266 jns positive_print
267
268 ; Print negative sign
269 push rax
270 mov rax , 1
271 mov rdi , 1
272 mov rsi , result_str
273 mov byte [ rsi ] , ’ - ’
274 mov rdx , 1
275 syscall
276 pop rax
277 neg rax ; Make positive for printing
278
279 positive_print :
280 mov rbx , 10 ; Divisor
281 mov rcx , 0 ; Digit counter
282 mov rsi , result_str
283 add rsi , 24 ; Point to end of buffer
284 mov byte [ rsi ] , 0 ; Null terminate
285
286 ; Handle zero case
287 test rax , rax
288 jnz divide_loop
289 dec rsi
290 mov byte [ rsi ] , ’0 ’
291 inc rcx
292 jmp print_digits
293
294 divide_loop :
295 xor rdx , rdx ; Clear remainder
296 div rbx ; Divide by 10
297 add dl , ’0 ’ ; Convert remainder to ASCII
298 dec rsi
299 mov [ rsi ] , dl
300 inc rcx
301 test rax , rax
302 jnz divide_loop
303
304 print_digits :
305 mov rax , 1 ; sys_write
306 mov rdi , 1 ; stdout
307 mov rdx , rcx ; Number of digits
308 syscall
309
310 pop r8
311 pop rsi
312 pop rdx
313 pop rcx
314 pop rbx
315 pop rax
316 pop rbp
317 ret
Assembly Programming Report Page 29

8.3 Sample Input

1 Enter a number to calculate factorial : 5

8.4 Sample Output

1 Factorial of 5 is : 120

9 Program 9: GCD Calculator

9.1 Problem Statement
Write a program that takes two positive integers as input and computes their Greatest Common Divisor
(GCD) using the Euclidean algorithm.

9.2 Code

1 section .bss
2 buf resb 20 ; input buffer
3 section .data
4 prompt1 db " Enter first number : " ,0
5 plen1 equ $ - prompt1
6 prompt2 db " Enter second number : " ,0
7 plen2 equ $ - prompt2
8 newline db 10
9 section .text
10 global _start
11 _start :
12 ; --- input first number ---
13 mov rax , 1
14 mov rdi , 1
15 mov rsi , prompt1
16 mov rdx , plen1
17 syscall
18 mov rax , 0
19 mov rdi , 0
20 mov rsi , buf
21 mov rdx , 20
22 syscall
23 ; convert string to integer -> r12
24 mov rsi , buf
25 xor r12 , r12
26 .convert1 :
27 mov al , [ rsi ]
28 cmp al , 10
29 je .done1
30 cmp al , 0
31 je .done1
32 sub al , ’0 ’
33 imul r12 , r12 , 10
34 add r12 , rax
35 inc rsi
36 jmp .convert1
37 .done1 :
38 ; --- input second number ---
39 mov rax , 1
40 mov rdi , 1
41 mov rsi , prompt2
42 mov rdx , plen2
43 syscall
44 mov rax , 0
Assembly Programming Report Page 30

45 mov rdi , 0
46 mov rsi , buf
47 mov rdx , 20
48 syscall
49 ; convert string to integer -> r13
50 mov rsi , buf
51 xor r13 , r13
52 .convert2 :
53 mov al , [ rsi ]
54 cmp al , 10
55 je .done2
56 cmp al , 0
57 je .done2
58 sub al , ’0 ’
59 imul r13 , r13 , 10
60 add r13 , rax
61 inc rsi
62 jmp .convert2
63 .done2 :
64 ; --- compute GCD using Euclidean algorithm ---
65 mov rax , r12
66 mov rbx , r13
67 gcd_loop :
68 cmp rbx , 0
69 je .gcd_done
70 xor rdx , rdx
71 div rbx ; RAX / RBX -> quotient in RAX , remainder in RDX
72 mov rax , rbx ; move divisor to RAX
73 mov rbx , rdx ; remainder to RBX
74 jmp gcd_loop
75 .gcd_done :
76 ; RAX now has GCD
77 ; --- print GCD ---
78 call print_num
79 call print_newline
80 ; exit
81 mov rax , 60
82 xor rdi , rdi
83 syscall
84 ; ===============================
85 ; print number in RAX
86 ; ===============================
87 print_num :
88 mov rbx , 10
89 lea rsi , [ buf +19]
90 mov byte [ rsi ] , 0
91 .convert :
92 xor rdx , rdx
93 div rbx
94 add dl , ’0 ’
95 dec rsi
96 mov [ rsi ] , dl
97 test rax , rax
98 jnz .convert
99 mov rax , 1
100 mov rdi , 1
101 mov rdx , buf +19
102 sub rdx , rsi
103 mov rsi , rsi
104 syscall
105 ret
106 print_newline :
107 mov rax , 1
108 mov rdi , 1
109 mov rsi , newline
110 mov rdx , 1
Assembly Programming Report Page 31

111 syscall
112 ret

9.3 Sample Input

1 Enter first number : 48

2 Enter second number : 18

9.4 Sample Output

16

10 Program 10: LCM Calculator

10.1 Problem Statement
Write a program that takes two positive integers as input and computes their Least Common Multiple (LCM)
using the formula LCM(a,b) = (a*b)/GCD(a,b).

10.2 Code

1 section .bss
2 buf resb 20 ; input buffer
3 section .data
4 prompt1 db " Enter first number : " ,0
5 plen1 equ $ - prompt1
6 prompt2 db " Enter second number : " ,0
7 plen2 equ $ - prompt2
8 newline db 10
9 section .text
10 global _start
11 _start :
12 ; --- input first number ---
13 mov rax , 1
14 mov rdi , 1
15 mov rsi , prompt1
16 mov rdx , plen1
17 syscall
18 mov rax , 0
19 mov rdi , 0
20 mov rsi , buf
21 mov rdx , 20
22 syscall
23 ; convert string to integer -> rbx
24 mov rsi , buf
25 xor rbx , rbx
26 .convert1 :
27 mov al , [ rsi ]
28 cmp al , 10
29 je .done1
30 cmp al , 0
31 je .done1
32 sub al , ’0 ’
33 imul rbx , rbx , 10
34 add rbx , rax
35 inc rsi
36 jmp .convert1
37 .done1 :
38 mov r12 , rbx ; store first number in r12
Assembly Programming Report Page 32

39 ; --- input second number ---

40 mov rax , 1
41 mov rdi , 1
42 mov rsi , prompt2
43 mov rdx , plen2
44 syscall
45 mov rax , 0
46 mov rdi , 0
47 mov rsi , buf
48 mov rdx , 20
49 syscall
50 ; convert string to integer -> rbx
51 mov rsi , buf
52 xor rbx , rbx
53 .convert2 :
54 mov al , [ rsi ]
55 cmp al , 10
56 je .done2
57 cmp al , 0
58 je .done2
59 sub al , ’0 ’
60 imul rbx , rbx , 10
61 add rbx , rax
62 inc rsi
63 jmp .convert2
64 .done2 :
65 mov r13 , rbx ; store second number in r13
66 ; --- compute GCD ---
67 mov rax , r12
68 mov rbx , r13
69 call_gcd :
70 cmp rbx , 0
71 je .gcd_done
72 xor rdx , rdx
73 div rbx
74 mov rax , rbx
75 mov rbx , rdx
76 jmp call_gcd
77 .gcd_done :
78 mov r14 , rax ; gcd stored in r14
79 ; --- compute LCM = ( num1 * num2 ) / gcd ---
80 mov rax , r12
81 imul rax , r13 ; multiply numbers
82 xor rdx , rdx
83 mov rcx , r14 ; gcd
84 div rcx ; rax = LCM
85 ; --- print LCM ---
86 call print_num
87 call print_newline
88 ; exit
89 mov rax , 60
90 xor rdi , rdi
91 syscall
92 ; ===============================
93 ; print number in RAX
94 ; ===============================
95 print_num :
96 mov rbx , 10
97 lea rsi , [ buf +19]
98 mov byte [ rsi ] , 0
99 .convert :
100 xor rdx , rdx
101 div rbx
102 add dl , ’0 ’
103 dec rsi
104 mov [ rsi ] , dl
Assembly Programming Report Page 33

105 test rax , rax

106 jnz .convert
107 mov rax , 1
108 mov rdi , 1
109 mov rdx , buf +19
110 sub rdx , rsi
111 mov rsi , rsi
112 syscall
113 ret
114 print_newline :
115 mov rax , 1
116 mov rdi , 1
117 mov rsi , newline
118 mov rdx , 1
119 syscall
120 ret

10.3 Sample Input

1 Enter first number : 12

2 Enter second number : 8

10.4 Sample Output

1 24

11 Program 11: Left Triangle Pattern

11.1 Problem Statement
Write a program that prompts the user to enter a positive integer for the height of a triangle and prints a
left-aligned star triangle pattern with that height.

11.2 Code

1 section .data
2 prompt db " Enter the height of the triangle : " , 0
3 prompt_len equ $ - prompt
4 star db " * " , 0
5 space db " " , 0
6 newline db 10 , 0
7 error_msg db " Error : Please enter a positive number ! " , 10 , 0
8 error_msg_len equ $ - error_msg
9 section .bss
10 height resq 1 ; Height of triangle
11 row resq 1 ; Current row counter
12 col resq 1 ; Current column counter
13 stars resq 1 ; Number of stars for current row
14 buffer resb 20 ; Input buffer
15 section .text
16 global _start
17 _start :
18 ; Print prompt
19 mov rax , 1 ; sys_write
20 mov rdi , 1 ; stdout
21 mov rsi , prompt
22 mov rdx , prompt_len
23 syscall
24 ; Read height input
Assembly Programming Report Page 34

25 call read_number
26 mov [ height ] , rax
27 ; Validate input ( must be positive )
28 cmp rax , 0
29 jle error_exit
30 ; Initialize row counter
31 mov qword [ row ] , 1
32 row_loop :
33 ; Check if we ’ ve printed all rows
34 mov rax , [ row ]
35 cmp rax , [ height ]
36 jg done
37 ; Calculate number of stars for current row
38 ; stars = row ( no spaces needed for left triangle )
39 mov rax , [ row ]
40 mov [ stars ] , rax
41 print_stars :
42 ; Print stars for current row
43 mov qword [ col ] , 0
44 star_loop :
45 mov rax , [ col ]
46 cmp rax , [ stars ]
47 jge next_row
48
49 ; Print a star
50 mov rax , 1
51 mov rdi , 1
52 mov rsi , star
53 mov rdx , 1
54 syscall
55
56 inc qword [ col ]
57 jmp star_loop
58 next_row :
59 ; Print newline
60 mov rax , 1
61 mov rdi , 1
62 mov rsi , newline
63 mov rdx , 1
64 syscall
65
66 ; Move to next row
67 inc qword [ row ]
68 jmp row_loop
69 done :
70 ; Exit program
71 mov rax , 60 ; sys_exit
72 mov rdi , 0 ; exit status
73 syscall
74 error_exit :
75 ; Print error message
76 mov rax , 1
77 mov rdi , 1
78 mov rsi , error_msg
79 mov rdx , error_msg_len
80 syscall
81 ; Exit with error code
82 mov rax , 60
83 mov rdi , 1
84 syscall
85 ; Function to read a number from stdin
86 read_number :
87 push rbp
88 mov rbp , rsp
89 push rbx
90 push rcx
Assembly Programming Report Page 35

91 push rdx
92 push rsi
93
94 ; Read string input
95 mov rax , 0 ; sys_read
96 mov rdi , 0 ; stdin
97 mov rsi , buffer
98 mov rdx , 20
99 syscall
100 ; Convert string to integer
101 mov rsi , buffer
102 xor rax , rax ; Clear result
103 xor rcx , rcx ; Clear digit counter
104 mov rbx , 10 ; Base 10
105 convert_loop :
106 movzx rdx , byte [ rsi + rcx ]
107 cmp dl , 10 ; Check for newline
108 je convert_done
109 cmp dl , 0 ; Check for null terminator
110 je convert_done
111 cmp dl , ’0 ’
112 jl convert_done
113 cmp dl , ’9 ’
114 jg convert_done
115 sub dl , ’0 ’ ; Convert ASCII to digit
116 imul rax , rbx ; Multiply current result by 10
117 add rax , rdx ; Add new digit
118 inc rcx
119 jmp convert_loop
120 convert_done :
121 pop rsi
122 pop rdx
123 pop rcx
124 pop rbx
125 pop rbp
126 ret

11.3 Sample Input

1 Enter the height of the triangle : 7

11.4 Sample Output

1 *
2 **
3 ***
4 ****
5 *****
6 ******
7 *******

12 Program 12: Star Pyramid Pattern

12.1 Problem Statement
Write a program that prompts the user to enter the number of rows and prints a centered pyramid pattern
made of stars with proper spacing.
Assembly Programming Report Page 36

12.2 Code

1 BITS 64
2 GLOBAL _start
3 % define SYS_READ 0
4 % define SYS_WRITE 1
5 % define SYS_EXIT 60
6 % define STDIN 0
7 % define STDOUT 1
8 SECTION .data
9 prompt : db " Enter number of rows : " ,0 Ah ,0 ; message with newline
10 SECTION .bss
11 inputbuf : resb 16 ; buffer for user input
12 linebuf : resb 512 ; buffer for building pyramid line
13 SECTION .text
14 _start :
15 ; print prompt
16 mov rax , SYS_WRITE
17 mov rdi , STDOUT
18 mov rsi , prompt
19 mov rdx , 22 ; length of prompt string
20 syscall
21 ; read user input ( max 15 bytes )
22 mov rax , SYS_READ
23 mov rdi , STDIN
24 mov rsi , inputbuf
25 mov rdx , 16
26 syscall
27 ; convert ascii input -> integer in r12
28 mov rsi , inputbuf
29 xor r12 , r12 ; r12 = result = 0
30 .convert_loop :
31 movzx rax , byte [ rsi ]
32 cmp al , 10 ; newline?
33 je .conv_done
34 cmp al , 0
35 je .conv_done
36 cmp al , ’0 ’
37 jb .conv_done
38 cmp al , ’9 ’
39 ja .conv_done
40 imul r12 , r12 , 10
41 sub al , ’0 ’
42 add r12 , rax
43 inc rsi
44 jmp .convert_loop
45 .conv_done :
46 xor r13 , r13 ; i = 0
47 .row_loop :
48 cmp r13 , r12
49 jge .done
50 ; spaces = (N -1 - i )
51 mov rax , r12
52 dec rax
53 sub rax , r13
54 mov r14 , rax
55 ; stars = 2* i + 1
56 lea r15 , [ r13 *2 + 1]
57 mov rdi , linebuf
58 ; spaces
59 mov rcx , r14
60 jrcxz .skip_spaces
61 .write_space :
62 mov byte [ rdi ] , ’ ’
63 inc rdi
64 loop .write_space
Assembly Programming Report Page 37

65 .skip_spaces :
66 ; stars
67 mov rcx , r15
68 jrcxz .skip_stars
69 .write_star :
70 mov byte [ rdi ] , ’* ’
71 inc rdi
72 loop .write_star
73 .skip_stars :
74 ; newline
75 mov byte [ rdi ] , 10
76 inc rdi
77 ; write line
78 mov rdx , rdi
79 sub rdx , linebuf
80 mov rax , SYS_WRITE
81 mov rdi , STDOUT
82 mov rsi , linebuf
83 syscall
84 inc r13
85 jmp .row_loop
86 .done :
87 mov rax , SYS_EXIT
88 xor rdi , rdi
89 syscall

12.3 Sample Input

1 Enter number of rows : 5

12.4 Sample Output

1 *
2 ***
3 *****
4 *******
5 *********

13 Program 13: Matrix Addition

13.1 Problem Statement
Write a program in assembly language that takes two matrices as input from the user and displays their
addition as the resultant matrix.

13.2 Code

1 section .data
2 prompt_rows : db " Enter number of rows : " , 0
3 prompt_cols : db " Enter number of columns : " , 0
4 prompt_mat1 : db " Enter elements of Matrix 1: " , 10 , 0
5 prompt_mat2 : db " Enter elements of Matrix 2: " , 10 , 0
6 prompt_element : db " Enter element [ " , 0
7 prompt_element2 : db " ][ " , 0
8 prompt_element3 : db " ]: " , 0
9 result_msg : db " Resultant Matrix ( A + B ) : " , 10 , 0
10 space : db " " , 0
11 newline : db 10 , 0
12
Assembly Programming Report Page 38

13 section .bss
14 rows : resd 1
15 cols : resd 1
16 matrix1 : resd 100 ; Maximum 10 x10 matrix
17 matrix2 : resd 100 ; Maximum 10 x10 matrix
18 result : resd 100 ; Result matrix
19 input_buffer : resb 16 ; Buffer for input
20 num_buffer : resb 16 ; Buffer for number conversion
21
22 section .text
23 global _start
24
25 _start :
26 ; Get number of rows
27 mov rsi , prompt_rows
28 call print_string
29 call read_number
30 mov [ rows ] , eax
31
32 ; Get number of columns
33 mov rsi , prompt_cols
34 call print_string
35 call read_number
36 mov [ cols ] , eax
37
38 ; Input Matrix 1
39 mov rsi , prompt_mat1
40 call print_string
41
42 mov r12 , 0 ; Row counter
43 mov r14 , matrix1 ; Matrix 1 base address
44
45 input_matrix1 :
46 mov eax , [ rows ]
47 cmp r12d , eax
48 jge in p ut_matrix2_start
49
50 mov r13 , 0 ; Column counter
51
52 input _matrix1_col :
53 mov eax , [ cols ]
54 cmp r13d , eax
55 jge i n p u t_ mat ri x1_ ne xt_ row
56
57 ; Print element prompt
58 mov rsi , prompt_element
59 call print_string
60 mov rax , r12
61 call print_number
62 mov rsi , prompt_element2
63 call print_string
64 mov rax , r13
65 call print_number
66 mov rsi , prompt_element3
67 call print_string
68
69 ; Read element
70 call read_number
71 mov [ r14 ] , eax
72
73 add r14 , 4
74 inc r13d
75 jmp inpu t_matrix1_col
76
77 in p u t _ m a t r i x 1_n ex t_r ow :
78 inc r12d
Assembly Programming Report Page 39

79 jmp input_matrix1
80
81 inp u t _m a tr i x2_start :
82 ; Input Matrix 2
83 mov rsi , prompt_mat2
84 call print_string
85
86 mov r12 , 0 ; Row counter
87 mov r14 , matrix2 ; Matrix 2 base address
88
89 input_matrix2 :
90 mov eax , [ rows ]
91 cmp r12d , eax
92 jge perform_addition
93
94 mov r13 , 0 ; Column counter
95
96 input _matrix2_col :
97 mov eax , [ cols ]
98 cmp r13d , eax
99 jge i n p u t_ mat ri x2_ ne xt_ row
100
101 ; Print element prompt
102 mov rsi , prompt_element
103 call print_string
104 mov rax , r12
105 call print_number
106 mov rsi , prompt_element2
107 call print_string
108 mov rax , r13
109 call print_number
110 mov rsi , prompt_element3
111 call print_string
112
113 ; Read element
114 call read_number
115 mov [ r14 ] , eax
116
117 add r14 , 4
118 inc r13d
119 jmp inpu t_matrix2_col
120
121 in p u t _ m a t r i x 2_n ex t_r ow :
122 inc r12d
123 jmp input_matrix2
124
125 perform_addition :
126 ; Perform matrix addition
127 mov r12 , 0 ; Element counter
128 mov eax , [ rows ]
129 imul eax , [ cols ] ; Total elements = rows * cols
130 mov r15d , eax ; Store total elements
131
132 mov r13 , matrix1 ; Matrix 1 pointer
133 mov r14 , matrix2 ; Matrix 2 pointer
134 mov rbx , result ; Result matrix pointer
135
136 addition_loop :
137 cmp r12d , r15d
138 jge display_result
139
140 ; Add corresponding elements
141 mov eax , [ r13 ]
142 add eax , [ r14 ]
143 mov [ rbx ] , eax
144
Assembly Programming Report Page 40

145 ; Move to next elements

146 add r13 , 4
147 add r14 , 4
148 add rbx , 4
149 inc r12d
150 jmp addition_loop
151
152 display_result :
153 ; Display result matrix
154 mov rsi , result_msg
155 call print_string
156
157 mov r12 , 0 ; Row counter
158 mov r14 , result ; Result matrix base address
159
160 display_loop :
161 mov eax , [ rows ]
162 cmp r12d , eax
163 jge program_exit
164
165 mov r13 , 0 ; Column counter
166
167 display_col :
168 mov eax , [ cols ]
169 cmp r13d , eax
170 jge display_next_row
171
172 ; Display current element
173 mov eax , [ r14 ]
174 call print_number
175 mov rsi , space
176 call print_string
177
178 add r14 , 4
179 inc r13d
180 jmp display_col
181
182 display_next_row :
183 ; Print newline after each row
184 mov rsi , newline
185 call print_string
186
187 inc r12d
188 jmp display_loop
189
190 program_exit :
191 mov rax , 60 ; sys_exit
192 mov rdi , 0 ; exit status
193 syscall
194
195 ; Function to print a string
196 ; Input : rsi = pointer to null - terminated string
197 print_string :
198 push rax
199 push rdi
200 push rdx
201 push rcx
202
203 ; Calculate string length
204 mov rdi , rsi
205 call strlen
206 mov rdx , rax ; length
207
208 mov rax , 1 ; sys_write
209 mov rdi , 1 ; stdout
210 syscall
Assembly Programming Report Page 41

211
212 pop rcx
213 pop rdx
214 pop rdi
215 pop rax
216 ret
217
218 ; Function to calculate string length
219 ; Input : rdi = pointer to string
220 ; Output : rax = length
221 strlen :
222 push rdi
223 mov rax , 0
224 strlen_loop :
225 cmp byte [ rdi + rax ] , 0
226 je strlen_done
227 inc rax
228 jmp strlen_loop
229 strlen_done :
230 pop rdi
231 ret
232
233 ; Function to read a number from stdin
234 ; Output : eax = number read
235 read_number :
236 push rbx
237 push rcx
238 push rdx
239 push rsi
240 push rdi
241
242 ; Read input
243 mov rax , 0 ; sys_read
244 mov rdi , 0 ; stdin
245 mov rsi , input_buffer
246 mov rdx , 16
247 syscall
248
249 ; Convert string to number
250 mov rsi , input_buffer
251 call atoi
252
253 pop rdi
254 pop rsi
255 pop rdx
256 pop rcx
257 pop rbx
258 ret
259
260 ; Function to convert string to integer
261 ; Input : rsi = pointer to string
262 ; Output : eax = integer value
263 atoi :
264 push rbx
265 push rcx
266 push rdx
267
268 xor rax , rax ; result = 0
269 xor rbx , rbx ; temp for digit
270 mov rcx , 10 ; multiplier
271
272 atoi_loop :
273 movzx rbx , byte [ rsi ] ; get character
274 cmp bl , 10 ; check for newline
275 je atoi_done
276 cmp bl , 0 ; check for null terminator
Assembly Programming Report Page 42

277 je atoi_done
278 cmp bl , ’0 ’ ; check if less than ’0 ’
279 jl atoi_done
280 cmp bl , ’9 ’ ; check if greater than ’9 ’
281 jg atoi_done
282
283 sub bl , ’0 ’ ; convert ASCII to digit
284 mul rcx ; result *= 10
285 add rax , rbx ; result += digit
286
287 inc rsi ; next character
288 jmp atoi_loop
289
290 atoi_done :
291 pop rdx
292 pop rcx
293 pop rbx
294 ret
295
296 ; Function to print a number
297 ; Input : rax = number to print
298 print_number :
299 push rax
300 push rbx
301 push rcx
302 push rdx
303 push rsi
304 push rdi
305
306 ; Handle negative numbers
307 test rax , rax
308 jns print_positive
309
310 ; Print minus sign
311 push rax
312 mov rax , 1 ; sys_write
313 mov rdi , 1 ; stdout
314 mov rsi , num_buffer
315 mov byte [ rsi ] , ’ - ’
316 mov rdx , 1
317 syscall
318 pop rax
319 neg rax ; make positive
320
321 print_positive :
322 mov rsi , num_buffer
323 add rsi , 15 ; point to end of buffer
324 mov byte [ rsi ] , 0 ; null terminator
325 dec rsi
326
327 mov rbx , 10 ; divisor
328
329 convert_loop :
330 xor rdx , rdx ; clear remainder
331 div rbx ; divide by 10
332 add dl , ’0 ’ ; convert remainder to ASCII
333 mov [ rsi ] , dl ; store digit
334 dec rsi
335 test rax , rax ; check if quotient is 0
336 jnz convert_loop
337
338 inc rsi ; point to first digit
339 call print_string
340
341 pop rdi
342 pop rsi
Assembly Programming Report Page 43

343 pop rdx

344 pop rcx
345 pop rbx
346 pop rax
347 ret

13.3 Sample Input

1 Enter number of rows : 2

2 Enter number of columns : 2
3 Enter elements of Matrix 1:
4 Enter element [0][0]: 1
5 Enter element [0][1]: 2
6 Enter element [1][0]: 3
7 Enter element [1][1]: 4
8 Enter elements of Matrix 2:
9 Enter element [0][0]: 5
10 Enter element [0][1]: 6
11 Enter element [1][0]: 7
12 Enter element [1][1]: 8

13.4 Sample Output

1 Resultant Matrix ( A + B ) :
26 8
3 10 12

14 Program 14: Matrix Subtraction

14.1 Problem Statement
Write a program in assembly language that takes two matrices as input from the user and displays their
subtraction (A - B) as the resultant matrix.

14.2 Code

1 section .data
2 prompt_rows : db " Enter number of rows : " , 0
3 prompt_cols : db " Enter number of columns : " , 0
4 prompt_mat1 : db " Enter elements of Matrix 1: " , 10 , 0
5 prompt_mat2 : db " Enter elements of Matrix 2: " , 10 , 0
6 prompt_element : db " Enter element [ " , 0
7 prompt_element2 : db " ][ " , 0
8 prompt_element3 : db " ]: " , 0
9 result_msg : db " Resultant Matrix ( A - B ) : " , 10 , 0
10 space : db " " , 0
11 newline : db 10 , 0
12
13 section .bss
14 rows : resd 1
15 cols : resd 1
16 matrix1 : resd 100 ; Maximum 10 x10 matrix
17 matrix2 : resd 100 ; Maximum 10 x10 matrix
18 result : resd 100 ; Result matrix
19 input_buffer : resb 16 ; Buffer for input
20 num_buffer : resb 16 ; Buffer for number conversion
21
22 section .text
23 global _start
Assembly Programming Report Page 44

24
25 _start :
26 ; Get number of rows
27 mov rsi , prompt_rows
28 call print_string
29 call read_number
30 mov [ rows ] , eax
31
32 ; Get number of columns
33 mov rsi , prompt_cols
34 call print_string
35 call read_number
36 mov [ cols ] , eax
37
38 ; Input Matrix 1
39 mov rsi , prompt_mat1
40 call print_string
41
42 mov r12 , 0 ; Row counter
43 mov r14 , matrix1 ; Matrix 1 base address
44
45 input_matrix1 :
46 mov eax , [ rows ]
47 cmp r12d , eax
48 jge in p ut_matrix2_start
49
50 mov r13 , 0 ; Column counter
51
52 input _matrix1_col :
53 mov eax , [ cols ]
54 cmp r13d , eax
55 jge i n p u t_ mat ri x1_ ne xt_ row
56
57 ; Print element prompt
58 mov rsi , prompt_element
59 call print_string
60 mov rax , r12
61 call print_number
62 mov rsi , prompt_element2
63 call print_string
64 mov rax , r13
65 call print_number
66 mov rsi , prompt_element3
67 call print_string
68
69 ; Read element
70 call read_number
71 mov [ r14 ] , eax
72
73 add r14 , 4
74 inc r13d
75 jmp inpu t_matrix1_col
76
77 in p u t _ m a t r i x 1_n ex t_r ow :
78 inc r12d
79 jmp input_matrix1
80
81 inp u t _m a tr i x2_start :
82 ; Input Matrix 2
83 mov rsi , prompt_mat2
84 call print_string
85
86 mov r12 , 0 ; Row counter
87 mov r14 , matrix2 ; Matrix 2 base address
88
89 input_matrix2 :
Assembly Programming Report Page 45

90 mov eax , [ rows ]

91 cmp r12d , eax
92 jge pe r form_subtraction
93
94 mov r13 , 0 ; Column counter
95
96 input _matrix2_col :
97 mov eax , [ cols ]
98 cmp r13d , eax
99 jge i n p u t_ mat ri x2_ ne xt_ row
100
101 ; Print element prompt
102 mov rsi , prompt_element
103 call print_string
104 mov rax , r12
105 call print_number
106 mov rsi , prompt_element2
107 call print_string
108 mov rax , r13
109 call print_number
110 mov rsi , prompt_element3
111 call print_string
112
113 ; Read element
114 call read_number
115 mov [ r14 ] , eax
116
117 add r14 , 4
118 inc r13d
119 jmp inpu t_matrix2_col
120
121 in p u t _ m a t r i x 2_n ex t_r ow :
122 inc r12d
123 jmp input_matrix2
124
125 per f o rm _ su b traction :
126 ; Perform matrix subtraction ( A - B )
127 mov r12 , 0 ; Element counter
128 mov eax , [ rows ]
129 imul eax , [ cols ] ; Total elements = rows * cols
130 mov r15d , eax ; Store total elements
131
132 mov r13 , matrix1 ; Matrix 1 pointer
133 mov r14 , matrix2 ; Matrix 2 pointer
134 mov rbx , result ; Result matrix pointer
135
136 subtraction_loop :
137 cmp r12d , r15d
138 jge display_result
139
140 ; Subtract corresponding elements ( A [ i ] - B [ i ])
141 mov eax , [ r13 ] ; Load element from matrix1
142 sub eax , [ r14 ] ; Subtract element from matrix2
143 mov [ rbx ] , eax ; Store result
144
145 ; Move to next elements
146 add r13 , 4
147 add r14 , 4
148 add rbx , 4
149 inc r12d
150 jmp subtraction_loop
151
152 display_result :
153 ; Display result matrix
154 mov rsi , result_msg
155 call print_string
Assembly Programming Report Page 46

156
157 mov r12 , 0 ; Row counter
158 mov r14 , result ; Result matrix base address
159
160 display_loop :
161 mov eax , [ rows ]
162 cmp r12d , eax
163 jge program_exit
164
165 mov r13 , 0 ; Column counter
166
167 display_col :
168 mov eax , [ cols ]
169 cmp r13d , eax
170 jge display_next_row
171
172 ; Display current element ( sign extend 32 - bit to 64 - bit )
173 mov eax , [ r14 ]
174 cdqe ; Convert dword in EAX to qword in RAX ( sign extend )
175 call print_number
176 mov rsi , space
177 call print_string
178
179 add r14 , 4
180 inc r13d
181 jmp display_col
182
183 display_next_row :
184 ; Print newline after each row
185 mov rsi , newline
186 call print_string
187
188 inc r12d
189 jmp display_loop
190
191 program_exit :
192 mov rax , 60 ; sys_exit
193 mov rdi , 0 ; exit status
194 syscall
195
196 ; Function to print a string
197 ; Input : rsi = pointer to null - terminated string
198 print_string :
199 push rax
200 push rdi
201 push rdx
202 push rcx
203
204 ; Calculate string length
205 mov rdi , rsi
206 call strlen
207 mov rdx , rax ; length
208
209 mov rax , 1 ; sys_write
210 mov rdi , 1 ; stdout
211 syscall
212
213 pop rcx
214 pop rdx
215 pop rdi
216 pop rax
217 ret
218
219 ; Function to calculate string length
220 ; Input : rdi = pointer to string
221 ; Output : rax = length
Assembly Programming Report Page 47

222 strlen :
223 push rdi
224 mov rax , 0
225 strlen_loop :
226 cmp byte [ rdi + rax ] , 0
227 je strlen_done
228 inc rax
229 jmp strlen_loop
230 strlen_done :
231 pop rdi
232 ret
233
234 ; Function to read a number from stdin
235 ; Output : eax = number read
236 read_number :
237 push rbx
238 push rcx
239 push rdx
240 push rsi
241 push rdi
242
243 ; Clear input buffer first
244 mov rcx , 16
245 mov rdi , input_buffer
246 xor al , al
247 clear_buffer :
248 mov [ rdi ] , al
249 inc rdi
250 loop clear_buffer
251
252 ; Read input
253 mov rax , 0 ; sys_read
254 mov rdi , 0 ; stdin
255 mov rsi , input_buffer
256 mov rdx , 16
257 syscall
258
259 ; Convert string to number
260 mov rsi , input_buffer
261 call atoi
262
263 pop rdi
264 pop rsi
265 pop rdx
266 pop rcx
267 pop rbx
268 ret
269
270 ; Function to convert string to integer ( supports negative numbers )
271 ; Input : rsi = pointer to string
272 ; Output : eax = integer value
273 atoi :
274 push rbx
275 push rcx
276 push rdx
277 push r8
278
279 xor rax , rax ; result = 0
280 xor rbx , rbx ; temp for digit
281 mov rcx , 10 ; multiplier
282 mov r8 , 1 ; sign (1 for positive , -1 for negative )
283
284 ; Skip whitespace and check for sign
285 atoi_skip_space :
286 movzx rbx , byte [ rsi ]
287 cmp bl , ’ ’
Assembly Programming Report Page 48

288 je atoi_next_char
289 cmp bl , 9 ; tab
290 je atoi_next_char
291 cmp bl , 10 ; newline
292 je atoi_done
293 cmp bl , 13 ; carriage return
294 je atoi_next_char
295 cmp bl , 0 ; null terminator
296 je atoi_done
297
298 ; Check for negative sign
299 cmp bl , ’ - ’
300 jne atoi_check_plus
301 mov r8 , -1 ; set negative sign
302 inc rsi ; skip minus sign
303 jmp atoi_loop
304
305 atoi_check_plus :
306 cmp bl , ’+ ’
307 jne atoi_loop
308 inc rsi ; skip plus sign
309
310 atoi_loop :
311 movzx rbx , byte [ rsi ] ; get character
312 cmp bl , 10 ; check for newline
313 je atoi_done
314 cmp bl , 13 ; check for carriage return
315 je atoi_done
316 cmp bl , 0 ; check for null terminator
317 je atoi_done
318 cmp bl , ’ ’ ; check for space
319 je atoi_done
320 cmp bl , ’0 ’ ; check if less than ’0 ’
321 jl atoi_done
322 cmp bl , ’9 ’ ; check if greater than ’9 ’
323 jg atoi_done
324
325 sub bl , ’0 ’ ; convert ASCII to digit
326 mul rcx ; result *= 10
327 add rax , rbx ; result += digit
328
329 inc rsi ; next character
330 jmp atoi_loop
331
332 atoi_next_char :
333 inc rsi
334 jmp atoi_skip_space
335
336 atoi_done :
337 imul rax , r8 ; apply sign
338 pop r8
339 pop rdx
340 pop rcx
341 pop rbx
342 ret
343
344 ; Function to print a number ( supports negative numbers )
345 ; Input : rax = 64 - bit signed number to print
346 print_number :
347 push rax
348 push rbx
349 push rcx
350 push rdx
351 push rsi
352 push rdi
353 push r8
Assembly Programming Report Page 49

354
355 ; Save the original number ( as 64 - bit signed )
356 mov r8 , rax
357
358 ; Handle zero case
359 test r8 , r8
360 jnz handle_nonzero
361 mov rdi , num_buffer
362 mov byte [ rdi ] , ’0 ’
363 mov byte [ rdi + 1] , 0
364 mov rsi , num_buffer
365 call print_string
366 jmp prin t_number_exit
367
368 handle_nonzero :
369 mov rdi , num_buffer ; Point to start of buffer
370
371 ; Handle negative numbers
372 test r8 , r8
373 jns convert_positive
374
375 ; Store minus sign
376 mov byte [ rdi ] , ’ - ’
377 inc rdi
378 neg r8 ; make number positive (64 - bit operation )
379
380 convert_positive :
381 ; Convert number to string ( we ’ ll reverse it later )
382 mov rax , r8
383 mov rbx , 10
384 mov rcx , 0 ; digit counter
385
386 digit_loop :
387 xor rdx , rdx
388 div rbx ; 64 - bit divide by 10
389 add dl , ’0 ’ ; convert remainder to ASCII
390 mov [ rdi + rcx ] , dl ; store digit
391 inc rcx ; increment digit counter
392 test rax , rax
393 jnz digit_loop
394
395 ; Null terminate
396 mov byte [ rdi + rcx ] , 0
397
398 ; Reverse the digits ( they ’ re backwards )
399 mov rsi , rdi ; start of digits
400 mov rdx , rdi
401 add rdx , rcx
402 dec rdx ; end of digits
403
404 reverse_loop :
405 cmp rsi , rdx
406 jge print_final
407
408 ; Swap characters
409 mov al , [ rsi ]
410 mov bl , [ rdx ]
411 mov [ rsi ] , bl
412 mov [ rdx ] , al
413
414 inc rsi
415 dec rdx
416 jmp reverse_loop
417
418 print_final :
419 mov rsi , num_buffer
Assembly Programming Report Page 50

420 call print_string

421
422 print _number_exit :
423 pop r8
424 pop rdi
425 pop rsi
426 pop rdx
427 pop rcx
428 pop rbx
429 pop rax
430 ret

14.3 Sample Input

1 Enter number of rows : 2

2 Enter number of columns : 2
3 Enter elements of Matrix 1:
4 Enter element [0][0]: 5
5 Enter element [0][1]: 7
6 Enter element [1][0]: 9
7 Enter element [1][1]: 4
8 Enter elements of Matrix 2:
9 Enter element [0][0]: 2
10 Enter element [0][1]: 3
11 Enter element [1][0]: 6
12 Enter element [1][1]: 8

14.4 Sample Output

1 Resultant Matrix ( A - B ) :
23 4
3 3 -4