1621 lines
33 KiB
NASM
1621 lines
33 KiB
NASM
; Tests for opcode range 0xD0-0xDF
|
|
; ---------------------------------
|
|
|
|
; 0xD0 - 8-Bit Shifts and Rotate Opcodes
|
|
; ############################################################
|
|
|
|
TEST_D0_0:
|
|
|
|
; ROL
|
|
; Test against Register
|
|
|
|
mov ax,0817F
|
|
rol al,1
|
|
cmp ax,081FE
|
|
jne FAIL_D0_0 ; Only lower byte should be rotated
|
|
|
|
mov bx,0817F
|
|
rol bl,1
|
|
jc FAIL_D0_0 ; Carry should not be set
|
|
|
|
mov cx,08180
|
|
rol cl,1
|
|
cmp cx,08101
|
|
jne FAIL_D0_0 ; Only lower byte should be rotated
|
|
|
|
mov dx,08180
|
|
rol dl,1
|
|
jnc FAIL_D0_0 ; Carry should be set
|
|
|
|
mov dx,08180
|
|
rol dl,1
|
|
jno FAIL_D0_0 ; Overflow should be set
|
|
|
|
mov dx,081FF
|
|
rol dl,1
|
|
jo FAIL_D0_0 ; Overflow should NOT be set
|
|
|
|
|
|
; ROL
|
|
; Test against Memory
|
|
|
|
mov word[00050],0817F
|
|
rol byte[00050],1
|
|
cmp word[00050],081FE
|
|
jne FAIL_D0_0 ; Only lower byte should be rotated
|
|
|
|
mov word[00050],0817F
|
|
rol byte[00050],1
|
|
jc FAIL_D0_0 ; Carry should not be set
|
|
|
|
mov word[00050],08180
|
|
rol byte[00050],1
|
|
cmp word[00050],08101
|
|
jne FAIL_D0_0 ; Only lower byte should be rotated
|
|
|
|
mov word[00050],08180
|
|
rol byte[00050],1
|
|
jnc FAIL_D0_0 ; Carry should be set
|
|
|
|
mov word[00050],08180
|
|
rol byte[00050],1
|
|
jno FAIL_D0_0 ; Overflow should be set
|
|
|
|
mov word[00050],081FF
|
|
rol byte[00050],1
|
|
jo FAIL_D0_0 ; Overflow should NOT be set
|
|
|
|
|
|
jmp TEST_D0_1
|
|
|
|
|
|
FAIL_D0_0:
|
|
mov dx,00030 ; Print a 0
|
|
mov ax,00202
|
|
int 021
|
|
|
|
|
|
TEST_D0_1:
|
|
; ROR
|
|
; Test against Register
|
|
|
|
mov ax,081FE
|
|
ror al,1
|
|
cmp ax,0817F
|
|
jne FAIL_D0_1 ; Only lower byte should be rotated
|
|
|
|
mov bx,081FE
|
|
ror bl,1
|
|
jc FAIL_D0_1 ; Carry should not be set
|
|
|
|
mov cx,0813F
|
|
ror cl,1
|
|
cmp cx,0819F
|
|
jne FAIL_D0_1 ; Only lower byte should be rotated
|
|
|
|
mov dx,0812F
|
|
ror dl,1
|
|
jnc FAIL_D0_1 ; Carry should be set
|
|
|
|
mov dx,08180
|
|
ror dl,1
|
|
jno FAIL_D0_1 ; Overflow should be set
|
|
|
|
mov dx,081FF
|
|
ror dl,1
|
|
jo FAIL_D0_1 ; Overflow should NOT be set
|
|
|
|
; ROR
|
|
; Test against Memory
|
|
|
|
mov word[00050],081FE
|
|
ror byte[00050],1
|
|
cmp word[00050],0817F
|
|
jne FAIL_D0_1 ; Only lower byte should be rotated
|
|
|
|
mov word[00050],0813E
|
|
ror byte[00050],1
|
|
jc FAIL_D0_1 ; Carry should not be set
|
|
|
|
mov word[00050],0813F
|
|
ror byte[00050],1
|
|
cmp word[00050],0819F
|
|
jne FAIL_D0_1 ; Only lower byte should be rotated
|
|
|
|
mov word[00050],0812F
|
|
ror byte[00050],1
|
|
jnc FAIL_D0_1 ; Carry should be set
|
|
|
|
|
|
mov word[00050],08180
|
|
ror byte[00050],1
|
|
jno FAIL_D0_1 ; Overflow should be set
|
|
|
|
mov word[00050],081FF
|
|
ror byte[00050],1
|
|
jo FAIL_D0_1 ; Overflow should NOT be set
|
|
|
|
jmp TEST_D0_2
|
|
|
|
FAIL_D0_1:
|
|
mov dx,00030 ; Print a 0
|
|
mov ax,00202
|
|
int 021
|
|
|
|
|
|
|
|
TEST_D0_2:
|
|
|
|
; RCL
|
|
; Test against Register
|
|
|
|
clc
|
|
mov ax,0817F
|
|
rcl al,1
|
|
cmp ax,081FE
|
|
jne FAIL_D0_2 ; Only lower byte should be rotated
|
|
|
|
clc
|
|
mov cx,08180
|
|
rcl cl,1
|
|
cmp cx,08100
|
|
jne FAIL_D0_2 ; Only lower byte should be rotated
|
|
|
|
stc
|
|
mov ax,0817F
|
|
rcl al,1
|
|
cmp ax,081FF
|
|
jne FAIL_D0_2 ; Only lower byte should be rotated
|
|
|
|
stc
|
|
mov cx,08180
|
|
rcl cl,1
|
|
cmp cx,08101
|
|
jne FAIL_D0_2 ; Only lower byte should be rotated
|
|
|
|
clc
|
|
mov bx,0817F
|
|
rcl bl,1
|
|
jc FAIL_D0_2 ; Carry should not be set
|
|
|
|
clc
|
|
mov dx,08180
|
|
rcl dl,1
|
|
jnc FAIL_D0_2 ; Carry should be set
|
|
|
|
mov dx,08180
|
|
rcl dl,1
|
|
jno FAIL_D0_2 ; Overflow should be set
|
|
|
|
mov dx,081FF
|
|
rcl dl,1
|
|
jo FAIL_D0_2 ; Overflow should NOT be set
|
|
jmp TEST_D0_22
|
|
|
|
|
|
FAIL_D0_2:
|
|
mov dx,00039 ; Print a 0
|
|
mov ax,00202
|
|
int 021
|
|
|
|
|
|
TEST_D0_22:
|
|
; RCL
|
|
; Test against Memory
|
|
|
|
clc
|
|
mov word[00050],0817F
|
|
rcl byte[00050],1
|
|
cmp word[00050],081FE
|
|
jne FAIL_D0_22 ; Only lower byte should be rotated
|
|
|
|
clc
|
|
mov word[00050],08180
|
|
rcl byte[00050],1
|
|
cmp word[00050],08100
|
|
jne FAIL_D0_22 ; Only lower byte should be rotated
|
|
|
|
stc
|
|
mov word[00050],0817F
|
|
rcl byte[00050],1
|
|
cmp word[00050],081FF
|
|
jne FAIL_D0_22 ; Only lower byte should be rotated
|
|
|
|
stc
|
|
mov word[00050],08180
|
|
rcl byte[00050],1
|
|
cmp word[00050],08101
|
|
jne FAIL_D0_22 ; Only lower byte should be rotated
|
|
|
|
mov word[00050],0817F
|
|
rcl byte[00050],1
|
|
jc FAIL_D0_22 ; Carry should not be set
|
|
|
|
mov word[00050],08180
|
|
rcl byte[00050],1
|
|
jnc FAIL_D0_22 ; Carry should be set
|
|
|
|
mov word[00050],08180
|
|
rcl byte[00050],1
|
|
jno FAIL_D0_22 ; Overflow should be set
|
|
|
|
mov word[00050],081FF
|
|
rcl byte[00050],1
|
|
jo FAIL_D0_22 ; Overflow should NOT be set
|
|
jmp TEST_D0_3
|
|
|
|
|
|
FAIL_D0_22:
|
|
mov dx,00030 ; Print a 0
|
|
mov ax,00202
|
|
int 021
|
|
|
|
|
|
|
|
TEST_D0_3:
|
|
|
|
; RCR
|
|
; Test against Register
|
|
|
|
clc
|
|
mov ax,0817F
|
|
rcr al,1
|
|
cmp ax,0813F
|
|
jne FAIL_D0_3 ; Only lower byte should be rotated
|
|
|
|
clc
|
|
mov cx,08180
|
|
rcr cl,1
|
|
cmp cx,08140
|
|
jne FAIL_D0_3 ; Only lower byte should be rotated
|
|
|
|
stc
|
|
mov ax,08100
|
|
rcr al,1
|
|
cmp ax,08180
|
|
jne FAIL_D0_3 ; Only lower byte should be rotated
|
|
|
|
stc
|
|
mov cx,08108
|
|
rcr cl,1
|
|
cmp cx,08184
|
|
jne FAIL_D0_3 ; Only lower byte should be rotated
|
|
|
|
clc
|
|
mov bx,08110
|
|
rcr bl,1
|
|
jc FAIL_D0_3 ; Carry should not be set
|
|
|
|
clc
|
|
mov dx,08181
|
|
rcr dl,1
|
|
jnc FAIL_D0_3 ; Carry should be set
|
|
|
|
stc
|
|
mov dx,08100
|
|
rcr dl,1
|
|
jno FAIL_D0_3 ; Overflow should be set
|
|
|
|
clc
|
|
mov dx,08100
|
|
rcr dl,1
|
|
jo FAIL_D0_3 ; Overflow should NOT be set
|
|
jmp TEST_D0_32
|
|
|
|
|
|
FAIL_D0_3:
|
|
mov dx,00030 ; Print a 0
|
|
mov ax,00202
|
|
int 021
|
|
|
|
|
|
TEST_D0_32:
|
|
; RCR
|
|
; Test against Memory
|
|
|
|
clc
|
|
mov word[00050],0817F
|
|
rcr byte[00050],1
|
|
cmp word[00050],0813F
|
|
jne FAIL_D0_32 ; Only lower byte should be rotated
|
|
|
|
clc
|
|
mov word[00050],08180
|
|
rcr byte[00050],1
|
|
cmp word[00050],08140
|
|
jne FAIL_D0_32 ; Only lower byte should be rotated
|
|
|
|
stc
|
|
mov word[00050],08100
|
|
rcr byte[00050],1
|
|
cmp word[00050],08180
|
|
jne FAIL_D0_32 ; Only lower byte should be rotated
|
|
|
|
stc
|
|
mov word[00050],08108
|
|
rcr byte[00050],1
|
|
cmp word[00050],08184
|
|
jne FAIL_D0_32 ; Only lower byte should be rotated
|
|
|
|
mov word[00050],08110
|
|
rcr byte[00050],1
|
|
jc FAIL_D0_32 ; Carry should not be set
|
|
|
|
mov word[00050],08181
|
|
rcr byte[00050],1
|
|
jnc FAIL_D0_32 ; Carry should be set
|
|
|
|
stc
|
|
mov word[00050],08100
|
|
rcr byte[00050],1
|
|
jno FAIL_D0_32 ; Overflow should be set
|
|
|
|
clc
|
|
mov word[00050],08100
|
|
rcr byte[00050],1
|
|
jo FAIL_D0_32 ; Overflow should NOT be set
|
|
jmp TEST_D0_4
|
|
|
|
|
|
FAIL_D0_32:
|
|
mov dx,00030 ; Print a 0
|
|
mov ax,00202
|
|
int 021
|
|
|
|
|
|
TEST_D0_4:
|
|
|
|
; SAL
|
|
; Test against Register
|
|
|
|
mov ax,08122
|
|
sal al,1
|
|
cmp ax,08144
|
|
jne FAIL_D0_4 ; Only lower byte should be rotated
|
|
|
|
mov bx,08122
|
|
sal bl,1
|
|
jc FAIL_D0_4 ; Carry should not be set
|
|
|
|
mov cx,08188
|
|
sal cl,1
|
|
cmp cx,08110
|
|
jne FAIL_D0_4 ; Only lower byte should be rotated
|
|
|
|
mov dx,08180
|
|
sal dl,1
|
|
jnc FAIL_D0_4 ; Carry should be set
|
|
|
|
mov dx,08180
|
|
sal dl,1
|
|
jno FAIL_D0_4 ; Overflow should be set
|
|
|
|
mov dx,081FF
|
|
sal dl,1
|
|
jo FAIL_D0_4 ; Overflow should NOT be set
|
|
|
|
|
|
; SAL
|
|
; Test against Memory
|
|
|
|
mov word[00050],08122
|
|
sal byte[00050],1
|
|
cmp word[00050],08144
|
|
jne FAIL_D0_4 ; Only lower byte should be rotated
|
|
|
|
mov word[00050],08122
|
|
sal byte[00050],1
|
|
jc FAIL_D0_4 ; Carry should not be set
|
|
|
|
mov word[00050],08188
|
|
sal byte[00050],1
|
|
cmp word[00050],08110
|
|
jne FAIL_D0_4 ; Only lower byte should be rotated
|
|
|
|
mov word[00050],08180
|
|
sal byte[00050],1
|
|
jnc FAIL_D0_4 ; Carry should be set
|
|
|
|
mov word[00050],08180
|
|
sal byte[00050],1
|
|
jno FAIL_D0_4 ; Overflow should be set
|
|
|
|
mov word[00050],081FF
|
|
sal byte[00050],1
|
|
jo FAIL_D0_4 ; Overflow should NOT be set
|
|
|
|
|
|
jmp TEST_D0_5
|
|
|
|
|
|
FAIL_D0_4:
|
|
mov dx,00030 ; Print a 0
|
|
mov ax,00202
|
|
int 021
|
|
|
|
|
|
TEST_D0_5:
|
|
; SAR
|
|
; Test against Register
|
|
|
|
mov ax,08180
|
|
sar al,1
|
|
cmp ax,081C0
|
|
jne FAIL_D0_5 ; Only lower byte should be rotated
|
|
|
|
mov bx,081FE
|
|
sar bl,1
|
|
jc FAIL_D0_5 ; Carry should not be set
|
|
|
|
mov cx,0817F
|
|
sar cl,1
|
|
cmp cx,0813F
|
|
jne FAIL_D0_5 ; Only lower byte should be rotated
|
|
|
|
mov dx,0812F
|
|
sar dl,1
|
|
jnc FAIL_D0_5 ; Carry should be set
|
|
|
|
mov dx,081FF
|
|
sar dl,1
|
|
jo FAIL_D0_5 ; Overflow should NOT be set
|
|
|
|
; SAR
|
|
; Test against Memory
|
|
|
|
mov word[00050],08180
|
|
sar byte[00050],1
|
|
cmp word[00050],081C0
|
|
jne FAIL_D0_5 ; Only lower byte should be rotated
|
|
|
|
mov word[00050],081FE
|
|
sar byte[00050],1
|
|
jc FAIL_D0_5 ; Carry should not be set
|
|
|
|
mov word[00050],0817F
|
|
sar byte[00050],1
|
|
cmp word[00050],0813F
|
|
jne FAIL_D0_5 ; Only lower byte should be rotated
|
|
|
|
mov word[00050],0812F
|
|
sar byte[00050],1
|
|
jnc FAIL_D0_5 ; Carry should be set
|
|
|
|
mov word[00050],081FF
|
|
sar byte[00050],1
|
|
jo FAIL_D0_5 ; Overflow should NOT be set
|
|
|
|
jmp TEST_D0_6
|
|
|
|
FAIL_D0_5:
|
|
mov dx,00030 ; Print a 0
|
|
mov ax,00202
|
|
int 021
|
|
|
|
|
|
|
|
TEST_D0_6:
|
|
; SHR
|
|
; Test against Register
|
|
|
|
mov ax,08180
|
|
shr al,1
|
|
cmp ax,08140
|
|
jne FAIL_D0_6 ; Only lower byte should be rotated
|
|
|
|
mov bx,081FE
|
|
shr bl,1
|
|
jc FAIL_D0_6 ; Carry should not be set
|
|
|
|
mov cx,0817F
|
|
shr cl,1
|
|
cmp cx,0813F
|
|
jne FAIL_D0_6 ; Only lower byte should be rotated
|
|
|
|
mov dx,0812F
|
|
shr dl,1
|
|
jnc FAIL_D0_6 ; Carry should be set
|
|
|
|
mov dx,081FF
|
|
shr dl,1
|
|
jno FAIL_D0_6 ; Overflow should be set
|
|
|
|
mov dx,0812F
|
|
shr dl,1
|
|
jo FAIL_D0_6 ; Overflow should NOT be set
|
|
|
|
|
|
; SHR
|
|
; Test against Memory
|
|
|
|
mov word[00050],08180
|
|
shr byte[00050],1
|
|
cmp word[00050],08140
|
|
jne FAIL_D0_6 ; Only lower byte should be rotated
|
|
|
|
mov word[00050],081FE
|
|
shr byte[00050],1
|
|
jc FAIL_D0_6 ; Carry should not be set
|
|
|
|
mov word[00050],0817F
|
|
shr byte[00050],1
|
|
cmp word[00050],0813F
|
|
jne FAIL_D0_6 ; Only lower byte should be rotated
|
|
|
|
mov word[00050],0812F
|
|
shr byte[00050],1
|
|
jnc FAIL_D0_6 ; Carry should be set
|
|
|
|
mov word[00050],081FF
|
|
shr byte[00050],1
|
|
jno FAIL_D0_6 ; Overflow should be set
|
|
|
|
mov word[00050],0812F
|
|
shr byte[00050],1
|
|
jo FAIL_D0_6 ; Overflow should NOT be set
|
|
|
|
jmp TEST_D1_0
|
|
|
|
FAIL_D0_6:
|
|
mov dx,00030 ; Print a 0
|
|
mov ax,00202
|
|
int 021
|
|
|
|
|
|
|
|
; 0xD1 - 16-Bit Shifts and Rotate Opcodes
|
|
; ############################################################
|
|
|
|
TEST_D1_0:
|
|
|
|
; ROL
|
|
; Test against Register
|
|
|
|
mov ax,08000
|
|
rol ax,1
|
|
cmp ax,00001
|
|
jne FAIL_D1_0
|
|
|
|
mov bx,00022
|
|
rol bx,1
|
|
jc FAIL_D1_0 ; Carry should not be set
|
|
|
|
mov cx,01111
|
|
rol cx,1
|
|
cmp cx,02222
|
|
jne FAIL_D1_0
|
|
|
|
mov dx,08180
|
|
rol dx,1
|
|
jnc FAIL_D1_0 ; Carry should be set
|
|
|
|
mov dx,08180
|
|
rol dx,1
|
|
jno FAIL_D1_0 ; Overflow should be set
|
|
|
|
mov dx,01234
|
|
rol dx,1
|
|
jo FAIL_D1_0 ; Overflow should NOT be set
|
|
|
|
|
|
; ROL
|
|
; Test against Memory
|
|
|
|
mov word[00050],08000
|
|
rol word[00050],1
|
|
cmp word[00050],00001
|
|
jne FAIL_D1_0
|
|
|
|
mov word[00050],00022
|
|
rol word[00050],1
|
|
jc FAIL_D1_0 ; Carry should not be set
|
|
|
|
mov word[00050],01111
|
|
rol word[00050],1
|
|
cmp word[00050],02222
|
|
jne FAIL_D1_0
|
|
|
|
mov word[00050],08180
|
|
rol word[00050],1
|
|
jnc FAIL_D1_0 ; Carry should be set
|
|
|
|
mov word[00050],08180
|
|
rol word[00050],1
|
|
jno FAIL_D1_0 ; Overflow should be set
|
|
|
|
mov word[00050],01234
|
|
rol word[00050],1
|
|
jo FAIL_D1_0 ; Overflow should NOT be set
|
|
|
|
|
|
jmp TEST_D1_1
|
|
|
|
|
|
FAIL_D1_0:
|
|
mov dx,00031 ; Print a 0
|
|
mov ax,00202
|
|
int 021
|
|
|
|
|
|
TEST_D1_1:
|
|
; ROR
|
|
; Test against Register
|
|
|
|
mov ax,00001
|
|
ror ax,1
|
|
cmp ax,08000
|
|
jne FAIL_D1_1
|
|
|
|
mov bx,02222
|
|
ror bx,1
|
|
jc FAIL_D1_1 ; Carry should not be set
|
|
|
|
mov cx,04444
|
|
ror cx,1
|
|
cmp cx,02222
|
|
jne FAIL_D1_1
|
|
|
|
mov dx,01111
|
|
ror dx,1
|
|
jnc FAIL_D1_1 ; Carry should be set
|
|
|
|
mov dx,08180
|
|
ror dx,1
|
|
jno FAIL_D1_1 ; Overflow should be set
|
|
|
|
mov dx,02222
|
|
ror dx,1
|
|
jo FAIL_D1_1 ; Overflow should NOT be set
|
|
|
|
; ROR
|
|
; Test against Memory
|
|
|
|
mov word[00050],00001
|
|
ror word[00050],1
|
|
cmp word[00050],08000
|
|
jne FAIL_D1_1
|
|
|
|
mov word[00050],02222
|
|
ror word[00050],1
|
|
jc FAIL_D1_1 ; Carry should not be set
|
|
|
|
mov word[00050],04444
|
|
ror word[00050],1
|
|
cmp word[00050],02222
|
|
jne FAIL_D1_1
|
|
|
|
mov word[00050],01111
|
|
ror word[00050],1
|
|
jnc FAIL_D1_1 ; Carry should be set
|
|
|
|
|
|
mov word[00050],08180
|
|
ror word[00050],1
|
|
jno FAIL_D1_1 ; Overflow should be set
|
|
|
|
mov word[00050],02222
|
|
ror word[00050],1
|
|
jo FAIL_D1_1 ; Overflow should NOT be set
|
|
|
|
jmp TEST_D1_2
|
|
|
|
FAIL_D1_1:
|
|
mov dx,00031 ; Print a 0
|
|
mov ax,00202
|
|
int 021
|
|
|
|
|
|
|
|
TEST_D1_2:
|
|
|
|
; RCL
|
|
; Test against Register
|
|
|
|
clc
|
|
mov ax,0817F
|
|
rcl ax,1
|
|
cmp ax,002FE
|
|
jne FAIL_D1_2
|
|
|
|
clc
|
|
mov cx,01111
|
|
rcl cx,1
|
|
cmp cx,02222
|
|
jne FAIL_D1_2
|
|
|
|
stc
|
|
mov ax,0817F
|
|
rcl ax,1
|
|
cmp ax,002FF
|
|
jne FAIL_D1_2
|
|
|
|
stc
|
|
mov cx,01111
|
|
rcl cx,1
|
|
cmp cx,02223
|
|
jne FAIL_D1_2
|
|
|
|
clc
|
|
mov bx,07777
|
|
rcl bx,1
|
|
jc FAIL_D1_2 ; Carry should not be set
|
|
|
|
clc
|
|
mov dx,08888
|
|
rcl dx,1
|
|
jnc FAIL_D1_2 ; Carry should be set
|
|
|
|
mov dx,08000
|
|
rcl dx,1
|
|
jno FAIL_D1_2 ; Overflow should be set
|
|
|
|
mov dx,0FFFF
|
|
rcl dx,1
|
|
jo FAIL_D1_2 ; Overflow should NOT be set
|
|
jmp TEST_D1_22
|
|
|
|
|
|
FAIL_D1_2:
|
|
mov dx,00039 ; Print a 0
|
|
mov ax,00202
|
|
int 021
|
|
|
|
|
|
TEST_D1_22:
|
|
; RCL
|
|
; Test against Memory
|
|
|
|
clc
|
|
mov word[00050],0817F
|
|
rcl word[00050],1
|
|
cmp word[00050],002FE
|
|
jne FAIL_D1_22
|
|
|
|
clc
|
|
mov word[00050],01111
|
|
rcl word[00050],1
|
|
cmp word[00050],02222
|
|
jne FAIL_D1_22
|
|
|
|
stc
|
|
mov word[00050],0817F
|
|
rcl word[00050],1
|
|
cmp word[00050],002FF
|
|
jne FAIL_D1_22
|
|
|
|
stc
|
|
mov word[00050],01111
|
|
rcl word[00050],1
|
|
cmp word[00050],02223
|
|
jne FAIL_D1_22
|
|
|
|
mov word[00050],07777
|
|
rcl word[00050],1
|
|
jc FAIL_D1_22 ; Carry should not be set
|
|
|
|
mov word[00050],08888
|
|
rcl word[00050],1
|
|
jnc FAIL_D1_22 ; Carry should be set
|
|
|
|
mov word[00050],08000
|
|
rcl word[00050],1
|
|
jno FAIL_D1_22 ; Overflow should be set
|
|
|
|
mov word[00050],0FFFF
|
|
rcl word[00050],1
|
|
jo FAIL_D1_22 ; Overflow should NOT be set
|
|
jmp TEST_D1_3
|
|
|
|
|
|
FAIL_D1_22:
|
|
mov dx,00031 ; Print a 0
|
|
mov ax,00202
|
|
int 021
|
|
|
|
|
|
|
|
TEST_D1_3:
|
|
|
|
; RCR
|
|
; Test against Register
|
|
|
|
clc
|
|
mov ax,0447F
|
|
rcr ax,1
|
|
cmp ax,0223F
|
|
jne FAIL_D1_3
|
|
|
|
clc
|
|
mov cx,01111
|
|
rcr cx,1
|
|
cmp cx,00888
|
|
jne FAIL_D1_3
|
|
|
|
stc
|
|
mov ax,00001
|
|
rcr ax,1
|
|
cmp ax,08000
|
|
jne FAIL_D1_3
|
|
|
|
stc
|
|
mov cx,08000
|
|
rcr cx,1
|
|
cmp cx,0C000
|
|
jne FAIL_D1_3
|
|
|
|
clc
|
|
mov bx,08110
|
|
rcr bx,1
|
|
jc FAIL_D1_3 ; Carry should not be set
|
|
|
|
clc
|
|
mov dx,08181
|
|
rcr dx,1
|
|
jnc FAIL_D1_3 ; Carry should be set
|
|
|
|
stc
|
|
mov dx,00F00
|
|
rcr dx,1
|
|
jno FAIL_D1_3 ; Overflow should be set
|
|
|
|
clc
|
|
mov dx,00000
|
|
rcr dx,1
|
|
jo FAIL_D1_3 ; Overflow should NOT be set
|
|
jmp TEST_D1_32
|
|
|
|
|
|
FAIL_D1_3:
|
|
mov dx,00031 ; Print a 0
|
|
mov ax,00202
|
|
int 021
|
|
|
|
|
|
TEST_D1_32:
|
|
; RCR
|
|
; Test against Memory
|
|
|
|
clc
|
|
mov word[00050],0447F
|
|
rcr word[00050],1
|
|
cmp word[00050],0223F
|
|
jne FAIL_D1_32
|
|
|
|
clc
|
|
mov word[00050],01111
|
|
rcr word[00050],1
|
|
cmp word[00050],00888
|
|
jne FAIL_D1_32
|
|
|
|
stc
|
|
mov word[00050],00001
|
|
rcr word[00050],1
|
|
cmp word[00050],08000
|
|
jne FAIL_D1_32
|
|
|
|
stc
|
|
mov word[00050],08000
|
|
rcr word[00050],1
|
|
cmp word[00050],0C000
|
|
jne FAIL_D1_32
|
|
|
|
mov word[00050],08110
|
|
rcr word[00050],1
|
|
jc FAIL_D1_32 ; Carry should not be set
|
|
|
|
mov word[00050],08181
|
|
rcr word[00050],1
|
|
jnc FAIL_D1_32 ; Carry should be set
|
|
|
|
stc
|
|
mov word[00050],00F00
|
|
rcr word[00050],1
|
|
jno FAIL_D1_32 ; Overflow should be set
|
|
|
|
clc
|
|
mov word[00050],00000
|
|
rcr word[00050],1
|
|
jo FAIL_D1_32 ; Overflow should NOT be set
|
|
jmp TEST_D1_4
|
|
|
|
|
|
FAIL_D1_32:
|
|
mov dx,00031 ; Print a 0
|
|
mov ax,00202
|
|
int 021
|
|
|
|
|
|
TEST_D1_4:
|
|
|
|
; SAL
|
|
; Test against Register
|
|
|
|
mov ax,07FFF
|
|
sal ax,1
|
|
cmp ax,0FFFE
|
|
jne FAIL_D1_4
|
|
|
|
mov bx,02222
|
|
sal bx,1
|
|
jc FAIL_D1_4 ; Carry should not be set
|
|
|
|
mov cx,00001
|
|
sal cx,1
|
|
cmp cx,00002
|
|
jne FAIL_D1_4
|
|
|
|
mov dx,08000
|
|
sal dx,1
|
|
jnc FAIL_D1_4 ; Carry should be set
|
|
|
|
mov dx,08180
|
|
sal dx,1
|
|
jno FAIL_D1_4 ; Overflow should be set
|
|
|
|
mov dx,0FFFF
|
|
sal dx,1
|
|
jo FAIL_D1_4 ; Overflow should NOT be set
|
|
|
|
|
|
; SAL
|
|
; Test against Memory
|
|
|
|
mov word[00050],07FFF
|
|
sal word[00050],1
|
|
cmp word[00050],0FFFE
|
|
jne FAIL_D1_4
|
|
|
|
mov word[00050],02222
|
|
sal word[00050],1
|
|
jc FAIL_D1_4 ; Carry should not be set
|
|
|
|
mov word[00050],00001
|
|
sal word[00050],1
|
|
cmp word[00050],00002
|
|
jne FAIL_D1_4
|
|
|
|
mov word[00050],08000
|
|
sal word[00050],1
|
|
jnc FAIL_D1_4 ; Carry should be set
|
|
|
|
mov word[00050],08180
|
|
sal word[00050],1
|
|
jno FAIL_D1_4 ; Overflow should be set
|
|
|
|
mov word[00050],0FFFF
|
|
sal word[00050],1
|
|
jo FAIL_D1_4 ; Overflow should NOT be set
|
|
|
|
|
|
jmp TEST_D1_5
|
|
|
|
|
|
FAIL_D1_4:
|
|
mov dx,00031 ; Print a 0
|
|
mov ax,00202
|
|
int 021
|
|
|
|
|
|
TEST_D1_5:
|
|
; SAR
|
|
; Test against Register
|
|
|
|
mov ax,08000
|
|
sar ax,1
|
|
cmp ax,0C000
|
|
jne FAIL_D1_5
|
|
|
|
mov bx,04444
|
|
sar bx,1
|
|
jc FAIL_D1_5 ; Carry should not be set
|
|
|
|
mov cx,00001
|
|
sar cx,1
|
|
cmp cx,00000
|
|
jne FAIL_D1_5
|
|
|
|
mov dx,00001
|
|
sar dx,1
|
|
jnc FAIL_D1_5 ; Carry should be set
|
|
|
|
mov dx,081FF
|
|
sar dx,1
|
|
jo FAIL_D1_5 ; Overflow should NOT be set
|
|
|
|
; SAR
|
|
; Test against Memory
|
|
|
|
mov word[00050],08000
|
|
sar word[00050],1
|
|
cmp word[00050],0C000
|
|
jne FAIL_D1_5
|
|
|
|
mov word[00050],04444
|
|
sar word[00050],1
|
|
jc FAIL_D1_5 ; Carry should not be set
|
|
|
|
mov word[00050],00001
|
|
sar word[00050],1
|
|
cmp word[00050],00000
|
|
jne FAIL_D1_5
|
|
|
|
mov word[00050],00001
|
|
sar word[00050],1
|
|
jnc FAIL_D1_5 ; Carry should be set
|
|
|
|
mov word[00050],081FF
|
|
sar word[00050],1
|
|
jo FAIL_D1_5 ; Overflow should NOT be set
|
|
|
|
jmp TEST_D1_6
|
|
|
|
FAIL_D1_5:
|
|
mov dx,00031 ; Print a 0
|
|
mov ax,00202
|
|
int 021
|
|
|
|
|
|
|
|
TEST_D1_6:
|
|
; SHR
|
|
; Test against Register
|
|
|
|
mov ax,0FFFF
|
|
shr ax,1
|
|
cmp ax,07FFF
|
|
jne FAIL_D1_6
|
|
|
|
mov bx,04444
|
|
shr bx,1
|
|
jc FAIL_D1_6 ; Carry should not be set
|
|
|
|
mov cx,04444
|
|
shr cx,1
|
|
cmp cx,02222
|
|
jne FAIL_D1_6
|
|
|
|
mov dx,00001
|
|
shr dx,1
|
|
jnc FAIL_D1_6 ; Carry should be set
|
|
|
|
mov dx,081FF
|
|
shr dx,1
|
|
jno FAIL_D1_6 ; Overflow should be set
|
|
|
|
mov dx,00000
|
|
shr dx,1
|
|
jo FAIL_D1_6 ; Overflow should NOT be set
|
|
|
|
|
|
; SHR
|
|
; Test against Memory
|
|
|
|
mov word[00050],0FFFF
|
|
shr word[00050],1
|
|
cmp word[00050],07FFF
|
|
jne FAIL_D1_6
|
|
|
|
mov word[00050],04444
|
|
shr word[00050],1
|
|
jc FAIL_D1_6 ; Carry should not be set
|
|
|
|
mov word[00050],04444
|
|
shr word[00050],1
|
|
cmp word[00050],02222
|
|
jne FAIL_D1_6
|
|
|
|
mov word[00050],00001
|
|
shr word[00050],1
|
|
jnc FAIL_D1_6 ; Carry should be set
|
|
|
|
mov word[00050],081FF
|
|
shr word[00050],1
|
|
jno FAIL_D1_6 ; Overflow should be set
|
|
|
|
mov word[00050],00000
|
|
shr word[00050],1
|
|
jo FAIL_D1_6 ; Overflow should NOT be set
|
|
|
|
jmp TEST_D2_0
|
|
|
|
FAIL_D1_6:
|
|
mov dx,00031 ; Print a 0
|
|
mov ax,00202
|
|
int 021
|
|
|
|
|
|
|
|
; 0xD2 - 8-Bit Shifts and Rotate Opcodes with CL
|
|
; ############################################################
|
|
|
|
TEST_D2_0:
|
|
; ROL, cl - Test against Register and Memory
|
|
mov ax,0004A
|
|
mov word[00050],00001
|
|
mov cx,0000F
|
|
mov bx,00000
|
|
mov dx,00000
|
|
cli
|
|
|
|
L_D2_0: ; Do 16 shifts of 16 different cl's
|
|
rol al,cl ; and add up all results into dx and bx
|
|
rol byte[00050],cl
|
|
add dx,ax
|
|
add bx,word[00050]
|
|
loop L_D2_0
|
|
sti
|
|
cmp dx,005B0 ; Final result of additions of all shifts
|
|
jne FAIL_D2_0
|
|
cmp bx,001FD
|
|
jne FAIL_D2_0
|
|
jmp TEST_D2_1
|
|
|
|
FAIL_D2_0:
|
|
mov dx,00032 ; Print a 2
|
|
mov ax,00202
|
|
int 021
|
|
|
|
|
|
TEST_D2_1:
|
|
; ROR, cl - Test against Register and Memory
|
|
mov ax,00084
|
|
mov word[00050],00005
|
|
mov cx,0000F
|
|
mov bx,00000
|
|
mov dx,00000
|
|
cli
|
|
|
|
L_D2_1: ; Do 16 shifts of 16 different cl's
|
|
ror al,cl ; and add up all results into dx and bx
|
|
ror byte[00050],cl
|
|
add dx,ax
|
|
add bx,word[00050]
|
|
loop L_D2_1
|
|
sti
|
|
cmp dx,00378 ; Final result of additions of all shifts
|
|
jne FAIL_D2_1
|
|
cmp bx,003F7
|
|
jne FAIL_D2_1
|
|
jmp TEST_D2_2
|
|
|
|
FAIL_D2_1:
|
|
mov dx,00032 ; Print a 2
|
|
mov ax,00202
|
|
int 021
|
|
|
|
|
|
TEST_D2_2:
|
|
; RCL, cl - Test against Register and Memory
|
|
mov ax,00099
|
|
mov word[00050],00006
|
|
mov cx,0000F
|
|
mov bx,00000
|
|
mov dx,00000
|
|
cli
|
|
|
|
L_D2_2: ; Do 16 shifts of 16 different cl's
|
|
rcl al,cl ; and add up all results into dx and bx
|
|
rcl byte[00050],cl
|
|
add dx,ax
|
|
add bx,word[00050]
|
|
loop L_D2_2
|
|
sti
|
|
cmp dx,0076E ; Final result of additions of all shifts
|
|
jne FAIL_D2_2
|
|
cmp bx,0025E
|
|
jne FAIL_D2_2
|
|
jmp TEST_D2_3
|
|
|
|
FAIL_D2_2:
|
|
mov dx,00032 ; Print a 2
|
|
mov ax,00202
|
|
int 021
|
|
|
|
|
|
TEST_D2_3:
|
|
; RCR, cl - Test against Register and Memory
|
|
mov ax,00083
|
|
mov word[00050],00012
|
|
mov cx,0000F
|
|
mov bx,00000
|
|
mov dx,00000
|
|
cli
|
|
|
|
L_D2_3: ; Do 16 shifts of 16 different cl's
|
|
rcr al,cl ; and add up all results into dx and bx
|
|
rcr byte[00050],cl
|
|
add dx,ax
|
|
add bx,word[00050]
|
|
loop L_D2_3
|
|
sti
|
|
cmp dx,005CB ; Final result of additions of all shifts
|
|
jne FAIL_D2_3
|
|
cmp bx,00262
|
|
jne FAIL_D2_3
|
|
jmp TEST_D2_4
|
|
|
|
FAIL_D2_3:
|
|
mov dx,00032 ; Print a 2
|
|
mov ax,00202
|
|
int 021
|
|
|
|
|
|
TEST_D2_4:
|
|
; SAL, cl - Test against Register and Memory
|
|
mov ax,00099
|
|
mov word[00050],00006
|
|
mov cx,00003
|
|
mov bx,00000
|
|
mov dx,00000
|
|
cli
|
|
|
|
L_D2_4: ; Do 16 shifts of 16 different cl's
|
|
sal al,cl ; and add up all results into dx and bx
|
|
sal byte[00050],cl
|
|
add dx,ax
|
|
add bx,word[00050]
|
|
loop L_D2_4
|
|
sti
|
|
cmp dx,00128 ; Final result of additions of all shifts
|
|
jne FAIL_D2_4
|
|
cmp bx,00170
|
|
jne FAIL_D2_4
|
|
jmp TEST_D2_5
|
|
|
|
FAIL_D2_4:
|
|
mov dx,00032 ; Print a 2
|
|
mov ax,00202
|
|
int 021
|
|
|
|
|
|
TEST_D2_5:
|
|
; SHR, cl - Test against Register and Memory
|
|
mov ax,00083
|
|
mov word[00050],00012
|
|
mov cx,00003
|
|
mov bx,00000
|
|
mov dx,00000
|
|
cli
|
|
|
|
L_D2_5: ; Do 16 shifts of 16 different cl's
|
|
shr al,cl ; and add up all results into dx and bx
|
|
shr byte[00050],cl
|
|
add dx,ax
|
|
add bx,word[00050]
|
|
loop L_D2_5
|
|
sti
|
|
cmp dx,00016 ; Final result of additions of all shifts
|
|
jne FAIL_D2_5
|
|
cmp bx,00002
|
|
jne FAIL_D2_5
|
|
jmp TEST_D2_6
|
|
|
|
FAIL_D2_5:
|
|
mov dx,00032 ; Print a 2
|
|
mov ax,00202
|
|
int 021
|
|
|
|
|
|
TEST_D2_6:
|
|
; SAR, cl - Test against Register and Memory
|
|
mov ax,00083
|
|
mov word[00050],00012
|
|
mov cx,00003
|
|
mov bx,00000
|
|
mov dx,00000
|
|
cli
|
|
|
|
L_D2_6: ; Do 16 shifts of 16 different cl's
|
|
sar al,cl ; and add up all results into dx and bx
|
|
sar byte[00050],cl
|
|
add dx,ax
|
|
add bx,word[00050]
|
|
loop L_D2_6
|
|
sti
|
|
cmp dx,002EA ; Final result of additions of all shifts
|
|
jne FAIL_D2_6
|
|
cmp bx,00002
|
|
jne FAIL_D2_6
|
|
jmp TEST_D3_0
|
|
|
|
FAIL_D2_6:
|
|
mov dx,00032 ; Print a 2
|
|
mov ax,00202
|
|
int 021
|
|
|
|
|
|
; 0xD3 - 16-Bit Shifts and Rotate Opcodes with CL
|
|
; ############################################################
|
|
|
|
TEST_D3_0:
|
|
; ROL, cl - Test against Register and Memory
|
|
mov ax,01234
|
|
mov word[00050],01234
|
|
mov cx,0000F
|
|
mov bx,00000
|
|
mov dx,00000
|
|
cli
|
|
|
|
L_D3_0: ; Do 16 shifts of 16 different cl's
|
|
rol ax,cl ; and add up all results into dx and bx
|
|
rol word[00050],cl
|
|
add dx,ax
|
|
add bx,word[00050]
|
|
loop L_D3_0
|
|
sti
|
|
cmp dx,0EDC7 ; Final result of additions of all shifts
|
|
jne FAIL_D3_0
|
|
cmp bx,0EDC7
|
|
jne FAIL_D3_0
|
|
jmp TEST_D3_1
|
|
|
|
FAIL_D3_0:
|
|
mov dx,00033 ; Print a 3
|
|
mov ax,00202
|
|
int 021
|
|
|
|
|
|
TEST_D3_1:
|
|
; ROR, cl - Test against Register and Memory
|
|
mov ax,05678
|
|
mov word[00050],05678
|
|
mov cx,0000F
|
|
mov bx,00000
|
|
mov dx,00000
|
|
cli
|
|
|
|
L_D3_1: ; Do 16 shifts of 16 different cl's
|
|
ror ax,cl ; and add up all results into dx and bx
|
|
ror word[00050],cl
|
|
add dx,ax
|
|
add bx,word[00050]
|
|
loop L_D3_1
|
|
sti
|
|
cmp dx,0A980 ; Final result of additions of all shifts
|
|
jne FAIL_D3_1
|
|
cmp bx,0A980
|
|
jne FAIL_D3_1
|
|
jmp TEST_D3_2
|
|
|
|
FAIL_D3_1:
|
|
mov dx,00033 ; Print a 3
|
|
mov ax,00202
|
|
int 021
|
|
|
|
|
|
TEST_D3_2:
|
|
; RCL, cl - Test against Register and Memory
|
|
mov ax,09999
|
|
mov word[00050],09999
|
|
mov cx,0000F
|
|
mov bx,00000
|
|
mov dx,00000
|
|
cli
|
|
clc
|
|
|
|
L_D3_2: ; Do 16 shifts of 16 different cl's
|
|
rcl ax,cl ; and add up all results into dx and bx
|
|
rcl word[00050],cl
|
|
add dx,ax
|
|
add bx,word[00050]
|
|
loop L_D3_2
|
|
sti
|
|
cmp dx,0EB59 ; Final result of additions of all shifts
|
|
jne FAIL_D3_2
|
|
cmp bx,05B7A
|
|
jne FAIL_D3_2
|
|
jmp TEST_D3_3
|
|
|
|
FAIL_D3_2:
|
|
mov dx,00033 ; Print a 3
|
|
mov ax,00202
|
|
int 021
|
|
|
|
|
|
TEST_D3_3:
|
|
; RCR, cl - Test against Register and Memory
|
|
mov ax,02112
|
|
mov word[00050],02112
|
|
mov cx,0000F
|
|
mov bx,00000
|
|
mov dx,00000
|
|
clc
|
|
cli
|
|
|
|
L_D3_3: ; Do 16 shifts of 16 different cl's
|
|
rcr ax,cl ; and add up all results into dx and bx
|
|
rcr word[00050],cl
|
|
add dx,ax
|
|
add bx,word[00050]
|
|
loop L_D3_3
|
|
sti
|
|
cmp dx,0CA0B ; Final result of additions of all shifts
|
|
jne FAIL_D3_3
|
|
cmp bx,092C5
|
|
jne FAIL_D3_3
|
|
jmp TEST_D3_4
|
|
|
|
FAIL_D3_3:
|
|
mov dx,00033 ; Print a 3
|
|
mov ax,00202
|
|
int 021
|
|
|
|
|
|
TEST_D3_4:
|
|
; SAL, cl - Test against Register and Memory
|
|
mov ax,01414
|
|
mov word[00050],01414
|
|
mov cx,00003
|
|
mov bx,00000
|
|
mov dx,00000
|
|
cli
|
|
|
|
L_D3_4: ; Do 16 shifts of 16 different cl's
|
|
sal ax,cl ; and add up all results into dx and bx
|
|
sal word[00050],cl
|
|
add dx,ax
|
|
add bx,word[00050]
|
|
loop L_D3_4
|
|
sti
|
|
cmp dx,02820 ; Final result of additions of all shifts
|
|
jne FAIL_D3_4
|
|
cmp bx,02820
|
|
jne FAIL_D3_4
|
|
jmp TEST_D3_5
|
|
|
|
FAIL_D3_4:
|
|
mov dx,00033 ; Print a 3
|
|
mov ax,00202
|
|
int 021
|
|
|
|
|
|
TEST_D3_5:
|
|
; SHR, cl - Test against Register and Memory
|
|
mov ax,02345
|
|
mov word[00050],02345
|
|
mov cx,00003
|
|
mov bx,00000
|
|
mov dx,00000
|
|
cli
|
|
|
|
L_D3_5: ; Do 16 shifts of 16 different cl's
|
|
shr ax,cl ; and add up all results into dx and bx
|
|
shr word[00050],cl
|
|
add dx,ax
|
|
add bx,word[00050]
|
|
loop L_D3_5
|
|
sti
|
|
cmp dx,0060F ; Final result of additions of all shifts
|
|
jne FAIL_D3_5
|
|
cmp bx,0060F
|
|
jne FAIL_D3_5
|
|
jmp TEST_D3_6
|
|
|
|
FAIL_D3_5:
|
|
mov dx,00033 ; Print a 3
|
|
mov ax,00202
|
|
int 021
|
|
|
|
|
|
TEST_D3_6:
|
|
; SAR, cl - Test against Register and Memory
|
|
mov ax,09090
|
|
mov word[00050],09090
|
|
mov cx,00003
|
|
mov bx,00000
|
|
mov dx,00000
|
|
cli
|
|
|
|
L_D3_6: ; Do 16 shifts of 16 different cl's
|
|
sar ax,cl ; and add up all results into dx and bx
|
|
sar word[00050],cl
|
|
add dx,ax
|
|
add bx,word[00050]
|
|
loop L_D3_6
|
|
sti
|
|
cmp dx,0ECD8 ; Final result of additions of all shifts
|
|
jne FAIL_D3_6
|
|
cmp bx,0ECD8
|
|
jne FAIL_D3_6
|
|
jmp TEST_D4_0
|
|
|
|
FAIL_D3_6:
|
|
mov dx,00033 ; Print a 3
|
|
mov ax,00202
|
|
int 021
|
|
|
|
|
|
; 0xD4 - AAM
|
|
; ############################################################
|
|
|
|
TEST_D4_0:
|
|
mov ax,0000
|
|
mov dx,0000
|
|
mov cx,00FF
|
|
|
|
L_D4: AAM
|
|
add dx,ax
|
|
inc al
|
|
loop L_D4
|
|
|
|
cmp dx,01D6F
|
|
jne FAIL_D4_0
|
|
jmp TEST_D5_0
|
|
|
|
FAIL_D4_0:
|
|
mov dx,00034 ; Print a 4
|
|
mov ax,00202
|
|
int 021
|
|
|
|
|
|
|
|
; 0xD5 - AAD
|
|
; ############################################################
|
|
|
|
TEST_D5_0:
|
|
mov ax,00000
|
|
mov dx,00000
|
|
mov cx,0FFFF
|
|
|
|
L_D5: AAD
|
|
add dx,ax
|
|
inc al
|
|
loop L_D5
|
|
|
|
cmp dx,07F01
|
|
jne FAIL_D5_0
|
|
jmp TEST_D7_0
|
|
|
|
FAIL_D5_0:
|
|
mov dx,00035 ; Print a 5
|
|
mov ax,00202
|
|
int 021
|
|
|
|
|
|
|
|
; 0xD7 - XLAT
|
|
; ############################################################
|
|
|
|
TEST_D7_0:
|
|
mov byte [07788], 05A
|
|
mov bx,07777
|
|
mov ax,03311
|
|
xlat
|
|
cmp al,05A
|
|
jne FAIL_D7_0
|
|
jmp TEST_D7_1
|
|
|
|
TEST_D7_1:
|
|
mov byte ss:[04455], 0AB
|
|
mov bx,04444
|
|
mov ax,03311
|
|
ss: xlat
|
|
cmp al,0AB
|
|
jne FAIL_D7_0
|
|
jmp TEST_D8_0
|
|
|
|
FAIL_D7_0:
|
|
mov dx,00037 ; Print a 7
|
|
mov ax,00202
|
|
int 021
|
|
|
|
|
|
; 0xD8-0xDF - ESC
|
|
; ############################################################
|
|
|
|
TEST_D8_0:
|
|
; esc [bx]
|
|
; esc [bx+si]
|
|
; esc [01234]
|
|
|
|
|
|
; xxxxxxxxxxxxxxxxxxxxxxx
|
|
; End
|
|
; xxxxxxxxxxxxxxxxxxxxxxx
|
|
Z_END:
|
|
mov ax,00000 ; DOS Command=Exit
|
|
int 021
|
|
|
|
|
|
|