; ============================================================
; PROGRAMA:
; Sumar dos números de 2 o 3 dígitos y mostrar el resultado
; (hasta 4 dígitos) convertido a ASCII.
;
; Ejemplo:
;
;       475 + 868 = 1343
;
; Salida:
;
;       Resultado: 1343
;
; ENTORNO:
;       NASM x86-64
;       Linux
;       syscall
;
; Instrucciones usadas: mov, add, div, xor, syscall
; (sin ciclos, sin saltos, sin comparaciones)
;
; Para cambiar la suma, modifica los dos números en el PASO 2.
; Con números de 3 dígitos el resultado máximo es:
;       999 + 999 = 1998  (4 dígitos)
; ============================================================


; ------------------------------------------------------------
; SECCIÓN DE DATOS
; ------------------------------------------------------------
section .data

    ; Texto que mostramos antes del resultado
    mensaje db "Resultado: "
    longitud equ $ - mensaje

    ; Salto de línea (10 = '\n' en ASCII)
    salto db 10


; ------------------------------------------------------------
; SECCIÓN BSS
; ------------------------------------------------------------
section .bss

    ; Reservamos 4 bytes, uno por cada dígito del resultado:
    ;
    ; resultado[0] = millares
    ; resultado[1] = centenas
    ; resultado[2] = decenas
    ; resultado[3] = unidades
    ;
    ; Para 1343:
    ;
    ; '1' '3' '4' '3'
    ;
    resultado resb 4


; ------------------------------------------------------------
; SECCIÓN DE CÓDIGO
; ------------------------------------------------------------
section .text

    global _start


_start:

    ; ========================================================
    ; PASO 1
    ; MOSTRAR EL TEXTO "Resultado: "
    ; ========================================================

    mov rax, 1              ; syscall 1 = write
    mov rdi, 1              ; descriptor 1 = stdout (pantalla)
    mov rsi, mensaje        ; dirección del texto
    mov rdx, longitud       ; cantidad de bytes a escribir
    syscall


    ; ========================================================
    ; PASO 2
    ; REALIZAR LA SUMA
    ; ========================================================

    ; Primer número (2 o 3 dígitos)
    ;
    ; RAX = 475
    ;
    mov rax, 475

    ; Segundo número (2 o 3 dígitos)
    ;
    ; Antes:   RAX = 475
    ; Después: RAX = 475 + 868 = 1343
    ;
    add rax, 868


    ; ========================================================
    ; PASO 3
    ; SEPARAR LOS DÍGITOS (millares, centenas, decenas, unidades)
    ;
    ; La instrucción DIV divide RDX:RAX entre el divisor.
    ; Por eso, antes de cada división ponemos RDX = 0 con XOR.
    ;
    ; Después de cada DIV:
    ;
    ; RAX = cociente  (el dígito)
    ; RDX = residuo   (lo que falta por separar)
    ; ========================================================


    ; --------------------------------------------------------
    ; 3.1  MILLARES:   1343 / 1000
    ;
    ; RAX = 1   (millares)
    ; RDX = 343 (residuo)
    ; --------------------------------------------------------
    mov rbx, 1000
    xor rdx, rdx
    div rbx

    ; Convertimos 1 a ASCII:  01h + 30h = 31h = '1'
    add rax, 30h
    mov [resultado], al


    ; --------------------------------------------------------
    ; 3.2  CENTENAS:   343 / 100
    ;
    ; El residuo anterior (RDX = 343) pasa a ser
    ; el nuevo dividendo, así que lo copiamos a RAX.
    ;
    ; RAX = 3  (centenas)
    ; RDX = 43 (residuo)
    ; --------------------------------------------------------
    mov rax, rdx
    mov rbx, 100
    xor rdx, rdx
    div rbx

    ; 03h + 30h = 33h = '3'
    add rax, 30h
    mov [resultado + 1], al


    ; --------------------------------------------------------
    ; 3.3  DECENAS:    43 / 10
    ;
    ; RAX = 4  (decenas)
    ; RDX = 3  (unidades)
    ; --------------------------------------------------------
    mov rax, rdx
    mov rbx, 10
    xor rdx, rdx
    div rbx

    ; 04h + 30h = 34h = '4'
    add rax, 30h
    mov [resultado + 2], al


    ; --------------------------------------------------------
    ; 3.4  UNIDADES
    ;
    ; Ya no hace falta dividir: lo que quedó en RDX
    ; (el último residuo) es directamente la unidad.
    ;
    ; RDX = 3
    ; --------------------------------------------------------

    ; 03h + 30h = 33h = '3'
    add dl, 30h
    mov [resultado + 3], dl


    ; En memoria ahora tenemos:
    ;
    ; resultado
    ;
    ; ┌──────┬──────┬──────┬──────┐
    ; │ '1'  │ '3'  │ '4'  │ '3'  │
    ; │ 31h  │ 33h  │ 34h  │ 33h  │
    ; └──────┴──────┴──────┴──────┘


    ; ========================================================
    ; PASO 4
    ; IMPRIMIR EL RESULTADO "1343"
    ; ========================================================

    mov rax, 1              ; syscall 1 = write
    mov rdi, 1              ; stdout
    mov rsi, resultado      ; dirección de los 4 caracteres
    mov rdx, 4              ; escribimos 4 bytes
    syscall


    ; ========================================================
    ; PASO 5
    ; IMPRIMIR UN SALTO DE LÍNEA
    ; ========================================================

    mov rax, 1
    mov rdi, 1
    mov rsi, salto
    mov rdx, 1
    syscall


    ; ========================================================
    ; PASO 6
    ; TERMINAR EL PROGRAMA
    ; ========================================================

    mov rax, 60             ; syscall 60 = exit
    xor rdi, rdi            ; código de salida 0 (RDI = 0 con XOR)
    syscall