[Assembly] Mips, prodotto scalare matrice vettore

[frab1]

Buongiorno, sto scrivendo un programmino in Assembly per processori Mips che calcola il prodotto scalare tra una matrice quadrata di ordine 10 ed un vettore a 10 elementi...la matrice la creo sommando l'indice di riga e colonna(es. la prima riga sarà: 0 1 2 3 4 5 6 7 8 9 ) e il vettore sulla stessa lunghezza d'onda lo creo da 1 a 10...ora ho scritto tutto il codice che funziona quasi a meraviglia...se non che calcolando i prodotti estraendo gli elementi da matrice e vettore non so per quale assurdo motivo dalla matrice come primo elemento estrae un 4 non uno 0...quindi mi sbaglia tutti iconti..ecco il codice:

          .data

    prodotto:   .word 10
    vettore:   .word 10         # definizione numero elementi del vettore
    nrig:       .word 10         # definizione del valore del numero di righe della matrice
    ncol:       .word 10          # definizione del valore del numero di colonne della matrice
    matrice:    .word 0:100          # definizione dell'area di memoria che conterrà la matrice -- (100 words inizializzate col valore 0)
    spazio:      .asciiz "  "
    acapo:      .asciiz "\n"   
                   
         .text

         .globl __start
    ######################################################################################
    #USO I REGISTRI $S0, $S1, $S2, $s4 PER FAR RIFERIMENTO AL VETTORE;
    #USO I REGISTRI $t0, $t1, $t2,$t3, $t4,$t5 PER FAR RIFERIMENTO ALLA MATRICE;
    ######################################################################################

    ##CREA MATRICE

    __start:

          li $t0,0         # in $t0 viene posto l'indice di riga i che assume valori da 0 a 9
          li $t1,0         # in $t1 viene posto l'indice di colonna j che assume valori da 0 9
          li $t2,0         # in $t2 viene posto l'indice k utilizzato per lo scorrimento delle locazioni di memoria
          lw $t3,nrig         # numero totale di righe in $t3            
          lw $t4,ncol         # numero totale di colonne in $t4
             
    ciclo:

          add $t5, $t0, $t1      #t5=i + j
          sw $t5, matrice($t2)      #scrivo i+j nella prima casella della matrice
          addi $t2, $t2, 4      #indirizzamento al byte
          addi $t1, $t1, 1      #incremento j, colonna successiva      
          blt $t1, $t4, ciclo      #se la nuova colonna è < delle colonne totali ripeti il ciclo
          li $t1, 0         #altrimenti poni a 0 l'indice di colonna
          addi $t0,$t0,1         #passa alla riga successiva
          blt $t0, $t3, ciclo      #e se la riga successiva è minore del totale ripeti il ciclo
        
          jal stampa_matrice
          la $a0, acapo         #stampo un "a capo" prima di calcolare il vettore
          li $v0, 4
          syscall

    ##CREA VETTORE
    #vett:
          li $s0, 0
          li $s1, 0
          lw $s2, vettore

    crea_vettore:
          addi $s4, $s0, 1
          sw $s4, vettore($s1)
          addi $s1, $s1, 4      #incremento indice di memoria
          addi $s0, $s0, 1      #incremento indice
          blt $s0, $s2, crea_vettore
          jal stampa_vettore

          la $a0, acapo         #stampo un "a capo" prima di calcolare il vettore
          li $v0, 4
          syscall

          li $s0, 0         #azzero s0
          li $t5, 0         #registro risultato
          li $t0, 0         #azzera contatore righe
          li $t1, 0         #azzera contatore colonne
          li $s1, 0         #punta al primo elemento del vettore
          li $t2, 0          #punta al primo elemento della matrice
          li $t9,10         #contatore d'appoggio
    pr_scalare:
          lw $t7, vettore($s1)      #carico il primo elemento del vettore
          lw $t6, matrice($t2)      #carico il primo elemento della 1 riga della matrice
          mul $t5, $t6, $t7      #moltiplico..
          add $s5, $s5, $t5
          addi $s1, $s1, 4      #.....
          addi $t2, $t2, 4      #.....
          addi $t9, $t9, -1      #decr. contatore d'appoggio
          bgt $t9, $zero,pr_scalare   
          sw $s5, prodotto($s7)      #scrivo il risultato nel vettore prodotto
          addi $s7, $s7, 4      #indirizzamento al byte...
          addi $s0, $s0, 1      #incremento contatore risultato
    #      addi $t1, $t1, 1      #passo alla colonna dopo
          addi $s1, $s1, 4      #.....
          addi $t2, $t2, 4      #.....
          blt $s0, 10, pr_scalare
          jal stampa_prodotto
             
          j esci 

Per semplicità ometto le routine di stampa che funzionano..il problema si presenta a livello del codice che comincia con l'etichetta "pr_scalare" e precisamente all'istruzione di " lw $t6, matrice($t2) " estrae un 4 invece di uno zero!! ...
Qualcuno riesce ad aiutarmi a capire dove sbaglio?

Grazie mille a tutti