masm programs

Electronics Saturday, October 27, 2007 8086 PROGRAMS USING MASM 5.1 ; Program to separate an array of N numbers into Even and Odd ; numbers and find their respective sums. Assume memory operands. .MODEL SMALL .DATA ARRAY DB 50H DUP(?) ARRAY_COUNT DB 0AH EVEN_ARRAY DB 50H DUP(?) ODD_ARRAY DB 50H DUP(?) EVEN_SUM DW ? ODD_SUM DW ? .CODE MOV AX,@DATA MOV DS,AX LEA SI,ARRAY LEA DI,EVEN_ARRAY LEA BX,ODD_ARRAY UP: MOV AL,BYTE PTR[SI] MOV AH,AL RCR AL,01H JC ODD MOV BYTE PTR[DI],AH ADD CL,AH ADC CH,00H INC DI JMP NEXT ODD: MOV BYTE PTR[BX],AH ADD DL,AH ADC DH,00H INC BX NEXT: INC SI DEC ARRAY_COUNT JNZ UP MOV EVEN_SUM,CX MOV ODD_SUM,DX MOV AH,04CH INT 21H END ; Factorial of an 8 bit number. Using procedure. Number read from keyboard. ; Re sult stored in memory. .MODEL SMALL DISPLAY MACRO MSG CLD MOV DX,OFFSET MSG MOV AH,09H INT 21H ENDM .DATA MSG1 DB 10,13," ENTER A NUMBER : $" MSG2 DB 10,13," OUT OF RANGE $" NUM DB ? RESULT DW 02H DUP(?) .CODE MOV AX,@DATA MOV DS,AX DISPLAY MSG1 MOV AH,01H INT 21H

MOV NUM,AL CALL ASCII_TO_HEX CMP AL,0CH JA L1 CALL FACTORIAL JMP L2 ASCII_TO_HEX PROC NEAR MOV AL,NUM CMP AL,39H JA S1 SUB AL,30H JMP S2 S1: SUB AL,37H S2: MOV NUM,AL RET FACTORIAL PROC NEAR XOR AX,AX XOR DX,DX XOR BX,BX XOR CX,CX MOV AL,NUM MOV BL,AL CMP AL,01H JBE NEXT2 DEC BX UP: MOV CX,AX MOV AX,DX MUL BX XCHG AX,CX MUL BX ADD DX,CX DEC BX JNZ UP MOV RESULT,AX MOV RESULT+2,DX JMP LAST NEXT2: MOV RESULT,0001H MOV RESULT+2,0000H LAST: RET L1: DISPLAY MSG2 L2: MOV AH,04CH INT 21H END ; Factorial using Recursive procedure. .MODEL SMALL DISPLAY MACRO MSG CLD MOV DX,OFFSET MSG MOV AH,09H INT 21H ENDM .STACK .DATA MSG1 DB 10,13," ENTER A NUMBER : $" MSG2 DB 10,13," OUT OF RANGE $" NUM DB ? RESULT DW 02H DUP(?) .CODE MOV AX,@DATA MOV DS,AX

DISPLAY MSG1 MOV AH,01H INT 21H MOV NUM,AL CALL ASCII_TO_HEX MOV BL,NUM CMP BL,0CH JA INVALID XOR AX,AX XOR DX,DX MOV AX,0001H CMP BL,01H JB NEXT CALL FACT NEXT: MOV RESULT,AX ; LOWER WORD FROM AX MOV RESULT+2,DX ; HIGHER WORD FROM DX JMP EXIT ASCII_TO_HEX PROC NEAR MOV AL,NUM CMP AL,39H JA S1 SUB AL,30H JMP S2 S1: SUB AL,37H S2: MOV NUM,AL RET FACT PROC NEAR CMP BL,01H JZ L1 PUSH BX DEC BX CALL FACT POP BX MOV CX,AX MOV AX,DX XOR DX,DX MUL BX XCHG AX,CX MUL BX ADD DX,CX RET L1: MOV AX,0001H RET INVALID:DISPLAY MSG2 EXIT: MOV AH,04CH INT 21H END ; LCM and GCD of two 16 bit numbers. Display results on screen. Numbers are ; st ored in memory. .MODEL SMALL DISPLAY MACRO MSG MOV DX,OFFSET MSG MOV AH,09H INT 21H ENDM .DATA NUM1 DW ? NUM2 DW ? LCM DW 02H DUP(?) GCD DW ?

MSG1 DB 10,13," THE LCM OF THE TWO NUMBERS IS : $" MSG2 DB 10,13," THE GCD OF THE TWO NUMBERS IS : $" LCM_DISPLAY DB 08H DUP(?) DB '$' GCD_DISPLAY DB 04H DUP(?) DB '$' .CODE MOV AX,@DATA MOV DS,AX XOR AX,AX CALL LCM_PROCEDURE CALL GCD_PROCEDURE LEA SI,LCM+3 LEA DI,LCM_DISPLAY MOV CH,04H BACK: MOV AL,BYTE PTR[SI] CALL HEX_TO_ASCII MOV BYTE PTR[DI],AH INC DI MOV BYTE PTR[DI],AL DEC SI INC DI DEC CH JNZ BACK MOV AL,GCD+1 CALL HEX_TO_ASCII MOV GCD_DISPLAY,AH MOV GCD_DISPLAY+1,AL MOV AL,GCD CALL HEX_TO_ASCII MOV GCD_DISPLAY+2,AH MOV GCD_DISPLAY+3,AL DISPLAY MSG1 DISPLAY LCM_DISPLAY DISPLAY MSG2 DISPLAY GCD_DISPLAY JMP EXIT LCM_PROCEDURE PROC NEAR XOR DX,DX MOV AX,NUM1 MOV BX,NUM2 CMP AX,BX JAE L1 XCHG AX,BX L1: MOV CX,AX UP: MOV LCM,AX MOV LCM+2,DX DIV BX CMP DX,0000H JZ L2 MOV AX,LCM MOV DX,LCM+2 ADD AX,CX ADC DX,0000H JMP UP L2: RET GCD_PROCEDURE PROC NEAR XOR AX,AX XOR BX,BX XOR CX,CX

XOR DX,DX MOV AX,NUM1 MOV BX,NUM2 CMP AX,BX JAE G1 XCHG AX,BX G1: XOR DX,DX MOV CX,AX DIV BX CMP DX,0000H JZ G2 MOV AX,BX MOV BX,DX JMP G1 G2: MOV GCD,BX RET HEX_TO_ASCII PROC NEAR MOV AH,AL MOV CL,04H ROR AH,CL AND AH,0FH CMP AH,09H JBE H1 ADD AH,37H JMP H2 H1: ADD AH,30H H2: AND AL,0FH CMP AL,09H JBE H3 ADD AL,37H JMP H4 H3: ADD AL,30H H4: RET EXIT: MOV AH,04CH INT 21H END -------------------------------------------------------------------------------------------------------------------------------------------------------; CODE TO CHECK IF A STRING IS PALINDROME OR NOT WITHOUT USING ; STRING INSTRUCTIONS .MODEL SMALL DISPLAY MACRO MSG MOV DX,OFFSET MSG CLD MOV AH,09H INT 21H ENDM .DATA MSG1 DB 10,13," ENTER A STRING : $" MSG2 DB 10,13," PALINDROME $" MSG3 DB 10,13," NOT A PALINDROME $" BUFFER DB 50H DB ? DB 50H DUP(?) .CODE MOV AX,@DATA MOV DS,AX DISPLAY MSG1 MOV DX,OFFSET BUFFER CLD MOV AH,0AH

INT 21H MOV AL,BUFFER+1 MOV CL,AL MOV BL,02H XOR AH,AH DIV BL RCR CL,01H JNC NEXT INC AL NEXT: MOV CL,AL XOR CH,CH LEA DI,BUFFER+1 LEA SI,BUFFER+2 MOV AL,BUFFER+1 XOR AH,AH ADD DI,AX UP: MOV AL,BYTE PTR[SI] CMP AL,BYTE PTR[DI] JNZ INVALID INC SI DEC DI LOOP UP DISPLAY MSG2 JMP EXIT INVALID: DISPLAY MSG3 EXIT: MOV AH,04CH INT 21H END ; PALINDROME USING STRING INSTRUCTIONS DISPLAY MACRO MSG MOV DX,OFFSET MSG CLD MOV AH,09H INT 21H ENDM DATA SEGMENT MSG1 DB 10,13," ENTER A STRING : $" MSG2 DB 10,13," PALINDROME $" MSG3 DB 10,13," NOT A PALINDROME $" BUFFER DB 50H DB ? DB 50H DUP(?) DATA ENDS EXTRA SEGMENT INVERT DB 50H DUP(?) EXTRA ENDS CODE SEGMENT ASSUME DS:DATA,ES:EXTRA,CS:COD DS:DATA,ES:EXTRA,CS:CODE E BEGIN: MOV AX,DATA MOV DS,AX MOV BX,DATA MOV ES,BX XOR AX,AX XOR BX,BX DISPLAY MSG1 MOV DX,OFFSET BUFFER CLD MOV AH,0AH INT 21H XOR CX,CX

MOV CL,BUFFER+1 LEA SI,BUFFER+1 ADD SI,CX LEA DI,INVERT UP: MOV AL,BYTE PTR[SI] MOV BYTE PTR[DI],AL DEC SI INC DI LOOP UP XOR CX,CX MOV CL,BUFFER+1 LEA SI,BUFFER+2 LEA DI,INVERT CLD REPZ CMPSB JNZ INVALID DISPLAY MSG2 JMP EXIT INVALID: DISPLAY MSG3 EXIT: MOV AH,04CH INT 21H CODE ENDS END BEGIN -------------------------------------------------------------------------------------------------------------------------------------------------------; ACCEPTS A STRING AND A CHARACTER FROM THE USER AND DISPLAYS THE COUNT ; AND THE POSITION OF THE CHARACTER. .MODEL SMALL DISPLAY MACRO MSG MOV DX,OFFSET MSG CLD MOV AH,09H INT 21H ENDM .DATA BUFFER DB 50H DB ? DB 50H DUP(?) POSITION_ARRAY DB 50H DUP(?) POSITION_ARRAY_DISPLAY DB 50H DUP(?) COUNT DB ? DB ? DB '$' MSG1 DB 10,13," ENTER A STRING : $" MSG2 DB 10,13," ENTER THE CHARACTER : $" MSG3 DB 10,13," THE COUNT OF THE GIVEN CHARACTER IS : $" MSG4 DB 10,13," AND THE POSITION(S) ARE : $" MSG5 DB 10,13," CHARACTER NOT FOUND $" .CODE MOV AX,@DATA MOV DS,AX DISPLAY MSG1 MOV DX,OFFSET BUFFER CLD MOV AH,0AH INT 21H DISPLAY MSG2 CLD MOV AH,01H INT 21H MOV BL,AL ; CHARACTER IN BL

MOV BH,BUFFER+1 ; STRING LENGTH IN BH XOR CX,CX LEA DI,POSITION_ARRAY LEA SI,BUFFER+2 MOV CL,01H ; POSITION IN CL REGISTER UP: CMP BL,BYTE PTR[SI] JNZ NEXT INC CH ; INCREMENT COUNT (COUNT IN CH REGISTER ) MOV BYTE PTR[DI],CL INC DI NEXT: INC CL INC SI DEC BH JNZ UP CMP CH,01H JB NOTFOUND MOV AL,CH CALL HEX_TO_ASCII MOV COUNT,AH MOV COUNT+1,AL DISPLAY MSG3 DISPLAY COUNT MOV DH,CH LEA SI,POSITION_ARRAY LEA DI,POSITION_ARRAY_DISP DI,POSITION_ARRAY_DISPLAY LAY UP2: MOV AL,BYTE PTR[SI] CALL HEX_TO_ASCII MOV BYTE PTR[DI],AH INC DI MOV BYTE PTR[DI],AL INC DI MOV BYTE PTR[DI],20H INC DI INC SI DEC DH JNZ UP2 MOV BYTE PTR[DI],'$' DISPLAY MSG4 DISPLAY POSITION_ARRAY_DISPLAY JMP EXIT HEX_TO_ASCII PROC NEAR PUSH CX XOR CX,CX MOV AH,AL MOV CL,04H ROR AH,CL AND AH,0FH CMP AH,09H JBE H1 ADD AH,37H JMP H2 H1: ADD AH,30H H2: AND AL,0FH CMP AL,09H JBE NEXT2 ADD AL,37H JMP NEXT3 NEXT2: ADD AL,30H NEXT3: POP CX RET

NOTFOUND: DISPLAY MSG5 EXIT: MOV AH,04CH INT 21H END ; THIS PROGRAM ACCEPTS A STRING AND GIVES DETAILS ABOUT THE INDIVIDUAL AND ; TOTAL NUMBER OF VOWELS. .MODEL SMALL DISPLAY MACRO MSG CLD MOV DX,OFFSET MSG MOV AH,09H INT 21H ENDM .DATA BUFFER DB 50H DB ? DB 50H DUP(?) MSG1 DB 10,13," ENTER A STRING : $" MSG2 DB 10,13," THE VOWELS ARE : $" MSG3 DB 10,13," A = $" MSG4 DB 10,13," E = $" MSG5 DB 10,13," I = $" MSG6 DB 10,13," O = $" MSG7 DB 10,13," U = $" MSG8 DB 10,13," TOTAL COUNT = $" A DB ? DB ? DB '$' E DB ? DB ? DB '$' I DB ? DB ? DB '$' O DB ? DB ? DB '$' U DB ? DB ? DB '$' TOTAL_COUNT DB ? DB ? DB '$' .CODE MOV AX,@DATA MOV DS,AX DISPLAY MSG1 CLD MOV DX,OFFSET BUFFER MOV AH,0AH INT 21H MOV BL,BUFFER+1 ; STORE STRING LENGTH IN BL REGISTER CALL COMPARE MOV AL,A CALL HEX_TO_ASCII MOV A,AH MOV A+1,AL MOV AL,E CALL HEX_TO_ASCII MOV E,AH

MOV E+1,AL MOV AL,I CALL HEX_TO_ASCII MOV I,AH MOV I+1,AL MOV AL,O CALL HEX_TO_ASCII MOV O,AH MOV O+1,AL MOV AL,U CALL HEX_TO_ASCII MOV U,AH MOV U+1,AL MOV AL,TOTAL_COUNT CALL HEX_TO_ASCII MOV TOTAL_COUNT,AH MOV TOTAL_COUNT+1,AL DISPLAY MSG2 DISPLAY MSG3 DISPLAY A DISPLAY MSG4 DISPLAY E DISPLAY MSG5 DISPLAY I DISPLAY MSG6 DISPLAY O DISPLAY MSG7 DISPLAY U DISPLAY MSG8 DISPLAY TOTAL_COUNT JMP EXIT COMPARE PROC NEAR LEA SI,BUFFER+2 UP6: MOV AL,BYTE PTR[SI] CMP AL,'A' JNZ NEXT UP: INC A INC TOTAL_COUNT JMP AHEAD NEXT: CMP AL,'a' JNZ AHEAD JMP UP AHEAD: CMP AL,'E' JNZ NEXT2 UP2: INC E INC TOTAL_COUNT JMP AHEAD2 NEXT2: CMP AL,'e' JNZ AHEAD2 JMP UP2 AHEAD2: CMP AL,'I' JNZ NEXT3 UP3: INC I INC TOTAL_COUNT JMP AHEAD3 NEXT3: CMP AL,'i' JNZ AHEAD3 JMP UP3 AHEAD3: CMP AL,'O' JNZ NEXT4

UP4: INC O INC TOTAL_COUNT JMP AHEAD4 NEXT4: CMP AL,'o' JNZ AHEAD4 JMP UP4 AHEAD4: CMP AL,'U' JNZ NEXT5 UP5: INC U INC TOTAL_COUNT JMP AHEAD5 NEXT5: CMP AL,'u' JNZ AHEAD5 JMP UP5 AHEAD5: INC SI DEC BL JNZ UP6 RET HEX_TO_ASCII PROC NEAR MOV AH,AL AND AH,0F0H ;UNPACK HIGHER BYTE MOV CL,04H ROR AH,CL CMP AH,09H JBE L1 ADD AH,37H JMP L2 L1: ADD AH,30H L2: AND AL,0FH CMP AL,09H JBE L3 ADD AL,37H JMP L4 L3: ADD AL,30H L4: RET EXIT: MOV AH,04CH INT 21H END -------------------------------------------------------------------------------------------------------------------------------------------------------; Program to multiply two matrices where each element of the matrices ; is a byte. product is 16 bit. Read the order of the matrices from ; keyboard. .MODEL SMALL DISPLAY MACRO MSG MOV DX,OFFSET MSG MOV AH,09H INT 21H ENDM .DATA MSG1 DB 10,13," ENTER DIMENSIONS OF MATRIX_1 IN ROW*COLUMN FORMAT : $" MSG2 DB 10,13," ENTER DIMENSIONS OF MATRIX_2 IN ROW*COLUMN FORMAT : $" MSG3 DB 10,13," ENTER THE ELEMENTS OF MATRIX_1 IN XX FORMAT : $" MSG4 DB 10,13," ENTER THE ELEMENTS OF MATRIX_2 IN XX FORMAT : $" MSG_INVALID DB 10,13," DIMENSION ERROR $" CLEAR DB 10,13," $" M1 DB ? N1 DB ? M2 DB ? N2 DB ? M3 DB ?

N3 DB ? MAT1 DB 50H DUP(?) MAT2 DB 50H DUP(?) MAT3 DB 50H DUP(?) COMMON_COUNT DB ? ROW_COUNT DB ? X DW 0000H Y DW 0000H .CODE MOV AX,@DATA MOV DS,AX XOR AX,AX DISPLAY MSG1 DISPLAY CLEAR MOV AH,01H INT 21H CALL ASCII_TO_HEX MOV M1,AL MOV DL,'*' MOV AH,02H INT 21H XOR DX,DX MOV AH,01H INT 21H CALL ASCII_TO_HEX MOV N1,AL DISPLAY MSG2 DISPLAY CLEAR MOV AH,01H INT 21H CALL ASCII_TO_HEX MOV M2,AL MOV DL,'*' MOV AH,02H INT 21H XOR DX,DX MOV AH,01H INT 21H CALL ASCII_TO_HEX MOV N2,AL XOR AX,AX MOV AL,N1 CMP AL,M2 JNZ INVALID XOR AX,AX XOR BX,BX XOR CX,CX XOR DX,DX MOV AL,M1 MOV M3,AL MOV AL,N2 MOV N3,AL LEA SI,MAT1 LEA DI,MAT2 LEA BX,MAT3 MOV DL,N2 MOV AL,N3 MOV ROW_COUNT,AL ; STORE THE VALUE OF N3 IN ROW_COUNT TOP: MOV Y,0000H ; RESET THE VALUE OF Y MOV AL,ROW_COUNT ; RELOAD THE VALUE OF N3

MOV N3,AL UP: XOR CX,CX CALL MAT_MULT LEA SI,MAT1 LEA DI,MAT2 INC Y ADD DI,Y ADD SI,X DEC N3 JNZ UP LEA SI,MAT1 LEA DI,MAT2 XOR AX,AX MOV AL,N1 ADD X,AX ADD SI,X DEC M3 JNZ TOP JMP EXIT INVALID:JMP WRONG MAT_MULT PROC NEAR MOV AL,N1 MOV COMMON_COUNT,AL BACK: MOV AL,BYTE PTR[SI] MUL BYTE PTR[DI] ADC CX,AX INC SI ADD DI,DX DEC COMMON_COUNT JNZ BACK MOV WORD PTR[BX],CX INC BX INC BX RET ASCII_TO_HEX PROC NEAR CMP AL,39H JA L1 SUB AL,30H JMP L2 L1: SUB AL,37H L2: RET WRONG: DISPLAY MSG_INVALID EXIT: MOV AH,4CH INT 21H END ; Password authentication using String instructions. DISPLAY MACRO MSG CLD MOV DX,OFFSET MSG MOV AH,09H INT 21H ENDM DATA SEGMENT MSG1 DB 10,13," ENTER PASSWORD : $" MSG2 DB 10,13," ACCESS GRANTED $" MSG3 DB 10,13," ACCESS DENIED $" PASSWORD DB "SHARAD$" PASSWORD_LENGTH DB 06H DATA ENDS EXTRA SEGMENT

BUFFER DB 50H DB ? DB 50H DUP(?) EXTRA ENDS CODE SEGMENT ASSUME DS:DATA,ES:EXTRA,CS:COD DS:DATA,ES:EXTRA,CS:CODE E MOV AX,DATA MOV DS,AX MOV BX,DATA MOV ES,BX XOR AX,AX XOR BX,BX DISPLAY MSG1 MOV DX,OFFSET BUFFER CLD MOV AH,0AH INT 21H LEA SI,PASSWORD LEA DI,BUFFER+2 MOV CL,PASSWORD_LENGTH CMP CL,BUFFER+1 JNZ INVALID REPE CMPSB JNZ INVALID DISPLAY MSG2 JMP EXIT INVALID:DISPLAY MSG3 EXIT: MOV AH,04CH INT 21H CODE ENDS END -------------------------------------------------------------------------------------------------------------------------------------------------------; THIS PROGRAM READS AND IMPLEMENTS SYSTEM TIME USE DOS SERVICES. .MODEL SMALL DISPLAY MACRO MSG CLD MOV DX,OFFSET MSG MOV AH,09H INT 21H ENDM .DATA TIME DB ? DB ? DB ':' DB ? DB ? DB ':' DB ? DB ? DB '$' CLEAR DB 08H DUP(08H) DB '$' HOUR DB ? MIN DB ? SEC DB ? MSG1 DB 10,13," THE CURRENT TIME IS : $" D1 DW ? D2 DW ? .CODE MOV AX,@DATA

MOV DS,AX DISPLAY MSG1 UP: MOV AH,02CH INT 21H MOV HOUR,CH MOV MIN,CL MOV SEC,DH MOV AL,HOUR CALL HEX_TO_BCD CALL BCD_TO_ASCII MOV TIME,AL MOV TIME+1,AH MOV AL,MIN CALL HEX_TO_BCD CALL BCD_TO_ASCII MOV TIME+3,AL MOV TIME+4,AH MOV AL,SEC CALL HEX_TO_BCD CALL BCD_TO_ASCII MOV TIME+6,AL MOV TIME+7,AH DISPLAY TIME CALL DELAY DISPLAY CLEAR JMP UP HEX_TO_BCD PROC NEAR XOR AH,AH XOR BL,BL MOV BL,0AH DIV BL ; AL= HIGHER UNPACKED BCD = QUOTIENT RET ; AH= LOWER UNPACKED BCD = REMAINDER BCD_TO_ASCII PROC NEAR ADD AX,3030H RET DELAY PROC NEAR MOV D1,0050H L2: MOV D2,0FFFH L1: DEC D2 JNZ L1 DEC D1 JNZ L2 RET EXIT: MOV AH,04CH INT 21H END ; Implementation of 16 bit counter. Counter being displayed on the ; screen .MODEL SMALL DISPLAY MACRO MSG MOV DX,OFFSET MSG MOV AH,09H INT 21H ENDM .DATA DISPLAY_ARRAY DB 04H DUP(?) DB '$' CLEAR DB 04H DUP(08H) DB '$' D1 DW ?

D2 DW ? .CODE MOV AX,@DATA MOV DS,AX XOR AX,AX XOR BX,BX UP: MOV AL,BH CALL HEX_TO_ASCII MOV DISPLAY_ARRAY,AH MOV DISPLAY_ARRAY+1,AL MOV AL,BL CALL HEX_TO_ASCII MOV DISPLAY_ARRAY+2,AH MOV DISPLAY_ARRAY+3,AL DISPLAY DISPLAY_ARRAY CALL DELAY DISPLAY CLEAR INC BX CMP BX,00FFH JNZ UP JMP EXIT HEX_TO_ASCII PROC NEAR MOV AH,AL MOV CL,04H ROR AH,CL AND AH,0FH CMP AH,09H JBE NEXT1 ADD AH,37H JMP NEXT2 NEXT1: ADD AH,30H NEXT2: AND AL,0FH CMP AL,09H JBE NEXT3 ADD AL,37H JMP NEXT4 NEXT3: ADD AL,30H NEXT4: RET DELAY PROC NEAR MOV D1,0050H L2: MOV D2,0FFFH L1: DEC D2 JNZ L1 DEC D1 JNZ L2 RET EXIT: MOV AH,04CH INT 21H END ; Generation of first N prime numbers. .MODEL SMALL .DATA ARRAY DB 01H DB 02H DB 50H DUP(?) N DB 0FFH .CODE MOV AX,@DATA MOV DS,AX XOR AX,AX

LEA SI,ARRAY+2 MOV CX,0003H TOP: MOV BL,02H UP: MOV AX,CX DIV BL CMP AH,00H JZ INVALID INC BL CMP BL,CL JB UP MOV BYTE PTR[SI],CL INC SI INC DL ; TO STORE THE COUNT INVALID:INC CL CMP DL,N JNZ TOP MOV AH,04CH INT 21H END Posted by Skywalker at 12:47 PM Labels: PROGRAMS No comments: Post a Comment Newer Post Older Post Home Subscribe to: Post Comments (Atom) Blog Archive â¢ â¼ 2007 (4) o âº December (1) o â¼ October (2) ï§ AMD BARCELONA DIE ï§ 8086 PROGRAMS USING MASM 5.1 o âº August (1) About Me View my complete profile