Experiment 2:

DATA SEGMENT

NUM1 DB 05H

NUM2 DB 07H

SUM DB ?

DATA ENDS

CODE SEGMENT

ASSUME CS:CODE, DS:DATA

START:

MOV AX,DATA

MOV DS,AX

MOV AL,NUM1

MOV BL,NUM2

ADD AL,BL

MOV SUM,AL

MOV AH,4CH

INT 21H

CODE ENDS

END START

Experiment 3:

;16 BIT ADDITION:

DATA SEGMENT

NUM1 DW 1111H

NUM2 DW 3333H
 SUM DW ?

DATA ENDS

CODE SEGMENT

ASSUME CS:CODE, DS:DATA

START:

MOV AX,DATA

MOV DS,AX

MOV AX,NUM1

MOV BX,NUM2

ADD AX,BX

MOV SUM,AX

MOV AH,4CH

INT 21H

CODE ENDS

END START

;8 BIT ADDITION

DATA SEGMENT

NUM1 DB 01H

NUM2 DB 02H

SUM DB ?

DATA ENDS

CODE SEGMENT

ASSUME CS:CODE,DS:DATA
START:

MOV AX,DATA

MOV DS,AX

MOV AL,NUM1

MOV BL,NUM2

ADD AL,BL

MOV SUM,AL

MOV AH,4CH

INT 21H

CODE ENDS

END START

;16 BIT SUBTRACTION

DATA SEGMENT

NUM1 DW 3333H

NUM2 DW 1111H

DIFF DW ?

DATA ENDS

CODE SEGMENT

ASSUME CS:CODE,DS:DATA

START:

MOV AX,DATA

MOV DS,AX

MOV AX,NUM1

MOV BX,NUM2
 SUB AX,BX

MOV DIFF,AX

MOV AH,4CH

INT 21H

CODE ENDS

END START

;8 BIT SUBTRACTION

DATA SEGMENT

NUM1 DB 07H

NUM2 DB 02H

DIFF DB ?

DATA ENDS

CODE SEGMENT

ASSUME CS:CODE, DS:DATA

START:

MOV AX,DATA

MOV DS,AX

MOV AL,NUM1

MOV BL,NUM2

SUB AL,BL

MOV DIFF,AL

MOV AH,4CH

INT 21H

CODE ENDS
END START

Experiment 4:

;SIGNED MULTIPLICATION

DATA SEGMENT

NUM1 DW -1212H

NUM2 DW 2121H

PROD DW ?

DATA ENDS

CODE SEGMENT

ASSUME CS:CODE, DS:DATA

START:

MOV AX,DATA

MOV DS,AX

MOV AX,NUM1

MOV BX,NUM2

IMUL BX

MOV PROD,AX

MOV AH,4CH

INT 21H

CODE ENDS

END START

;UNSIGNED MULTIPLICATION

DATA SEGMENT
 NUM1 DW 0001H

NUM2 DW 0005H

PROD DW ?

DATA ENDS

CODE SEGMENT

ASSUME CS:CODE, DS:DATA

START:

MOV AX,DATA

MOV DS,AX

MOV AX,NUM1

MOV BX,NUM2

MUL BX

MOV PROD,AX

MOV AH,4CH

INT 21H

CODE ENDS

END START

Experiment 7:

;8-bit forward transfer without string instructions

DATA SEGMENT

BLOCK1 DB 10H,20H,30H,40H,50H

BLOCK2 DB O5H DUP(00H)

DATA ENDS
CODE SEGMENT

ASSUME CS:CODE,DS:DATA

START:

MOV AX,DATA

MOV DS,AX

LEA SI,BLOCK1

LEA DI,BLOCK2

MOV CX,0005H

UP:

MOV AL,[SI]

MOV [DI],AL

INC SI

INC DI

LOOP UP

MOV AH,4CH

INT 21H

CODE ENDS

END START

;8-bit forward transfer with string instructions

DATA SEGMENT

B1 DB 10H,20H,30H,40H,50H

B2 DB 05H DUP(00H)

DATA ENDS
CODE SEGMENT

ASSUME CS:CODE,DS:DATA

START:

MOV AX,DATA

MOV DS,AX

MOV ES,AX

LEA SI,B1

LEA DI,B2

MOV CX,0005H

CLD

REP MOV SB

MOV AH,4CH

INT 21H

CODE ENDS

END START

;WRITE AN ALP TO TRANSFER OF BLOCK OF 16-BIT NUMBERS

DATA SEGMENT

BLOCK1 DW 1234H, 5678H, 9ABCH, 0DEFH, 1357H

BLOCK2 DW 5 DUP(0000H)

DATA ENDS

CODE SEGMENT

ASSUME CS:CODE, DS:DATA

START:
 MOV AX, DATA

MOV DS, AX

MOV ES, AX

LEA SI, BLOCK1 ; Source pointer

LEA DI, BLOCK2 ; Destination pointer

MOV CX, 0005H ; Number of 16-bit words

TRANSFER:

MOV AX, [SI] ; Load 16-bit word from source

MOV [DI], AX ; Store into destination

ADD SI, 2 ; Move to next word

ADD DI, 2

LOOP TRANSFER

MOV AH, 4CH

INT 21H

CODE ENDS

END START

;WRITE AN ALP TO PERFORM BLOCK TRANSFER IN REVERSE ORDER

DATA SEGMENT

BLOCK1 DB 10H, 20H, 30H, 40H, 50H

BLOCK2 DB 5 DUP(00H)

DATA ENDS
CODE SEGMENT

ASSUME CS:CODE, DS:DATA

START:

MOV AX, DATA

MOV DS, AX

MOV ES, AX

LEA SI, BLOCK1

LEA DI, BLOCK2

MOV CX, 0005H

ADD SI, CX ; Move SI to end of BLOCK1

ADD DI, CX ; Move DI to end of BLOCK2

DEC SI ; Point to last element

DEC DI

STD ; Set Direction Flag (process in reverse)

REVERSE_TRANSFER:

LODSB ; Load byte from DS:SI → AL, SI--

STOSB ; Store AL into ES:DI, DI--

LOOP REVERSE_TRANSFER

CLD ; Clear direction flag (restore normal)

MOV AH, 4CH

CODE ENDS

END START

Experiment 8:

;SUM OF SERIES WITHOUT DAA

DATA SEGMENT

Array DB 01H,02H,03H,04H,05H ; 5 bytes: the series to be summed

SUM DB ? ; Variable to store the result

DATA ENDS

CODE SEGMENT

ASSUME CS:CODE,DS:DATA

START:

MOV AX,DATA

MOV DS,AX ; Initialize DS with data segment

LEA SI,Array ; Load address of Array into SI

MOV CX,0005H ; Set counter for 5 elements

MOV AL,00H ; AL will store the sum

UP:

MOV BL,[SI] ; Load current byte into BL

ADD AL,BL ; Add it to AL (running total)

INC SI ; Move to next element

LOOP UP ; Repeat until CX = 0

MOV AH,4CH ; Exit program

INT 21H

CODE ENDS

END START

;SUM OF SERIES WITH DAA

DATA SEGMENT

ARRAY DB 31H,29H,07H,02H,01H

SUM DB ?

DATA ENDS

CODE SEGMENT

ASSUME CS:CODE,DS:DATA

START:

MOV AX,DATA

MOV DS,AX

MOV AL,00H

MOV CX,O5H

LEA SI,ARRAY

UP:

MOV BL,[SI]

ADD AL,BL

DAA

INC SI

LOOP UP:
 MOV SUM,AL

MOV AH,4CH

INT 21H

CODE ENDS

END START

Experiment 9:

;SMALLEST NUMBER FROM ARRAY

DATA SEGMENT

ARRAY DB 25H,11H,21H,01H,02H

SMALLEST DB ?

DATA ENDS

CODE SEGMENT

ASSUME CS:CODE,DS:DATA

START:

MOV AX,DATA

MOV DS,AX

LEA SI,ARRAY

MOV BL,05H

MOV AL,[SI]

DEC BL

UP:

INC SI

CMP AL,[SI]

JC NEXT
 MOV AL,[SI]

NEXT:

DEC BL

JNZ UP

MOV SMALLEST,AL

MOV AH,4CH

INT 21H

CODE ENDS

END START

;LARGEST NUMBER FROM ARRAY

DATA SEGMENT

ARRAY DB 25H,02H,11H,21H,01H

LARGEST DB ?

DATA ENDS

CODE SEGMENT

ASSUME CS:CODE,DS:DATA

START:

MOV AX,DATA

MOV DS,AX

LEA SI,ARRAY

MOV BL,05H

MOV AL,[SI]

DEC BL
 UP:

INC SI

CMP AL,[SI]

JNC NEXT

MOV AL,[SI]

NEXT:

DEC BL

JNZ UP

MOV LARGEST,AL

MOV AH,4CH

INT 21H

CODE ENDS

END START

;WRITE AN ALP TO FIND SMALLEST NUMBER FROM ARRAY OF 5, 16-BIT NUMBERS USING LOOP
INSTRUCTION

DATA SEGMENT

ARRAY DW 2511H,1122H,1234H,0101H,5134H

SMALLEST DW ?

DATA ENDS

CODE SEGMENT

ASSUME CS:CODE,DS:DATA

START:

MOV AX,DATA
 MOV DS,AX

LEA SI,ARRAY

MOV CX,05H

MOV AX,[SI]

DEC CX

UP:

ADD SI,2

CMP AX,[SI]

JC NEXT

MOV AX,[SI]

NEXT:

LOOP UP

MOV SMALLEST,AX

MOV AH,4CH

INT 21H

CODE ENDS

END START

Experiment 10:

;ASCENDING ORDER

DATA SEGMENT

ARRAY DB 16H,03H,25H,97H,48H

DATA ENDS

CODE SEGMENT

ASSUME CS:CODE,DS:DATA
START:

MOV AX,DATA

MOV DS,AX

MOV CX,0005H

UP:

LEA SI,ARRAY

MOV BX,0004H

L1:

MOV AL,[SI]

CMP AL,[SI+1]

JNZ L2

XCHG AL,[SI+1]

MOV [SI],AL

L2:

INC SI

DEC BX

JNZ L1

DEC CX

JNZ UP

MOV AH,4CH

INT 21H

CODE ENDS

END START

;DESCENDING ORDER
DATA SEGMENT

ARRAY DB 16H,97H,25H,03H,48H

DATA ENDS

CODE SEGMENT

ASSUME CS:CODE,DS:DATA

START:

MOV AX,DATA

MOV DS,AX

MOV CX,0005H

UP:

LEA SI,ARRAY

MOV BX,0004H

L1:

MOV AL,[SI]

CMP AL,[SI+1]

JC L2

XCHG AL,[SI+1]

MOV [SI],AL

L2:

JNC SI

DEC BX

JNZ L1

DEC CX

JNZ UP

MOV AH,4CH
 INT 21H

CODE ENDS

END START

Experiment 11:

;LENGTH OF STRING

DATA SEGMENT

STR1 DB 'RISHI$'

LEN DB ?

DATA ENDS

CODE SEGMENT

ASSUME CS : CODE, DS :DATA

START :

MOV AX, DATA

MOV DS, AX

MOV CL, 00H

LEA SI, STR1

MOV AL, '$'

UP :

CMP AL, [SI]

JNC EXIT

ADD CL, 01H

JMP UP

EXIT :

MOV LEN, CL

MOV AH, 4CH

INT 21H

CODE ENDS

END START

;CONCATENATION OF STRING

DATA SEGMENT

STR1 DB 'RISHI$'

STR2 DB 'USER$'

LEN DB ?

DATA ENDS

CODE SEGMENT

ASSUME CS : CODE, DS :DATA

START :

MOV AX, DATA

MOV DS, AX

MOV ES, AX
 MOV CL, 00H

LEA SI, STR1

LEA DI, STR2

MOV AL, '$'

UP :

CMP AL, [SI]

JNC DN

INC SI

JMP UP

DN :

CMP AL, [DI]

JNC EXIT

MOV BL, [DI]

MOV [SI], BL

INC SI

INC DI

JMP DN

EXIT :

MOV AH, 4CH

INT 21H

CODE ENDS

END START
;WRITE AN ALP TO PERFORM STRING COPY OPERATION

DATA SEGMENT

SRC_STR DB 'HELLO$',0

DEST_STR DB 6 DUP('$')

DATA ENDS

CODE SEGMENT

ASSUME CS:CODE,DS:DATA

START:

MOV AX,DATA

MOV DS,AX

MOV EX,AX

LEA SI,SRC_STR

LEA DI,DEST_STR

COPY_LOOP:

MOV AL,[SI]

MOV [DI],AL

INC SI

INC DI

CMP AL,'$'

JNE COPY_LOOP

MOV AH,4CH

INT 21H

CODE ENDS

END START
Experiment 13:

;WITHOUT STRING FUNCTION

DATA SEGMENT

STR1 DB 'HELLO$'

STR2 DB 'HELLO$'

MSG DB 'MATCHING$'

NOT_MSG DB 'NOT MATCHING$'

DATA ENDS

CODE SEGMENT

ASSUME CS:CODE,DS:DATA

START:

MOV AX,DATA

MOV DS,AX

LEA SI,STR1

LEA DI,STR2

COMPARE:

MOV AL,[SI]

MOV BL,[DI]

CMP AL,BL

JNE NOT_EQUAL

INC SI

INC DI

CMP AL,'$'

JZ MATCHING

JMP COMPARE
 NOT_EQUAL:

LEA DX,NOT_MSG

JMP PRINT_MSG

MATCHING:

LEA DX,MSG

PRINT_MSG:

MOV AH,4CH

INT 21H

CODE ENDS

END START

;WRITE AN ALP TO COMPARE TWO STRINGS USING STRING INTSTRUCTION

DATA SEGMENT

P_STR1 DB 'HELLO$'

P_STR2 DB 'HELLO$'

P_NOT_MSG DB 0DH,0AH,'THE STRINGS ARE NOT SAME$'

P_SAME_MSG DB 0DH,0AH,'THE STRINGS ARE SAME$'

DATA ENDS

CODE SEGMENT

ASSUME CS:CODE,DS:DATA

START:

MOV AX,DATA

MOV DS,AX

LEA SI,P_STR1
 LEA DI,P_STR2

MOV CX,6 ; Number of characters to compare (including $)

REP CMPSB

JNE STR_NOT_SAME

STR_SAME:

LEA DX,P_SAME_MSG

MOV AH,09H

INT 21H

JMP QUIT

STR_NOT_SAME:

LEA DX,P_NOT_MSG

MOV AH,09H

INT 21H

QUIT:

MOV AH,4CH

INT 21H

CODE ENDS

END START

Experiment 14:

DATA SEGMENT

NUM DB 30H
 ODD DB 00H

EVE DB 00H

DATA ENDS

CODE SEGMENT

ASSUME CS:CODE, DS:DATA

START:

MOV AX, DATA

MOV DS, AX

MOV AL, NUM ; Initialize AL with NUM

ROR AL, 1 ; Rotate AL right by 1

JC DN ; Jump to DN if carry is set (odd)

ROL AL, 1 ; Restore original AL value

MOV ODD, AL ; Store in ODD

JMP EXIT

DN:

ROL AL, 1 ; Restore original AL value

MOV EVE, AL ; Store in EVE

EXIT:

MOV AH, 4CH

INT 21H
CODE ENDS

END START

;WRITE AN ALP TO COUNT ODD AS WELL AS EVEN NUMBERS IN ARRAY OF 10 NUMBERS

DATA SEGMENT

NUM DB 01H,02H,03H,04H,05H,06H,07H,08H,09H,10H

ODD DB 00H

EVEN DB 00H

DATA ENDS

CODE SEGMENT

ASSUME CS:CODE,DS:DATA

START:

MOV AX,DATA

MOV DS,AX

MOV CX,000AH

LEA SI,NUM

MOV BH,ODD

MOB BL,EVEN

UP:

MOV AL,[SI]

ROR AL,1

JNC DN

ROL AL,1

ADD BL,01H
 JMP EXIT

DN:

ROL AL,1

ADD BH,01H

EXIT:

INC SI

MOV ODD,BH

MOV EVEN,BL

MOV AH,4CH

INT 21H

CODE ENDS

END START

;WRITE AN ALP TO ADD THE ALL EVEN NUMBERS IN ARRAY OF 10 NUMBERS

DATA SEGMENT

NUM DB 01H,02H,03H,04H,05H,06H,07H,08H,09H,10H

EVEN DB 00H

DATA ENDS

CODE SEGMENT

ASSUME CS:CODE,DS:DATA

START:

MOV AX,DATA

MOV DS,AX

MOV CX,000AH
 LEA SI,NUM

MOV BL,EVEN

UP:

MOV AL,[SI]

ROR AL,1

INC DN

ROL AL,1

JMP EXIT

DN:

ROL AL,1

ADD BL,AL

EXIT:

INC SI

LOOP UP:

MOV EVEN,BL

MOV AH,4CH

INT 21H

CODE ENDS

END START

Experiment 15:

DATA SEGMENT

NUM DB 83H

POS DB 00H

NEGV DB 00H
DATA ENDS

CODE SEGMENT

ASSUME CS:CODE,DS:DATA

START:

MOV AX,DATA

MOV DS,AX

MOV AL,NUM

ROL AL,1

JNC DN

ROR AL,1

MOV NEGV,AL

JMP EXIT

DN:

ROR AL,1

MOV POS,AL

EXIT:

MOV AH,4CH

INT 21H

CODE ENDS

END START

;WRITE AN ALP TO COUNT POSITIVE AS WELL AS NEGATIVE NUMBERS IN ARRAY OF 10

DATA SEGMENT
 NUM DB 05H,72H,A1H,82H,31H,FFH,21H,40H,81H,35H

POS DB 00H

NEG DB 00H

DATA ENDS

CODE SEGMENT

ASSUME CS:COSE,DS:DATA

START:

MOV AX,DATA

MOB DS,AX

LEA SI,NUM

MOV CX,000AH

UP:

MOV AL,[SI]

ROL AL,1

JNC DN

INC NEG

JMP DN2

DN:

INC POS

DN2:

INC SI

LOOP UP

MOV AH,4CH

INT 21H

CODE ENDS
END START

;WRITE AN ALP TO ADD THE ALL POSITIVE NUMBERS IN ARRAY OF 10 NUMBERS

DATA SEGMENT

NUM DB 05H,72H,A1H,82H,31H,FFH,21H,40H,81H,35H

EVE DB 00H

DATA ENDS

CODE SEGMENT

ASSUME CS:CODE,DS:DATA

START:

MOV AX,DATA

MOV DS,AX

MOV CX,000AH

LEA SI,NUM

MOV BL,EVE

UP:

MOV AL,[SI]

ROL AL,1

JNC DN

ROR AL,1

JMP EXIT

DN:

ROR AL,1

ADD BL,AL
 EXIT:

INC SI

LOOP UP

MOV EVE,BL

MOV AH,4CH

INT 21H

CODE ENDS

END START

Experiment 17:

DATA SEGMENT

NUM1 DB 10H ; First number for addition & subtraction

NUM2 DB 20H ; Second number for addition & subtraction

SUM DB ? ; Store sum result

SUB_RES DB ? ; Store subtraction result

MUL_NUM1 DB 05H ; First number for multiplication

MUL_NUM2 DB 02H ; Second number for multiplication

PRODUCT DW ? ; Store multiplication result

DIV_NUM1 DW 0006H ; Dividend for division (Word size)

DIV_NUM2 DB 02H ; Divisor for division

RESULT_QUO DB ? ; Store quotient

RESULT_REM DB ? ; Store remainder

DATA ENDS
CODE SEGMENT

ASSUME CS:CODE, DS:DATA

START:

MOV AX, DATA

MOV DS, AX

; Perform Addition

CALL ADD_NUM

; Perform Subtraction

CALL SUB_NUM

; Perform Multiplication

CALL MUL_NUM

; Perform Division

CALL DIV_PROC

MOV AH, 4CH

INT 21H

; Procedure for Addition

ADD_NUM PROC

MOV AL, NUM1

ADD AL, NUM2

RET

ADD_NUM ENDP

; Procedure for Subtraction

SUB_NUM PROC

MOV AL, NUM1

SUB AL, NUM2

MOV SUB_RES, AL

RET

SUB_NUM ENDP

; Procedure for Multiplication

MUL_NUM PROC

MOV AL, MUL_NUM1

MUL MUL_NUM2 ; AL = AL * MUL_NUM2, result in AX

MOV PRODUCT, AX ; Store result

RET

MUL_NUM ENDP

; Procedure for Division

DIV_PROC PROC

MOV AX, DIV_NUM1 ; Move dividend into AX

DIV DIV_NUM2 ; AL = Quotient, AH = Remainder

MOV RESULT_QUO, AL

MOV RESULT_REM, AH
 RET

DIV_PROC ENDP

CODE ENDS

END START

;WRITE AN ALP TO FIND SMALLEST NUMBER FROM THE ARRAY OF 10 NUMBERS USING
PROCEDURE

DATA SEGMENT

NUMBERS DB 45H,12H,67H,09H,34H,56H,23H,11H,30H

MINIMUM DB ?

DATA ENDS

CODE SEGMENT

ASSUME CS:CODE,DS:DATA

START:

MOV AX,DATA

MOV DS,AX

CALL FIND_SMALLEST

MOV AH,4CH

INT 21H

FIND_SMALLEST PROC

LEA SI,NUMBERS

MOV AL,[SI]

MOV CX,9
 INC SI

COMPARE_LOOP:

CMP AL,[SI]

JBE SKIP

MOV AL,[SI]

SKIP:

INC SI

LOOP COMPARE_LOOP

MOV MINIMUM,AL

RET

FIND_SMALLEST ENDP

CODE ENDS

END START