COAL MANUAL 2023

COMPUTER ORG AND

ASSEMBLY LANGUAGE

SUBMITTED TO: MA’AM MEHWISH

CLASS : BSCS-3RD/A
GROUP 03 :
SUBMITTED BY:
(GUL-E-RANA 17)
SEHAR IJAZ 88
NIMRA SALEEM 14
ASHFA FATIMA 82
ALISHBA SHAHID 1
SUMIA 13
AMNA IKHLAQ 8
WAJEEHA BHATTI 93
BISMA BHATTI 92
IQRA JAMIL 11
NOOR-UL-AIN 91
TABLE OF CONTENT:
WEEK:01
MOV STATEMENTS:
1. WRITE A PROGRAM IN EMULATOR 8086 TO (MOV) STORE A VALUE
IN THE EMULATOR REGISTER.
2. WRITE A ASSEMBLY PROGRAM THAT STORES TWO
DIFFERENT VALUES IN TWO DIFFERENT REGISTERS (AX) AND
(BX):
3. WRITE A PROGRAM IN EMULATOR 8086 TO STORE DIFFERENT
VALUES IN THE GENERAL PURPOSE REGISTERS:
ADD STATEMENTS:
4. WRITE AN ASSEMBLY LANGUAGE PROGRAM IN EMULATOR 8086 TO
IMPLEMENT TWO ADDRESSING MODE. IMPLEMENTING ADDITION
AND SUBTRACTION:
WEEK:02
1. CALCULATING EXPRESSION ON CALCULATOR.
2. CONVERT THE FOLLOWING USING BASE CONVERTER.
3. EXECUTE THE FOLLOWING INSTRUCTION IN EMU8086 AND
MENTION THE CHANGES IN THE CONTENTS OF DESTINATION
REGISTERS.
WEEK:03
1. EXECUTE THE FOLLOWING INSTRUCTIONS (SINGLE-STEP) IN
EMU8086 AND MENTION THE CHANGES IN CONTENTS OF
DESTINATION OPERAND.
2. NOW EXECUTE THE FOLLOWING INSTRUCTION IN EMU8086 AND
OBSERVE THE CHANGES IN THE CONTENTS OF DESTINATION
OPERAND. IF ANY INSTRUCTION GIVES AN ERROR, CORRECT THAT
ERROR.
3. FOR EACH OF THE FOLLOWING ASSEMBLY LANGUAGE
INSTRUCTIONS, WHAT WILL BE THE POSSIBLE REGISTER VALUE (IN
HEX)? ASSUME ALL STATEMENTS ARE BEING EXECUTED IN A
SEQUENCE AND INITIALLY ALL REGISTERS CONTAIN ZERO.
WEEK:04
1. WRITE AN ASSEMBLY PROGRAM THAT PRINTS “HELLO WORLD”.
2. WRITE AN ASSEMBLY PROGRAM TO PRINT YOUR FIRST NAME ,
LAST NAME , CLASS, SEMESTER.
 3. WRITE AN ASSEMBLY PROGRAM TO ADD 3 NUMBERS
USING REGISTERS.
4. WRITE AN ASSEMBLY PROGRAM TO ADD 2 NUMBERS
USING REGISTERS.
WEEK:05
1. WRITE AN ASSEMBLY PROGRAM THAT READS CHARACTER
FROM USER, STORE IT AND PRINT IT ON SCREEN.
2. WRITE AN ASSEMBLY PROGRAM THAT TAKES AN
UPPERCASE LETTER AND CONVERT IT INTO LOWERCASE
LETTER.
WEEK:06
1. WRITE AN ASSEMBLY PROGRAM THAT MOVES AX,2001H
PREDICT OUTPUT AND OBSERVE FLAGS.
2.MAKE A TABLE FOR FOLLOWING INSTRUCTION AND OBSERVE
THE FLAGS AFTER PREDICTING OUTPUT.
3.PREDICT THE OUTPUT OF THE FOLLOWING CODE AND MAKE A
TABLE FOR OBSERVING FLAGS.
4.WRITE AN ASSEMBLY PROGRAM TO ADD THREE NUMBERS
AND OBSERVE FLAGS.
5.WRITE AN ASSEMBLY PROGRAM TO PRINT YOUR BIO_DATA
ON SCREEN.
7. 2+2+3+1+1=9 WAP TO PRINT THE OUTPUT.
8. WRITE A PROGRAM TO PRINT YOUR NAME’S SINGLE CHARACTER
IN ONE LINE.
WEEK:07
WRITE A PROGRAM TO (A) DISPLAY A "?", (B) READ TWO DECIMAL
DIGITS WHO.SE SUM "IS LESS THAN 10, (C) DISPLAY THEM AND THEIR
SUM ON THE NEXT LINE, WITH AN APPROPRIATE MESSAGE.
WEEK:08
WEEK:09
QUESTION NO: 08 TO 12 FROM BOOK CHAP#04
WEEK:10
WEEK:11
WEEK:12
WEEK:13
 WEEK: 01
EMULATOR 8086

INTERFACE OF EMULATOR
WRITE A PROGRAM IN EMULATOR 8086 TO (MOV)
STORE A VALUE IN THE EMULATOR REGISTER.
2. WRITE A ASSEMBLY PROGRAM THAT STORES TWO
DIFFERENT VALUES IN TWO DIFFERENT
REGISTERS (AX) AND (BX):
3. WRITE A PROGRAM IN EMULATOR 8086 TO STORE
DIFFERENT VALUES IN THE GENERAL
PURPOSE REGISTERS:
4. WRITE AN ASSEMBLY LANGUAGE PROGRAM IN
EMULATOR 8086 TO IMPLEMENT TWO ADDRESSING
MODE. IMPLEMENTING ADDITION AND
SUBTRACTION:
 WEEK: 02
CALCULATOR

1. CALCULATING EXPRESSION ON CALCULATOR.

2. 2CH + 2

3. 9EH + 4DH
4. 9AH + 1CH

5. 8BH + 2CH

6. 4CH + 6AH
CONVERTOR

2. CONVERT THE FOLLOWING USING BASE CONVERTER.

1. BINARY TO OCTAL, DECIMAL , HEXADECIMAL

2. HEXADECIMAL TO BINARY, OCTAL AND DECIMAL.

3. OCTAL TO BINARY , HEXADECIMAL AND DECIMAL.
 3. EXECUTE THE FOLLOWING INSTRUCTION IN
EMU8086 AND MENTION THE CHANGES IN THE
CONTENTS OF DESTINATION REGISTERS.

SR. INSTRUCTION H L
NO.

1. MOV AX, ‘B’ 00 42

2. MOV AX, 42H 00 42

3. MOV AX, 42D 00 2A

4. MOV AX, 0100 0010B 03 AE

5. MOV AX, 123AH 12 3A

6. MOV AX, 0FE44H FE 44

WEEK: 03

1. EXECUTE THE FOLLOWING INSTRUCTIONS (SINGLE-

STEP) IN EMU8086 AND MENTION THE CHANGES IN
CONTENTS OF DESTINATION OPERAND.

1. MOV AX , ‘B’
2. MOV AX , 42H

3. MOV AX , 42D
4. MOV AX, 0100 0010B

5. MOV AX, 123AH

6. MOV AX, 0FE44H
 2. NOW EXECUTE THE FOLLOWING INSTRUCTION IN
EMU8086 AND OBSERVE THE CHANGES IN THE
CONTENTS OF DESTINATION OPERAND. IF ANY
INSTRUCTION GIVES AN ERROR, CORRECT THAT
ERROR.

SR.
NO. INSTRUCTION CHANGES HIGH LOW

1. MOV AL, 256 MOV AL, 255 00 FF

2. MOV AX, F1AB MOV AX, 0F1ABH F1 AB

3. MOV AH, 0100 0001B MOV AH, 0100 0001B 03 E9

4. MOV AL, AC3H MOV AL,0AC3H 0A C3

5. MOV 1234H, BX MOV BX,1234H 12 34

6. MOV DX, 33H MOV DX, 33H 00 33

7. MOV AX,-123 MOV AX,-123 FF 85

8. MOV BX, 123 MOV BX, 123 00 7B

9. MOV CX, ‘AB’ MOV CX, ‘AB’ 41 42

 3. FOR EACH OF THE FOLLOWING ASSEMBLY
LANGUAGE INSTRUCTIONS, WHAT WILL BE THE
POSSIBLE REGISTER VALUE (IN HEX)? ASSUME ALL
STATEMENTS ARE BEING EXECUTED IN A SEQUENCE
AND INITIALLY ALL REGISTERS CONTAIN ZERO.

SR. INSTRUCTIONS AX BX CX DX
NO AH AL BH BL CH CL DH DL
.
1. MOV AX, 010B 00 02 00 00 00 03 00 00
2. MOV BH, 10H 00 02 10 00 00 05 00 00
3. MOV CX, 10 00 02 10 00 00 0A 00 00
4. MOV DX, 1234H 00 02 10 00 00 0A 12 34
5. ADD DH, DL 00 02 10 00 00 0A 46 34
6. ADD AX, BX 10 02 10 00 00 0A 46 34
7. SUB CX, BX 10 02 10 00 F0 0A 46 34
8. SUB AH, DL DC 02 10 00 F0 0A 46 34
9. INC AX DC 03 10 00 F0 0A 46 34
10. INC BL DC 03 10 01 F0 0A 46 34
11. DEC DX DC 03 10 01 F0 0A 46 34
12. DEC CH DC 03 10 01 EF 0A 46 33

TASK

FIND OUT THE ASCII VALUE BY READING A CHARACTER FROM USER

AND NOTICE THE CHANGE IN REGISTERS?
 TASK 4

PRINT YOUR NAME ON THE SCREEN USING INSTRUCTIONS?

STEP 1:

WRITE INSTRUCTIONS TO READ AND WRITE ON SCREEN.

STEP 2:

EMULATE FIRST AND THEN RUN EACH OF THE SINGLE STEP.

STEP 3:

YOU WILL SEE YOUR NAME ON THE SCREEN AT THE END.

 WEEK: 04
1. WRITE AN ASSEMBLY PROGRAM THAT
PRINTS “HELLO WORLD”.

2. WRITE AN ASSEMBLY PROGRAM TO PRINT YOUR

FIRST NAME , LAST NAME , CLASS, SEMESTER.

ORG 100H
.DATA
FIRSTNAME DB "NAME=NIMRA SALEEM", 0DH, 0AH,'$'
FNAME DB "FATHER NAME=MUHAMMAD SALEEM", 0DH,
0DH, 0AH,'$'
CLASS DB "CLASS & SEMESTER=BSCS 3RD A",0DH,0AH,'$'
SUBJECT DB "SUBJECT=COAL",0DH,0AH,'$'
.CODE
MOV AX,@DATA
MOV DX,AX
MOV AH,09H
MOV DX,OFFSET FIRSTNAME
INT 21H

MOV DX,OFFSET FNAME

INT 21H

MOV DX,OFFSET CLASS

INT 21H

MOV DX,OFFSET SUBJECT

INT 21H

MOV AX,4C00H
INT 21H
RET
3. WRITE AN ASSEMBLY PROGRAM TO ADD 3
NUMBERS USING REGISTERS.
 AX BX CX DX

H L H L H L H
L
4C 00 00 0F 00 13 1
00

4. WRITE AN ASSEMBLY PROGRAM TO ADD 2

NUMBERS USING REGISTERS.

AX BX CX DX

H L H H H
L L L
4C 00 00 00 00
00 0E 00

WEEK: 05
1. READ A CHARACTER FROM USER, STORE IT AND PRINT ON SCREEN?

ORG 100H
.CODE

MAIN PROC

MOV AH,1

INT 21H

MOV BL,AL

MOV AH,2

MOV DL,0AH

INT 21H

MOV AH,2

MOV DL,BL

INT 21H

MOV AH,4CH

INT 21H

RET
INSTRUCTIONS AH AL BH BL CH CL DH DL
MOV AH,1 01 00 00 00 00 03 00 00
INT 21H 01 52 00 00 00 05 00 00
MOV BL,AL 01 52 00 52 00 07 00 00
MOV AH,2 02 52 00 52 00 09 00 00
MOV DL,0AH 02 52 00 52 00 0B 00 0L
INT 21H 02 0A 00 52 00 0D 00 0A
MOV AH,2 02 0A 00 52 00 00 00 0A
MOV DL,BL 02 0A 00 52 00 00 00 52
INT 21H 02 52 00 52 00 00 00 52
MOV AH,4CH 4C 52 00 52 00 00 00 52
INT 21H 4C 52 00 52 00 00 00 52
RET 4C 52 00 52 00 00 00 52
LAB TASK
2. TAKE UPPERCASE LETTER AND CONVRT IT INTO LOWERCASE LETTER AND DISPLAY ON
THE SCREEN?
ORG 100H

.DATA

MCG1 DB 'ENTER THE UPPERCASE',0AH,'$'

MCG2 DB 0AH,0DH,'CORRESPONDING LETTER

IS:' CHAR DB ?,'$'

.CODE

MAIN PROC

MOV AX,@DATA

MOV DS,AX

LEA DX,MCG1

MOV AH,9

INT 21H

MOV AH,1

INT 21H

ADD AL,32

MOV CHAR,AL
LEA DX,MCG2

MOV AH,9

INT 21H

MOV AH,4CH

INT 21H

MAIN ENDP

END MAIN

RET

INSTRUCTIONS AH AL BH BL CH CL DH DL
MOV AX,@DATA 07 00 00 00 00 00 00 00
MOV DS,AX 07 00 00 00 00 00 00 00
LEA DX,MCG1 07 00 00 00 00 00 01 02
MOV AH,9 09 00 00 00 00 00 01 02
INT 21H 09 24 00 00 00 00 01 02
MOV AH,1 01 24 00 00 00 00 01 02
INT 21H 01 45 00 00 00 00 01 02
ADD AL,32 01 65 00 00 00 00 01 02
MOV CHAR,AL 01 65 00 00 00 00 01 02
LEA DX,MCG2 01 65 00 00 00 00 01 16
MOV AH,9 09 65 00 00 00 00 01 16
INT 21H 09 24 00 00 00 00 01 16
MOV AH,4CH 4C 24 00 00 00 00 01 16
INT 21H 4C 24 00 00 00 00 01 16
MAIN ENDP 4C 24 00 00 00 00 01 16

OUTPUT:

LAB TASK

3. OBSERVE VARIATIONS IN REGISTERS & FLAGS?

FLAGS VARIATIONS

INSTRUCTIONS CF ZF SF OF PF AF IF DF
MOV AX,4000H 0 0 0 0 0 0 1 0
ADD AX,AX 0 0 0 0 0 0 1 0
SUB AX,0FFFFH 0 0 1 1 1 0 1 0
NEG AX 1 0 1 0 0 1 1 0
INC AX 1 0 0 0 1 1 1 0
MOV AH 1 0 1 1 1 1 1 0
INT 21H 1 0 1 1 1 1 1 0
WEEK 06
1.OBSERVE FLAGS BY MOVING 2001 IN AX REGISTER?
 FLAGS VARIATIONS

INSTRUCTIONS CF ZF SF OF PF AF IF DF
MOV AX,2001 0 0 0 0 0 0 1 0
ADD AX,AX 0 0 0 0 0 0 1 0
SUB AX,0FFFFH 0 0 0 0 0 0 1 0
NEG AX 1 0 0 0 1 1 1 0
INC AX 1 0 1 0 0 1 1 0
MOV AH 1 0 1 0 0 0 1 0
INT 21H 1 0 1 0 0 0 1 0

LAB TASK

LAB WORK

3. READ AN UPPERCASE LETTER (OMIT ERROR CHECKING), AND DISPLAY IT AT THE NEXT POSITION ON
THE SAME LINE IN LOWER CASE?

SOURCE CODE:

ORG 100H

.DATA

MCG1 DB 'ENTER THE UPPERCASE','$'

MCG2 DB 0AH,0DH,'CORRESPONDING LETTER

IS:' CHAR DB ?,'$'

.CODE
MAIN PROC

MOV AX,@DATA

MOV DS,AX

LEA DX,MCG1

MOV AH,9

INT 21H

MOV AH,1

INT 21H

ADD AL,32

MOV CHAR,AL

LEA DX,MCG2

MOV AH,9

INT 21H

MOV AH,4CH

INT 21H

MAIN ENDP

END MAIN

RET

OUTPUT:
3. MAKE A TABLE FOR FOLLOWING INSTRUCTION AND
OBSERVE THE FLAGS AFTER PREDICTING
OUTPUT.

INSTRUCTIO CF ZF SF OF PF AF IF DF
N
ADD AX,BX 1 0 1 0 0 1 0 0
ADD AL,BL 1 1 0 0 1 1 0 0
SUB AX,BX 0 0 0 1 1 1 0 0
INC AL 0 1 0 0 1 1 0 0
MOV AX,-5 0 0 0 0 0 0 0 0

4. WRITE AN ASSEMBLY PROGRAM TO ADD

THREE NUMBERS AND OBSERVE FLAGS.
ORG 100H
MOV AX,5
MOV BX,10
ADD AX,BX
MOV BX,15
ADD AX,BX
MOV AX,4CH
INT 21H
INSTRUCTIONS CF ZF SF OF PF AF IF DF
MOV AX,5 0 0 0 0 0 0 1 0
MOV BX,10 0 0 0 0 0 0 1 0
ADD AX,BX 0 0 0 0 0 0 1 0
MOV BX,15 0 0 0 0 1 0 1 0
ADD AX,BX 0 0 0 0 1 0 1 0
MOV AX,4CH 0 0 0 0 1 1 1 0
INT 21H 0 0 0 0 1 1 0 0

5. WRITE AN ASSEMBLY PROGRAM TO PRINT

YOUR BIO_DATA ON SCREEN.
ORG 100H
.DATA

FIRSTNAME DB "NAME:NIMRA SALEEM " ,0DH ,0AH,'$'

CLASS DB "CLASS :BSCS" ,0DH ,0AH ,'$'
SEMESTER DB "SEMESTER:3RD" ,0DH,0AH,'$'
SECTION DB "SECTION:A" ,0DH ,0AH,'$'
ROLLCALL DB "ROLL_NO:14", 0DH ,0AH ,'$'
.CODE

MOV AX,@DATA
MOV DX,AX
MOV AH,09H
MOV DX,OFFSET FIRSTNAME
INT 21H

MOV DX,OFFSET CLASS

INT 21H

MOV DX,OFFSET SEMESTER

INT 21H

MOV DX,OFFSET SECTION

INT 21H
MOV DX,OFFSET ROLLCALL
INT 21H
MOV AX, 4C00H
INT 21H

RET

6. WRITE A PROGRAM TO PRINT YOUR NAME’S

SINGLE CHARACTER IN ONE LINE.

ORG 100H

.MODEL SMALL

.CODE
MAIN PROC

MOV AH,1

INT 21H

MOV BL,AL

MOV AH,2

MOV DL,BL

INT 21H

MOV AH,4CH

INT 21H

MAIN ENDP

RET

OUTPUT:
9. WRITE AN ASSEMBLY LANGUAGE PROGRAM
TO DISPLAY YOUR SYSTEM’S DATE?
CODE:

;DECLARATION PART

.MODEL SMALL

.DATA

.CODE

START: MOV AX,@DATA

MOV DS,AX

;DAY PART

DAY:

MOV AH,2AH ; TO GET SYSTEM DATE

INT 21H

MOV AL,DL ; DAY IS IN

DL AAM

MOV BX,AX

CALL DISP

MOV DL,'/'

MOV AH,02H ; TO PRINT / IN DOS

INT 21H
 ;MONTH PART

MONTH:

MOV AH,2AH ; TO GET SYSTEM DATE

INT 21H

MOV AL,DH ; MONTH IS IN

DH AAM

MOV BX,AX

CALL DISP

MOV DL,'/' ; TO PRINT / IN DOS

MOV AH,02H

INT 21H

;YEAR PART

YEAR:

MOV AH,2AH ; TO GET SYSTEM DATE

INT 21H

ADD CX,0F830H ; TO NEGATE THE EFFECTS OF 16BIT VALUE,

MOV AX,CX ; SINCE AAM IS APPLICABLE ONLY FOR AL (YYYY ->

YY) AAM

MOV BX,AX

CALL DISP

;TO TERMINATE THE PROGRAM

MOV AH,4CH ; TO TERMINATE THE PROGRAM

INT 21H

;DISPLAY PART

DISP PROC

MOV DL,BH ; SINCE THE VALUES ARE IN BX, BH

PART ADD DL,30H ; ASCII ADJUSTMENT

MOV AH,02H ; TO PRINT IN

DOS INT 21H

MOV DL,BL ; BL PART

ADD DL,30H ; ASCII

ADJUSTMENT MOV AH,02H

; TO PRINT IN DOS

INT 21H

RET

DISP ENDP ; END DISP PROCEDURE

END START ; END OF MAIN

OUTPUT:
 WEEK: 07

1. WRITE A PROGRAM TO (A) DISPLAY A "?", (B) READ

TWO DECIMAL DIGITS WHO.SE SUM "IS LESS THAN
10, (C) DISPLAY THEM AND THEIR SUM ON THE NEXT
LINE, WITH AN APPROPRIATE MESSAGE.

ORG 100H

.MODEL SMALL
.DATA
MSG DB 0AH,0DH,'THE SUM OF '
C1 DB ?,' AND '
C2 DB ?,'$'
SUM DB ,'$'
.CODE
MAIN PROC
MOV AX,@DATA
MOV DS,AX

MOV AH,2
MOV DL,'?'
INT 21H

MOV AH,1
INT 21H
MOV C1,AL

INT 21H
MOV C2,AL

ADD AL,C1
SUB AL,30H
MOV SUM,AL

LEA DX,MSG
MOV AH,9
INT 21H

MOV AH,4CH
INT 21H

MAIN ENDP

RET
 2. WRITE A PROGRAM TO (A) PROMPT THE USER, (B)
READ FIRST, MIDDLE, AND LAST INITIALS OF A
PERSON'S NAME, AND (C) DISPLAY THEM DOWN THE
LEFT MARGIN.
CODE:
ORG 100H
.MODEL SAMLL
.DATA
MSG DB 0AH,0DH,'ENTER THREE INITIALS $'
C1 DB ?,0AH,0DH
C2 DB ?,0AH,0DH
C3 DB ?,'$'
.CODE
MAIN PROC
MOV AX,@DATA
MOV DS,AX

MOV AH,9
LEA DX,MSG
INT 21H

MOV AH,1
INT 21H
MOV C1,AL
INT 21H
MOV C2,AL

INT 21H
MOV C3,AL

MOV AH,2
MOV DL,0AH
INT 21H
MOV DL,0DH
INT 21H

MOV AH,9
LEA DX,C1
INT 21H

MOV AH,4CH
INT 21

END MAIN

RET
3. WRITE· A PROGRAM TO READ ONE OF THE HEX
DIGITS A-I', AND DISPLAY IT ON THE NEXT LINE
IN DECIMAL.
CODE:
ORG 100H

.MODEL SAMLL
.DATA
MSG DB 'ENTER A HEX DIGIT: $'
MSG_1 DB 'IT,S DEC VALUE IS: $',0DH,0AH
HEX DB ?,'$'
.CODE
MAIN PROC
MOV AX,@DATA ;INTIALIZING DS
MOV DS,AX

MOV AH,9
LEA DX,MSG ;LOAD AND DISPLAY
MSG INT 21H
MOV AH,1
INT 21H
MOV HEX,AL
SUB HEX,11H

MOV AH,9
LEA DX,MSG_1 ;LOAD AND DISPLAY MSG_1
INT 21H

MOV AH,2
MOV DL,31H
INT 21H

MOV DL,HEX
INT 21H

MOV AH,4CH
INT 21H

MAIN ENDP
RET
4. WRITE A PROGRAM TO DISPLAY A T 0 X 10 SOLID
BOX OF ASTERISKS. HINT: DECLARE A STRING IN
THE DATA SEGMENT THAT SPECIFIES THE BOX, AND
DISPLAY IT WITH INT 2LH, FUNCTION 9H.
CODE:

ORG 100H

.MODEL SAMLL
.DATA
STARS DB 0AH,0DH,'******','$'

.CODE
MAIN PROC
MOV AX,@DATA
MOV DS,AX

MOV AH,9
LEA DX,STARS
INT 21H
INT
21H INT
21H INT
21H INT
21H INT
21H INT
21H INT
21H INT
21H INT
21H

MOV AH,4CH
INT 21H

MAIN ENDP

RET
5. WRITE A PROGRAM TO (A) DISPLAY"?", (B) READ
THREE INITIALS,(<;) DISPLAY THEM IN THE MIDDLE
OF AN 11 X 11 BOX OF ASTC:RI5KS, AND (D) BEEP THE
COMPUTER.
CODE:
ORG 100H

.MODEL SMALL
.DATA
STARS DB,'**********',0AH,0DH,'$'
MID DB,'***'
C1 DB?
C2 DB?
C3 DB?,'***',0AH,0DH,'$'

.CODE
MAIN PROC
MOV AX,@DATA
MOV DS,AX

MOV AH,1
INITAILS

INT 21H
MOV C1,AL
INT 21H

MOV C2,AL
INT 21H

MOV C3,AL

MOV AH,2
MOV DL,0DH
INT 21H

MOV AH,9
LEA DX,STARS
INT 21H
INT
21H INT
21H INT
21H

LEA DX,MID
 INT 21H

LEA DX,STARS
INT 21H
INT
21H INT
21H INT
21H INT
21H

MOV AH,4CH
INT 21H

MAIN ENDP

RET

WEEK#08
1. WRITE A PROGRAM TO MUL 8 BIT NUMBERS.

ORG 100H
DATA SEGMENT
A DB 09H
B DB 02H
C DW ?
DATA ENDS

CODE SEGMENT
ASSUME CS:CODE, DS:DATA
START:
MOV AX,DATA
MOV DS,AX
MOV AX,0000H
MOV BX,0000H
MOV AL,A
MOV BL,B
MUL B
MOV C,AX
INT 3
CODE ENDS
END START

RET
 1. SUPPOSE YOU HAVE TO MULTIPLY 35 WITH 15
WHOSE ANSWER IS 525 AND 20D IN HEXADECIMAL.
WRITE AN ASSEMBLY CODE FOR THAT STATEMENT.
ORG 100H
.CODE
MOV AL, 35
MOV BH,
15 MUL BH
RET
3. WRITE A PROGRAM TO MUL 16 BIT NUMBERS.

ORG 100H

DATA SEGMENT
A DW 1234H
B DW 5678H
C DD ?
DATA ENDS

CODE SEGMENT
ASSUME DS:DATA, CS:CODE
START:
MOV AX,DATA
MOV DS,AX
MOV AX,A
MOV BX,B
MUL BX
MOV WORD PTR C,AX
MOV WORD PTR C+2,DX
INT 3
CODE ENDS
END START

RET
4. CONVERT THE C++ INSTRUCTION IN ASSEMBLY CODE.
X+Y*(A- B*D).

ORG 100H
.DATA
A DB 2
B DB 5
D DB 33
X DB 10
Y DB 12
.CODE
MOV AL,A
SUB AL,B
MOV BL,D
MUL BL
MOV AH,X
ADD AH,Y
MUL AL

RET
.MODEL SMALL
.DATA
MSG DB "+"
MSG2 DB "="
A DB 2
B DB 2
C DB 3
D DB 1
E DB 1
F DB ?
.CODE
MOV DL,A
ADD DL,30H
MOV AH,2
INT 21H
MOV DL,MSG
MOV AH,2
INT 21H
MOV DL,B
ADD DL,30H
MOV AH,2
INT 21H
MOV DL,MSG
MOV AH,2
INT 21H
MOV DL,C
ADD DL,30H
MOV AH,2
INT 21H
MOV DL,MSG
MOV AH,2
INT 21H
MOV DL,D
ADD DL,30H
MOV AH,2
INT 21H
MOV DL,MSG
MOV AH,2
INT 21H
MOV DL,E
ADD DL,30H
MOV AH,2
INT 21H
MOV DL,MSG2
MOV AH,2
INT 21H
MOV AL,A
ADD AL,B
ADD AL,C
ADD AL,D
ADD AL,E
MOV F,AL
MOV DL,F
ADD DL,30H
MOV AH,2
INT 21H
MENTION THE DIVIDE OVERFLOW MESSAGE BY EXECUTING GIVEN
INSTRUCTIONS?
 WEEK# 09
MULTIPLY INSTRUCTIONS
EX#01

EX#02
EX#03

EX#04
EX#05

EX#06
EX#07
 DIVIDE INSTRUCTIONS
EX#08

EX#09
EX#10

EX#11
DIVIDE OVERFLOW EXAMPLE:
 CWD INSTRUCTIONS
EX#12

EX#13

CBW INSTRUCTIONS
EX#13

EX#14
 DIVIDE WITH CWD INSTRUCTION
EX#15

EX#16
EX#17
WEEK 10
COMPARE INSTRUCTIONS:
1)MOV AX,5
CMP AX,10

EX#01

2)EX#02
EX#03
EX#04
QUESTION :01
REPLACE A NUMBER IN AX BY ITS ABSOLUTE VALUE
IF AX<0
THEN
AX IS REPLACED TO –AX
END_IF
ORG 100H

MOV AX,-2

CMP AX,0

JNL END_IF

JMP REPLACE:
REPLACE:

NEG AX

MOV DX,AX

ADD DX,30H

MOV AH,2

INT 21H

JMP END_IF

END_IF:

MOV AH,4CH

INT 21H

RET

APPLY JUMP STATEMENTS BY TAKING JUMP IF NOT LESS?

IF AX CONTAINS NEGATIVE THEN -1 IN BX,IF AX CONTAINS POSITIVE VALUE
THEN MOVE 1 INTO BX AND IF AX CONTAINS 0 THEN MOVE 0 INTO BX?
CHECK EVEN,ODD NUMBERS BY DISPLAYING “E” AND “O” ?
 WEEK 11
QUESTION:01 READ A CHARACTER IF IT IS UPPERCASE THEN DISPLAY ON THE
SCREEN OTHERWISE TERMINATE THE PROGRAM ?
READ A CHARACTER AND IF USER ENTERS CAPITAL Y AND SMALL Y DISPLAY
THE CHARCTER ON THE SCREEN OTHERWISE TERMINATE THE PROGRAM?

PRINT THE “*” ON THE SCREEN 80 TIMES USING LOOP?

 WEEK 12
CHAPTER 6
QUESTION: 01 WRITE ASSEMBLY CODE FOR EACH OF THE FOLLOWING STRUCTURE DECSIONS:
a. ·IF AX < 0 THEN PUT -1 IN BX END

IF ORG 100H

MOV AX,1
CMP AX,0
JL NEGATIVE
JMP EXIT
NEGATIVE:
MOV BX,-1
JMP EXIT
EXIT:
MOV AH,4CH
INT 21H
 RET
B. IF AL < 0 THEN PUT FFH IN AH' ELSE PUT 0 IN AH END_IF?
ORG 100H

MOV AL,1
CMP AL,0
JL IF
MOV AH,0
RET
;MOV AH,4CH
;INT 21H
IF:
MOV AH,0FFH
JMP EXIT
EXIT:

RET
c. SUPPOSE DL CONTAINS THE ASCII CODE OF A CHARACTER
IF (DL>=”A”)AND(DL<=”Z”)
THEN DISPLAY DL
ELSE END_IF?
ORG 100H

MOV DL,"S"
CMP DL,"A"
JGE TRUE
RET
TRUE:
CMP DL,"Z"
JLE FINAL
RET
FINAL:
MOV AH,2
INT 21H

RET
d. IF AX<BX

THEN IF BX < CX
THEN PUT 0 IN AX.
ELSE PUT 0 IN BX
END_IF
END_IF
ORG 100H

MOV AX,5
MOV BX,8
MOV CX,7
CMP AX,BX
JL TRUE1
MOV BX,0
JMP END_IF
TRUE1:
CMP BX,CX
JL TRUE2
MOV BX,0
JMP END_IF
TRUE2:
MOV AX,0
END_IF:
RET

e. IF

(AX<BX)OR(BX<CX) THEN
PUT 0 IN DX
ELSE
PUT 1 IN DX?
ORG 100H

MOV AX,4
MOV BX,3
MOV CX,1
CMP AX,BX
JL TRUE
CMP BX,CX
JL TRUE
JMP ELSE
ELSE:
MOV DX,1
RET
TRUE:
MOV DX,0
RET

f. IF AX<BX

THEN
PUT 0 IN AX
ELSE
IF BX<CX
THEN
PUT 0 IN BX
ELSE
PUT 0 IN CX
END_IF
END_IF?
ORG 100H

MOV AX,1
MOV BX,2
MOV CX,3
CMP AX,BX
JL CONDITION1
CMP BX,CX
JL CONDITION2
MOV CX,0
JMP END_IF
CONDITION1:
MOV AX,0
JMP END_IF
CONDITION2:
MOV BX,0
JMP END_IF
END_IF:
RET
QUESTION: 02 USE A CASE STRUCTURE TO CODE THE FOLLOWING:
READ A CHARACTER.
IF IT’S ‘A’, THEN EXECUTE CARRIAGE
RETURN. IF IT’S ‘B’, THEN EXECUTE LINE
FEED.
IF IT’S ANY OTHER CHARACTER, THEN RETURN TO DOS.
ORG 100H

MOV AH,1

INT 21H

MOV BL,AL

CMP BL,'A'

JE CARRIAGE

CMP BL,'B'

JE LINEFEED

JMP EXIT

CARRIAGE:

MOV AH,2

MOV DL,0DH

INT 21H

MOV DL,BL

INT 21H
JMP EXIT
LINEFEED:

MOV AH,2

MOV DL,0AH

INT 21H

MOV DL,BL

INT 21H

EXIT:

MOV AH,4CH

INT 21H

RET

QUESTION: 03 WRITE A SEQUENCE OF INSTRUCTIONS TO DO EACH OF THE FOLLOWING:

a. PUT THE SUM OF “1 + 4 + 7"+ .. .+. 148 IN AX.

ORG 100H
MOV CX,49
MOV AX,1
TOP:
ADD AX,3
LOOP TOP
MOV AH,4CH
INT 21H

RET

B. PUT THE SUM 100 + 95 + 90 + ... + 5 IN

AX. ORG 100H
MOV CX,19
MOV AX,100
MOV BX,100
TOP:
SUB BX,5
ADD AX,BX
LOOP TOP
RET
QUESTION: 4 APPLY LOOP INSTRUCTIONS TO DO THE FOLLOWING:
A)PUT THE SUM OF FIRST 50 TERMS OF THE SEQUENCE 1,5,9,13,……. IN DX.
ORG 100H
MOV CX,12
MOV AX,1
TOP:
ADD AX,4
LOOP TOP
MOV DX,AX

RET
B) READ A CHARACTER AND DISPLAY IT 80 TIMES ON THE NEXT
LINE? ORG 100H

MOV CX,80
MOV AH,1
INT 21H
MOV BL,AL
MOV AH,2
MOV DL,0DH
INT 21H
MOV AH,2
MOV DL,0AH
INT 21H
MOV AH,2
MOV DL,BL
TOP:
INT 21H
MOV AH,2
MOV DL,BL
MOV AH,2
LOOP TOP

RET
C)READ A FIVE CHARACTER PASSWORD AND OVERPRINT IT BY EXECUTING A CARRIAGE RETURN
AND DISPLAYING FIVE X’S.YOU NEED NO INPUT TO STORE THE INPUT CHARACTERS ANYWHERE?
ORG 100H
MOV CX,5
TOP1:
MOV AH,1
INT 21H
LOOP TOP1
MOV CX,5
;TOP2:
MOV AH,2
MOV DL,0DH
INT 21H
TOP3:
MOV DL,"X"
MOV AH,2
INT 21H
LOOP TOP3
RET
QUESTION: 5 THE FOLLOWING ALGORITHM MAY BE USED TO CARRY OUT DIVISION OF TWO
NONNEGATIVE NUMBERS BY REPEATED SUBTRACTION:
INITIALIZE QUOTIENT TO 0
WHILE DIVIDEND>=DIVISOR DO
INCREMENT QUOTIENT
SUBTRACT DIVISOR FROM DIVIDEND
END_WHILE
WRITE A SEQUENCE OF INSTRUCTIONS TO DIVIDE.AX BY BX, AND PUT THE QUOTIENT IN CX.
ORG 100H

.DATA
QUOTIENT DW 0
.CODE
MOV DX,0000H
MOV AX,5000H
MOV BX,0003H
CMP AX,BX
JGE WHILE
JMP END_WHILE
WHILE:
INC QUOTIENT
SUB AX,BX
;JMP END_WHILE
DIV BX
MOV CX,QUOTIENT
JMP END_WHILE

END_WHILE:
RET
QUESTION: 6 THE FOLLOWING ALGORITHM MAY BE USED TO CARRY OUT MULTIPLICATION OF
TWO POSITIVE NUMBERS M AND N BY REPEATED ADDITION:
INITIALIZE PRODUCT 0
REPEAT
ADD M TO
PRODUCT
DECREMENT N
UNTIL N=0
Q) WRITE A SEQUENCE OF INSTRUCTIONS TO MULTIPLY AX BY BX AND PUT THE PRODUCT IN CX.
YOU MAY IGNORE THE POSSIBILITY OF OVERFLOW?
.DATA
PRODUCT DW 0
.CODE
MOV AX,5 ;M
MOV BX,4 ;N
JMP CONDITION
CONDITION:
CMP BX,0 ;IF N=0
JE MULTIPLICATION;JUMP TO MULTIPLICATION
JMP REPEAT
REPEAT:
ADD AX,PRODUCT;ADD M TO 0(PRODUCT)
DEC BX ;DECREMENT N
JMP CONDITION
;LOOP REPEAT
EXIT:
RET
MULTIPLICATION:
MUL BX
MOV PRODUCT,AX
MOV CX,PRODUCT
JMP EXIT
QUESTION 7: IT IS POSSIBLE TO SET UP A COUNT-CONTROLLED LOOP THAT WILL CONTINUE TO
EXECUTE AS' LONG AS SOME CONDITION IS SATISFIED. THE INSTRUCTIONS
LOOP LABEL ;LOOP WHILE EQUAL
AND
LOOPZ LABEL; LOOP WHILE ZERO
CAUSE EX TO BE DECREMENTED, THEN IF CX <>. 0 AND ZF = 1, CONTROL TRANSFERS TO THE
INSTRUCTION AT THE DESTINATION LABEL; IF EITHER EX = 0 OR ZF = 0, THE INSTRUCTION FOLLOWING
THE LOOP IS DONE. SIMILARLY, THE INSTRUCTIONS LOOPNE LABEL AND LOOPNZ LABEL ;LOOP WHILE
NOT EQUAL ; LOOP WHILE NOT ZERO CAUSE EX TO BE DECREMENTED, THEN IF CX <> 0 AND ZF .. 0,
CONTROL TRANSFERS TO THE INSTRUCTION AT THE DESTINATION LABEL; IF EITHER EX .. 0 OR ZF "' 1,
THE INSTRUCTION FOLLOWING THE LOOP IS DONE.
a. WRITE INSTRUCTIONS TO READ CHARACTERS UNTIL EITHER A NONBLANK CHARACTER IS
TYPED, OR 80 CHARACTERS HAVE BEEN TYPED. USE LOO PE.

ORG 100H
MOV CX,80;GIVEN CONDITION OR LIMIT
MOV AH,1
L1:
INT 21H
CMP AL,20H; 20H=BLANK(SPACE BAR KEY)
LOOPE L1;(LOOP WORKS UNTIL A CHARACTER IS TYPED)
RET

b. WRITE INSTRUCTIONS TO READ CHARACTERS UNTIL EITHER A CARRIAGE RETURN IS TYPED OR

80 CHARACTERS HAVE BEEN TYPED. USE LOOPNE.
 ORG 100H

MOV CX,80
MOV AH,1
L1:
INT 21H
CMP AL,0DH;NEXT LINE(ENTER KEY )
LOOPNE L1 ;(LOOP WORK UNTIL AND UNLESS ENTER IS NOT PRESSED)

RET

PROGRAMMING EXERCISE
QUESTION: 8 WRITE A PROGRAM TO DISPLAY A "?", READ TWO CAPITAL LETTERS, AND DISPLAY
THEM ON THE NEXT LINE.
ORG 100H

.MODEL SMALL
.CODE
MAIN PROC
 MOV AH,2
MOV DL,'?'
INT 21H
MOV AH,1
INT 21H
MOV BL,AL
INT 21H
MOV CL,AL
CMP BL,CL;IF NOT ORDERED
JG SWITCH
JMP DISPLAY
SWITCH:
XCHG CL,BL
DISPLAY:
MOV AH,2
MOV DL,0AH
INT 21H
MOV DL,BL
INT 21H
MOV DL,CL
INT 21H
OUT_:
MOV AH,4CH
INT 21H
MAIN ENDP
END MAIN

RET
QUESTION: 9 WRITE A PROGRAM TO DISPLAY THE EXTENDED ASCII CHARACTERS (ASCII CODES 80H
TO FF_H). DISPLAY 10 CHARACTERS PER LINE, SEPARATED BY BLANKS. STOP AFTER THE EXTENDED
CHARACTERS HAVE BEEN DISPLAYED ONCE.
ORG 100H

.MODEL SMALL
.CODE
MAIN PROC
MOV CX,127 ;LAST TERM-FIRST TERM/DIFFERENCE (FFH-80H/1=127(DECIMAL))
MOV BH,0 ;COUNTER
MOV AH,2
MOV DL,80H ;GIVEN IN QUESTION TO PRINT FROM 80H TO FFH
TOP: ;FIRST LABEL TO DISPLAY
INT 21H
INC BH ;COUNTER INCREMENTS
CMP DL,0FFH
JLE TRUE ;IF DL<=FFH THEN JUMP ON
TRUE JMP EXIT ;IF CONDITION IS NOT
SATISFIED TRUE: ;SECOND LABEL
MOV BL,DL ;COPING DL TO BL
INC BL ;INCREMENT TO ASCII CHARACTER
CMP BL,DL ;COMPARE PREVIOUS AND NEW ASCII
VALUES JE EXIT ;IF SAME THEN TERMINATE PGM
JMP TOP2 ;IF NOT EQUAL THEN TRANSFER TO THIRD LABEL
TOP2: ;THIRD LABEL
MOV DL,32 ;DISPLAY SPACE (32 IS THE ASCII VALUE OF SPACE BAR IN KEYBOARD)
INT 21H
CMP BH,10 ;CHECK IF COUNTER REACHED TO ITS LIMIT THEN MOV TO NEXT LINE(LABEL)
JE NEXT_LINE ;JUMP IF EQUAL
JMP F_CONDITION ;OTHERWISE MOVE TRANSFER TO THE FORTH LABEL(F_CONDITION)
F_CONDITION: ;FORTH LABEL
MOV DL,BL
MOV AH,2
LOOP TOP ;LOOP TO CONTINUE FURTHER ACTIONS
NEXT_LINE: ;LABEL
MOV AH,2
MOV DL,0DH ;CARRIAGE RETURN
INT 21H
MOV DL,0AH ;NEXT LINE
INT 21H
MOV BH,0 ;INITIALIZE COUNTER TO ZERO
JMP F_CONDITION ;MOVE CONTROL TO FINAL CONDITION
EXIT: ;FIFTH LABEL OR LAST LABEL
RET
QUESTION: 10 WRITE A PROGRAM THAT WILL PROMPT THE USER TO ENTER A HEX DIGIT
CHARACTER ("0"· ... "9" OR "A" ... "F"), DISPLAY IT ON THE NEXT LINE IN DECIMAL, AND ASK THE USER
I.I HE OR SHE WANTS TO DO IT AGAIN. IF THE USER TYPES "Y" OR "Y", THE ·PROGRAM REPEATS; IF THE
USER TYPES ANYTHING ELSE, THE PROGRAM TERMINATES. IF THE USER ENTERS AN ILLEGAL
CHARACTER, PROMPT THE USER TO TRY AGAIN. SAMPLE EXECUTION
1 ENTER A HEX DIGIT: 9 IN DECIMAL IS IT
9 DO YOU WANT TO DO IT AGAIN? Y
ENTER A HEX DIGIT: C ILLEGAL CHARACTER - ENTER 0 .. 9 OR A .. F: C IN DECIMAL IT IS 12
DO YOU WANT TO DO IT AGAIN? N
ORG 100H
.MODEL SMALL
.DATA
MSG1 DW " ENTER A HEXADECIMAL DIGIT ", '$'
MSG2 DW " IN DECIMAL IT IS: ", '$'
MSG3 DW " DO YOU WANT TO DO IT AGAIN? ", '$'
EMSG DW " ILLEGAL CHARACTER, ENTER 0..9 OR A..F: ", '$'
.CODE
MAIN PROC
; PRINT USER PROMPT
LEA DX,MSG1 ; GET MESSAGE
MOV AH, 09H ; DISPLAY STRING FUNCTION
INT 21H ; DISPLAY IT
JMP USERIN ; JUMPS TO USER INPUT SO IF ILLEGAL CHARACTER IS ENTERED MESSAGE
WON'T DISPLAY AGAIN
USERIN:
; INPUT A HEXIDECIMAL NUMBER THEN COMPARE TO ASCII
CODES MOV AH, 01H ; KEYBOARD INPUT FUNCTION
INT 21H ; CHARACTER INPUT, COPIES CHARACTER INTO AL
MOV BH, AL ; MOVES AL INTO BH TO AVOID AL BEING MESSED
WITH CMP BH, 30H ; COMPARES INPUT TO ASCII CODE
FOR 0
JL ERROR ; IF INPUT IS LESS THAN 0 JUMP TO MAIN
CMP BH, 39H ; COMPARES INPUT TO ASCII CODE FOR
9
JLE PRINT1 ; IF INPUT IS LESS THAN OR EQUAL TO 9 JUMP TO
PRINT CMP BH, 41H ; COMPARES INPUT TO ASCII CODE
FOR 'A'
JL ERROR ; IF INPUT IS LESS THAN 'A' JUMP TO MAIN
CMP BH, 46H ; COMPARES INPUT TO ASCII CODE FOR
'F'
JLE CONVERT1 ; IF INPUT IS LESS THAN OR EQUAL TO 'F' JUMP TO CONVERT1
CMP BH, 61H ; COMPARES INPUT TO ASCII CODE FOR 'A'
JL ERROR ; IF INPUT IS LESS THAN 'A' JUMP TO MAIN
CMP BH, 66H ; COMPARES INPUT TO ASCII CODE FOR
'F'
JLE CONVERT2 ; IF INPUT IS LESS THAN OF EQUAL TO 'F' JUMP TO CONVERT2
 JG ERROR ; IF INPUT IS GREATER THAN 'Z' JUMP TO
MAIN ERROR:
; DISPLAYS ERROR MESSAGE THEN JUMPS BACK
LEA DX, EMSG ; MOVES ERROR MESSAGE INTO DISPLAY STRING REGISTER
MOV AH, 09H ; DISPLAY STRING FUNCTION
INT 21H ; DISPLAYS IT
JMP USERIN ; JUMPS BACK TO USER
INPUT CONVERT1:
; CONVERTS INPUT FROM HEXADECIMAL A-F TO DECIMAL
SUB BH, 16 ; SUBTRACTS 0FH FROM INPUT TO GET
DECIMAL JMP PRINT2 ; JUMPS TO PRINT
CONVERT2:
; CONVERTS INPUT FROM HEXIDECIMAL A-F TO DECIMAL
SUB BH, 48 ; SUBTRACTS 30H FROM THE INPUT TO
GET JMP PRINT2 ; JUMPS TO PRINT
PRINT1:
; PRINTS THE INPUT IN DECIMAL FORM
LEA DX, MSG2 ; MOVES MSG2 INTO DISPLAY STRING REGISTER
MOV AH, 09H ; DISPLAY STRING FUNCTION
INT 21H ; DISPLAY MSG2 "IN DECIMAL IT IS:"
MOV DL, BH ; MOVES INPUT INTO DISPLAY CHARACTER
REGISTER MOV AH, 02H ; DISPLAY CHARACTER FUNCTION
INT 21H ; DISPLAY INPUT IN DECIMAL
FORM JMP AGAIN ; JUMPS TO AGAIN
PRINT2:
;PRINTS THE INPUT IN DECIMAL FORM
LEA DX, MSG2 ; MOVES MSG2 INTO DISPLAY STRING REGISTER
MOV AH, 09H ; DISPLAY STRING FUNCTION
INT 21H ; DISPLAY MSG2 "IN DECIMAL IT IS:"
MOV DL, 1D ; WILL ADD 10 TO THE CONVERTED ASCII CODE
 MOV AH, 02H ; DISPLAY CHARACTER FUNCTION
INT 21H ; DISPLAY 1 IN FRONT OF INPUT IN DECIMAL FORM
MOV DL, BH ; MOVES CONVERTED INPUT TO DISPLAY CHARACTER
REGISTER MOV AH, 02H ; DISPLAY CHARACTER FUNCTION
INT 21H ; DISPLAYS CONVERTED
INPUT JMP AGAIN ; JUMPS TO
AGAIN
AGAIN:
; ASKS IF USER WANTS TO DO IT AGAIN
LEA DX, MSG3 ; MOVES MSG2 INTO DISPLAY STRING REGISTER
MOV AH, 09H ; DISPLAY STRING FUNCTION
INT 21H ; DISPLAY MSG3 "DO YOU WANT TO DO IT
AGAIN?" MOV AH, 01H ; KEYBOARD INPUT FUNCTION
INT 21H ; CHARACTER INPUT, COPIES INTO AL
CMP AL, 59H ; COMPARES INPUT TO ASCII CODE FOR
'Y' JE MAIN ; IF INPUT IS EQUAL TO 'Y' JUMP TO MAIN
JL EXIT ; IF INPUT IS LESS THAN 'Y' JUMP TO EXIT
CMP AL, 79H ; COMPARES INPUT TO ASCII CODE FOR 'Y'
JE MAIN ; IF INPUT IS EQUAL TO 'Y' JUMP TO MAIN
JNE EXIT ; IF INPUT IS NOT EQUAL TO 'Y' JUMP TO EXIT
EXIT:
;EXIT TO DOS
MOV AH, 04CH ; DOS FUNCTION: EXIT
PROGRAM MOV AL, 0 ; RETURN EXIT CODE
VALUE
INT 21H ; CALL DOS. TERMINATE PROGRAM
QUESTION :11 DO PROGRAMMING EXERCISE 10, EXCEPT THAT IF THE USER FAILS TO ENTER A HEX-
DIGIT CHARACTER IN THREE TRIES, DISPLAY A MESSAGE AND TERMINATE THE PROGRAM.
ORG 100H

.MODEL SMALL
.STACK 64

.DATA
CR EQU 0DH
LF EQU 0AH
M1 DB CR,LF,'ENTER A HEXA DIGIT :','$'
M2 DB CR,LF,'IN DECIMAL IT IS :'
C1 DB ?,'$'
M3 DB CR, LF,'DO YOU WANT TO DO IT AGAAIN?'
DB 'Y/N','$'
M4 DB CR,LF,'ILLEGAL CHARACTER-ENTER'
DB '0..9 OR A..F :','$'
M5 DB CR,LF,'IN DECIMAL IT IS :1','$'
M6 DB CR,LF,'ERROR THREE TIMES ENTERED'
DB 'ILLEGAL CHAIR !','$'
C2 DB ?,'$'
.CODE
MAIN PROC
MOV AX,@DATA
MOV DS,AX

BEGIN: MOV BL,0 ;COUNTER OF

ERROR MOV AH,9
LEA DX,M1
INT 21H

NEW: MOV AH,1

INT 21H

CMP AL,'0'
JL ILLEGAL
CMP AL,'9'
JG ILLEGAL

MOV C1,AL
MOV AH,9
LEA DX,M2
INT 21H

MSG: MOV AH,9

LEA DX,M3
INT 21H

MOV AH,1
INT 21H
CMP AL,'Y'
 JE BEGIN
CMP AL,'Y'
JE BEGIN
JMP ENDD

ILLEGAL: CMP AL,'A'

JL ILLEGAL2
CMP AL,'F'
JG ILLEGAL2
SUB AL,11H
MOV C2,AL
MOV AH,9
LEA DX,M5
INT 21H ;

JMP MSG

ILLEGAL2: MOV AH,9

LEA DX,M4
INT 21H
;COUNTER FOR 3_TIMES ILLEGAL
INPUT INC BL
CMP BL,3
JE ENDDD
JMP NEW
ENDDD: MOV AH,9
LEA DX,M6
INT 21H

ENDD: MOV AH,4CH

 INT 21H
MAIN ENDP
END MAIN

RET

QUESTION :12 (HARD) WRITE A PROGRAM THAT READS A STRING OF CAPITAL LETTERS, ENDING WITH
A CARRIAGE RETURN, AND DISPLAYS THE LONGEST SEQUENCE OF CONSECUTIVE ALPHABETICALLY
INCREASING CAPITAL LETTERS READ. SAMPLE EXEC11TIO11: ENTER A STKING OF CAPITAL LETTERS:
FGHADEFGHC THE LONGEST CONSECUTIVELY INCREASING STRING IS:DEFG
ORG 100H

.STACK 100H
.MODEL SMALL
.DATA
INPUTMSG DB 'ENTER A STRING OF CAPITAL LETTERS:$'
OUTPUTMSG DB 0DH,0AH,'THE LONGEST CONSECUTIVE STRING IS:
$'
.CODE
MAIN PROC
MOV AX,@DATA
MOV DS,AX
MOV CH,0
MOV AH,9
LEA DX,INPUTMSG
INT 21H
INPUT_1:
MOV AH,1
INT 21H
CMP AL,0DH
JE END_
MOV CL,1
MOV BL,AL
MOV DH,AL
INPUT_2:
INT 21H
CMP AL,0DH
JE END_
INC BL
CMP BL,AL
JNE INIT
INC CL
JMP INPUT_2
INIT:
CMP CH,CL
JL UPDATE
MOV CL,1
MOV BL,AL
MOV DH,AL
JMP INPUT_2
UPDATE:
MOV CH,CL
MOV BH,DH
 MOV CL,1
MOV BL,AL
MOV DH,AL
JMP INPUT_2
END_:
CMP CH,CL
JL REUPDATE
JMP END_2
REUPDATE:
MOV CH,CL
MOV BH,DH
JMP END_2
END_2:
MOV AH,9
LEA DX,OUTPUTMSG
INT 21H
MOV AH,2
MOV DL,BH
OUTPUT:
CMP CH,0
JE FINISH
DEC CH
INT 21H
INC DL
JMP OUTPUT
FINISH:
MOV AH,4CH
INT 21H
MAIN ENDP
END MAIN
RET

WEEK 13
QUESTION 1 USE THE TEST INSTRUCTION TO DO EACH OF THE FOLLOWING:
a) SET ZF IF THE CONTENTS OF AX IS ZERO.

BEFORE SETTING ZF AFTER SETTING

B) CLEAR ZF IF BX CONTAINS AN ODD NUMBER.

BEFORE CLEARING ZF AFTER CLEARING

C) SET SF IF DX CONTAINS A NEGATIVE NUMBER.

BEFORE SETTING SIGN FLAG AFTER SETTING

D) SET ZF IF DX CONTAINS A ZERO OR POSITIVE NUMBER.

BEFORE SETTING ZF AFTER SETTING

b) SET PF IF BL CONTAINS AN EVEN NUMBER OF 1

BITS. BEFORE SETTING PARITY FLAG

AFTER SETTING
QUESTION 2: WRITE A PROGRAM THAT PROMPTS THE USER TO ENTER A CHARACTER, AND ON
SUBSEQUENT LINES PRINTS ITS ASCII CODE IN BINARY, AND THE NUMBER OF 1 BITS IN ITS ASCII CODE.

SAMPLE EXECUTION: TYPE A CHARACTER: A

THE ASCII CODE OF A IN BINARY IS

010'00001 THE NUMBER OF L BITS IS 2

QUESTION 3 WRITE A PROGRAM THAT PROMPTS THE USER TO ENTER A CHARACTER AND PRINTS
THE ASCII CODE OF THE CHARACTER IN HEX ON THE NEXT LINE. REPEAT THIS PROCESS UNTIL THE USER
TYPES A CARRIAGE RETURN.

SAMPLE EXECUTION: TYPE A CHARACTER:

Z THE ASCII CODE OF Z IN HEX IS 5A

QUESTION 4: WRITE A PROGRAM THAT PROMPTS THE USER TO TYPE A HEX NUMBER OF FOUR HEX
DIGITS OR LESS, AND OUTPUTS IT IN BINARY ON THE NEXT LINE. IF THE USER ENTERS AN ILLEGAL
CHARACTER, HE OR SHE SHOULD BE PROMPTED TO BEGIN AGAIN. ACCEPT ONLY UPPERCASE LETTERS.
WHILE_: CMP AL,0DH

JE END_WHILE

CMP AL,'9'

JG LETTER

AND AL,0FH

JMP SHIFT

LETTER: CMP AL,'F'

JG ERR

CMP AL,'A'

JL ERR

SUB AL,37H

SHIFT: SHL BX,CL

OR BL,AL

INT 21H

JMP WHILE_

END_WHILE:MOV AH,9

LEA DX,M2

INT 21H

MOV CX,16
MOV AH,2

SHOW: SHL BX,1

JC ONE

ONE: MOV DL,'1'

INT 21H

LOOP1: LOOP SHOW

JMP OUT_

ERR: MOV AH,9

LEA DX,M3

INT 21H

JMP START

OUT_:

MOV AH,4CH

INT 21H

ENDP
END MAIN

RET
WEEK 14

CLEAR THE SIGN BIT OF AL WHILE LEAVING THE OTHER BITS UNCHANGED

SOLUTION: USE THE AND INSTRUCTION WITH 01111111B = 7FH AS THE MASK.

AND AL,7FH

SET THE MOST SIGNIFICANT AND LEAST SIGNIFICANT BITS OF AL WHILE PRESERVING THE OTHER BITS.

USE THE OR INSTRUCTION WITH LOOOOOOLB = 81H AS THE MASK. THUS, OR AL,8LH
EXAMPLE 7.4 CHANGE THE SIGN BIT OF DX.

USE THE XOR INSTRUCTION WITH A MASK OF 800011. THUS,

XOR DX,8000H

JUMP TO LABEL BELOW IF AL CONTAINS AN EVEN NUMBER.

EVEN NUMBERS HAVE A 0 IN BIT 0.

THUS, THE MASK IS OOOOOOOLB S: 1.

TEST AL, 1

JZ BELOW ;IS AL
EVEN?

BELOW:

MOV DL,’0’

RET
SUPPOSE DH CONTAINS 8AH AND CL CONTAINS 3. WHAT ARE THE VALUES OF DH AND OF CF AFTER
THE INSTRUCTION SHL DH,CL IS EXECUTED?

SOLUTION: THE BINARY VALUE OF DH IS 10001010. AFTER 3 LEFT SHIFTS, CF WILL CONTAIN 0. THE
NEW CONTENTS QF DH MAY BE OBTAINED BY ERASING THE LEFTMOST THREE BITS AND ADDING
THREE ZERO BITS TO THE RIGHT END, THUS 01010000B = 50H.

USE ROL TO COUNT THE NUMBER OF L BITS IN BX, WITHOUT CHANGING BX. PUT THE ANSWER IN AX.

XOR AX,AX ;AX COUNTS BITS

MOV AX,16 ;LOOP COUNTER

TOP: ROL BX,1 ;C. F C BIT ROTATED OUT

JNC NEXT ;O BIT

INC AX ;L BIT, INCREMENT TOTAL

NEXT: LOOP TOP ;LOOP UNTIL