; ============================================================
; PROGRAMA:
; Sumar N números e imprimir un resultado de cualquier
; cantidad de dígitos.
;
; Ejemplo:
;       8 + 7 + 25 + 100 + 3 = 143
;
; Salida:
;       Resultado: 143
;
; ENTORNO:
;       NASM x86-64
;       Linux
;       syscall
; ============================================================


section .data

    mensaje db "Resultado: "
    longitud equ $ - mensaje

    ; Lista de números a sumar (cada uno ocupa 8 bytes: dq).
    ; Puedes agregar o quitar números; el programa se adapta solo.
    numeros dq 8, 7, 25, 100, 3

    ; Cantidad de números = bytes totales / 8 bytes por número.
    ; IMPORTANTE: debe ir justo después de la lista.
    cantidad equ ($ - numeros) / 8

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


section .bss

    ; Buffer para guardar los dígitos como texto.
    ; Un número de 64 bits tiene máximo 20 dígitos.
    buffer resb 20


section .text
    global _start


_start:

    ; ========================================================
    ; PASO 1: MOSTRAR "Resultado: "
    ; ========================================================
    mov rax, 1              ; write
    mov rdi, 1              ; stdout
    mov rsi, mensaje
    mov rdx, longitud
    syscall


    ; ========================================================
    ; PASO 2: SUMAR TODOS LOS NÚMEROS (CICLO)
    ; ========================================================
    xor rax, rax            ; RAX = acumulador de la suma = 0
    xor rcx, rcx            ; RCX = índice = 0

suma:
    cmp rcx, cantidad       ; ¿ya recorrimos todos?
    jge fin_suma            ; si sí, salimos del ciclo

    add rax, [numeros + rcx*8]  ; acumulador += numeros[rcx]
    inc rcx                 ; siguiente número
    jmp suma

fin_suma:
    ; Aquí RAX = suma total (por ejemplo 143)


    ; ========================================================
    ; PASO 3: CONVERTIR A ASCII (CUALQUIER CANTIDAD DE DÍGITOS)
    ;
    ; Dividimos entre 10 repetidamente. Cada residuo es un dígito,
    ; pero salen de derecha a izquierda (unidades primero).
    ; Por eso llenamos el buffer desde el FINAL hacia atrás.
    ;
    ;   143 / 10 = 14  residuo 3  -> buffer[19] = '3'
    ;    14 / 10 =  1  residuo 4  -> buffer[18] = '4'
    ;     1 / 10 =  0  residuo 1  -> buffer[17] = '1'
    ; ========================================================
    mov rbx, 10             ; divisor
    lea rdi, [buffer + 20]  ; RDI apunta al final del buffer
    xor rcx, rcx            ; RCX = contador de dígitos

convertir:
    xor rdx, rdx            ; RDX = 0 antes de dividir
    div rbx                 ; RAX = cociente, RDX = residuo (dígito)
    add dl, '0'             ; dígito -> ASCII (suma 30h)
    dec rdi                 ; retrocedemos una posición
    mov [rdi], dl           ; guardamos el carácter
    inc rcx                 ; contamos el dígito
    test rax, rax           ; ¿el cociente llegó a 0?
    jnz convertir           ; si no, seguimos con el siguiente dígito

    ; Ahora RDI apunta al primer dígito y RCX = cuántos dígitos hay.


    ; ========================================================
    ; PASO 4: IMPRIMIR EL RESULTADO
    ; ========================================================
    mov rsi, rdi            ; RSI = dirección del primer dígito
    mov rdx, rcx            ; RDX = cantidad de dígitos
    mov rax, 1              ; write
    mov rdi, 1              ; stdout
    syscall


    ; ========================================================
    ; PASO 5: IMPRIMIR SALTO DE LÍNEA
    ; ========================================================
    mov rax, 1
    mov rdi, 1
    mov rsi, salto
    mov rdx, 1
    syscall


    ; ========================================================
    ; PASO 6: TERMINAR
    ; ========================================================
    mov rax, 60             ; exit
    mov rdi, 0              ; código 0 = todo bien
    syscall