Altri Linguaggi - Assembly Mips - problema

Ciao a tutti! Avrei bisogno di una mano con questo piccolo programma assembly. Il programma deve fare questo: l'utente può inserire un numero (da 0 a 5) che indica il numero di oggetti da permutare, quindi se ad esempio viene inserito 3 il programma stamperà:

123
213
231
...
...

Prima di "buttarmi" nella programmazione assembly ho codificato questo algoritmo in Java. Vi posto il codice:

public class perm {
 
 
 static void permutazioni(int anagramma[], int elementiMancanti[]){
  if (elementiMancanti.length == 0){ 
   print(anagramma);
   return;
  }
  
  int[] anag = new int[anagramma.length + 1];
  for (int i=0; i<anagramma.length; i++)
   anag[i]=anagramma[i];
  
  for (int i=0; i<elementiMancanti.length; i++){
   anag[anag.length-1] = elementiMancanti[i];  //in assembler anag.length - 1 = anagramma.length
   
   int[] manc = new int[elementiMancanti.length-1];
   int k=0;
   for (int j=0; j<elementiMancanti.length; j++){
    if (j!=i){
     manc[k]=elementiMancanti[j];
     k++;
    }
   }
   
   
   permutazioni(anag, manc);
  }
 }
 
 
 static void print(int[] anagramma){
  for (int i=0; i<anagramma.length; i++)
   System.out.print(anagramma[i]);
  System.out.println();
 }

}

L'ho fatto in java perchè è l'unico linguaggio che conosco.
Ora vi posto il codice .asm, non è completo ma una parte della codifica. Il problema è che non so se quello che sto scrivendo è esatto. Non posso provarlo finchè non è finito visto che sfrutta al 100% la ricorsione.

.data

elemMancanti: .space 16
anagramma: .space 16
anag: .space 20

string1: .asciiz "Inserisci elementi: "

.text

.globl main

main:

	addi $t2, $zero, 0				#dimensione iniziale anagramma
	addi $t3, $zero, 1				#dimensione anag al primo giro

acquis:

	li $v0, 4						#Seleziona print_string
	la $a0, string1					#$a0 = indirizzo dell'etichetta string1
	syscall						#chiama la procedura per stampare una stringa

	li $v0, 5						#seleziona read_int
	syscall						#chiama la procedura per leggere un intero
	
	add $s0, $zero, $v0				#$s0 = oggetti da utilizzare
	
	la $s1, elemMancanti				#uso $s1 per memorizzare la base dell'array
	la $s2, anagramma					#uso $s2 per memorizzare la base dell'array
	la $s3, anag					#uso $s3 per memorizzare la base dell'array
		
	li $t0, 0 						#uso $t0 per memorizzare l'indice (in questo caso 0)

riempi_elemMancanti:
	
	slt $t4, $t0, $s0
	beq $t4, $zero, elabora

	move $a0, $t0					#carico in $a0 il valore dell'indice
	sll $t1, $t0, 2 					#$t1 = t0 * 4
	add $t1, $s1, $t1 				#$t1 = inizio_elemMancanti + i*4
	sw $a0, 0($t1) 					#elemMancanti[i]= i
	
	addi $t0, $t0, 1					#incremento contatore
	j riempi_elemMancanti				#goto riempi_elemMancanti

	move $a0, $s1					#$a0 = base di elemMancanti
	move $a1, $s2					#$a1 = base di anagramma
	move $a2, $s0					#$a2 = dimensione di elemMancanti
	move $a3, $t2					#$a3 = dimensione di anagramma

	jal permutazioni					#vai alla procedura permutazioni

permutazioni:

	bne $s0, $zero, calcola				#se la "dimensione" del vettore elemMancanti != 0 goto calcola

	li $t0, 0						#uso $t0 per memorizzare l'indice (in questo caso 0)

stampa_anagramma:

	slt $t1, $t0, $t2					#se i < dimensione Anagramma allora $t1 = 1
	beq $t0, $t2, ritorna
	beq $t1, $zero, calcola				#se $t1 == 0 allora goto calcola, else stampo vettore
	
	move $a0, $t0					#carico in $a0 il valore dell'indice
	sll $t1, $t0, 2					#$t1 = $t0 * 4
	add $t1, $s2, $t1					#$t1 = inizio_anagramma + i*4
	lw $a0, 0($t1)					#$a0 = anagramma[i]
	
	li $v0, 1						#Seleziona print_int
	syscall						#chiama la procedura per stampare un intero
	
	addi $t0, $t0, 1					#incremento contatore
	j stampa_anagramma				#goto stampa_anagramma

ritorna:
	
	j $ra
	
calcola:	
	
	li $t0, 0						#uso $t0 per memorizzare l'indice (in questo caso 0)

step1:

	slt $t1, $t0, $t2					#se i < dimensione anagramma allora $t1 = 1
	beq $t1, $zero, step2				#se $t1 == 0 allora goto step2, else elabora calcoli
	
	move $a0, $t0					#carico in $a0 il valore dell'indice
	sll $t1, $t0, 2					#$t1 = $t0 * 4
	add $t1, $s2, $t1					#$t1 = inizio_anagramma + i*4
	lw $a0, 0($t1)					#$a0 = anagramma[i]
	sll $t1, $t0, 2					#$t1 = $t0 * 4
	add $t1, $s3, $t1					#$t1 = inizio_anag + i*4
	lw $a1, 0($t1)					#$a1 = anag[i]
	sw $a0, 0($a1)					#anag[i] = anagramma[i]

	addi $t0, $t0, 1					#incremento contatore
	j step1						#goto step1

step2:

	li $t0, 0 						#uso $t0 per memorizzare l'indice (in questo caso 0)

	slt $t4, $t0, $s0
	beq $t4, $zero, elabora

	move $a0, $t0					#carico in $a0 il valore dell'indice
	sll $t1, $t0, 2 					#$t1 = t0 * 4
	add $t1, $s1, $t1 				#$t1 = inizio_elemMancanti + i*4
	move $a1, $t1					#preservo il contenuto in $a1, cosi riutilizzo $t1
	sll $t1, $t3, 2					#$t1 = $t3 * 4, ho settato $t3 = 1 all'inizio perche anag parte con length = 1
	add $t1, $s3, $t1					#$t1 = inizio_anag + i*4
	addi $t1, $t1, -4					#$t1 = anag - 1
	sw $a1, 0($t1)					#anag[anag.length-1] = elementiMancanti[i]
	
	
	addi $t0, $t0, 1					#incremento contatore
	j riempi_elemMancanti
	
	
	
	
	
	
	li $v0, 10
	syscall

Grazie mille in anticipo!