section .data
msg db ‘Factorial: %d’, 10, 0
num db 5 ; Change this value to calculate factorial of a different number

section .bss
result resd 1

section .text
extern printf
global _start

_start:
mov ecx, [num] ; Load the number into ECX
mov eax, 1 ; Initialize EAX to 1 (factorial of 0 or 1)

factorial_loop:
cmp ecx, 1 ; Compare ECX with 1
jle done ; If ECX <= 1, we are done mul ecx ; Multiply EAX by ECX loop factorial_loop ; Decrement ECX and loop if not zero done: mov [result], eax ; Store the result push eax ; Push the result to print push msg ; Push the message format call printf ; Call printf add esp, 8 ; Clean up the stack (2 pushed items) ; Exit the program mov eax, 1 ; sys_exit xor ebx, ebx ; Return 0 int 0x80 ; Call kernel

use std::ffi::CString;
use std::ptr;

extern “C” fn printf(format: *const i8, value: i32);

fn main() {
let num: u8 = 5; // Change this number for a different factorial
let mut result: u64 = 1; // To store the factorial result

if num == 0 {
result = 1; // Factorial of 0 is 1
} else {
let mut rbx = 1; // Initialize rbx to 1
let mut rax = num as u64;

while rbx <= rax { result *= rbx as u64; // rax = rax * rbx rbx += 1; // Increment rbx } } // Print the result let msg = CString::new("Factorial is: %dn").unwrap(); unsafe { printf(msg.as_ptr(), result as i32); } // Exit std::process::exit(0); }

section .data
prompt db ‘Enter your age: ‘, 0
prompt_len equ $ – prompt
output_msg db ‘Your birth year is: ‘, 0
output_len equ $ – output_msg
current_year db ‘2023’, 0

section .bss
age resb 4
birth_year resb 5

section .text
global _start

_start:
; Prompt for age
mov eax, 4 ; syscall: write
mov ebx, 1 ; file descriptor: stdout
mov ecx, prompt ; pointer to message
mov edx, prompt_len ; message length
int 0x80 ; call kernel

; Read age
mov eax, 3 ; syscall: read
mov ebx, 0 ; file descriptor: stdin
mov ecx, age ; buffer to store input
mov edx, 4 ; max number of bytes to read
int 0x80 ; call kernel

; Convert age to integer
sub byte [age], ‘0’ ; Convert ASCII to integer (assuming single-digit)
movzx eax, byte [age] ; Zero extend to eax

; Calculate birth year: 2023 – age
mov ebx, 2023 ; Load current year
sub ebx, eax ; Subtract age
add ebx, 1900 ; Add 1900 (for 20xx years)

; Convert birth year to string
mov ecx, birth_year
mov edx, 10 ; Divisor for converting to string
call itoa

; Output result
mov eax, 4 ; syscall: write
mov ebx, 1 ; file descriptor: stdout
mov ecx, output_msg ; pointer to output message
mov edx, output_len ; message length
int 0x80 ; call kernel

mov eax, 4 ; syscall: write
mov ebx, 1 ; file descriptor: stdout
mov ecx, birth_year ; pointer to birth year
mov edx, 5 ; message length
int 0x80 ; call kernel

; Exit program
mov eax, 1 ; syscall: exit
xor ebx, ebx ; exit code 0
int 0x80 ; call kernel

itoa:
; Converts integer in EBX to ASCII in ECX
mov edi, 0 ; Counter for characters
itoa_loop:
xor edx, edx ; Clear edx
div dword [edx] ; Divide by 10
add dl, ‘0’ ; Convert remainder to ASCII
push dx ; Push character on stack
inc edi ; Increment character count
test eax, eax ; Check if quotient is 0
jnz itoa_loop ; Repeat if not

; Pop characters from stack to buffer
itoa_output:
pop dx ; Pop character from stack
mov [ecx], dl ; Store in buffer
inc ecx ; Move to next position
dec edi ; Decrement character count
jnz itoa_output ; Repeat until all characters are popped
mov byte [ecx], 0 ; Null-terminate string
ret

fn main() {
use std::io::{self, Write};

let prompt = “Enter your age: “;
let output_msg = “Your birth year is: “;
let current_year = 2023;

// Prompt for age
print!(“{}”, prompt);
io::stdout().flush().unwrap();

let mut age_input = String::new();
io::stdin().read_line(&mut age_input).unwrap();
let age: i32 = age_input.trim().parse().unwrap();

// Calculate birth year: 2023 – age
let birth_year = current_year – age + 1900;

// Output result
println!(“{}{}”, output_msg, birth_year);
}