Как сделать полностью правильными вычисления.

[alonil]

Выражение a*c*(a+b)-d вычисляется правильно только ,если при операциях над числами не получаются очень крупных чисел.
Переменные имеют следующий тип.

 a db ?
        b db ?
        c db ?
        d dw ?
        result dw ?

Vichislenia:   
        mov al,[a]
        imul [c]
        mov  bx, ax
        mov al,[a]
        add al,[b]
        imul bx
        sub  ax,[d]
        mov  [result],  ax

Помогите,чтобы считало,правильно даже когда я ввожу например
a=110
b=54
c=63
d=59
Вот при таких значениях он считает уже неправильно.
А при таких допустим считает всё правильно
a=-11
b=12
c=-13
d=14
А полностью код выглядит так

.model small
 data segment
        msg_a db 13,10, "a = ", '$'
        msg_b db 13,10, "b = ", '$'
        msg_c db 13,10, "c = ", '$'
        msg_d db 13,10, "d = ", '$'
        msg_result db 13,10, "a*c*(a+b)-d = ", '$'
        a db ?
        b db ?
        c db ?
        d dw ?
        result dw ?
data ends
stk segment stack
    db 256 dup(?)
stk ends
code segment
    assume cs: code, ds: data, ss: stk 
 start:
        mov ax, data
        mov ds, ax
 Vvod_peremenou:
        mov ah, 09h
        lea dx, [msg_a]
        int 21h
        mov di, offset store_A
        jmp ReadInt16
store_A:
        mov [a], al
        
        mov ah, 09h
        lea dx, [msg_b]
        int 21h
        mov di, offset store_B
        jmp ReadInt16
store_B:
        mov [b], al
        
        mov ah, 09h
        lea dx, [msg_c]
        int 21h
        mov di, offset store_C
        jmp ReadInt16
store_C:
        mov [c], al
        
        mov ah, 09h
        lea dx, [msg_d]
        int 21h
        mov di, offset store_D
        jmp ReadInt16
store_D:
        mov [d], ax
 Vichislenia:   
        mov al,[a]
        imul [c]
        mov  bx, ax
        mov al,[a]
        add al,[b]
        imul bx
        sub  ax,[d]
        mov  [result],  ax
Vivod_resultata:      
        mov     ah,     09h
        lea     dx,     [msg_result]
        int     21h
        mov     ax,     [result]

Vivod_result:        
        mov     bx,     10      
        xor     cx,     cx      
        or      ax,     ax     
        jns     _div
                neg     ax      
                push    ax      
                mov     ah,     02h
                mov     dl,     '-'
                int     21h
                pop     ax
        _div:                  
                xor     dx,     dx
                div     bx
                push    dx      
                inc     cx      
                or      ax,     ax
                jnz     _div           
        mov     ah,     02h
        store:
                pop     dx      
                add     dl,     '0'    
                int     21h     
        loop    store
ReadInt16:
        xor     bx,     bx      
        xor     cx,     cx      
        do:
                mov     ah,     00h 
                int     16h
                
                mov dl, al 
                cmp al, 0Dh 
                je  _break
                cmp al, '-'
                jne  @endif
                mov  bx, 1
                        jmp     putchar
                @endif:
                sub al, '0'
                jc do
                cmp al, 9+1
                jnc    do
                xor     ah,     ah
                shl     cx,     1      
                mov     si,     cx
                shl     cx,     1
                shl     cx,     1
                add     cx,     si
                add     cx,     ax     
        putchar:
                mov     ah,     02h
                int     21h
        jmp     do
_break:
        mov  ax, cx
        
        test bx, bx
        jz  exit
        neg  ax
exit:
        jmp di

        mov     ax,     4C00h
code ends
end    start

Помогите,пожалуйста, чтобы вычисления и для тех значений были верными

[alonil]

Уже исправил спасибо.

[macomics]

У вас в выражении 3 умножения. При каждом умножении количество бит операндов удваивается. Таким образом после 2-х умножений вы получите результат размером в 32-бита записанный в dx:ax. Тогда вычитать d вам надо из пары регистров dx:ax с учетом переносов

; a + b
mov al, [b]
cbw ; Необходимо расширить переменную до слова т.к. будем умножать уже слова
mov cx, ax
mov al, [a]
cbw ; и a тоже расширяем перед сложением
add cx, ax

; a * c
; После расширения значение al не изменилось и все еще содержит значение a
imul [c] ; Перемножаем два значения размером в байт и результат получается размером в слово

; a * c * (a + b)
imul cx ; Перемножаем два значения размером в слово и результат получается размером в двойное слово

; a * c * (a + b) - d
sub ax, [d]
sbb dx, 0

; Если значение dx:ax получилось больше чем -32768 .. 32767 тогда записать результат в переменную типа word не выйдет