The question to the problem.

n pow.s you will implement a main function and a pow function. pow will take two

integers $($let$$s call them n and m$)$ and return nm $.$ You must compute nm using recursion.

Can you find a smaller power computation inside $25?$ What is the base case? What is

the recursive case?

$.$global main

$.$type main, $\%$function

main:

sub sp$,$ sp$,$ #$16$

str lr$,[$sp$]$

$//$we$\text{'}$ll store two ints at $[$sp$,$ #$8]$ and $[$sp$,$ #$12]$

ldr x$0,=$int$\_$scanf

add x$1,$ sp$,$ #$8$

add x$2,$ sp$,$ #$12$

bl scanf

$//===============$

$//$ don't touch anything above this line.

$//$ Fix: call pow using the two ints on the stack as parameters the first parameter is at sp$+8$ and the second is at sp$+12$

$//$Fix: Print out the results using the int$\_$printf format

mov w$0,$ #$0$

ldr lr$,[$sp$]$

add sp$,$ sp$,$ #$16$

ret

$.$global pow

$.$type pow, $\%$function

pow:

$//$fix: implement the recursive function $`$int pow$($int n$,$ int m$)`$ that returns n$^$m$.$

$.$data

int$\_$scanf: $.$asciz $"\%$d $\%$d$"$

int$\_$printf: $.$asciz $"\%$d

$"$

Here is my code that I had already implemented.

$.$global main

$.$type main, $\%$function

main:

sub sp$,$ sp$,$ #$16//$ Allocate space on stack

str lr$,[$sp$]//$ Save return address

$//$ Read two integers $($n and m$)$ from input

ldr x$0,=$int$\_$scanf

add x$1,$ sp$,$ #$8//$ Address for $\text{'}$n$\text{'}$

add x$2,$ sp$,$ #$12//$ Address for $\text{'}$m$\text{'}$

bl scanf

$//$ Load n and m from the stack and call pow$($n$,$ m$)$

ldr w$0,[$sp$,$ #$8]//$ Load n

ldr w$1,[$sp$,$ #$12]//$ Load m

bl pow $//$ Call pow$($n$,$ m$),$ result in w$0$

$//$ Print the result using printf

ldr x$0,=$int$\_$printf

mov w$1,$ w$0//$ Move result to w$1$ for printing

bl printf

$//$ Clean up and return

ldr lr$,[$sp$]//$ Restore return address

add sp$,$ sp$,$ #$16//$ Deallocate stack space

ret

$.$global pow

$.$type pow, $\%$function

pow:

sub sp$,$ sp$,$ #$16//$ Allocate stack space for recursion

str lr$,[$sp$,$ #$8]//$ Save link register

$//$ Base case: if m $==0,$ return $1$

cmp w$1,$ #$0$

beq base$\_$case

$//$ Recursive case: compute n$^($m$-1)$ and multiply by n

sub w$1,$ w$1,$ #$1//$ Decrease m by $1$

mov w$2,$ w$0//$ Store n in w$2$

bl pow $//$ Recursive call pow$($n$,$ m$-1)$

mul w$0,$ w$0,$ w$2//$ Multiply result by n $($w$2)$

$//$ Restore link register and return

ldr lr$,[$sp$,$ #$8]$

add sp$,$ sp$,$ #$16$

ret

base$\_$case:

mov w$0,$ #$1//$ Base case: return $1$

ldr lr$,[$sp$,$ #$8]//$ Restore link register

add sp$,$ sp$,$ #$16//$ Deallocate stack space

ret

$.$data

int$\_$scanf: $.$asciz $"\%$d $\%$d$"//$ Format for scanf

int$\_$printf: $.$asciz $"+\%$d

$"//$ Format for printf