Write a complete program in Assembly Language 1 Prompts the

Write a complete program in Assembly Language: 1. Prompts the user to enter 10 numbers. 2. saves those numbers in a 32 bit integer array. 3. Calculates the sum of the numbers and displays it. 4. Calcualtes the mean of the array and displays it. 5. Prints the array with the same order it was enterd. 6. Rotates the members in the array forward one position for 9 times. so the last rotation will display the array in reversed order. Print the array after each rotation. check the sample run. Here is Sample Run: Please enter a number: 2 Please enter a number: 3 Please enter a number: 4 Please enter a number: 5 Please enter a number: 6 Please enter a number: 7 Please enter a number: 8 Please enter a number: 9 Please enter a number: 0 Please enter a number: 10 The sum is: 54 The mean is: 5 4/10 The original array: 2 3 4 5 6 7 8 9 0 10 After a rotation: 10 2 3 4 5 6 7 8 9 0 After a rotation: 10 0 2 3 4 5 6 7 8 9 After a rotation: 10 0 9 2 3 4 5 6 7 8 After a rotation: 10 0 9 8 2 3 4 5 6 7 After a rotation: 10 0 9 8 7 2 3 4 5 6 After a rotation: 10 0 9 8 7 6 2 3 4 5 After a rotation: 10 0 9 8 7 6 5 2 3 4 After a rotation: 10 0 9 8 7 6 5 4 2 3 After a rotation: 10 0 9 8 7 6 5 4 3 2 Press any key to continue . . .

Solution

.model small
.stack 100h
.data
prompt db 13, 10, \'First number:\',\'$\'
prompt db 13,10, \'Second number:\', \'$\'
result db 13, 10, \'Sum\',\'$\'

;Variables

num1 db ?
num2 db ?
sum db ?

.code
main proc

   mov ax,@data       ;get data segment address
   mov ds,ax           ;initialize ds

;Display Prompt

   mov ah,9   ;print string function
   mov dx,offset prompt;ds:dx points to string
   int 21h

; Numbers from the user
    mov ah,1    ;input function
    int 21h
    mov bl,al    ;save the value from input
   mov num1,al

   mov ah,9
   lea dx, prompt    ;print prompt
   int 21h

   mov ah,2    ;input second function
    int 21h
    mov bh,al    ;save the value from second input
   mov num2,al

;Addition
       mov ax,num1           ;move num1 into ax
       add ax,num2           ;add first and second numbers together
       mov sum,ax           ;move the total sum of numbers in sum

;Print Sum
   mov ah,9
       lea dx, result       ; print result
   int 21h

   mov ah,2
   mov dl,bl
   int 21h

       mov dl,\'+\'           ;display + sign
   int 21h

   mov dl,bh
   int 21h

       mov dl,\'=\'           ;display = sign
   int 21h

   mov dl,bh
   int 21h

       mov ah,4ch
       int 21h

main endp

end main

3.

MOV AX, DATA
MOV DS, AX
XOR AL, AL
LEA SI, NUM
MOV CX, 0005
MOV AH, 00
NEXT:    ADD AL, [SI]
INC SI
LOOP NEXT
MOV CL, 05
DIV CL
MOV SUM, AL
END

or

DATA SEGMENT
NUM1 DB 5
NUM2 DB 9
NUM3 DB 7
AVG DB ?
ENDS
CODE SEGMENT
ASSUME DS:DATA CS:CODE
START:
MOV AX,DATA
MOV DS,AX

MOV AL,NUM1
ADD AL,NUM2
ADD AL,NUM3

MOV AH,0

MOV DL,3
DIV DL

MOV AVG,AL

MOV AH,4CH
INT 21H   
ENDS

or

.MODEL SMALL
.DATA
VAL1 DB ?
NL1 DB 0AH,0DH,\'ENTER HOW MANY NO U WANT:\',\'$\'
NL2 DB 0AH,0DH,\'ENTER NO:\',\'$\'
NL3 DB 0AH,0DH,\'AVEARGE:\',\'$\'
.CODE
MAIN PROC
MOV AX,@DATA
MOV DS,AX

LEA DX,NL1
MOV AH,09H
INT 21H

MOV AH,01H
INT 21H
SUB AL,30H

MOV CL,AL
MOV BL,AL
MOV AL,00
MOV VAL1,AL

LBL1:
LEA DX,NL2
MOV AH,09H
INT 21H

MOV AH,01H
INT 21H
SUB AL,30H

ADD AL,VAL1
MOV VAL1,AL
LOOP LBL1

LBL2:
LEA DX,NL3
MOV AH,09H
INT 21H

MOV AX,00
MOV AL,VAL1
DIV BL
ADD AX,3030H
MOV DX,AX
MOV AH,02H
INT 21H

MOV AH,4CH
INT 21H

MAIN ENDP
END MAIN

4.
.MODEL SMALL
.STACK 100H

.DATA
PROMPT_1 DB \'Enter the Array elements :\',0DH,0AH,\'$\'
PROMPT_2 DB \'The Array elements are : $\'

ARRAY DW 10 DUP(0)

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

MOV BX, 10 ; set BX=10

LEA DX, PROMPT_1 ; load and display the string PROMPT_1
MOV AH, 9   
INT 21H

LEA SI, ARRAY ; set SI=offset address of ARRAY

CALL READ_ARRAY ; call the procedure READ_ARRAY

LEA DX, PROMPT_2 ; load and display the string PROMPT_2
MOV AH, 9
INT 21H

LEA SI, ARRAY ; set SI=offset address of ARRAY

CALL PRINT_ARRAY ; call the procedure PRINT_ARRAY

MOV AH, 4CH ; return control to DOS
INT 21H
MAIN ENDP

;**************************************************************************;
;**************************************************************************;
;------------------------- Procedure Definitions ------------------------;
;**************************************************************************;
;**************************************************************************;

;**************************************************************************;
;----------------------------- READ_ARRAY -------------------------------;
;**************************************************************************;

READ_ARRAY PROC
; this procedure will read the elements for an array
; input : SI=offset address of the array
; : BX=size of the array
; output : none

PUSH AX ; push AX onto the STACK
PUSH CX ; push CX onto the STACK
PUSH DX ; push DX onto the STACK

MOV CX, BX ; set CX=BX

@READ_ARRAY: ; loop label
CALL INDEC ; call the procedure INDEC

MOV [SI], AX ; set [SI]=AX
ADD SI, 2 ; set SI=SI+2

MOV DL, 0AH ; line feed
MOV AH, 2 ; set output function
INT 21H ; print a character
LOOP @READ_ARRAY ; jump to label @READ_ARRAY while CX!=0

POP DX ; pop a value from STACK into DX
POP CX ; pop a value from STACK into CX
POP AX ; pop a value from STACK into AX

RET ; return control to the calling procedure
READ_ARRAY ENDP

;**************************************************************************;
;----------------------------- PRINT_ARRAY ------------------------------;
;**************************************************************************;

PRINT_ARRAY PROC
; this procedure will print the elements of a given array
; input : SI=offset address of the array
; : BX=size of the array
; output : none

PUSH AX ; push AX onto the STACK   
PUSH CX ; push CX onto the STACK
PUSH DX ; push DX onto the STACK

MOV CX, BX ; set CX=BX

@PRINT_ARRAY: ; loop label
MOV AX, [SI] ; set AX=AX+[SI]

CALL OUTDEC ; call the procedure OUTDEC

MOV AH, 2 ; set output function
MOV DL, 20H ; set DL=20H
INT 21H ; print a character

ADD SI, 2 ; set SI=SI+2
LOOP @PRINT_ARRAY ; jump to label @PRINT_ARRAY while CX!=0

POP DX ; pop a value from STACK into DX
POP CX ; pop a value from STACK into CX
POP AX ; pop a value from STACK into AX

RET ; return control to the calling procedure
PRINT_ARRAY ENDP

;**************************************************************************;
;------------------------------- INDEC ----------------------------------;
;**************************************************************************;

INDEC PROC
; this procedure will read a number indecimal form
; input : none
; output : store binary number in AX

PUSH BX ; push BX onto the STACK
PUSH CX ; push CX onto the STACK
PUSH DX ; push DX onto the STACK

JMP @READ ; jump to label @READ

@SKIP_BACKSPACE: ; jump label
MOV AH, 2 ; set output function
MOV DL, 20H ; set DL=\' \'
INT 21H ; print a character

@READ: ; jump label
XOR BX, BX ; clear BX
XOR CX, CX ; clear CX
XOR DX, DX ; clear DX

MOV AH, 1 ; set input function
INT 21H ; read a character

CMP AL, \"-\" ; compare AL with \"-\"
JE @MINUS ; jump to label @MINUS if AL=\"-\"

CMP AL, \"+\" ; compare AL with \"+\"
JE @PLUS ; jump to label @PLUS if AL=\"+\"

JMP @SKIP_INPUT ; jump to label @SKIP_INPUT

@MINUS: ; jump label
MOV CH, 1 ; set CH=1
INC CL ; set CL=CL+1
JMP @INPUT ; jump to label @INPUT

@PLUS: ; jump label
MOV CH, 2 ; set CH=2
INC CL ; set CL=CL+1

@INPUT: ; jump label
MOV AH, 1 ; set input function
INT 21H ; read a character

@SKIP_INPUT: ; jump label

CMP AL, 0DH ; compare AL with CR
JE @END_INPUT ; jump to label @END_INPUT

CMP AL, 8H ; compare AL with 8H
JNE @NOT_BACKSPACE ; jump to label @NOT_BACKSPACE if AL!=8

CMP CH, 0 ; compare CH with 0
JNE @CHECK_REMOVE_MINUS ; jump to label @CHECK_REMOVE_MINUS if CH!=0

CMP CL, 0 ; compare CL with 0
JE @SKIP_BACKSPACE ; jump to label @SKIP_BACKSPACE if CL=0
JMP @MOVE_BACK ; jump to label @MOVE_BACK

@CHECK_REMOVE_MINUS: ; jump label

CMP CH, 1 ; compare CH with 1
JNE @CHECK_REMOVE_PLUS ; jump to label @CHECK_REMOVE_PLUS if CH!=1

CMP CL, 1 ; compare CL with 1
JE @REMOVE_PLUS_MINUS ; jump to label @REMOVE_PLUS_MINUS if CL=1

@CHECK_REMOVE_PLUS: ; jump label

CMP CL, 1 ; compare CL with 1
JE @REMOVE_PLUS_MINUS ; jump to label @REMOVE_PLUS_MINUS if CL=1
JMP @MOVE_BACK ; jump to label @MOVE_BACK

@REMOVE_PLUS_MINUS: ; jump label
MOV AH, 2 ; set output function
MOV DL, 20H ; set DL=\' \'
INT 21H ; print a character

MOV DL, 8H ; set DL=8H
INT 21H ; print a character

JMP @READ ; jump to label @READ
  
@MOVE_BACK: ; jump label

MOV AX, BX ; set AX=BX
MOV BX, 10 ; set BX=10
DIV BX ; set AX=AX/BX

MOV BX, AX ; set BX=AX

MOV AH, 2 ; set output function
MOV DL, 20H ; set DL=\' \'
INT 21H ; print a character

MOV DL, 8H ; set DL=8H
INT 21H ; print a character

XOR DX, DX ; clear DX
DEC CL ; set CL=CL-1

JMP @INPUT ; jump to label @INPUT

@NOT_BACKSPACE: ; jump label

INC CL ; set CL=CL+1

CMP AL, 30H ; compare AL with 0
JL @ERROR ; jump to label @ERROR if AL<0

CMP AL, 39H ; compare AL with 9
JG @ERROR ; jump to label @ERROR if AL>9

AND AX, 000FH ; convert ascii to decimal code

PUSH AX ; push AX onto the STACK

MOV AX, 10 ; set AX=10
MUL BX ; set AX=AX*BX
MOV BX, AX ; set BX=AX

POP AX ; pop a value from STACK into AX

ADD BX, AX ; set BX=AX+BX
JS @ERROR ; jump to label @ERROR if SF=1
JMP @INPUT ; jump to label @INPUT

@ERROR: ; jump label

MOV AH, 2 ; set output function
MOV DL, 7H ; set DL=7H
INT 21H ; print a character

XOR CH, CH ; clear CH

@CLEAR: ; jump label
MOV DL, 8H ; set DL=8H
INT 21H ; print a character

MOV DL, 20H ; set DL=\' \'
INT 21H ; print a character

MOV DL, 8H ; set DL=8H
INT 21H ; print a character
LOOP @CLEAR ; jump to label @CLEAR if CX!=0

JMP @READ ; jump to label @READ

@END_INPUT: ; jump label

CMP CH, 1 ; compare CH with 1   
JNE @EXIT ; jump to label @EXIT if CH!=1
NEG BX ; negate BX

@EXIT: ; jump label

MOV AX, BX ; set AX=BX

POP DX ; pop a value from STACK into DX
POP CX ; pop a value from STACK into CX
POP BX ; pop a value from STACK into BX

RET ; return control to the calling procedure
INDEC ENDP

;**************************************************************************;
;-------------------------------- OUTDEC --------------------------------;
;**************************************************************************;

OUTDEC PROC
; this procedure will display a decimal number
; input : AX
; output : none

PUSH BX ; push BX onto the STACK
PUSH CX ; push CX onto the STACK
PUSH DX ; push DX onto the STACK

CMP AX, 0 ; compare AX with 0
JGE @START ; jump to label @START if AX>=0

PUSH AX ; push AX onto the STACK

MOV AH, 2 ; set output function
MOV DL, \"-\" ; set DL=\'-\'
INT 21H ; print the character

POP AX ; pop a value from STACK into AX

NEG AX ; take 2\'s complement of AX

@START: ; jump label

XOR CX, CX ; clear CX
MOV BX, 10 ; set BX=10

@OUTPUT: ; loop label
XOR DX, DX ; clear DX
DIV BX ; divide AX by BX
PUSH DX ; push DX onto the STACK
INC CX ; increment CX
OR AX, AX ; take OR of Ax with AX
JNE @OUTPUT ; jump to label @OUTPUT if ZF=0

MOV AH, 2 ; set output function

@DISPLAY: ; loop label
POP DX ; pop a value from STACK to DX
OR DL, 30H ; convert decimal to ascii code
INT 21H ; print a character
LOOP @DISPLAY ; jump to label @DISPLAY if CX!=0

POP DX ; pop a value from STACK into DX
POP CX ; pop a value from STACK into CX
POP BX ; pop a value from STACK into BX

RET ; return control to the calling procedure
OUTDEC ENDP

;**************************************************************************;
;--------------------------------------------------------------------------;
;**************************************************************************;

END MAIN

;**************************************************************************;
;**************************************************************************;
;------------------------------ THE END ---------------------------------;
;**************************************************************************;
;**************************************************************************;

\\