converting c recursion code to mips

Question

I am in the process of trying to convert this C code to MIPS. This is only my second project so far and I feel like I am so close. Here is the C code.

//fast modular exponentiation
int fme(int x, int k, int n)
{
    int temp;
    int result = 1;
    if (k>0)
    {
        temp = fme(x,k/2,n);
        if(k%2==1)
        {
            result = x % n;
        }
        //as n<1000 the result of multiplication is less than 2^30
        result = (result*temp*temp)%n;
    }
    return result;
}

Here is the code I have so far in MIPS. In my main method before this code snippet I just ask for an input of values for x, k, and n.

Essentially the code is trying to run the method for fast modular exponentiation. a^k * mod n. The case when the exponent k is less than 0 returns 1 correctly, but any other values of k result in nothing being returned. I can't seem to figure out where I messed up so It would be greatly appreciated if I could have another set of eyes give it a look please and thanks.

I am unsure in my fme function about the recursion call after doing k/2 if I should store a1 before executing jal? Is that part right? Also I am unsure about the (temp * temp % n) line of c code if my mips code matches that correctly. Appreciate it greatly

---

# Call fme function
# place x,k,n into $a0,a1,a2
addi $a0, $s0, 0
addi $a1, $s1, 0
addi $a2, $s2, 0

addi $sp, $sp, -16 #reserve the stack for 4 items, x,k,n, result
sw $ra, 0($sp) #save ra which is going to be the result
sw $a0, 4($sp) #save argument number x
sw $a1, 8($sp) #save argument number k
sw $a2, 12($sp) #save argument number n
jal fme
lw $a2, 12($sp) #restore arg number n
lw $a1, 8($sp) #restore arg number k
lw $a0, 4($sp) #restore arg number x
lw $ra, 0($sp) #restore return address
addi $sp, $sp, 16 #restore sp stack
move $a0, $v0

#print result
li $v0, 1
syscall

########################
# Terminate program
li $v0, 10
syscall




#######################
# fme Function
# x^k mod n
#a0 is x, a1 is k, a2 is n

fme:
slt $t0, $zero, $a1 #check if 0 is less than k.
beq $t0, 0, returnone #if(k<0)then return result as 1

addi $t4, $zero, 2 #placeholder for the number 2
                    #(k>0)
div $a1, $t4 #divide k by 2
mfhi $t1    #$t1 is remainder of k/2
mflo $a1    #$a1 is quotient of k/2


#temp = fme(x, k/2, n)

jal fme #recursive call with k/2


beq $t1, 1, kmodtwo #if (k%2==1)

#if (k%2 !=1)
#result = (result * temp * temp) % n
# result = (1 * temp * temp) % n
# result = (temp * temp) % n
mult $v0, $v0 #temp * temp
mflo $t2
div $t2, $a2  #(temp*temp) % n
mfhi $v0      #result is in $t3

j fmedone     #return call





fmedone:    #closes the stack and returns.
lw $ra, 0($sp)
lw $a0, 4($sp)
lw $a1, 8($sp)
lw $a2, 12($sp)
addi $sp, $sp, 16
jr $ra


returnone:
#addi $v0, $v0, 1
li $v0, 1
jr $ra


kmodtwo:
#if (k%2==1)
#result = x % n
div $a0, $a2 #x/n
mfhi $a0 #remainder of x/n which is x%n

add $v0, $a0, $zero
j fmedone