# Write the following procedures : a. A procedure READ that lets the user enter a binary number and stores it in AX. b. A procedure RANDOM..............

``` .MODEL SMALL
.STACK 100H

.DATA
PROMPT_1   DB \'Enter the binary number (0000000000000001 - 0111111111111111) : \$\'
PROMPT_2   DB  0DH,0AH,\'The 100 random numbers are :\',0DH,0AH,\'\$\'
AGAIN      DB  0DH,0AH,\'Invalid Number. Try Again : \$\'
BLANKS     DB  \'    \$\'

COUNTER_1  DB  25
COUNTER_2  DB  ?

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

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

CALL READ                    ; call the procedure READ

PUSH AX                      ; PUSH AX onto the STACK

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

POP AX                       ; pop a value from STACK to AX

@LOOP_1:                     ; loop label
MOV COUNTER_2, 4           ; set COUNTER_2=4

@LOOP_2:                   ; loop label
PUSH AX                  ; push AX onto the STACK

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

POP AX                   ; pop a value from STACK into AX

CALL RANDOM              ; call the procedure RANDOM
CALL WRITE               ; call the procedure WRITE

DEC COUNTER_2            ; decrement COUNTER_2
CMP COUNTER_2, 0         ; compare COUNTER_2 with 0
JNE @LOOP_2                ; jump to label @LOOP_2 if COUNTER_2!=0

DEC COUNTER_1              ; decrement COUNTER_1
CMP COUNTER_1, 0           ; compare COUNTER_1 with 0
JNE @LOOP_1                  ; jump to label @LOOP_1 if COUNTER_1!=0

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

;------------------------  PROCEDURE DEFINITIONS  -------------------------;

;---------------------------------  READ  ---------------------------------;

READ PROC
; this procedure will read a number in binary form
; input : none
; output : store binary number in AX
; uses : MAIN

JMP @START                     ; jump to label @START

@AGAIN:                        ; jump label

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

@START:                        ; jump label

MOV CX, 16                     ; initialize loop counter
XOR BX, BX                     ; clear BX
MOV AH, 1                      ; set input function

@INPUT:                        ; loop label
INT 21H                      ; read a character

CMP AL, 0DH                  ; compare input and CR
JE @END                      ; jump to label @END if input is CR

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

CMP AL, 31H                  ; compare AL with 1
JG @AGAIN                    ; jump to label @AGAIN if AL>1

AND AL, 0FH                  ; convert ascii to decimal code
SHL BX, 1                    ; shift BX by 1 position towards left
OR  BL, AL                   ; place the input decimal digit in BL
LOOP @INPUT                    ; jump to label @INPUT if CX!=0

@END:                          ; jump label

CMP BX, 0                      ; compare BX with 0
JLE @AGAIN                     ; jump tolabel if BX<=0

MOV AX, BX                     ; set AX=BX

RET                            ; return control to the calling procedure
READ ENDP

;---------------------------------  WRITE  --------------------------------;

WRITE PROC
; this procedure will display a number in binary form
; input : AX
; output : display the binary number in AX
; uses : MAIN

PUSH AX                        ; push AX onto the STACK

MOV BX, AX                     ; set BX=AX

MOV CX, 16                     ; initialize loop counter
MOV AH, 2                      ; set output function

@OUTPUT:                       ; loop label
SHL BX, 1                    ; shift BX by 1 position towards left
JC @ONE                      ; jump to label @ONE if CF=1
MOV DL, 30H                  ; move 0 to DL
JMP @DISPLAY                 ; jump tp label @DISPLAY

@ONE:                        ; jump label
MOV DL, 31H                ; move 1 to DL

@DISPLAY:                    ; jump label
INT 21H                    ; display a digit
LOOP @OUTPUT                   ; jump to label @OUTPUT if CX!=0

POP AX                         ; pop a value from STACK into AX

RET                            ; return control to the calling procedure
WRITE ENDP

;---------------------------------  RANDOM  -------------------------------;

RANDOM PROC
; this procedure will generate a random number
; input : AX
; output : AX
; uses : MAIN

SHL AX, 1                      ; shift AX towards left by 1 position
XOR DX, DX                     ; clear DX

TEST AX, 8000H                 ; test the 15-bit of AX
JNE @FIFTEEN_BIT               ; jump to label @FIFTEEN_BIT if 15-bit=1
JMP @SKIP_1                    ; jump to label @SKIP_1

@FIFTEEN_BIT:                  ; jump label
MOV DH, 1                      ; set DH=1

@SKIP_1:                       ; jump label

TEST AX, 4000H                 ; test the 14-bit of AX
JNE @FOURTEEN_BIT              ; jump to label @FOURTEEN_BIT if 14-bit=1
JMP @SKIP_2                    ; jump to label @SKIP_2

@FOURTEEN_BIT:                 ; jump label
MOV DL, 1                      ; set DL=1

@SKIP_2:                       ; jump label

XOR DH, DL                     ; take XOR of DH & DL
AND AX, 0FFFEH                 ; clear 0-bit of AX
OR AL, DH                      ; set LSB of AL by XOR of DH & DL
AND AX, 7FFFH                  ; clear 15-bit of AX

RET                            ; return control to the calling procedure
RANDOM ENDP

END MAIN
```