[x86 + DOS] Acquisizione matrice di interi

Ciao, devo scrivere un codice in assembly che mi memorizzi una matrice di interi con segno utilizzando una procedura per quanto riguarda la parte di conversione in decimali dei caratteri acquisiti.
Nel mio codice agisco in questo modo:
1)Lancio int 21h per memorizzare un carattere
2) sottraggo '0'
3)Metto il carattere convertito nello stack
4) lancio la procedura "converti" che non fa altro che prendere i numeri nello stack che compongono il valore decimale che voglio inserire nella matrice, moltiplicarli per dieci secondo il loro ordine e sommarli fra loro; alla fine se il numero è negativo lo moltiplico per -1.

e il tutto ripetuto per ogni elemento della matrice che voglio acquisire.

La procedura funziona a pennello ho già verificato, la cosa che mi manda in bestia è che non capisco perché subito dopo aver inserito l'elemento desiderato nella matrice, proprio nel momento in cui all'iterazione successiva lancio l'int21h, l'elemento che ho inserito io nella matrice viene modificato!!!! E non ne ho la minima idea del perché!!!! Nel debug guardo l'IP: non appena va a 200 e nel code viewer viene evidenziata l'istruzione BIOS DI il valore viene modificato !!! E non solo quello relativo al primo elemento, ma anche quello successivo!!!!

Ho provato a lanciare un programma simile in un altro progetto, dove invece non usavo procedure e l'inconveniente dell'int 21h non si è verificato, per cui deduco che il problema risieda proprio nella procedura, anche se ripeto che mi sembra assolutamente fuori dal mondo perché funziona perfettamente

Questo è il codice incriminato:

COLONNE EQU 6
                      RIGHE EQU 4
                      CR    EQU  13
                      
                      .MODEL small
                      .STACK
                      .DATA
                      matrice DW RIGHE*COLONNE*2 DUP (0)
                      
                      .CODE
                      .STARTUP

                      MOV BX, 0
                      MOV CX, -1
                      MOV SI, 0
                      
                      MOV DI, 0
                      
acquisizione:         MOV AH, 1
                      INT 21H
                      CMP AL, CR
                      
                      JZ continua
                      
                      CMP AL, '-'
                      JZ meno                
                      
                      SUB AL, '0'
meno:                 CBW
                      PUSH AX
                      ADD CX, 1
                      CMP CX, 4
                      JNZ acquisizione
          
continua:             PUSH CX
                      CALL converti
                      MOV matrice[BX][DI], AX
                      MOV AX, 0
                      MOV CX, -1
                      ADD DI, 2
                      CMP DI, 10
                      JNZ acquisizione
                      
                      ADD BX, DI
                      MOV DI, 0
                      CMP BX, (RIGHE-1)*(COLONNE-1)*2
                      JNZ acquisizione
             
converti PROC
                     MOV BP, SP
                     SUB SP, 2
                     MOV [BP-2], 1
                     JMP dopo

segno:               MOV [BP-2], -1
                     MOV AX, 0
                     JMP unità
                     
dopo:                PUSH BX
                     PUSH DI
                     MOV CX, [BP+2]
                     MOV BX, 2
                     MOV SI, -1
                     MOV DX, 0
                     
                     
ciclo:               ADD BX, 2
                     MOV DI, BX
                     MOV AX, [BP+DI]
                     INC SI
                     
                     CMP SI, 0
                     JZ unità
                     
                     CMP AX, '-'
                     JZ segno

                     PUSH BX
                     MOV DI, 0
                     MOV BL, 10
                     
potenza:             MUL BL
                     INC DI
                     CMP DI, SI
                     JNZ potenza                   
                     
                     POP BX
                     
unità:               ADD DX, AX
     
                     CMP SI, CX
                     JNZ ciclo
                     
                     POP DI
                     POP BX
                     POP CX
                     MOV AX, CX
                     CBW
                     MOV CX, AX
                     MOV AX, DX
                     CWD
                     IMUL CX
 
                     RET 8
converti             ENDP
                      
                      .EXIT