// ****************************************************************************
// * Lenguajes de Interfaz en TECNM Campus ITT
// * Nombre del archivo: practica.s
// * Descripción: Programa que genera una multiplicacion con datos almacenados en registros.
// * Autor: [America Fernanda Nevarez de la Cruz]
// * Fecha: [2025-04-03]
// * Plataforma: Raspberry Pi OS (64 bits)
// * Demostración:  [https://asciinema.org/a/7lEEdGYS8fhpLSQNmXrwuFLT6]
// ****************************************************************************

// ****************************************************************************
// * Codigo equivalente en C
// * #include <stdio.h>
// *    int main() {
// *        printf("Multiplicacion\n");
// *        printf("6 x 7 = ");
// *        int resultado = 6 * 7;
// *        printf("%d\n", resultado);
// *    return 0;
// ****************************************************************************

.global _start              // Punto de entrada del programa

.section .data
mensaje: .asciz "Multiplicacion\n"   // Mensaje inicial
resultado_msg: .asciz "6 x 7 = "    // Mensaje antes del resultado
salto: .asciz "\n"                  // Salto de línea

.section .bss
resultado_buffer: .skip 3            // Espacio para el número convertido (2 dígitos + null)

.section .text
_start:
    // Imprimir "¡Hola, ARM64!"
    mov x0, 1                  // Descriptor de archivo STDOUT (1)
    ldr x1, =mensaje           // Dirección del mensaje
    mov x2, 15                 // Longitud del mensaje
    mov x8, 64                 // Syscall write
    svc 0                      // Llamada al sistema

    // Imprimir "6 x 7 = "
    mov x0, 1                  // Descriptor de archivo STDOUT (1)
    ldr x1, =resultado_msg     // Dirección del mensaje
    mov x2, 8                  // Longitud del mensaje
    mov x8, 64                 // Syscall write
    svc 0                      // Llamada al sistema

    // Multiplicar 6 x 7
    mov w0, 6                  // Primer número
    mov w1, 7                  // Segundo número
    mul w2, w0, w1             // w2 = w0 * w1 (6 * 7 = 42)

    // Convertir resultado (42) a ASCII
    ldr x3, =resultado_buffer  // Dirección del buffer donde guardaremos el resultado

    // Cargar 10 en un registro para división
    mov w10, 10                // w10 = 10

    // Extraer decenas
    mov w4, w2                 // Copia el número
    udiv w5, w4, w10           // w5 = w4 / 10  → obtiene el dígito de las decenas
    mul w6, w5, w10            // w6 = w5 * 10  → obtiene el valor real de las decenas
    sub w4, w4, w6             // w4 = w4 - w6  → obtiene el dígito de las unidades

    // Convertir a ASCII y almacenar en buffer
    add w5, w5, '0'            // Convertir decenas a ASCII
    add w4, w4, '0'            // Convertir unidades a ASCII
    strb w5, [x3], #1          // Guardar decenas en buffer y avanzar
    strb w4, [x3], #1          // Guardar unidades en buffer y avanzar
    mov w7, 0                  // Null terminator
    strb w7, [x3]              // Almacenar '\0' al final del string

    // Imprimir resultado convertido
    mov x0, 1                  // Descriptor de archivo STDOUT (1)
    ldr x1, =resultado_buffer  // Dirección del resultado convertido
    mov x2, 2                  // Longitud del resultado (2 caracteres)
    mov x8, 64                 // Syscall write
    svc 0                      // Llamada al sistema

    // Imprimir salto de línea
    mov x0, 1                  // Descriptor de archivo STDOUT (1)
    ldr x1, =salto             // Dirección del salto de línea
    mov x2, 1                  // Longitud del salto de línea
    mov x8, 64                 // Syscall write
    svc 0                      // Llamada al sistema

    // Terminar el programa
    mov x0, 0                  // Código de salida 0
    mov x8, 93                 // Syscall exit
    svc 0                      // Llamada al sistema