XULYBCD ic macro m push ax push dx mov ah,9 lea dx,m int 21h pop dx pop ax endm "" ic dung

chung cho tat ca cac chuong trinh "" Title Cong BCD khong nen .model small .stack 100h .data m1 db 1000 dup(0) m2 db 1000 dup(0) m3 db 1001 dup(0) so db 0 sopt dw 0 xd db 10,13,'$' .code main proc mov ax,@data mov ds,ax l1: mov ah,1 int 21h cmp al,'0' jl l1 cmp al,'9' jg l1 and al,0Fh xor ah,ah mov sopt,ax ic xd xor bx,bx mov cx,sopt l2: call nhap mov al,so mov byte PTR m1[bx],al inc bx loop l2 ic xd xor bx,bx mov cx,sopt l3: call nhap mov al,so mov byte PTR m2[bx],al inc bx loop l3 ic xd lea di,m1 lea si,m2 lea bx,m3 add di,sopt add si,sopt add bx,sopt inc bx mov cx,sopt inc cx l4:

mov al,[di] adc al,[si] AAA mov [bx],al dec bx dec di dec si loop l4 adc [bx],0 mov cx,sopt add cx,1 lea bx,m3 mov ah,2 l5: mov dl,[bx] or dl,30h int 21h mov dl,' ' int 21h inc bx loop l5 mov ah,4Ch int 21h endp nhap proc push ax mov so,0 ll: mov ah,1 int 21h cmp al,'0' jl ll cmp al,'9' jg ll and al,0Fh mov so,al pop ax ret endp Title Cong BCD nen .model small .stack 100h .data n1 db 'nhap so phan tu day :$' n2 db 10,13,'nhap vao day BCD : ',10,13,'$' n3 db 10,13,'Tong 2 day vua nhap la : $' sopt dw 0 sopt1 dw 0 so db 0 a db 100 dup(0) b db 100 dup(0) c db 101 dup(0) .code main proc mov ax,@data mov ds,ax ;khoi tao ds ;nhap so BCD ic n1 l1: mov ah,1 int 21h cmp al,'0' jl l1 cmp al,'9'

jg l1 xor ah,ah and al,0Fh mov sopt,ax ic n2 mov di,0 mov cx,sopt l2: call soBCD mov al,so mov byte ptr a[di],al inc di mov ah,14 mov al,' ' int 10h loop l2 mov di,0 mov cx,sopt l22: call soBCD mov al,so mov byte ptr b[di],al inc di mov ah,14 mov al,' ' int 10h loop l22 ;cong 2 chuoi BCD mov di,sopt mov si,sopt dec di dec si mov bx,sopt mov cx,sopt ll1: mov al,byte ptr a[di] adc al,byte ptr b[si] daa mov byte ptr c[bx],al dec di dec si dec bx loop ll1 adc byte ptr c[bx],0 ic n3 lea di,c mov cx,sopt inc cx l3: call inBCD mov al,' ' mov ah,14 int 10h loop l3 mov ah,4Ch int 21h endp soBCD proc push cx mov cx,2 xor bl,bl mov ah,1 ll: int 21h cmp al,'0'

jl ll cmp al,'9' jg ll and al,0Fh shl bl,4 or bl,al loop ll mov so,bl pop cx ret endp inBCD proc mov al,[di] mov dl,al shr al,4 or al,30h mov ah,14 int 10h and dl,0Fh or dl,30h mov ah,2 int 21h inc di ret endp Title Tru BCD khong nen .model small .stack 100h .data m1 db 100 dup(0) m2 db 100 dup(0) m3 db 101 dup(0) so db 0 sopt dw 0 xd db 10,13,'$' .code main proc mov ax,@data mov ds,ax l1: mov ah,1 int 21h cmp al,'0' jl l1 cmp al,'9' jg l1 and al,0Fh xor ah,ah mov sopt,ax ic xd xor bx,bx mov cx,sopt l2: call nhap mov al,so mov byte PTR m1[bx],al inc bx loop l2 ic xd xor bx,bx mov cx,sopt l3: call nhap mov al,so

mov byte PTR m2[bx],al inc bx loop l3 ic xd mov cx,sopt xor dx,dx lea di,m1 lea si,m2 lam: mov al,[di] cmp al,[si] ja duong jb am inc di inc si inc dx loop lam duong: lea bx,m3 mov [bx],'+' call tru jmp thoat am: lea bx,m3 mov [bx],'-' xchg di,si call tru thoat: mov cx,sopt add cx,1 lea bx,m3 mov ah,2 mov dl,[bx] int 21h l5: inc bx mov dl,[bx] or dl,30h int 21h mov dl,' ' int 21h loop l5 mov ah,4Ch int 21h endp nhap proc push ax mov so,0 ll: mov ah,1 int 21h cmp al,'0' jl ll cmp al,'9' jg ll and al,0Fh mov so,al pop ax ret endp tru proc sub sopt,dx dec sopt add di,sopt add si,sopt

add bx,sopt mov cx,sopt inc cx inc bx ll1: mov al,[di] sbb al,[si] aas mov [bx],al dec di dec si dec bx loop ll1 ret endp Title Tru BCD nen cBCD macro x local l2 mov di,0 mov cx,sopt l2: call soBCD mov al,so mov byte ptr x[di],al inc di mov ah,14 mov al,' ' int 10h loop l2 endm .model small .stack 100h .data n1 db 'nhap so phan tu day :$' n2 db 10,13,'nhap vao day BCD : ',10,13,'$' n3 db 10,13,'Tru 2 day vua nhap la : $' n4 db 10,13,'Tru 2 day vua nhap la : 0$' sopt dw 0 so db 0 a db 100 dup(0) b db 100 dup(0) c db 101 dup(0) .code main proc mov ax,@data mov ds,ax ;khoi tao ds ic n1 l1: mov ah,1 int 21h cmp al,'0' jl l1 cmp al,'9' jg l1 xor ah,ah and al,0Fh mov sopt,ax ic n2 cBCD a cBCD b lea di,a lea si,b xor dx,dx mov cx,sopt

lll: mov al,[di] cmp al,[si] ja duong jb am inc di inc si inc dx loop lll duong: cmp dx,sopt je het lea bx,c mov [bx],'+' call tru jmp thoat am: lea bx,c mov [bx],'-' xchg di,si call tru thoat: ic n3 lea di,c mov cx,sopt mov ah,14 mov al,[di] int 10h l3: call inBCD mov al,' ' mov ah,14 int 10h loop l3 jmp kthuc het: ic n4 kthuc: mov ah,4Ch int 21h endp soBCD proc push cx mov cx,2 xor bl,bl mov ah,1 ll: int 21h cmp al,'0' jl ll cmp al,'9' jg ll and al,0Fh shl bl,4 or bl,al loop ll mov so,bl pop cx ret endp inBCD proc inc di mov al,[di] mov dl,al shr al,4

or al,30h mov ah,14 int 10h and dl,0Fh or dl,30h mov ah,2 int 21h ret endp tru proc sub sopt,dx cmp sopt,0 je ve mov cx,sopt add bx,sopt add di,sopt add si,sopt dec di dec si lam: mov al,[di] sbb al,[si] das mov [bx],al dec di dec si dec bx loop lam ve: ret endp Title Nhan BCD khong nen .model small .stack 100h .data m1 db 1000 dup(0) m3 db 1001 dup(0) so db 0 son db 0 sopt dw 0 xd db 10,13,'$' .code main proc mov ax,@data mov ds,ax mov ah,1 l1: int 21h cmp al,'0' jl l1 cmp al,'9' jg l1 and al,0Fh mov son,al ic xd ll1: int 21h cmp al,'0' jl ll1 cmp al,'9' jg ll1 and al,0Fh xor ah,ah mov sopt,ax

ic xd xor bx,bx mov cx,sopt l2: mov ah,1 int 21h cmp al,'0' jl l2 cmp al,'9' jg l2 and al,0Fh mov byte PTR m1[bx],al inc bx loop l2 ic xd ;nhan so BCD voi so tu nhien nho hon 10 lea di,m1 lea si,m3 add di,sopt dec di add si,sopt mov cx,sopt mov bl,son xor bh,bh l3: mov al,[di] mul bl add al,bh aam mov [si],al mov bh,ah dec di dec si loop l3 mov [si],ah mov cx,sopt add cx,1 lea bx,m3 mov ah,2 l5: mov dl,[bx] or dl,30h int 21h mov dl,' ' int 21h inc bx loop l5 mov ah,4Ch int 21h endp Title Chia BCD khong nen .model small .stack 100h .data m1 db 1000 dup(0) m3 db 1001 dup(0) so db 0 soc db 0 sopt dw 0 xd db 10,13,'$' .code main proc mov ax,@data mov ds,ax

mov ah,1 l1: int 21h cmp al,'0' jl l1 cmp al,'9' jg l1 and al,0Fh mov soc,al ic xd ll1: int 21h cmp al,'0' jl ll1 cmp al,'9' jg ll1 and al,0Fh xor ah,ah mov sopt,ax ic xd xor bx,bx mov cx,sopt l2: mov ah,1 int 21h cmp al,'0' jl l2 cmp al,'9' jg l2 and al,0Fh mov byte PTR m1[bx],al inc bx loop l2 ic xd ;chia so BCD voi so tu nhien nho hon 10 lea di,m1 lea si,m3 mov cx,sopt mov bl,soc xor bh,bh l3: mov ah,bh mov al,[di] aad div bl mov bh,ah mov [si],al inc di inc si loop l3 mov cx,sopt lea bx,m3 mov ah,2 l5: mov dl,[bx] or dl,30h int 21h mov dl,' ' int 21h inc bx loop l5 mov ah,4Ch int 21h endp

2)vit ct nhp vo 2 s A,B(hexa), ri o 3bit cui ca B, ri tm MAX, ly MAX / pn t cn li theo php tr VD: 8/3 => 8-3=5, 5-3=2 inrakqu cat macro push ax push bx push cx push dx endm lay macro pop dx pop cx pop bx pop ax endm inchuoi macro x cat mov ah,9 lea dx,x int 21h lay endm in_kt macro x push ax mov ah,14 mov al,x int 10h pop ax endm .model small .stack 100h .data m1 db "nhap so hexa thu nhat:$" m2 db 10,13,"nhap so hexa thu hai:$" m3 db 10,13,"so lon nhat trong hai so:$" m4 db 10,13,"ket qua can tim la:$" tam dw 0 so1 dw 0 so2 dw 0 .code main proc mov ax,@data mov ds,ax inchuoi m1 call nhap mov ax,tam mov so1,ax ;===== inchuoi m2 call nhap mov ax,tam mov so2,ax ; 0111=07h ;===== xor ax,07h;1 xor1=0;0 xor 0=0 ;0xor1=1;1xor0=1 cmp ax,so1 ;ax dang chua so2 jg chia xchg ax,so1 ;hoan doi ax voi so1 chia: xor dx,dx;dx:ax chia cho so1 div so1 000000001;00000000000000001

inchuoi m4 ;dx:ax=2^16+1 call xuat mov ah,4ch int 21h main endp ;==================== nhap proc ;nhap so hexa xoa duoc cat mov bx,0 ; chua so nhap vao mov cx,4 ; chua so lan lap l1: mov ah,1 int 21h cmp al,13 je kt ;xoa duoc================ cmp al,8 ;so sanh al co = 8 khong? jne nap shr bx,4 ;dich phai 4 bit push cx mov ah,10;ham 10 cua ngat 10h: in ki tu o ci tri con tro mov al,32 ;hien tai mov cx,1 int 10h pop cx inc cx jmp l1 ;============================ nap: cmp al,'0' jl loi cmp al,'9' jg tiep sub al,30h ;hoac dung and al,0Fh jmp tiep2 tiep: cmp al,'A' jl loi cmp al,'F' jg loi sub al,55;tru al cho 55;chuyen tu ma ascii qua chu tiep2: shl bx,4;dich trai bx 4 bit add bl,al; 00001001->000010011010000 loop l1 ;giam cx xuong 1 jmp kt ;neu cx = 0 thi thuc hien loi: ;xoa ki tu in_kt 8 in_kt 32 in_kt 8 jmp l1 kt: mov tam,bx ;luu vao bien tam va thoat khoi thu tuc lay ret nhap endp ;======================= xuat proc ;in so o dang thap phan cat ;so chua trong ax mov bx,10 mov cx,0 cmp ax,0 jl am jmp chia2 am:

in_kt '-' neg ax chia2: xor dx,dx div bx push dx inc cx cmp ax,0 jne chia2 mov ah,2 in_: pop dx add dl,30h int 21h loop in_ lay ret xuat endp ;======================= end main

pop cx pop bx pop ax endm inchuoi macro x cat mov ah,9 lea dx,x int 21h lay endm in_kt macro x push ax mov ah,14 mov al,x

3/vit chng trnh M c th tc nhp 1 mng 1 chiu a[5] kiu dB(nhp s thp phn khng du xa c) tnh tng cc phn t cha 2 ch s BCD nn, i kt qu ra m ASCII s ng phn, lu vo vng nh c a ch ofset t 4AC8H trong on DS

int 10h pop ax endm ;phan tren khong thay doi============

;==================================== cat macro push ax push bx push cx push dx endm lay macro pop dx

.model small .stack 100h .data m1 db 10,13,"nhap mang:$" m2 db 10,13,"a[$" m3 db "]=$" tam dw 0 chiso dw 0 tong dw 0

a db 5 dup(0) ;khai bao mang a 5 phan tu=0 .code main proc mov ax,@data mov ds,ax mov cx,5; inchuoi m1 lea di,a;di chua dia chi offset cua mang a lap: inchuoi m2 mov ax,chiso call xuat inchuoi m3 call nhap mov bx,tam mov [di],bl ;dua so nhap vao mang inc chiso ;tang 1 don vi inc di loop lap ;============================ lea di,a; dua di ve phan tu thu nhat cua mang mov cx,5;cx chua so phan tu lap2: mov al,[di];dua phan tu thu nhat cua mang ra al call kiemtra cmp si,1 je cong jmp tiep3 ;00100001 ;00000100

cong: xor ah,ah add tong,ax tiep3: inc di loop lap2 mov ax,tong mov di,4AC8h mov cx,16 lap3: mov bx,0 shl ax,1 adc bl,0 mov byte ptr [di],bl inc di loop lap3 mov di,4AC8h mov cx,16 in_kt 10 in_kt 13 lap4: mov al,[di] add al,30h in_kt al inc di loop lap4 mov ah,4ch int 21h

main endp ;==================== nhap proc ;nhap so thap phan khong dau xoa duoc cat mov bx,10 ; chua so nhap vao mov cx,0 ; mov tam,0 l1: mov ah,1 int 21h cmp al,13 je kt ;xoa duoc================ cmp al,8 ;so sanh al co = 8 khong? jne nap mov ax,tam cmp ax,0 je nap xor dx,dx div bx mov tam,ax jmp xoa nodiv: mov si,0 xoa: mov ah,10;ham 10 cua ngat 10h: in ki tu o ci tri con tro mov al,32 mov cx,1 ;hien tai

int 10h jmp l1 nap: cmp al,'0' jl loi cmp al,'9' jg loi sub al,30h ;hoac dung and al,0Fh xor ah,ah xchg ax,tam mul bx add tam,ax jmp l1 ;giam cx xuong 1

loi: ;xoa ki tu in_kt 8 in_kt 32 in_kt 8 jmp l1 kt: cmp si,0 je het neg tam het: lay ret nhap endp ;======================= xuat proc ;in so o dang thap phan

cat ;so chua trong ax mov bx,10 mov cx,0 cmp ax,0 jl am2 jmp chia2 am2: in_kt '-' neg ax chia2: xor dx,dx div bx push dx inc cx cmp ax,0 jne chia2 mov ah,2 in_: pop dx add dl,30h int 21h loop in_ lay ret xuat endp ;======================= kiemtra proc ;kiem tra so trong al co phai bcd nen hay khong cat ;neu la bcd nen thi si=1;neu khong si=0

mov bl,al and al,0FH;de xoa 4 bit cao cmp al,9 jle tiep jmp khong tiep: shr bl,4 cmp bl,9 jle phai khong: mov si,0 jmp het2 phai: mov si,1 het2: lay ret kiemtra endp end main

Nh p 2 s M,N d ng DW (nh phn xa c). Hy k t h p 10 bit th p c a N v i M (t o thnh chu i 26bit), th c hi n l y s % N. Hy xt n u s b t 1 trong byte cao c a s d l s l th i s d ra s BCD khng nn c t vo m ng a[5] ki u DB

cat macro push ax push bx push cx push dx endm lay macro pop dx pop cx pop bx pop ax endm inchuoi macro x cat mov ah,9 lea dx,x int 21h lay endm in_kt macro x push ax mov ah,14 mov al,x int 10h pop ax endm .model small .stack 200h .data m1 db "nhap so nhi phan 16 bit:$" m2 db 10,13,"nhap so nhi phan thu hai:$" m3 db 10,13,"so bcd khong nen la:$" m4 db 10,13,"byte thap cua so du chua so chu so 1 chan$" a db 5 dup(0) tam dw 0 m dw 0 n dw 0 so10 dw 10 sopt dw 0 .code main proc mov ax,@data mov ds,ax inchuoi m1 call nhap mov ax,tam mov m,ax ;dua vao m inchuoi m2 call nhap mov ax,tam mov n,ax ;dua vao n mov ax,m mov dx,n

and dx,03FFh mov bx,n div bx xor ah,ah mov al,dh test ax,ax jp kt call doi inchuoi m3 mov cx,sopt lea di,a mov ah,2 lap: mov al,[di] add al,30h in_kt al in_kt 32 inc di loop lap jmp kt2 kt: inchuoi m4 kt2: mov ah,4ch int 21h main endp ;======================== nhap proc cat mov bx,0 mov cx,16 l1: mov ah,1 int 21h cmp al,13 je ketthuc cmp al,8 jne nap shr bx,1 push cx mov cx,1 mov al,20h mov ah,10 int 10h pop cx jmp l1 nap: cmp al,'0' jl loi cmp al,'1' jg loi and al,0Fh shl bx,1 shr al,1 adc bx,0h loop l1 jmp ketthuc loi: in_kt 8 in_kt 32 in_kt 8 jmp l1 ketthuc: mov tam,bx lay

ret nhap endp ;==================== doi proc cat mov ax,dx mov cx,0 lea di,a h1: xor dx,dx div so10 push dx inc cx cmp ax,0 jne h1 mov sopt,cx h2: pop dx mov [di],dl inc di loop h2 lay ret doi endp end main

pop ax endm cseg segment assume cs:cseg,ds:cseg,ss:cseg org 100h begin: jmp main mau db 1 so dw 0 kt db ? tam dw ? muoi dw 10 m1 db 'nhap so: $' m3 db 'Cac so nguyen to khong lon hon $' m4 db 'la: $' xd db 10,13,'$' main: ;nhap so inxau m1 call nhapso cmp so,1 ja nhapdung ;nhap sai jmp main nhapdung: ;xoa man hinh mov ah,3 int 10h ;dat proc insonto vao push cs pop ds lea dx,insonto mov ax,251ch int 21h ;main endp insonto proc push cs pop ds mov ax,0b800h mov es,ax mov di,160 ;goc trai man hinh lea si,m3 ;in dong chu mau "Cac so nguyen to khong lon hon N la" inchuoi: inc mau mov ah,mau mov al,b.[si] mov w.es:[di],ax inc si add di,2 cmp mau,13 jb intiep ;setcl: mov mau,1 intiep: cmp [si],'$' jne inchuoi

4/Chn ngt in ra cac s nguyn t <=N nhp vo proc nhp s dw khng du

push_regs macro push ax push bx push cx push dx endm pop_regs macro pop dx pop cx pop bx pop ax endm inxau macro a push ax push dx mov ah,9 lea dx,a int 21h pop dx pop ax endm inkt macro b push ax mov al,b mov ah,14 int 10h

mov bx,so call inso lea si,m4 inchuoi1: inc mau mov ah,mau mov al,b.[si] mov w.es:[di],ax inc si add di,2 cmp [si],'$' jne inchuoi1 mov bx,1 lap: inc bx cmp bx,so ja xong call ktsonto cmp kt,0 je tiep ;in ra call inso tiep: jmp lap xong: IRET insonto endp inso proc push_regs mov ax,bx mov cx,0 mov mau,7 repeat: xor dx,dx div muoi push dx inc cx cmp ax,0 jne repeat print: pop ax or al,30h mov ah,mau mov w.es:[di],ax add di,2 loop print ;in dau cach mov ah,mau mov al,' ' mov w.es:[di],ax add di,2 pop_regs RET inso endp ktsonto proc push_regs mov kt,1 mov tam,bx cmp bx,3

jbe het shr bx,1 xor dx,dx kiemtra: cmp bx,1 je het mov ax,tam div bx cmp dx,0 je khong xor dx,dx dec bx jmp kiemtra khong: dec kt het: pop_regs Ret ktsonto endp nhapso proc push_regs mov bx,0 input: mov ah,1 int 21h cmp al,13 je ketthuc cmp al,8 je xoa cmp al,'0' jb loi cmp al,'9' ja loi jmp xuly xoa: inkt 32 inkt 08 xor dx,dx mov ax,bx div muoi mov bx,ax jmp input loi: inkt 7 inkt 8 inkt 32 inkt 8 jmp input xuly: xor ah,ah xchg ax,bx mul muoi sub bx,30h add bx,ax jmp input ketthuc: mov so,bx pop_regs RET

nhapso endp end 5/Kiemtraso ; macro print string printstr macro var push ax push dx lea dx,var mov ah,9 int 21h pop dx pop ax endm ; macro print char printchar macro var push ax mov ah,14 mov al,var int 10h pop ax endm ; macro push regiters PUSH_REGS macro push ax push bx push cx push dx push di push si endm ; macro pop registers POP_REGS macro pop si pop di pop dx pop cx pop bx pop ax endm ; start code .model small .stack 100h .data msg db 'So phan tu cua mang: $' msg1 db 10,13,'A[ ' c dw ? msg2 db '] = $' so dw 0 A dw 20 dup (0) msg3 db 10,13,'Cac phan tu cua mang: $' space db 5 dup(32),'$' snt_msg db 10,13,'Cac so nguyen to : $' shp_msg db 10,13,'Cac so hanh phuc : $' kepker_msg db 10,13,'Cac so kepker : $' armstrong_msg db 10,13,'Cac so armstrong: $' kt db ? tmp db 20 dup(0) min dw 0 sum dw 0 .code ; load data segment mov ax,@data mov ds,ax ; print msg

printstr msg call in_dec_del mov cx, so ; cx = so mov di,0 ; di = 0 arr_input: mov c,di ; c = bx add c,30h ; c += 30h ; print msg1 printstr msg1 ; input dec call in_dec_del mov ax,so ; ax = so mov bx,di ; bx = di add bx,bx ; bx = bx * 2 (boi vi cac gia tri kieu DW nen moi lan lay gia tri, phai tang bien chi so 2 don vi) mov w. A[bx], ax ; arr[bx] = ax inc di ; di +=1 loop arr_input ; print array printstr msg3 mov cx,c ; cx = c and cx,0fh ; cx = cx - '0' inc cx ; cx = cx + 1 mov di,0 ; di = 0 arr_output: mov bx,di ; bx = di add bx,bx ; bx = bx * 2 (boi vi cac gia tri kieu DW nen moi lan lay gia tri, phai tang bien chi so 2 don vi) mov ax,w. A[bx] ; ax = A[bx] mov so,ax ; so = ax call out_dec inc di printstr space loop arr_output ; types of number ; so nguyen to printstr snt_msg ; cac so nguyen to mov cx,c ; cx = c and cx,0fh ; cx = cx - '0' inc cx ; cx = cx + 1 mov di,0 ; di = 0 in_snt: mov ax,A[di] ; lay lan luot cac gia phan tu cua mang ra AX de kiem tra mov so,ax call SoNguyenTo ; kiem tra snt cmp kt,1 ; neu kt = 1 thi la snt jne next_check_snt ; kt = 0 thi kiem tra so tiep theo call out_dec ; dung la snt thi in ra printstr space ; in khoang trong next_check_snt: add di,2 ; chi so dia chi +2 moi lan lay tu mang A loop in_snt ; so hanh phuc printstr shp_msg mov cx,c ; cx = c and cx,0fh ; cx = cx - '0' inc cx ; cx = cx + 1 mov di,0 ; di = 0 in_shp: mov ax,A[di] ; lay lan luot cac gia phan tu cua mang ra AX de kiem tra mov so,ax

call SoHanhPhuc ; kiem tra shp cmp kt,1 ; neu kt = 1 thi la shp jne next_check_shp ; kt = 0 thi kiem tra so tiep theo call out_dec ; dung la snt thi in ra printstr space ; in khoang trong next_check_shp: add di,2 ; chi so dia chi +2 moi lan lay tu mang A loop in_shp ; so kepker printstr kepker_msg mov cx,c ; cx = c and cx,0fh ; cx = cx - '0' inc cx ; cx = cx + 1 mov di,0 ; di = 0 in_kepker: mov ax,A[di] ; lay lan luot cac gia phan tu cua mang ra AX de kiem tra mov so,ax call SoKepker ; kiem tra kepker cmp kt,1 ; neu kt = 1 thi la kepker jne next_check_kepker ; kt = 0 thi kiem tra so tiep theo call out_dec ; dung la kepker thi in ra printstr space ; in khoang trong next_check_kepker: add di,2 ; chi so dia chi +2 moi lan lay tu mang A loop in_kepker ; so armstrong printstr armstrong_msg mov cx,c ; cx = c and cx,0fh ; cx = cx - '0' inc cx ; cx = cx + 1 mov di,0 ; di = 0 in_armstrong: mov ax,A[di] ; lay lan luot cac gia phan tu cua mang ra AX de kiem tra mov so,ax call SoArmstrong ; kiem tra armstrong cmp kt,1 ; neu kt = 1 thi la armstrong jne next_check_armstrong ; kt = 0 thi kiem tra so tiep theo call out_dec ; dung la armstrong thi in ra printstr space ; in khoang trong next_check_armstrong: add di,2 ; chi so dia chi +2 moi lan lay tu mang A loop in_armstrong ; return dos mov ax,4ch int 21h ; proc in_dec_del in_dec_del proc PUSH_REGS mov so,0 ; so = 0 mov bx,10 ; bx = 10 mov si,0 ; si = 0 indec: cmp si,5 je xong ; nhap 1 chu so mov ah,1 int 21h

; so sanh nut Enter cmp al,13 je xong ; so sanh Backspace cmp al,8 je manual_del ; so sanh '0' cmp al,'0' jb auto_del ; so sanh '9' cmp al,'9' ja auto_del ; neu khong gap cac truong hop tren inc si ; si = si + 1 and al,0fh ; al = al - 30h xor cx,cx ; cx = 0 mov cl,al ; cl = al mov ax,so ; ax = so mul bx ; ax = ax*10 add ax,cx ; ax = ax + dx mov so,ax ; so = ax jmp indec manual_del: printchar 32 ; in dau Space printchar 8 ; in Backspace dec si ; si = si - 1 mov dx,0 ; dx = 0 mov ax,so ; ax = so div bx ; dx:ax / 10 mov so,ax ; so = ax jmp indec auto_del: printchar 8 ; in Backspace printchar 32 ; in dau Space printchar 8 ; in Backspace jmp indec xong: cmp si,0 ; Kiem tra neu chua nhap so nao ma da Enter je indec ; Neu dung thi quay lai nhap POP_REGS ret in_dec_del endp ; proc out_dec out_dec proc PUSH_REGS mov dx,0 ; dx = 0 mov ax,so ; ax = so mov bx,10 ; bx = 10 mov cx,0 ; cx = 0 push_stack: cmp ax,0 ; so sanh ax voi 0 je inra ; neu ax = 0 thi inra div bx ; dx:ax / 10 push dx ; cat phan du dx vao stack mov dx,0 ; dx = 0 inc cx ; cx = cx + 1 jmp push_stack ; quay lai push_stack inra: cmp cx,0 ; kiem tra neu so la so 0 jne khac0 printchar '0' ; in so 0 jmp out_dec_ret khac0: pop dx ; lay lan luot tung chu so trong stack ra va in

add dx,'0' ; dx = dx + '0' mov ah,2 int 21h ; in ra dx loop inra out_dec_ret: POP_REGS ret out_dec endp ; check snt SoNguyenTo proc PUSH_REGS mov kt,0 ; bien kt = 0 neu k la snt, kt = 1 la snt mov ax,so ; ax = so cmp ax,1 ; so sanh ax voi 1 jbe snt_ret ; neu <=1 thi ket thuc mov dx,0 ; dx = 0 mov cx,ax ; cx = ax shr cx,1 ; cx = cx/2 mov si,1 ; si = 1 la bien dem mov bx,1 ; bx = 1 chia: mov ax,so ; ax = so div bx ; dx:ax/bx, phan du nam o dx cmp dx,0 ; so sanh dx = 0 ? jne next_chia ; khong bang thi nhay inc si ; neu bang thi si+=1 cmp si,2 ; so sanh si voi 2? ja snt_ret ; si>2 thi nhay next_chia: mov dx,0 ; dx = 0 cho viec chia tiep theo inc bx ; bx +=1 cmp bx,cx ; so sanh bx voi cx jbe chia ; neu bx<=cx thi van chia tiep cmp si,2 ; so sanh si voi 2? jne snt_ret ; neu khong = thi nhay mov kt,1; neu si = 2 thi kt = 1 (day la snt) snt_ret: POP_REGS ret SoNguyenTo endp ; check so hanh phuc SoHanhPhuc proc PUSH_REGS mov ax,so ; ax = so mov dx,0 ; dx = 0 mov kt,0 ; bien kt = 0 neu k la snt, kt = 1 la snt mov bx,10 ; bx = 10 mov cx,0 ; cx = 0 dem_so_chu_so: cmp ax,0 ; So sanh ax = 0 je xuly_shp div bx ; dx:ax/10 inc cx ; cx = cx + 1 push dx ; push dx vao stack mov dx, 0 ; dx = 0 jmp dem_so_chu_so xuly_shp: cmp cx,0 je shp_ret mov ax,cx ; ax = cx = so chu so mov si,2 ; si = 2 div si ; ax/2 cmp dx,0 ; dx = 0 thi so chu so la chan jne so_chu_so_le mov bx,cx ; cat tam cx vao bx

mov di,0 ; di = tong nua sau mov si,0 ; si = tong nua truoc tinh_tong_nua_sau: shr cx,1 ; cx = cx/2 tongsau: pop dx ; lay dx ra tu stack add di,dx ; di = di + dx loop tongsau tinh_tong_nua_truoc: mov cx,bx ; lay lai cx tu bx shr cx,1 ; cx = cx/2 tongtruoc: pop dx ; lay dx ra tu stack add si,dx ; si = si + dx loop tongtruoc ; so sanh tong sau va tong truoc cmp di,si jne shp_ret mov kt,1 ; di = si thi kt = 1 jmp shp_ret so_chu_so_le: pop dx ; giai phong stack neu so chu so le loop so_chu_so_le shp_ret: POP_REGS ret SoHanhPhuc endp ; check so kepker SoKepker proc PUSH_REGS mov kt,0 ; kt = 0 mov ax,so ; ax = so mov dx,0 ; dx = 0 mov bx,10 ; bx = 10 lea si,tmp ; si = offset tmp mov cx,0 ; cx = 0 lay_cac_chu_so: cmp ax,0 ; so sanh ax voi 0 je next ; neu ax = 0 thi nhay div bx ; dx:ax / 10 mov [si],dl ; cat phan du vao tmp[si] mov dx,0 ; dx = 0 cho lan chia tiep theo inc si ; si = si + 1 inc cx ; cx = cx + 1 (dem so chu so) jmp lay_cac_chu_so next: cmp cx,0 je kepker_ret mov bx,cx ; bx = cx lea si,tmp ; si = offset tmp sap_xep_tang_dan: push cx mov di,si ; di = si sort_up: mov al,[si] ; so sanh tmp[di] voi tmp[si] cmp al,[di] ; jna next1 xchg al,[di] ; neu tmp[di]>tmp[di] thi swap [di] voi [si] mov [si],al next1: inc di ; di = di + 1 loop sort_up pop cx inc si ; si +=1

loop sap_xep_tang_dan ; min mov cx,bx ; cx = bx push cx ; cat cx vao stack mov min,0 ; min = 0 mov ax,min ; ax = min mov bx,10 ; bx = 10 lea si,tmp ; si = offset tmp mov dx,0 ; dx = 0 tinh_min: mul bx ; dx:ax * 10 xor dx,dx ; dx = 0 mov dl,[si] ; dx = tmp[si] add ax,dx ; ax += dx inc si ; si += 1 loop tinh_min mov min, ax ; min = ax pop cx ; lay lai cx tu stack dec si ; si -= 1 (hien dang o phan tu cuoi cung cua tmp mov ax,0 ; ax = 0 mov dx,0 ; dx = 0 tinh_max: mul bx ; dx:ax * 10 xor dx,dx ; dx = 0 mov dl,[si] ; dx = tmp[si] add ax,dx ; ax += dx dec si ; si -= 1 loop tinh_max sub ax,min cmp ax,so jne kepker_ret: mov kt,1 kepker_ret: POP_REGS ret SoKepker endp ; check armstrong SoArmstrong proc PUSH_REGS mov kt,0 ; kt = 0 (kt = 0 thi ko phai armstrong, kt = 1 thi la so armstrong) mov ax, so ; ax = so mov dx, 0 ; dx = 0 mov bx, 10 ; bx = 10 mov cx, 0 ; cx = 0 tinh_he_so_mu: cmp ax,0 ; so sanh ax voi 0 je tieptheo ; neu ax = 0 thi next div bx ; dx:ax/10, phan du o dx push dx ; cat dx vao stack mov dx,0 ; xoa dx inc cx ; cx+=1 jmp tinh_he_so_mu tieptheo: cmp cx,0 ; so sanh cx voi 0 je armstrong_ret ; neu cx = 0 thi so = 0, ket thuc mov bx,cx ; bx = cx mov sum,0 ; sum = 0 mov dx,0 ; dx = 0 sum0: pop si ; lay si ra tu stack mov ax,1 ; ax = 1 push cx ; cat cx vao stack mov cx,bx ; cx = bx

sum1: mul si ; ax *= si loop sum1 add sum, ax pop cx loop sum0 mov ax,sum ; ax = sum cmp ax,so ; so sanh ax voi so jne armstrong_ret ; neu ax khong bang so thi ket thuc mov kt,1 ; neu ax = so thi kt = 1 armstrong_ret: POP_REGS ret SoArmstrong endp

6/vi t asm nh p vo m ng a[5] ki u db(th p pn ko d u xa dc),tnh t ng s cc ph n t ko p i l bcd nn,xt s c p i s ng t ,n u l so ng to th in ra bt phn,

inxau macro tb lea dx,tb mov ah,9 int 21h endm inkt macro kt mov dl,kt mov ah,2 int 21h endm push_reg macro push ax push bx push cx push dx endm pop_reg macro pop dx pop cx pop bx pop ax endm stack segment dw 100 dup(0) stack ends data segment m1 db 10,13,'$' m3 db "In ra mang vua nhap:$" m4 db "[a$" m5 db ']=$' so db 0 sopt dw 5 a db 5 dup(0) tong dw 0 ktbcd db 0 data ends code segment assume cs:code, ds:data, ss:stack main: mov ax,data mov ds,ax mov cx,5 xor bl,bl lea di,a l1: inxau m1 inxau m4 inc bl push bx call xuat;in ra a[bx] inxau m5 call nhap mov bl,so mov byte ptr[di],bl;cat cac phan tu vao mang add di,1 pop bx loop l1

;xuat mang ral ai inxau m1 inxau m3 mov cx,5 lea di,a l2: mov bl,byte ptr[di] call Xuat ;bx luu so xuat ra inkt 32 add di,1 loop l2 ;bat dau xet mov cx,5 lea di,a L3: mov bl,byte ptr[di] call kt_bcd cmp ktbcd,1 je bo_qua xor bh,bh add tong,bx bo_qua: inc di Loop L3 ;ket thuc tra ve dos mov ah,4ch int 21h Nhap proc push_reg xor bx,bx lap: mov ah,1 int 21h cmp bl,0 jne Lap_1 ;bx =0 chua nhap so cmp al,8 jne lap_1 inkt 20h jmp lap lap_1: cmp al,13 je thoat cmp al,8 je xoa cmp al,'0' jl loi cmp al,'9' jg loi and al,0fh mov ah,0 push ax mov al,10 mul bl pop bx add bl,al;bl=bl*10+al jmp lap xoa: xor ah,ah mov al,bl mov cl,10 div cl mov bl,al inkt 32

inkt 8 jmp lap loi: inkt 8 inkt 32 inkt 8 jmp lap thoat: mov so,bl pop_reg ret nhap endp Xuat proc push_reg xor cx,cx mov ax,bx and ax,ax mov bx,10 jns so_duong1 push ax inkt '-' pop ax neg ax so_duong1: xor dx,dx div bx;ax chua thuong,dx chua du push dx inc cx cmp ax,0 je in_ra jmp so_duong1 in_ra: pop ax or al,30h mov ah,14 int 10h loop in_ra pop_reg ret Xuat endp kt_bcd proc push_reg mov ktbcd,0 xor bh,bh push bx and bl,0fh cmp bl,9 jg kt_ketthuc pop bx push bx shr bl,4 cmp bl,9 jg kt_ketthuc mov ktbcd,1 kt_ketthuc: pop bx pop_reg ret kt_bcd endp code ends end main

7/Doi2bitdaucuoi inxau macro tb push_reg lea dx,tb mov ah,9 int 21h pop_reg endm inkt macro kt push_reg mov dl,kt mov ah,2 int 21h pop_reg endm push_reg macro push ax push bx push cx push dx endm pop_reg macro pop dx pop cx pop bx pop ax endm stack segment dw 100 dup(0) stack ends data segment m1 db 10,13,'$' m2 db "Nhap vao so:$" m3 db "So vua nhap:$" m4 db "Dang nhi phan:$" m5 db "Dao 2 bit dau va cuoi cho nhau$" m6 db "Sau khi dao:$" m7 db "Doi ra bat phan: $" m8 db "Khong thoa$" so dw 0 daobit dw 0 trai dw 0 phai dw 0 data ends code segment assume cs:code, ds:data, ss:stack main: mov ax,@data mov ds,ax;khoi tao ds inxau m2 ;goi thu tuc nhap so bat phan co the xoa call nhaplucphan ;output so luu trong bx inxau m1 inxau m3 mov bx,so call xuatlucphan inxau m1 inxau m4 mov bx,so call xuatnhiphan inxau m1 inxau m5 inxau m1

inxau m6 mov bx,so call dao_bit mov bx,daobit call xuatnhiphan ;test-------------------inxau m1 inxau m7 mov ax,daobit and ah,0fh shr al,4 cmp ah,al jle ko_thoa;ah<=al thi ket thuc mov bx,daobit call xuatbatphan jmp ket_thuc ko_thoa: inxau m8 ket_thuc: ;test-------------mov ah,4ch int 21h nhaplucphan proc ;thu tuc nhap so bat phan push_reg xor bx,bx mov cx,4 N1: mov ah,1 int 21h cmp bx,0 jne N2 cmp al,8 jne N2 inkt 20h jmp N1 N2: cmp al,13 je thoat cmp al,8 je xoa cmp al,'0' jl loi cmp al,'9' jg kt_hoa and al,0fh jmp addbx kt_hoa: cmp al,'A' jl loi cmp al,'F' jg kt_thuong sub al,55 jmp addbx kt_thuong: cmp al,'a' jl loi cmp al,'f' jg loi sub al,87 addbx: shl bx,4 xor ah,ah or bx,ax Loop N1

jmp thoat xoa: shr bx,4 inc cx inkt 32 inkt 8 jmp N1 loi: inkt 8 inkt 32 inkt 8 jmp N1 thoat: mov so,bx pop_reg ret nhaplucphan endp xuatlucphan proc ;input= bx chua so push_reg mov ax,bx mov bx,16 xor cx,cx X1: xor dx,dx div bx;ax chua thuong,dx chua du push dx inc cx cmp ax,0 je Xuat jmp X1 Xuat: pop ax cmp al,9 jg x_chu or al,30h jmp in_ra x_chu: add al,55 in_ra: mov ah,14 int 10h loop Xuat pop_reg ret xuatlucphan endp xuatnhiphan proc ;input= bx chua so push_reg mov cx,16 X1_1: rcl bx,1 jc inkt1 inkt '0' jmp thoat_1 inkt1: inkt '1' thoat_1: loop X1_1 pop_reg ret xuatnhiphan endp dao_bit proc ;input: bx chua so can dao bit ;output : sau khi dao so dc luu bao bien daobit

push_reg mov bx,so xor dx,dx rol bx,2 and bx,0003h push bx mov bx,so ror bx,2 and bx,0C000h push bx mov bx,so and bx,3FFCh pop dx or bx,dx pop dx or bx,dx mov daobit,bx pop_reg ret dao_bit endp xuatbatphan proc ;input= bx chua so push_reg mov ax,bx mov bx,8 xor cx,cx X1_2: xor dx,dx div bx;ax chua thuong,dx chua du push dx inc cx cmp ax,0 je Xuat_2 jmp X1_2 Xuat_2: pop ax or al,30h mov ah,14 int 10h loop Xuat pop_reg ret xuatbatphan endp code ends end main

8/Channgatngaythangnam PUSH_REG MACRO PUSH AX PUSH BX PUSH CX PUSH DX PUSH_REG ENDM POP_REG MACRO POP DX POP CX POP BX POP AX POP_REG ENDM INXAU MACRO XAU PUSH_REG MOV AH,9 LEA DX,XAU INT 21H POP_REG INXAU ENDM CSEG SEGMENT ASSUME CS: CODE, DS: DATA, SS: STACK ORG 100H BEGIN: JMP MAIN ;================= MAU DB 13 SO DB 0 ;================= MAIN: ;dat ISRNEW vao PUSH CS POP DS LEA DX,ISRNEW MOV AH,25H MOV AL,1CH INT 21H MOV AH,0 INT 16H ;MAIN ENDP ISRNEW PROC PUSH CS POP DS ;IN NGAY THANG NAM ;DAT GIUA MAN HINH MOV AX,0B7FFH MOV ES,AX MOV DI,1024 ;LAY NGAY HE THONG MOV AH,2AH INT 21H XOR AX,AX MOV AX,CX PUSH AX XOR AX,AX

MOV AL,DH PUSH AX

;THANG

XOR AX,AX MOV AL,DL ;NGAY PUSH AX ;------POP AX CALL INNGAY ;IN NGAY CALL INGACH POP AX CALL INNGAY CALL INGACH ;IN THANG

POP AX CALL INNGAY ;IN NAM ;IN GIO PHUT GIAY PRINT: ;DAT GIUA MAN HINH MOV AX, 0B841H MOV ES,AX MOV DI,0 ;LAY GIO HE THONG MOV AH,2CH INT 21H XOR AH,AH MOV AL,DH ;cat giay PUSH AX MOV AL,CL ;cat phut PUSH AX MOV AL,CH ;cat gio ;------CALL INGIO CALL IN2CH POP AX CALL INGIO CALL IN2CH POP AX CALL INGIO JMP PRINT IRET ISRNEW ENDP INNGAY PROC MOV BX,10 PUSH BX CHIA: CMP AL,0 JE INRA MOV DX,0 DIV BX PUSH DX JMP CHIA INRA: POP AX CMP AX,10 JE THOAT MOV AH,13 ADD AL,30H

;NAM

MOV WORD PTR ES:[DI],AX ADD DI,2 JMP INRA THOAT: RET INNGAY ENDP INGIO PROC PUSH AX XOR DX,DX XOR AH,AH MOV BX,10 DIV BX PUSH DX OR AL,30H MOV AH,MAU MOV WORD PTR ES:[DI],AX ADD DI,2 POP AX OR AL,30H MOV AH,MAU MOV WORD PTR ES:[DI],AX ADD DI,2 POP AX RET INGIO ENDP IN2CH PROC PUSH AX MOV AL,':' MOV AH,MAU MOV WORD PTR ES:[DI],AX ADD DI,2 POP AX RET IN2CH ENDP INGACH PROC PUSH AX MOV AL,'/' MOV AH,MAU MOV WORD PTR ES:[DI],AX ADD DI,2 POP AX RET INGACH ENDP END MAIN CSEG ENDS