org 100h
jmp start

a   db  2
b   db  3
z   db  4
    
start:  
     

    
    ; calc 2a / z^2 
    mov     al, z  
    cbw
    imul    ax   ; ax = z * z
    push    ax
    pop     bx   ; bx = z^2
    
    mov     al, a
    add     al, [a]
    cbw     ; ax = 2a
                     
    xor     dx, dx
    idiv    bx      ; ax = 2a / z^2   
    
    push    ax      ; push ax in stack
    
    ; calc  b^3 / 3a
    mov     bl, 3
    mov     al, a
    cbw
    imul    bl      ; ax = 3a
    
    push    ax
    pop     bx
    
    mov     al, b
    cbw
    imul    [b]
    imul    [b]     ; ax= b^3
    
    xor     dx, dx
    idiv    bx      ;ax = b^3 / 3a
    
    ; calc  (2a / z^2) - (b^3 / 3a) 
    pop     bx      ; bx = 2a / z^2
    sub     bx, ax  ; bx =  (2a / z^2) - (b^3 / 3a)
    
    push    bx      ; res to stack
            
    ;calc   a^4 * b^2 
    mov     al, b
    cbw
    imul    ax      ; ax = b^2  
     
    push    ax
    pop     bx                              
                              
    mov     al, a
    cbw
    imul    ax      ; ax = a^2
    imul    ax      ; ax = a^4
    
    imul    bx      ; ax = a^4 * b^2
    
    pop     bx      ; bx =  (2a / z^2) - (b^3 / 3a)                 
    xor     dx, dx
    idiv    bx      ;ax =  ( a^4 * b^2) / ((2a / z^2) - (b^3 / 3a))
    
    push    ax
    
    ; calc a^2 / b^2
    
    mov     al, b
    cbw
    imul    ax      ; ax = b^2
    xchg    ax, bx
    mov     al, a
    cbw
    imul    ax      ; ax = a^2
    xor     dx, dx
    idiv    bx      ; ax = a^2 / b^2
    
    pop     bx
    add     ax, bx  ; ax = result
    
      
    call    print
       
    mov     ah, 0 
    int     16h 
       
; print sym
sym:    
    push ax
    mov ah, 02h
    int 21h
    pop ax
    ret
           
; print number
print:
    mov cx, 0
    mov bx, 10
    cmp ax, 0
    jge @next 
    neg ax     
    mov dl, '-'
    call sym
@next:
    xor dx, dx
    div bx
    add dl, '0'
    push dx   
    inc cx  
    cmp ax, 0
jne @next  
    
@out:
    pop dx
    call sym
loop @out       
ret 
       
ret