# Program that take a number of cents C, 0<=C<=99, and express C as half-dollars, quarters, dimes, nickels, and pennies. Use INDEC to enter C

``` .MODEL SMALL
.STACK 100H

.DATA
PROMPT        DB  \'Enter the Number of Cents (C) 0<=C<=99 = \$\'
ILLEGAL       DB  0DH,0AH,\'Invalid number of Cents. Try again = \$\'
HALF_DOLLARS  DB  0DH,0AH,\'Number of Half-Dollars = \$\'
QUARTERS      DB  0DH,0AH,\'Number of Quarters     = \$\'
DIMES         DB  0DH,0AH,\'Number of Dimes        = \$\'
NICKELS       DB  0DH,0AH,\'Number of Nickels      = \$\'
PENNIES       DB  0DH,0AH,\'Number of Pennies      = \$\'

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

LEA DX, PROMPT               ; load and print the string PROMPT
MOV AH, 9
INT 21H

@ILLEGAL:                    ; jump label

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

@START_AGAIN:                ; jump label

CALL INDEC                   ; call the procedure INDEC

CMP AX, 0                    ; compare AX with 0

CMP AX, 99                   ; compare AX with 99

MOV BL, 50                   ; set BL=50
DIV BL                       ; set AL=AX/BL , AH=AX%BL

MOV BH, AH                   ; set BH=AH
XOR AH, AH                   ; clear AH

PUSH AX                      ; push AX onto the STACK

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

POP AX                       ; pop a value from STACK into AX

CALL OUTDEC                  ; call the procedure OUTDEC

XOR AX, AX                   ; clear AX
MOV AL, BH                   ; set AL=BH
MOV BL, 25                   ; set BL=25

DIV BL                       ; set AL=AX/BL , AH=AX%BL

MOV BH, AH                   ; set BH=AH
XOR AH, AH                   ; clear AH

PUSH AX                      ; push AX onto the STACK

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

POP AX                       ; pop a value from STACK into AX

CALL OUTDEC                  ; call the procedure OUTDEC

XOR AX, AX                   ; clear AX
MOV AL, BH                   ; set AL=BH
MOV BL, 10                   ; set BL=10

DIV BL                       ; set AL=AX/BL , AH=AX%BL

MOV BH, AH                   ; set BH=AH
XOR AH, AH                   ; clear AH

PUSH AX                      ; pop a value from STACK into AX

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

POP AX                       ; pop a value from STACK into AX

CALL OUTDEC                  ; call the procedure OUTDEC

XOR AX, AX                   ; clear AX
MOV AL, BH                   ; set AL=BH
MOV BL, 5                    ; set BL=5

DIV BL                       ; set AL=AX/BL , AH=AX%BL

MOV BH, AH                   ; set BH=AH
XOR AH, AH                   ; clear AH

PUSH AX                      ; push AX onto the STACK

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

POP AX                       ; pop a value from STACK into AX

CALL OUTDEC                  ; call the procedure OUTDEC

XOR AX, AX                   ; clear AX
MOV AL, BH                   ; set AL=BH

PUSH AX                      ; push AX onto the STACK

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

POP AX                       ; pop a value from STACK into AX

CALL OUTDEC                  ; call the procedure OUTDEC

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

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

;-------------------------------  INDEC  ----------------------------------;

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

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

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

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 \"-\"

CMP AL, \"+\"                    ; compare AL with \"+\"

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

@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

CMP AL, 8H                   ; compare AL with 8H

CMP CH, 0                    ; compare CH with 0

CMP CL, 0                    ; compare CL with 0

@CHECK_REMOVE_MINUS:         ; jump label

CMP CH, 1                    ; compare CH with 1

CMP CL, 1                    ; compare CL with 1

@CHECK_REMOVE_PLUS:          ; jump label

CMP CL, 1                    ; compare CL with 1

@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

@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

@NOT_BACKSPACE:              ; jump label

INC CL                       ; set CL=CL+1

CMP AL, 30H                  ; compare AL with 0

CMP AL, 39H                  ; compare AL with 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

@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

@END_INPUT:                    ; jump label

CMP CH, 1                      ; compare CH with 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
; uses : MAIN

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

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

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

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
```