This mips code:

# initialize B$[0]$ to $1($A$[0]^0=1)$

addi $t$0,$ $t$0,1$

sw $t$0,0($$s$2)$

# initialize n$2$ to $1($since B$[0]$ is already set$)$

ori $s$3,$ $zero, $1$

# initialize loop var j to $1$

ori $t$1,$ $zero, $1$

start:

# exit loop if j $>=$ n$1$

bge $t$1,$ $s$1,$ loopend

# calculate A$[$j$]$ address and load A$[$j$]$

sll $t$2,$ $t$1,2$ # offset $=$ j$*4$

add $t$3,$ $s$0,$ $t$2$ # find address of A$[$j$]$

lw $t$4,0($$t$3)$ # load A$[$j$]$ into t$4$

# find exponent$($A$[$j$],$

j$)$

move $a$0,$ $t$4$ # a$[$j$]=$ argument $1$

move $a$1,$ $t$1$ # j $=$ arg $2$

jal exp # call to exponent callee

move $t$5,$ $v$0$ # store result $($v$0)$ in t$5$

#move result into B

move $a$0,$ $s$2$ # pass base adress of B

move $a$1,$ $s$3$ # pass length of B $($n$2$

move $a$2,$ $t$5$ # store result into t$5$

jal append # call to append func

addi $s$3,$ $s$3,1$ #n$2++$

#increment loop counter $($j$)$

addi $t$1,$ $t$1,1$

j start

# exponent func $-$ int exp$($intx$,$ inty$)$

exp:

move $t$0,$ $a$0$ # move x to t$0$

move $t$1,$ $a$0$ # y to t$1$

ori $t$2,$ $zero, $1$ # exp $=1$

beq $t$1,$ $zero, exp$\_$end #if y $=0,$ return $1$

exploop:

mul $t$2,$ $t$2,$ $t$0$ # exp $*=$x

addi $t$1,$ $t$1,-1$ # y $=-1$

slt $t$3,$ $zero, $t$1$ # t$3=1$ if t$1=0$

bne $t$3,$ $zero, exploop # t$3!=0,$ repeat until y$=0$

exp$\_$end:

move $v$0,$ $t$2$ # return val in v$0$

jr $ra

append:

sll $t$0,$ $a$1,2$ # find offset $=$ n$2*4$

add $t$1,$ $a$0,$ $t$0$ # calc adress of B$[$n$2]$

sw $a$2,0($$t$1)$ #store exp at B$[$n$2]$

jr $ra

loopend:

$/////////////////////$

Is supposed to mimic the following C pseudocode:

# Change your C code here $($if different$)$

#int main$()\{$

# B$[0]=1$; $//0$th element $=$ A$[0]^0=1$

# for $($int j $=1$; j $<$ n$1$; j$++)\{$

# n$2=$ j; $//$ Current length of array B

# exp $=$ exponent$($A$[$j$],$ j$)$;

# append$($B$,$ n$2,$ exp$)$;

# $\}$

# n$2++$;

# $\}$

#int exponent$($int x$,$ int y$)\{$

# int exp $=$ x;

# for $($int j $=1$; j $<$ y; j$++)\{$

# exp $=$ exp $*$ x;

# $\}$

# return$($exp$)$;

#$\}$

#void append$($int$*$ B$,$ int n$2,$ int exp$)\{$

# B$[$n$2]=$ exp;

#$\}$

Where register s$0$ is A$,$ s$1$ is n$1,$ s$2$ is B$,$ and s$3$ is n$2.$

I cannot find a reason as to why it hasn't been outputting the expected values i've tested it with,

If someone $($NOT CHATGPT PLS$)$ could help me with this it'd be greatly appreciated.

Registers Variables

$s$0$ A

$s$1$ n$1$

$s$2$ B

$s$3$ n$2$

Addresses Contents

$s$0$ A$[0]$

$s$0+4$ A$[1]$

$......$

$s$0+4*($n$-1)//$ A$[$n$-1]$

Gets tested with:

Registers Data

$s$04000$

$s$15$

$s$28000$

$s$30$

Addresses Contents

$400010$

$40045$

$4008-5$

$4012-2$

$40160$

Expect to get:

The resultant registers will be:

Registers Data

$s$28000$

$s$35$

The resultant array B is:

Addresses Contents

$80001$

$80045$

$800825$

$8012-8$

$80160$