Tarea de ensamblador - Cálculo de combinaciones

------------------------------

.LC0:
 .string "%i\n"

 .globl print
print:
 pushq %rbp
 movq  %rsp,  %rbp

 movq 16(%rsp), %rsi ;Mueve el valor de la memoria principal al registro %rsi
 movq $.LC0,   %rdi ;Mueve el puntero de el string al registro %rdi
 movl $0,   %eax ;Valor parametro para afirmar a printf que hay un solo valor parmetro
 call printf       ;Llama a la funcion printf

 leave
 ret


 .globl factorial
factorial:
 pushq %rbp
 movq  %rsp,   %rbp

 jmp .LF
.Factorial0:
 movq 16(%rsp), %rax ;Recupera el valor de la cima de la pila
 subq $1,  %rax ;Le resta uno al valor en %rax
 pushq %rax       ;Mueve el valor a la cima de la pila
 call  factorial      ;Llama a factorial
 popq %rax       ;Recupera el valor regresado por esta funcion

 movq 16(%rsp), %rdx 
 imulq %rax,  %rdx ;Este valor lo multiplica por el valor que recibio como parametro
 movq %rdx,  16(%rsp) ;Regresa el valor de la multiplicacion

 leave
 ret
.Factorial1:
 movq $1,  16(%rsp) ;Regresa el valor 1
 leave
 ret
.LF:
 cmpl  $1,   16(%rsp) ;Compara el valor en la memoria principal con 1
 jg .Factorial0   ;Si el valor es mayor que 1 pasa al bloque indicado

 cmpl $0,  16(%rsp) ;Si el valor es igual a 0 pasa al bloque indicado 
 je .Factorial1
 leave
 ret

.globl combinaciones
combinaciones:
 pushq %rbp  
 movq %rsp,  %rbp
 subq $24, %rsp

.L1:
 pushq 48(%rsp) ;Manda el segundo parametro recibido, como parametro para factorial
 call  factorial
 popq (%rsp)  ;Mueve el resultado a los primeros 8 bytes resevados
 
.L2:
 pushq 40(%rsp) ;Manda el primer parametro recibido, como parametro para factorial
 call factorial
 popq 8(%rsp)  ;Mueve el resultado a los siguientes 8 bytes resevados
.L3:
 movq 48(%rsp),  %rax
 movq 40(%rsp), %rdx ;Recupera los valores recibidos como parametros
 subq %rdx,  %rax ;Resta el primer parametro al segundo
 pushq %rax       ;Lo empuja a la cima de la pila
 call factorial      ;Obtiene su factorial
 popq 16(%rsp)      ;Lo recupera
.L4:
 movq 8(%rsp), %rax
 movq 16(%rsp), %rdx
 imulq %rax,  %rdx ;Multiplica los divisores

 movq (%rsp),  %rax
 movq %rdx,  %rbx
 movq $0,  %rdx
 idivq %rbx  ;Divide el factorial del primer parametro entre el divisor
 movq %rax,  48(%rsp) ;Pone el resultado en el primer parametro empujado a esta funcion

 leave
 ret

 
.globl main
 
main:
 pushq %rbp  ;Empuja el registro a la cima de la pila
 movq %rsp,  %rbp ;Mueve el registro %rsp a la cima de la funcion
 subq $32, %rsp ;Resta 32 al valor del registro %rsp
.M1:
 movq %rsi, %rax ;Mueve el valor puntero de %rsi a %rax
 movq %rax, (%rsp) 
 addq $8, %rax ;Mueve el puntero dos bytes arriba del stack
 movq (%rax), %rdi ;Esta vez mueve el valor en la memoria principal a el registro %rdi
 call  atoi  ;Manda a llamar al funcion atoi para convertir el valor en %rdi a entero 
 movq %rax, 16(%rsp) ;Recupera el valor regresado por atoi y lo mueve a la memoria principal
 
.M2:
 movq (%rsp), %rax ; recupera y convierte a entero el siguiente valor 
 addq $16, %rax 
 movq (%rax), %rdi 
 call  atoi  
 movq %rax, 24(%rsp)
.M3:
 movq 16(%rsp), %rax
 movq 24(%rsp), %rdx 
 pushq %rax  ;Empuja los parametros a la cima de la pila
 pushq %rdx  
 call combinaciones  ;Llama a la funcion de combinaciones
 
.M4:
 popq %rax  ;Recupera el valor que produce la funcion y luego lo manda a imprimir
 call print
 
 leave
 ret