; Program to calculate Factorial of a number using Recursion
; Input: num (e.g., 5)
; Output: result (e.g., 5! = 120 or 78h)

data segment
    num dw 0005h    ; The number to calculate factorial for (16-bit word)
    result dw ?     ; Variable to store the final 16-bit result
data ends

code segment
    assume cs:code, ds:data

start:
    mov ax, data
    mov ds, ax      ; Initialize Data Segment

    mov cx, num     ; Load the input number into CX register used as counter/argument
    mov ax, 0001h   ; Initialize accumulator AX to 1 (needed for multiplication)

    call factorial  ; Call the recursive procedure

    mov result, ax  ; Store final result from AX into memory variable
    int 3           ; Breakpoint to halt and check registers

;--- Recursive Procedure Definition ---
factorial proc near
    cmp cx, 1       ; BASE CASE: Check if number in CX is <= 1
    jbe base_case   ; If CX is 0 or 1, jump to base_case to return

    push cx         ; RECURSIVE STEP: Save current state of CX on STACK
    dec cx          ; Decrement CX to move towards base case (N-1)
    call factorial  ; Recursive Call: factorial(N-1)

    pop cx          ; UNWINDING: Restore the saved value of CX from STACK
    mul cx          ; AX = AX * CX. (Current Result * Current N)
    ret             ; Return to caller

base_case:
    mov ax, 1       ; Base case returns 1 (as 0! = 1 and 1! = 1)
    ret             ; Return to caller
factorial endp
;--------------------------------------

code ends
end start

; 8086 Program to Generate 10 Fibonacci Numbers
data segment
    COUNT       equ 10              ; Number of terms to generate
    FIB_SERIES  db COUNT dup(?)   ; Array to store the series
data ends

code segment
    assume cs:code, ds:data
start:
    ; Initialize Data Segment (DS) register
    mov ax, data
    mov ds, ax
    
    ; Use SI as a pointer to the array
    mov si, offset FIB_SERIES
    
    ; Seed the first two Fibonacci numbers
    ; Fib(0) = 0
    mov byte ptr [si], 00h
    
    ; Fib(1) = 1
    inc si
    mov byte ptr [si], 01h
    
    ; Set up loop counter. We already have 2 numbers,
    ; so we need to generate (COUNT - 2) more.
    mov cx, COUNT
    sub cx, 2
    
L1:
    ; AL = Fib(n-1) (e.g., [si])
    mov al, [si]
    
    ; BL = Fib(n-2) (e.g., [si-1])
    mov bl, [si-1]
    
    ; AL = Fib(n-1) + Fib(n-2)
    add al, bl
    
    ; Move pointer to next position Fib(n)
    inc si
    
    ; Store the new term: [si] = AL
    mov [si], al
    
    ; Decrement CX, loop if CX is not zero
    loop L1
    
    ; Halt execution for debugging
    int 3
    
code ends
end start