3. Colores Modificado 9

Modificación del programa # 9 " Colores " Por mi compañero Ambrocio isaias Laureano

CR EQU 13    ;Declaro retorno de carro
LF EQU 10    ;Declaro salto de linea
BIOS EQU 10H ;Declaro interrupcion 10h
DOS EQU 21H  ;Declaro interrupcion 21h
TEXTO EQU 3  ;Declaro el servicio 03 para la impresion de texto desde BIOS
FIN EQU 4C00H ;Declaro interrupcion de exit

VARIABLES SEGMENT          ;Declaro las variables  
    include "emu8086.inc"
    TITULO DB "JUENITO_XD" ;Un texto
    COLORES DB 01001110B   ;Una agrupacion de colores
    DB 11101111B           ;0= cursos parpadeante 000=color de fondo 0000=color del texto
    DB 10110001B
    DB 01011100B
    DB 00110001B
    DB 01011111B
    DB 01101011B
    DB 01011100B
    DB 01101111B
    DB 01001110B
    DB 00110001B
VARIABLES ENDS

VPILA SEGMENT;STACK       ;Declaro la pila
    DB 64 DUP("PILA")
VPILA ENDS

CODIGO SEGMENT
    COLO PROC FAR    ;Declaro un procedimiento
    ASSUME CS:CODIGO, DS:VARIABLES, SS:VPILA
    MOV AX,VARIABLES
    MOV DS,AX
    MOV AX,TEXTO     ;Invoco el servicio de impresion de texto 
    INT BIOS         ;Ejecuto el servicio con 10h
    MOV CX,11        ;Declaro el iterador en 11
    XOR SI,SI        ;Borro SI
    BUCLE:           ;Llamo al bucle
    PUSH CX
    MOV DX,SI        ;Indico la posicion de la letra a imprimir con SI
    ADD DX,35        ;Indico la coordenada en x, la coordenada inicial es x=35
    MOV DH,12        ;Indico la coordenada en y  
    CALL COLOCA      ;Llamo al sistema para que coloque el cursor donde yo quiero
    MOV AL,[SI+OFFSET TITULO] ;Le indico la letra a imprimir pasandole SI y el texto como parametros
    MOV BL,[SI+OFFSET COLORES]   ;Le indico los colores a imprimir pasandole SI y el conjunto de colores como parametros
    CALL COLOR                ;Llamo a la impresion del texto
    POP CX
    INC SI                     ;Incremento a SI para modificar la letra a imprimir y la coordenada en x
    
    LOOPNZ BUCLE
    MOV AH,8    ;08:Lee un caracter sin imprimir nada en pantalla
    INT DOS     ;Ejecuto el servicio
    XOR DX,DX   ;Limpio DX
    CALL COLOCA ;Coloco el cursor en las coordenadas x=0 y=0     
    PUT_CURSOR 10,10
    print "Hola mundo" 
    PUT_CURSOR 20,20
    print "Estas son las coordenadas( x=20, y=20)"
    TERMINA        ;MACRO TERMINA
    COLO ENDP
       
    include "C:\Users\Isaías\Desktop\Librerias.inc"
    
CODIGO ENDS
END COLO

 COLOR PROC  
    MOV AH,9         ;Invoco al servicio 09 para imprimir texto con formato
    XOR BH,BH        ;Limpio bh para indicarle que imprima en la misma pagina
    INT BIOS         ;Hago la impresion pidiendo la interrupcion 10h
    RET    ;retorno al programa principal
    COLOR ENDP
    
    COLOCA PROC
    MOV AH,2   ;Invoco al servicio 02 de 10h para posicionar el cursor
    XOR BX,BX  ;Limpio bx para decirle que debe ser en la misma pagina
    INT BIOS   ;Coloco el cursor con 10h en funcion del servicio 02
    RET   ;retorno al programa principal
    COLOCA ENDP
 
 PUT_CURSOR MACRO X,Y
 MOV AH,02H   ;Para posicionar el cursor
    MOV BH,00H   ;Coloco en la pagina 0
    MOV DH,X  ;Establesco las coordenadas, x=dh=renglon
 MOV DL,Y     ; Establesco las coordenadas y=dl=columna
    INT 10H      ;ejecuto la interrupción
 endm
 
 TERMINA MACRO
 MOV AX,4C00H  ;Termino el programa
    INT 21H     ;llamando a la interrupcion 21h
 ENDM

Programa 9: colores en letras y fondo por Torres.
CR EQU 13    ;Declaro retorno de carro
LF EQU 10    ;Declaro salto de linea
BIOS EQU 10H ;Declaro interrupcion 10h
DOS EQU 21H  ;Declaro interrupcion 21h
TEXTO EQU 3  ;Declaro el servicio 03 para la impresion de texto desde BIOS
FIN EQU 4C00H ;Declaro interrupcion de exit

VARIABLES SEGMENT          ;Declaro las variables 
    include "emu8086.inc"
    TITULO DB "Colores_UwU" ;Un texto      
    M1 DB "A",'$'
    COLORES DB 01001110B   ;Una agrupacion de colores
    DB 01101111B         
    DB 01110011B
    DB 01011100B
    DB 00110001B
    DB 01011111B
    DB 01101011B
    DB 01011100B
    DB 01101111B
    DB 01001110B
    DB 01101111B
VARIABLES ENDS

VPILA SEGMENT;STACK       ;Declaro la pila
    DB 64 DUP("PILA")
VPILA ENDS

CODIGO SEGMENT
    COLO PROC FAR    ;Declaro un procedimiento
    ASSUME CS:CODIGO, DS:VARIABLES, SS:VPILA
    MOV AX,VARIABLES
    MOV DS,AX
    MOV AX,TEXTO     ;Invoco el servicio de impresion de texto
    INT BIOS         ;Ejecuto el servicio con 10h
    MOV CX,11        ;Declaro el iterador en 11
    XOR SI,SI        ;Borro SI
    BUCLE:           ;Llamo al bucle
    PUSH CX
    MOV DX,SI        ;Indico la posicion de la letra a imprimir con SI
    ADD DX,35        ;Indico la coordenada en x, la coordenada inicial es x=35
    MOV DH,12        ;Indico la coordenada en y 
    CALL COLOCA      ;Llamo al sistema para que coloque el cursor donde yo quiero
    MOV AL,[SI+OFFSET TITULO] ;Le indico la letra a imprimir pasandole SI y el texto como parametros
    MOV BL,[SI+OFFSET COLORES]   ;Le indico los colores a imprimir pasandole SI y el conjunto de colores como parametros
    CALL COLOR                ;Llamo a la impresion del texto
    POP CX
    INC SI                     ;Incremento a SI para modificar la letra a imprimir y la coordenada en x
   
    LOOPNZ BUCLE
    MOV AH,8    ;08:Lee un caracter sin imprimir nada en pantalla
    INT DOS     ;Ejecuto el servicio
    XOR DX,DX   ;Limpio DX
    CALL COLOCA ;Coloco el cursor en las coordenadas x=0 y=0   
    PUT_CURSOR 2,32
    print "Colores modificado"
    PUT_CURSOR 20,20
    print "El programa a sido ejecutado correctamente"
    TERMINA        ;MACRO TERMINA
    COLO ENDP
     
    include "libtorres.inc" 
    
    
   
CODIGO ENDS
END COLO

include 'emu8086.inc'

CUADRO MACRO XI,YI,XF,YF,COLOR
MOV AX, 0600H ;
MOV BH, COLOR ; COLOR DE FONDO Y LETRA
MOV BL, 00H
MOV CH, YI ; Y INICIAL
MOV CL, XI ; X INICIAL
MOV DH, YF ; Y FINAL
MOV DL, XF ; X FINAL
INT 10h
endM

POSICION MACRO X,Y
; **** POSICIONA EL CURSOR ********
MOV DH, Y ; POSICI[ON EN Y
MOV DL, X ; POSICI[ON EN X
MOV AH, 02
MOV BH, 00
INT 10H
ENDM

DESPLEGAR MACRO MENSAJE
MOV AH,09 ;****** MUESTRA MENSAJE *******
MOV DX,OFFSET MENSAJE
INT 21h
ENDM

DATOS SEGMENT ;SEGMENTO DE DATOS
M1 DB "A",'$'
M2 DB "B",'$'
M3 DB "C",'$'
M4 DB "",'$'

datos ends
cincocuadros macro

cuadro 1,1,20,5,98
posicion 10,3
desplegar M1

cuadro 21,1,40,5,11011100b
posicion 30,3
desplegar M2

cuadro 41,1,60,5,36
posicion 50,3
desplegar M3




endM
CODIGO SEGMENT
ASSUME CS: CODIGO,DS:DATOS,SS:PILA
PRINCIPAL PROC

MOV AX,DATOS
MOV DS,AX

cincocuadros

PRINCIPAL ENDP ;FIN DEL PROCEDIMIENTO
CODIGO ENDS ;FIN DEL SEGMENTO

END PRINCIPAL

3. Macros local etiqueta p8

Programa 8 (pt-1): 

Imprime tres cadenas ingresadas por teclado

Código:

;PROGRAMA 08-1PT

CR EQU 13
LF EQU 10
FIN EQU 4C00H
BIOS EQU 10H

INCLUDE 'EMU8086.INC'
INCLUDE 'C:\emu8086\MySource\PROG-8-PT2.txt'           

DATOS SEGMENT
    NOMBRE DB 30 DUP(32), '$'
    DIR DB 30 DUP(32), '$'
    TLF DB 15 DUP(32), '$'
    MENS1 DB 'NOMBRE: ', '$'
    MENS2 DB 'DIRECCION: ', '$'
    MENS3 DB 'TELEFONO:', '$'
    ENTERR DB CR, LF, '$'
DATOS ENDS
        
PILA SEGMENT STACK
    DB 64 DUP('PILA')
PILA ENDS
                
CODIGO SEGMENT
    INICIO PROC FAR
    ASSUME CS:CODIGO, DS:DATOS, SS:PILA
    MOV AX, DATOS
    MOV DS, AX
    MODO_DE_VIDEO
    
    ESCRIBE MENS1
    PEDIR NOMBRE, 5
    ESCRIBE ENTERR
                  
    ESCRIBE MENS2
    PEDIR DIR, 8
    ESCRIBE ENTERR               
    ESCRIBE MENS3
    PEDIR TLF, 10
    ESCRIBE ENTERR
    
    ESCRIBE ENTERR
    ESCRIBE ENTERR
    
    ESCRIBE NOMBRE
    ESCRIBE ENTERR
    ESCRIBE DIR
    ESCRIBE ENTERR
    ESCRIBE TLF
    ESCRIBE ENTERR
    SALIR

CODIGO ENDS
END INICIO

Programa 8 (pt-2):  

Macros Pedir, Escribe ,Salir
Nombre asignado al archivo extensión .txt  PROG-8-PT2.txt

Segunda Parte

Código:

PROGRAMA 08-2PT

PEDIR MACRO NOM, N
    LOCAL BUCLE
    MOV SI, OFFSET NOM
    MOV CX, N
    BUCLE:    
        MOV AH, 8
        INT 21H
        MOV [SI], AL
        MOV AH, 2
        MOV DL, AL
        INT 21H   
        INC SI
        LOOPNZ BUCLE              
ENDM
                    
ESCRIBE MACRO MENS           
    MOV AH, 09
    MOV DX, OFFSET MENS
    INT 21H
ENDM
                  
MODO_DE_VIDEO MACRO
    MOV AX,3
    INT BIOS
ENDM
                   
SALIR MACRO
    MOV AX, FIN
    INT 21H    
ENDM   

Resultado:

Referencia:

https://www.alpertron.com.ar/INST8088.HTM

3. Multiplicación de números de 2 cifras (Modificado)

#De: Ambrocio Laureano

.model small ;Modelo de memoria m?s utilizado
.stack
.data        ;definición de datos(variables), donde se almacenara información      
include "emu8086.inc"
.code
imprimir macro num  
   mov ah,02h 
   mov dl,num
   add dl,30h
   int 21h    
endm   

leernum macro
   mov ah,01h     ;Function(character read) Guarda en AL
   int 21h        ;Interruption DOS functions
   sub al,30h     ;ajustamos valores
endm        

multiplica macro valor1, valor2
   mov al,valor1  ;al=5       ;unidad del segundo numero
   mov bl,valor2  ;bl=5       ;unidad del primer numero
   mul bl       ;al=25      ;multiplicar  
endm
    
suma macro valor1, valor2
   mov al,valor1      ;al=02        ;movemos el segundo resultado de la primera mult a al
   mov bl,valor2      ;bl=0         ;movemos primer resultado de la segunda mult a bl
   add al,bl      ;al=2   
endm  

separarUnidades macro
   mov ah,00h     ;ah=00        ;limpiamos el registro ah
   aam            ;ax=01 01     ;separamos de hex a dec
endm

   chr1  db ? ;primer digito
   chr2  db ? ;segundo digito
   chr3  db ? ;multiplo
   chr4  db ?
   r1    db ? ;resultado 1
   r2    db ? ;resultado 2
   r3    db ?
   r4    db ?
   ac    db 0 ;acarreo
   ac1   db 0     
   
.startup
   ;cls
   mov ah,00h     ;Function(Set video mode)
   mov al,03      ;Mode 80x25 8x8 16
   int 10h        ;Interruption Video
   
   leernum
   mov chr1,al    ;[chr1].chr2 * chr3 = ac.r1.r2
    
   leernum
   mov chr2,al    ;chr1.[chr2] * chr3 = ac.r1.r2

   print "*"

   leernum
   mov chr3,al    ;chr1.chr2 * [chr3] = ac.r1.r2
  
   leernum
   mov chr4,al    ;chr1.chr2 * [chr3] = ac.r1.r2

   print "="
   ;Realizamos operaci?n   
  
   multiplica chr4,chr2
   separarUnidades
   mov ac1,ah   ;ac1=02     ;decenas del primera multiplicacion
   mov r4,al    ;r4=05      ;unidades del primera multiplicacion
   
   multiplica chr4,chr1
   mov r3,al    ;r3=14h     ;movemos el resultado de la operacion a r3
   mov bl,ac1   ;bl=02      ;movemos el acarreo a bl
   add r3,bl    ;r3=16h     ;sumamos resultado mas acarreo
   mov al,r3    ;al=16h     ;movemos el resultado de la suma a al
   separarUnidades
   mov r3,al    ;r3=02      ;guardamos unidades en r3
   mov ac1,ah   ;ac1=0      ;guardamos decenas en ac1
  
   multiplica chr3,chr2
   separarUnidades
   mov ac,AH      ;ac=01    ;ac = AH (Acarreo)
   mov r2,AL      ;r2=0     ;r2 = AL       (Unidad del resultado)

   multiplica chr3,chr1
   mov r1,al      ;r1=8     ;r1 = AL       (Decena del resultado)
   mov bl,ac      ;bl=01    ;BL = Acarreo anterior
   add r1,bl      ;r1=9;    ;r1 = r1+ac (r1 + Acarreo)
   separarUnidades
   mov r1,al      ;r1=09    ;r1 = AL
   mov ac,ah      ;ac=0     ;ac = AH (Acarreo para la Centena del resultado)

   mov ax,0000h   ;limpiamos ax
   
   suma r3,r2
   separarUnidades
   mov r3,al      ;r3=02        ;r3 guarda las decenas del resultado final
   mov r2,ah      ;r2=0         ;r2 se utiliza como nuevo acarreo
  
   mov ax,0000h   ;''''
   
   suma ac1,r1
   suma al,r2
   separarUnidades
   mov r1,al      ;r1=01        ;r1 guarda las centenas
   mov r2,ah      ;R2=01        ;ah se sigue utilizando como acarreo
  
   mov al,r2      ;al=01        ;movemos el acarreo a al
   mov bl,ac      ;bl=00        movemos ac a bl
   add al,bl      ;al=01        ;sumamos al a bl
   ;aam            ;separamos hex a dec
   mov ac,al      ;ac=01        mov al a ac como nuestro acarreo final
 
   ;Mostramos resultado
   imprimir ac
   imprimir r1
   imprimir r3
   imprimir r4    
   
   DEFINE_SCAN_NUM
end  

2. Instrucciones aritmeticas mul2-libreria

Multi 2: Dos cifras con librería emu8086


Código:

include 'emu8086.inc'
.model small ;Modelo de memoria m?s utilizado
.stack

.data        ;definición de datos(variables), donde se almacenara información

.code

   chr1  db ? ;primer digito
   chr2  db ? ;segundo digito
   chr3  db ? ;multiplo
   chr4  db ?
   r1    db ? ;resultado 1
   r2    db ? ;resultado 2
   r3    db ?
   r4    db ?
   ac    db 0 ;acarreo
   ac1   db 0

.startup

   ;cls
   mov ah,00h     ;Function(Set video mode)
   mov al,03      ;Mode 80x25 8x8 16
   int 10h        ;Interruption Video

   printn 'Ingresa dos numeros de dos digitos.'

   printn 'Ingresa dos valores, seguido de enter y otros dos valores(ej:45(enter) 89)'   

   call scan_num
   mov al,cl
   mov ah,00h
   aam
   mov chr1,ah
   mov chr2,al
   
   gotoxy 3,2
   putc '*'
   
   mov ax,0000h
   mov cx,0000h
   call scan_num
   mov al,cl
   mov ah,00h
   aam
   mov chr3,ah
   mov chr4,al
   
   gotoxy 7,2
   putc '='


   ;Realizamos operaci?n 


   mov al,chr4  ;unidad del segundo numero
   mov bl,chr2  ;unidad del primer numero
   mul bl       ;multiplicar
   mov ah,0     ;limpiamos ah0
   aam          ;separamos de hex a dec

   mov ac1,ah   ;decenas del primera multiplicacion
   mov r4,al    ;unidades del primera multiplicacion         
   mov al,chr4  ;unidades del segundo numero
   mov bl,chr1  ;decentas del primer numero
   mul bl       ;multiplicar
   mov r3,al    ;movemos el resultado de la operacion a r3
   mov bl,ac1   ;movemos el acarreo a bl
   add r3,bl    ;sumamos resultado mas acarreo
   mov ah,00h   ;limpiamos ah por residuos
   mov al,r3    ;movemos el resultado de la suma a al
   aam          ;separamos  de hex a dec
   mov r3,al    ;guardamos unidades en r3
   mov ac1,ah   ;guardamos decenas en ac1


   mov al,chr3    ;al = chr3
   mov bl,chr2    ;bl = chr2
   mul bl         ;AL = chr3*chr2 (BL*AL)
   mov Ah,0h      ;
   AAM            ;ASCII Adjusment
   mov ac,AH      ;ac = AH (Acarreo)
   mov r2,AL      ;r2 = AL       (Unidad del resultado)

   mov al,chr3    ;AL = chr3
   mov bl,chr1    ;BL = chr1
   mul bl         ;AL = chr1*chr3 (BL*AL)
   mov r1,al      ;r1 = AL       (Decena del resultado)
   mov bl,ac      ;BL = Acarreo anterior
   add r1,bl      ;r1 = r1+ac (r1 + Acarreo)
   mov ah,00h     ;
   mov al,r1      ;AL = r1 (Asignaci?n para el ajust)
   AAM            ;ASCII Adjustment
   mov r1,al      ;r1 = AL
   mov ac,ah      ;ac = AH (Acarreo para la Centena del resultado)

   ;suma final

   ;R4 resulta ser las unidades de mul y no se toma en cuenta ya que se pasa entero 

   mov ax,0000h   ;limpiamos ax

   mov al,r3      ;movemos el segundo resultado de la primera mult a al
   mov bl,r2      ;movemos primer resultado de la segunda mult a bl
   add al,bl      ;sumamos
   mov ah,00h     ;limpiamos ah
   aam            ;separamos hex a dec
   mov r3,al      ;r3 guarda las decenas del resultado final
   mov r2,ah      ;r2 se utiliza como nuevo acarreo 

   mov ax,0000h   ;''''
   mov al,ac1     ;movemos el acarreo de la primera mult a al
   mov bl,r1      ;movemos segundo resultado de la segunda mult a bl
   add al,r2      ;sumamos el nuevo  acarreo de la suma anterior  a al
   add al,bl      ;sumamos al a bl

   mov ah,00h     ;limpiamos el registro ah
   aam            ;separamos de hex a dec
   mov r1,al      ;r1 guarda las centenas
   mov r2,ah      ;ah se sigue utilizando como acarreo
   mov al,r2      ;movemos el acarreo a al
   mov bl,ac      ;movemos ac a bl
   add al,bl      ;sumamos al a bl
   ;aam            ;separamos hex a dec
   mov ac,al      ;mov al a ac como nuestro acarreo final

   ;Mostramos resultado
   mov ah,02h
   mov dl,ac
   add dl,30h
   int 21h        ;Mostramos ac (millar)
   mov ah,02H
   mov dl,r1
   add dl,30h

   int 21h        ;Mostramos r1 (centena)
 
   mov ah,02H
   mov dl,r3
   add dl,30h
   int 21h        ;Mostramos r3 (decena)

   mov ah,02H
   mov dl,r4
   add dl,30h
   int 21h        ;unidad 

.exit

define_scan_num
define_print_num
define_print_num_uns
define_print_string
end  

Resultado:

2. Instrucciones aritmeticas mul

Multi 2: Dos cifras

A continuación una explicación para mejor compresión del funcionamiento del programa.

Código:

.model small ;Modelo de memoria m?s utilizado
.stack

 

.data        ;definición de datos(variables), donde se almacenara información
.code
   chr1  db ? ;primer digito
   chr2  db ? ;segundo digito
   chr3  db ? ;multiplo
   chr4  db ?
   r1    db ? ;resultado 1
   r2    db ? ;resultado 2
   r3    db ?
   r4    db ?
   ac    db 0 ;acarreo
   ac1   db 0
.startup
   ;cls
   mov ah,00h     ;Function(Set video mode)
   mov al,03      ;Mode 80x25 8x8 16
   int 10h        ;Interruption Video

   mov ah,01h     ;Function(character read) Guarda en AL
   int 21h        ;Interruption DOS functions
   sub al,30h     ;ajustamos valores
   mov chr1,al    ;[chr1].chr2 * chr3 = ac.r1.r2

   mov ah,01h     ;Function(character read) Guarda en AL
   int 21h        ;Interruption DOS functions
   sub al,30h     ;Ajustamos valores
   mov chr2,al    ;chr1.[chr2] * chr3 = ac.r1.r2

   mov ah,02h     ;Function(character to send to standard output)
   mov dl,'*'     ;Character to show
   int 21h

   mov ah,01h     ;Function(Read character) Guarda en AL
   int 21h        ;Interruption DOS Functions
   sub al,30h     ;Transform(0dec = 30hex)
   mov chr3,al    ;chr1.chr2 * [chr3] = ac.r1.r2
  
   mov ah,01h     ;Function(Read character) Guarda en AL
   int 21h        ;Interruption DOS Functions
   sub al,30h     ;Transform(0dec = 30hex)
   mov chr4,al    ;chr1.chr2 * [chr3] = ac.r1.r2

   mov ah,02h     ;Character to send to standar output
   mov dl,'='     ;
   int 21h        ;Interruption DOS functions

   ;Realizamos operaci?n   
  
   mov al,chr4  ;unidad del segundo numero
   mov bl,chr2  ;unidad del primer numero
   mul bl       ;multiplicar
   mov ah,0     ;limpiamos ah0
   aam          ;separamos de hex a dec
   mov ac1,ah   ;decenas del primera multiplicacion
   mov r4,al    ;unidades del primera multiplicacion
            
   mov al,chr4  ;unidades del segundo numero
   mov bl,chr1  ;decentas del primer numero
   mul bl       ;multiplicar
   mov r3,al    ;movemos el resultado de la operacion a r3
   mov bl,ac1   ;movemos el acarreo a bl
   add r3,bl    ;sumamos resultado mas acarreo
   mov ah,00h   ;limpiamos ah por residuos
   mov al,r3    ;movemos el resultado de la suma a al
   aam          ;separamos  de hex a dec
   mov r3,al    ;guardamos unidades en r3
   mov ac1,ah   ;guardamos decenas en ac1
  
      

   mov al,chr3    ;al = chr3
   mov bl,chr2    ;bl = chr2
   mul bl         ;AL = chr3*chr2 (BL*AL)
   mov Ah,0h      ;
   AAM            ;ASCII Adjusment
   mov ac,AH      ;ac = AH (Acarreo)
   mov r2,AL      ;r2 = AL       (Unidad del resultado)

   mov al,chr3    ;AL = chr3
   mov bl,chr1    ;BL = chr1
   mul bl         ;AL = chr1*chr3 (BL*AL)
   mov r1,al      ;r1 = AL       (Decena del resultado)
   mov bl,ac      ;BL = Acarreo anterior
   add r1,bl      ;r1 = r1+ac (r1 + Acarreo)
   mov ah,00h     ;
   mov al,r1      ;AL = r1 (Asignaci?n para el ajust)
   AAM            ;ASCII Adjustment
   mov r1,al      ;r1 = AL
   mov ac,ah      ;ac = AH (Acarreo para la Centena del resultado)
  
  
   ;suma final
   ;R4 resulta ser las unidades de mul y no se toma en cuenta ya que se pasa entero
  
  
   mov ax,0000h   ;limpiamos ax
  
   mov al,r3      ;movemos el segundo resultado de la primera mult a al
   mov bl,r2      ;movemos primer resultado de la segunda mult a bl
   add al,bl      ;sumamos
   mov ah,00h     ;limpiamos ah
   aam            ;separamos hex a dec
   mov r3,al      ;r3 guarda las decenas del resultado final
   mov r2,ah      ;r2 se utiliza como nuevo acarreo
  
   mov ax,0000h   ;''''
  
   mov al,ac1     ;movemos el acarreo de la primera mult a al
   mov bl,r1      ;movemos segundo resultado de la segunda mult a bl
   add al,r2      ;sumamos el nuevo  acarreo de la suma anterior  a al
   add al,bl      ;sumamos al a bl
   mov ah,00h     ;limpiamos el registro ah
   aam            ;separamos de hex a dec
   mov r1,al      ;r1 guarda las centenas
   mov r2,ah      ;ah se sigue utilizando como acarreo
  
   mov al,r2      ;movemos el acarreo a al
   mov bl,ac      ;movemos ac a bl
   add al,bl      ;sumamos al a bl
   ;aam            ;separamos hex a dec
   mov ac,al      ;mov al a ac como nuestro acarreo final ;amm ah convierte binario a h

  
 
  
   ;Mostramos resultado
   mov ah,02h 
   mov dl,ac
   add dl,30h
   int 21h        ;Mostramos ac (millar)

   mov ah,02H
   mov dl,r1
   add dl,30h
   int 21h        ;Mostramos r1 (centena)

                 
  
   mov ah,02H
   mov dl,r3
   add dl,30h
   int 21h        ;Mostramos r3 (decena)
  
   mov ah,02H
   mov dl,r4
   add dl,30h
   int 21h        ;unidad
  
.exit
end   

Resultado:

Explicación:

2. Saltos condicionales en Ensamblador (CMP JC JZ JNZ)

Saltos condicionales en Ensamblador (CMP JC JZ JNZ)

Comparar números

Código:

include 'emu8086.inc'
.model small
.stack
.data
    num1 db 8 ;numero a comparar - cambia e intenta
    num2 db 8 ;numero a comparar - cambia e intenta 
    msg1 db 'Numeros iguales','$'
    msg2 db 'Numero 1 mayor','$'
    msg3 db 'Numero 2 mayor','$'
     
.code
    main:
    mov ax, @data
    mov ds,ax
     
    mov al,num1
    cmp al,num2
     
    jc Mayor2   ;Brinca si es mayor el numero 2
    jz igual    ;Salta si es igual
    jnz Mayor1  ;Brinca si es mayor el numero 1
     
.exit
 
igual:
    mov ah,09h
    lea dx ,msg1
    int 21h  
    ;printn 'Los numeros son iguales'
.exit 
 
Mayor1:
    mov ah,09h
    lea dx, msg2
    int 21h
    ;printn 'El numero 1 es mayor'
.exit
 
Mayor2:
    mov ah,09h
    lea dx, msg3
    int 21h
    ;print 'El numero 2 es mayor'
.exit
end

Resultado:

Referencia:
https://www.youtube.com/watch?v=Ng4YEb2Jtcg

2. Saltos Incondicionales (JMP) y Saltos Condicionales

Controlar el flujo del programa es algo muy importante, aquí es donde su programa puede tomar decisiones de acuerdo con ciertas condiciones. 

Salto incondicional (JMP):
La instrucción básica que transfiere el control a otro punto del programa. La sintaxis básica es :

JMP etiqueta

JMP et1 ;Indica a donde saltara et1
.
.
.
et1: ;realiza lo que se encuentra en ella et1
MOV AX, 1 

Programa 1: Salto incondicional

Código:

org    100h

mov    ax, 5          ; se asigna 5 en ax. 
mov    bx, 2          ; se asigna 2 en bx. 

jmp    calc            ; va a 'calc'. 

back:  jmp stop      ; va a 'stop'. 

calc:
add    ax, bx         ; suma bx y ax. 
jmp    back           ; va a la etiqueta 'back'. 

stop:

ret                   ; return to operating system. 

Resultado:

Salto condicional (CMP):

Hay instrucciones que realizan saltos condicionales (salta solo cuando alguna condiciones están en acción)


Programa 2: Salto condicional, Compara un número

Código: 

include "emu8086.inc"

org    100h

mov    al, 25     ; establece al a 25. modificar a 10 para probar el igual
mov    bl, 10     ; establece bl a 10. 

cmp    al, bl     ; compara al - bl. 
je     equal      ; salta si al = bl (zf = 1). 

putc   'n'        ; si llega aqui, entonces al <> bl,

print  'No es igual'  

jmp    stop       ;  imprime 'n', y salta a stop. 

equal:            ; si llega aqui, 
putc   'y'        ; entonces al = bl, imprime 'y'. 
print  'Es igual'   
stop:

ret               ; llega aqui no importa que. 

Resultado:

Se asigna valores a los registros, compara  "al" y "bl".

Al ser diferente imprime n "No es igual".

En caso de comparar valores iguales imprime lo siguiente:

Instrucción LOOP:

Programa 3: LOOP Imprime 5 veces 1233333233333233333233333233333, se usa push para decrementar

Código:

org 100h

mov bx, 0  ; contador de pasos total. 

mov cx, 5
k1: 
   ;add bx, 1
    mov al,' ' ;guardamos un espacio en al 
    mov ah, 0eh

    int 10h 

    mov al, '1' ; al=1
    mov ah, 0eh ;invoca el servicio de impresion video
    int 10h     ;imprimimos
    push cx     ;resta 1 a cx: cx=cx-1 para loop1
    mov cx, 5   ;cx a 5 para loop 2
      k2: 
      ;add bx, 1
      mov al, '2'  ;al=2
      mov ah, 0eh  ;impresion de video    
      int 10h      ;imprime
      push cx        ;decrementa -1 loop2
         mov cx, 5    ;cx=5 loop3
         k3: add bx, 1  ;
         mov al, '3'    ;al=3
         mov ah, 0eh    ;impresion video
         int 10h        ;imprimimos
         loop k3    ; internal in internal loop. 
      pop  cx       ;resta 1 a cx loop3
      loop  k2      ; internal loop. bucle interno
    pop cx          ;resta 1 a cx loop2
loop k1             ; external loop. bucle externo

ret   ;retornamos control al ordenador

Resultado:

Instrucciones de salto que prueban una sola bandera.

Saltar instrucciones para números firmados.

 Saltar instrucciones para números sin firmar.

Bucle

Referencia:

https://www.youtube.com/watch?v=Ng4YEb2Jtcg
http://jbwyatt.com/253/emu/asm_tutorial_07.html
https://www.youtube.com/watch?v=llCG44dzPQM

1. Uso de librería emu8086 (parte 3)

Programa 1: Demostración de códigos.

Código:

include "emu8086.inc"
org 100h
 .data 
  mensaje1 db 13,10,"print_string imprime un mensaje guardado en el registro SI",0
.code
  print "Print muestra un mensaje en pantalla"    
  lea si,mensaje1
  call print_string
  gotoxy 6,6 ;esto mueve el cursor a la posicion deseada 
  print "GOTOXY mueve el cursor a la posicion deseada"
  gotoxy 6,7
  print "scan_num solicita un valor por teclado, este se guarda en cl: "
  call scan_num  
  xor ax,ax
  mov al,cl
  gotoxy 6,8
  print "print_num imprime en pantalla el valor numerico de al: "
  call print_num 
  gotoxy 6,9
  print "Putc imprime un solo caracter: "
  putc "a"  
  
  
  define_print_num 
  define_scan_num      
  define_print_num_uns
  define_print_string  
end

*

Programa 2: Hello World

Código:

include emu8086.inc

ORG    100h

PRINT 'Hello World!'

GOTOXY 10, 5

PUTC 65           ; 65 - is an ASCII code for 'A'
PUTC 'B'

RET               ; return to operating system.
END               ; directive to stop the compiler.

Resultado:

Programa 3: Demostracion del uso print_string y get_string

Código:

; demonstrate get_string and print_string
;----------------------------------------
include 'emu8086.inc'
ORG    100h

LEA    SI, msg1       ; set up pointer (SI) to msg
                      ; to ask for the number
CALL   print_string   ; print message that SI points to

LEA    DI, buffer     ; set up pointer (DI) to input buffer
MOV    DX, bufSize    ; set size of buffer
CALL   get_string     ; get name & put in buffer

LEA    SI, newln      ; point at CR/LF / Hello message 
CALL   print_string   ; print message that SI points to

RET                   ; return to operating system.

; data
msg1   DB "Enter your name: ", 0  
newln  DB 13, 10
       DB "Hello, "
buffer DB 20 DUP (0)  ; input buffer for get_string   
bufSize = $-buffer    ; calculates size of buffer

DEFINE_GET_STRING
DEFINE_PRINT_STRING
END                   ; directive to stop the compiler.

Resultado:

Programa 4: Uso scan_num, print_num, pthis

Código:

; demonstrate scan_num, print_num, pthis
;----------------------------------------
include 'emu8086.inc'
ORG    100h

LEA    SI, msg1       ; ask for the number
CALL   print_string   ;
CALL   scan_num       ; get number in CX.

MOV    AX, CX         ; copy the number to AX.

; print the following string:
CALL   pthis
DB  13, 10, 'You have entered: ', 0

CALL   print_num      ; print number in AX.

RET                   ; return to operating system.

; data
msg1   DB  'Enter the number: ', 0

; macros to define procs
DEFINE_SCAN_NUM
DEFINE_PRINT_STRING
DEFINE_PRINT_NUM
DEFINE_PRINT_NUM_UNS  ; required for print_num.
DEFINE_PTHIS

END                   ; directive to stop the compiler.

Resultado:

Programa 5: hola mundo uso de gotoxy

Código:

name 'hola mundo'

include 'emu8086.inc'


org 100h

.code
gotoxy 5,5

printn "hola mundo"
gotoxy 5,6

printn "hola mundo 2"
gotoxy 5,7

print "dame un numero:"

call scan_num

define_scan_num

putc "A"

ret

Resultado:

Programa 6: hola mundo  gotoxy- imprime número

Código:
 

include 'emu8086.inc'

org 100h

.code    
Cursoroff      ;apaga el cursor
call scan_num  ;pide un numero

define_scan_num  ;define la funcion 
gotoxy 2,5 
putc 'A'   ;imprime un solo caracter
gotoxy 5,7    ;define en donde se ira a la pantalla
print 'dame un numero: '
call scan_num   
mov ax,cx 
gotoxy 5,8 
call print_num                   
   
define_print_num 
define_print_num_uns
end
ret

Resultado:

Referencia:
http://jbwyatt.com/253/emu/asm_tutorial_05.html

1. Uso de libreria emu8086 (parte 2)

Programa 1: Al introducir la edad, compara si es mayor o menor de edad.

Código:

;De : Ambrocio Isaias
org 100h

.model small
.stack
.data                        
include "emu8086.inc"            
num1 db 0; variable para la edad
.code
inicio proc far
    
    ;poner el primer letrero
    print " Ingrese su edad: ";macro print
    
    ;lectura del valor
    call scan_num ;llamada al proc de la libreria para pedir un valor
    mov num1,cl
    
    ;lectura segundo valor
    

    xor ax,ax ;limpiar el registro ax
    mov al,num1
    cmp al,18d ;Si lo que se encuentra en al>18 
    JGE mayor ;salta a mayor
    JMP menor ;sino ve a menor  
    
    mayor:
        printn " "
        print "Eres mayor de edad"
        jmp final
    menor:
        printn " "
        print "Eres menor de edad"
               
        jmp final
           
           
    final:  
         print " "
         printn " "
         print "Presiona enter para salir..."
         mov ah,0 ;servicios de lectura de una pulsación de teclado
         int 16h  ;Invoca a servicios de teclado
         mov ah,4ch
         int 21h
         ret
define_print_string
define_print_num
define_print_num_uns ;para recibir numeros decimales
define_scan_num  ;del procedimiento scan_num
endp inicio

end

Resultado:

Programa 2: Nos permitirá mostrar si hemos aprobado o reprobado alguna asignatura en base a una calificación.

Código:

;De : Ambrocio Isaias
.MODEL SMALL
.STACK 64
.DATA  
    include "emu8086.inc"
    
    nota db 0

    
.CODE   
OPERACIONES PROC FAR ;DECLARACION DE PROCEDIMIENTO    
 
    ;MUESTRO EL MENSAJE         
    print " " ;usa macro print para un espacio
    print "Ingrese la calificacion: " ;macro imprime
    
    call scan_num    ;Leo el numero
    mov nota,cl      ;lo guardo en nota
    
    xor ax,ax        ;borro el contenido de ax
    mov al,nota      ;muevo nota a al
    
    CMP AL,70d       ;comparo al con 70
    JGE MAYOR        ;si es mayor o igual pasa a mayor
    JMP MENOR        ;si no a menor
        
   MAYOR:
    printn " "    
    print "Aprobado"
    JMP SALIR 
        
   MENOR:   
    printn " "    
    print "Reprobado"
    JMP SALIR
    
   SALIR:
         print " "
         printn " "
         gotoxy 10,10  ;coloco el cursor en las coordenadas 10x,10y
         print "Presiona enter para salir..." ;imprimo despues este mensaje
         mov ah,0  ;servicio de lectura de pulsacion de tecla
         int 16h   ;invoca servicios de teclado
         mov ah,4ch
         int 21h
         ret
       
OPERACIONES ENDP   

define_print_string
define_print_num
define_print_num_uns
define_scan_num    
    
END   

Resultado:

Programa 3: Suma de dos números, uso de la libreria emu8086.inc.

Código:

;De: Isaias Ambrocio
org 100h

name "suma de dos numeros"
include "emu8086.inc"
org 100h

.data
suma db 2 dup (?) ;manera de declarar un arreglo de 2 lugares 
.code
sumas proc     
    
    print " Introduce el primer numero: " ;macro de la lib
    call scan_num ;llamada a un procedimiento para pedir un num
    mov suma[0],cl ;mueve el valor de cl a la posicion 0 del array   
    printn " " ;macro que imprime un espacio 
    print " Introduce el segundo numero: " ;macro que imprime un letrero
    
    call scan_num ;llamada a un procedimiento para pedir num
    mov suma[1],cl ;;mueve el valor de cl a la posicion 1 del array   
    xor ax,ax ;xor nemonico que limpia registros
    
    add al,suma[0] ;valor de suma pos 0 []
    add al,suma[1] ;valor de suma pos 1
    
    printn " " ;macro de la libreria pone un espacio y retorno 
    print " La suma es: " ;macro que imprime un letrero 
   
    call print_num ;llamada a un procedimiento para imprimir un num del reg ax
sumas endp
exit:
    print " "
    printn " "
    print "Presiona enter para salir..."
    mov ah,0  ;servicio de pulsación de teclado
    int 16h   ;invoca a servicios de taclado
    ret
define_print_string ;no se uso
define_print_num ;es del print_num
define_print_num_uns ;conversion a decimal del scan_num
define_scan_num ;procedimiento del scan_num(macro)
end

ret

Resultado:

1 .Registro de Banderas ensamblador 8086

Registro de banderas:

Es un registro de 16 bits, de los cuales nueve sirven para indicar el estado actual de la maquina y el resultado del procedimiento.

Cada bandera es un bit y se usa para registrar la información de estado y de control de las operaciones del microprocesador. Hay nueve banderas (los 7 bits restantes no se utilizan):

Banderas de estado:

Registran el estado del procesador, normalmente asociado a una comparación o a una instrucción aritmética.

• CF (Carry Flag): Bandera de acarreo.
• OF (Overflow Flag): Bandera de desbordamiento (aritmético).
• ZF (Zero Flag): Bandera de resultado 0 o comparación igual.
• SF (Sign Flag): Bandera de resultado o comparación negativa.
• PF (Parity Flag): Bandera de paridad (número par de bits).
• AF (Auxiliary Flag): Bandera auxiliar. Indica si hay necesidad de ajuste en las operaciones aritméticas con números BCD.

Banderas de control:

• DF  (Direction Flag): Bandera de dirección. Controla la dirección de las operaciones con cadenas de caracteres (sentido de avance ascendente/descendente). Incrementando o decrementando automáticamente los registros índices (SI y DI)
• IF (Interrupt Flag): Bandera de interrupciones. Indica si están permitidas o no las interrupciones de los dispositivos
• externos.
• TF (Trap Flag): Bandera de atrape. Controla la operación de modo paso a paso (usada por el programa DEBUG).

► vídeo
[008] Registro de Banderas | Banderas en Ensamblador 8086

Programa 1:

Código:

cf:bandera de acarreo

programa:
.model small
.stack
.data

.code
    mov al, 2 ;1
    mov bl, 2 ;4
    sub al, bl
    
.exit
end    

La bandera ZF sirve para indicar que el valor del resultado es cero:

Programa 2:

Código:

org 100h

.model small
.stack
.data

.code
     mov al,255
     mov bl,1
     add al,bl
     
.exit
end

Para activar la bandera CF haremos una suma, una suma entre 2 números, en este caso 255 + 1, de manera que supere el límite del registro inferior.

Programa 3:

Código:

org 100h

org 100h

.model small
.stack
.data

.code
     
     mov al,1
     mov bl,4
     sub al,bl

.exit
end

ret

En el caso de SF esta se encenderá al obtener un resultado negativo en los registros:

Programa 4:

.model small
.stack
.data
.code
    mov al,100
    mov bl,50
    add al,bl

.exit
end          
     

La bandera OF se llevara a cabo cada vez que se lleve a cabo un acarreo de unidad aritmético, ejemplo, si sumamos 100 + 50, tendremos un acarreo de 5 decenas en la parte de la suma para generar el numero 150.
   

1. Resta de dos números.

Programa 1: Uso de la libreria emu8086, para realizar una resta.

Código:

name "Resta de dos numeros"
include "emu8086.inc"
org 100h

.data
resta db 2 dup (?)
.code
sumas proc
    print " Introduce el primer numero: "
    call scan_num
    mov resta[0],cl 
    printn " " 
    print " Introduce el segundo numero: "
    call scan_num
    mov resta[1],cl
    xor ax,ax
    mov al,resta[0]
    sub al,resta[1]
    printn " "
    print " La resta es: "
    call print_num
sumas endp
exit:
    print " "
    printn " "
    print "Presiona enter para salir..."
    mov ah,0  ;servicio de pulsación de teclado
    int 16h   ;invoca a servicios de taclado
    ret
define_print_string
define_print_num
define_print_num_uns
define_scan_num
end

Proceso:

Resultado:

1. Programa que realiza: suma, resta, división y multiplicación

Programa: Suma, resta, división y multiplicación

Código:

;por: alex gutierrez 

; suma, resta, multiplicacion y division sin tomar en cuenta el acarreo
; el 13,10 es un salto de linea

.model small
.stack 100
.data
msj1 db 'Numero 1: ','$'
msj2 db 13,10,'Numero 2: ','$'
msj3 db 13,10,'Suma: ','$'
msj4 db 13,10,'Resta: ','$'
msj5 db 13,10,'Multiplicacion: ','$'
msj6 db 13,10,'Division: ','$'
linea db 13,10,'$'
var1 db 0
var2 db 0
.code
.startup

call limpia
mov ah,09h
lea dx, msj1 ;desplegar numero 1:
int 21h

call leer ;lee primer numero
sub al,30h ;restar 30h para obtener el numero
mov var1,al ;lo guardo en var1
mov ah,09h
lea dx, msj2 ;desplegar numero 2:
int 21h

call leer ;lee segundo numero
sub al,30h ;restar 30h para obtener segundo valor
mov var2,al ;guardar en var2
mov bl,var2 ;mover a bl

;******************* SUMA
add bl,var1 ; realizo la suma de var2(bl) y var1 y el resultado queda en bl
mov ah,09h
lea dx,msj3 ;imprimir suma
int 21h
mov dl,bl ;pongo en dl el numero a imprimir var2(bl)
add dl,30h ; agrego 30h para obtener el caracter    
mov ah,02h ;imprime un caracter
int 21h

;******************RESTA
mov bl,var1
sub bl,var2
mov ah,09h
lea dx,msj4 ;desplegar resta:
int 21h
mov dl,bl ;mover resta a dl para imprimir
add dl,30h ;sumar 30 para obtener caracter
mov ah,02h ;imprimir un caracter
int 21h

;******************MULTIPLICACION
mov ah,09h
lea dx,msj5 ;desplegar mult
int 21h

mov al,var1 
mov bl,var2
mul bl ;mult al=al*bl
mov dl,al ;mover al a dl para imprimir
add dl,30h ;sumar 30 para obtener caracter
mov ah,02h ;imprimir caracter
int 21h

;*****************DIVISION
mov ah,09h
lea dx,msj6 ;desplegar div
int 21h
xor ax,ax ;limpiamos el registro ax. 
mov al,var2
mov bl,al
mov al,var1
div bl ; divide AX/BX el resultado lo almacena en AX, el residuo queda en DX
mov bl,al
mov dl,bl
add dl,30h
mov ah,02h
int 21h
.exit

; ****************PROCEDIMIENTOS
salto proc near
mov ah,09h
lea dx,linea
int 21h
mov dl,00h
ret
salto endp

leer proc near
mov ah,01h;leer caracter desde el teclado
int 21h;lee primer caracter
ret
leer endp

limpia proc near
mov ah,00h
mov al,03h
int 10h
ret
limpia endp
end

1. Uso de libreria emu8086 (parte 1)

Programas con Uso de librerías en Ensamblador 

Para facilitar la programación, hay algunas funciones comunes que pueden incluirse en su programa. Para hacer que su programa utilice funciones definidas en otro archivo, debe usar la directiva INCLUDE seguida de un nombre de archivo. El compilador busca automáticamente el archivo en la misma carpeta donde se encuentra el archivo de origen, y si no puede encontrar el archivo allí, busca en la carpeta Inc. 

Para usar cualquiera de las funciones en emu8086.inc, debe tener la siguiente línea al comienzo de su archivo fuente: 

 include 'emu8086.inc' 

Referencias externas al módulo: 

Son imprescindibles si se hace un programa en alto nivel con procedimientos en assembler. Hay tres: PUBLIC, EXTRN e INCLUDE. 

PUBLIC nombre[, nombre...]: Estos nombres simbólicos se escriben en el archivo objeto. Durante una sesión con el linker, los símbolos en diferentes módulos pero con los mismos nombres tendrán la misma dirección. 

EXTRN nombre:tipo [,nombre:tipo...]: Define una variable externa con el nombre y tipo (NEAR, FAR, BYTE, WORD, DWORD o ABS (número constante especificado con la directiva EQU o =)) especificado. El tipo debe ser el mismo que el del ítem indicado con la directiva PUBLIC en otro módulo. 
INCLUDE nombre_de_archivo: Ensambla las sentencias indicadas en dicho archivo. 

emu8086.inc define las siguientes macros : 

PRINT string - macro con 1 parámetro, imprime una cadena. 
PRINTN string - macro con 1 parámetro, imprime una cadena. Lo mismo que PRINT pero agrega automáticamente "retorno de carro" al final de la cadena. 
PUTC char - macro con 1 parámetro, imprime un carácter ASCII en la posición actual del cursor. 
GOTOXY col, fila - macro con 2 parámetros, establece la posición del cursor. 
CURSOROFF - apaga el cursor de texto. 
CURSORON - enciende el cursor de texto.

Ensamblador: Suma de dos números

Este código fue tomado del siguiente vídeo:

Código:

;include para añadir librerias http://jbwyatt.com/253/emu/asm_tutorial_05.html

;gmo
name 'Suma de dos numeros'
include 'emu8086.inc' ;nombre del programa 
org 100h              ;agregamos libreria emu8086.inc

.data     ;se abre el bloque de datos
suma db 2 dup (?) ;arreglo suma de 2 espacios(byte)

.code    ;directiva indica la continuacion del prog
Sumas proc     ;proceso Sumas
    printn " "
    print "Introduce el primer numero ==>"
    call scan_num  ;recibe los valores
    mov suma[0], cl;recibe de scan_num cl y se mandan a las posiciones del arreglo
    printn " "
    print "Introduce el segundo numero ==>"
    call scan_num
    mov suma[1], cl
    printn " "
    xor ax, ax  ;limpia el registro ax
    add al, suma[0]   ;manda la suma al registro al para poder imprimir con print_num
    add al, suma[1]
    printn " "
    print "La suma es: "
    call print_num
Sumas endp

exit:       ;etiqueta salir
    print ""
    printn ""
    print "Presiona enter para salir...  "
    mov ah, 0  ;termina el programa
    int 16h
    ret
    
define_print_string ;comando definido emu8086.inc  
define_print_num
define_print_num_uns
define_scan_num     
end

Resultado:

La suma de los valores 12 y 7 decimal da 19. Como se puede ver se guarda en el registro "ax" como 13 equivalente en hexadecimal.

Referencia:

https://www.youtube.com/watch?v=EftgPsQXTXs

https://www.alpertron.com.ar/INST8088.HTM

http://jbwyatt.com/253/emu/asm_tutorial_05.html