Halp plis for recursion

.data
Sbeginning:         .asciiz "Problema dello zaino (Knapsack)\n"
SinsertWTab:        .asciiz "Inserisci la dimensione orizzontale dello zaino: "
SinsertHTab:        .asciiz "Inserisci la dimensione verticale dello zaino: "
SinsertWRett:       .asciiz "Inserisci la dimensione orizzontale del blocco: "
SinsertHRett:       .asciiz "Inserisci la dimensione verticale del blocco: "
Sreinsert:          .asciiz "La dimensione deve essere un numero positivo.\n"
SnewRett:           .asciiz "Vuoi inserire un altro rettangolo? (1=si, 0/altro=no) "
ScreateRett:        .asciiz "Creo il rettangolo "
SinfoRett1:         .asciiz "Inserisco il rettangolo "
SinfoRett2:         .asciiz " :"
SinBag1:            .asciiz "Ho inserito nello zaino "
SinBag2:            .asciiz " rettangoli su "
SendBad:            .asciiz "Non posso piu' inserire blocchi!\n"
SendGood:           .asciiz "Zaino riempito con successo!\n"
Sfull:              .asciiz "X"
Sempty:             .asciiz "_"
Sreturn:            .asciiz "\n"

.text
.globl main

main:
##### Creo lo zaino
    li $v0,4        # Welcome!
    la $a0,Sbeginning
    syscall

errorInsertWTab:
    li $v0,4        # Richiesta larghezza zaino
    la $a0,SinsertWTab
    syscall

    li $v0,5        # Prendo il valore
    syscall

    bgt $v0,$zero,goodWTab

    li $v0,4        # Messaggio di errore
    la $a0,Sreinsert
    syscall

    j errorInsertWTab
goodWTab:
    move $s0,$v0    # Salvo WTab in s0

errorInsertHTab:
    li $v0,4        # Richiesta altezza zaino
    la $a0,SinsertHTab
    syscall

    li $v0,5        # Prendo il valore
    syscall

    bgt $v0,$zero,goodHTab

    li $v0,4        # Messaggio di errore
    la $a0,Sreinsert
    syscall

    j errorInsertHTab
goodHTab:
    move $s1,$v0    # Salvo HTab in s1

##  Creo lo zaino (tabella "srotolata" su una riga)
    mul  $t0,$s0,$s1
    sll  $t0,$t0,2  # x4... Altrimenti non siamo allineati
    sub  $sp,$sp,$t0
    move $s2,$sp    # Accedo allo zaino a partire da s2

##### Creo i rettangoli
    add  $s3,$zero,$zero # Giusto per essere sicuri
creaRett:
    addi $s3,1      # s3 contiene il numero di rettangoli inseriti
    li   $v0,4
    la   $a0,ScreateRett
    syscall
    li   $v0,1
    move $a0,$s3
    syscall
    li   $v0,4
    la   $a0,Sreturn
    syscall

errorInsertWRett:
    li $v0,4        # Richiesta larghezza rettangolo
    la $a0,SinsertWRett
    syscall

    li $v0,5        # Prendo il valore
    syscall

    bgt $v0,$zero,goodWRett

    li $v0,4        # Messaggio di errore
    la $a0,Sreinsert
    syscall

    j errorInsertWRett
goodWRett:
    move $t0,$v0    # Salvo WRett in t0

errorInsertHRett:
    li $v0,4        # Richiesta altezza rettangolo
    la $a0,SinsertHRett
    syscall

    li $v0,5        # Prendo il valore
    syscall

    bgt $v0,$zero,goodHRett

    li $v0,4        # Messaggio di errore
    la $a0,Sreinsert
    syscall

    j errorInsertHRett
goodHRett:
    move $t1,$v0    # Salvo HTab in t1

# Salvo il rettangolo nello stack
    addi $sp,$sp,-12 # In prima posizione inseriro' ra
    sw   $t0,4($sp)
    sw   $t1,8($sp)

# Chiedo se vuole un nuovo rettangolo
    li $v0,4
    la $a0,SnewRett
    syscall

    li $v0,5        # Prendo il valore
    syscall

    addi $t2,1      # Creo un nuovo rettangolo con '1' e non altro
    beq  $v0,$t2,creaRett

#### Inserisco i rettangoli

    move $a0,$s0 # Per convenzione...
    move $a1,$s1
    move $a2,$s2
    move $a3,$s3

    jal knapsack

    # Gestione risultato
    beq $v0,$zero,goodEnd

    li $v0,4
    la $a0,SendBad # Troppi blocchi
    syscall
    j end
goodEnd:
    li $v0,4
    la $a0,SendGood # Lieto fine
    syscall
end:
    li $v0,10       # Fine
    syscall



### Funzione di inserimento di un rettangolo nello zaino
# INPUT STATICI
# a0 <--> larghezza zaino
# a1 <--> altezza zaino
# a2 <--> puntatore all'inizio dello zaino
# a3 <--> rettangoli totali
# OUTPUT
# v0 <--> 0 ok, 1 errore
# Stampa il numero di blocchi inseriti


knapsack:
    sw $ra,0($sp)
    move $s0,$a0 # Per convenzione...
    move $s1,$a1
    move $s2,$a2
    move $s3,$a3
    addi $s4,$s4,1  # Conta il rettangolo che inserisco (s4 è 0 a meno di pasticci coi registri)
    move $s5,$zero  # X della casella di partenza inserimento
    move $s6,$zero  # Y della casella di partenza inserimento
    move $s7,$s2    # Posizione della casella in memoria


k_search:
    lw   $t0,0($s7)
    bne  $t0,$zero,k_shift_column # Casella piena
    j    k_checkBlock
k_shift_column:
    addi $s5,$s5,1
    addi $s7,$s7,4              # Nuova casella
    beq  $a0,$s0,k_shift_line   # EOL
    j k_search
k_shift_line:
    addi $a1,$a1,1
    beq  $a1,$s1,k_badEnd       # Fine matrice
    move $a0,$zero              # Inizio una nuova linea, resetto la X
    j k_search
k_checkBlock:
    lw   $t2,4($sp)     # Larghezza
    lw   $t3,8($sp)     # Altezza
    mult $t2,$t3
    mflo $t2            # Area blocco
    mult $s0,$s1
    mflo $t3            # Area zaino
    bge  $t2,$t3,k_badEnd

k_tryInsert:
    li  $v0,0
    jr  $ra
k_insertLine:


k_insertNewLine:
k_goodInsertLine:
k_goodInsertNewLine:








k_badEnd:
    addi $s4,$s4,-1 # "Qualcosa e' andato storto"
    jal  k_blockPrint
    lw   $ra,0($sp)
    li   $v0,1      # Errore
    jr   $ra
k_goodEnd:
    jal  k_blockPrint
    lw   $ra,0($sp)
    li   $v0,0      # Successo!
    jr   $ra
k_blockPrint: # Stampa quanti blocchi ha inserito l'algoritmo
    li   $v0,4
    la   $a0,SinBag1
    syscall
    li   $v0,1
    move $a0,$s4
    syscall
    li   $v0,4
    la   $a0,SinBag2
    syscall
    li   $v0,1
    move $a0,$s3
    syscall
    li   $v0,4
    la   $a0,Sreturn
    syscall
    jr   $ra