MEGAMON COMMAND SUMMARY

A OR *; MINI ASSEMBLER 
A <ADDR><MNEMONIC><OPERAND>

B ; SET/DISPLAY BREAKPOINT 
B <BRKPT#><ADDR> (B=DISPLAY)

C ; COMPARE MEMORY
C <START><END><TARGET>

D ; DISSASSEMBLE MEMORY
D <START><END>

E ; MEMORY DISPLAY W/CHECKSUM
E <START><END>

F ; FILL MEMORY
F <START><END><BYTE>




G ; EXECUTE PROGRAM 'GO'
G <ADDR>

H ; HUNT MEMORY
H <START><END>[<NUMBER:STRING>]

I ; SET/DISPLAY IRQ VECTOR
I <ADDR> (I ALONE TO DISPLAY)

J ; RESET MONITOR

K ; KILL BREAKPOINT
K <BREAKPOINT#>

L ; LOAD A FILE
L <"NAME"><DEV><ADDR>

M ; MEMORY DUMP (HEX OR ASCII)
M <START><END>



N ; DYNAMIC MEMORY SCAN
N <ADDR>

O ; OUTPUT REDIRECTION
O <DEV><SECONDARY ADDR><"TEXT">

P ; DISPLAY DISK DIR
P <"MASK"><DEV> OR (P <RETURN>)

Q ; QUIT (COLD START)

R ; DISPLAY/CHG  REGISTERS

S ; SAVE A FILE 
S <"NAME"><DEV><START><END>

T ; TRANSFER BLOCK OF MEMORY
T <START><END><DESTINATION>




U ; USER DEFINABLE COMMAND
U <ANYTHING>

V ; SET/DISPLAY USER VECTORS
V <ADDR> (ALONE TO DISPLAY)

W ; SINGLE STEP (WALK) 
W <ADDR> SEE WALK COMMAND

X ; EXIT MONITOR (WARM START)
X CAUTION SEE EØIT COMMAND

Y ; SET COLORS
Y <TEXT><BGND><BRDR> (0-15)DECIMAL

% ; COMMENT 'NULL' LINE
% <ANYTHING>

# ; CONVERT NUMBER
# 34F0 OR # &49152


+ ; ADD NUMBERS
+ FFD2 &32768

- ; SUBTRACT NUMBERS
- FFD2 D020


? ; DISPLAY HELP FILE
? "NAME" DEV (OPTIONAL)

@ ; I/O TO DISK (LIKE WEDGE)
@ "N0:NAME,00"

: MODIFY MEMORY
: ADDR BYTES  

! ; TEXT TO MEMORY
! C000 "TEXT AT C000"




; ; 'MASS REGISTER CHANGE
; PC A X Y SP SR  OR R CMD

^ ; CONFIGURATION MODE


NUMBERS MAY BE INPUT IN THESE FORMATS
HEX $ IS OPTIONAL. $FFD2 OR FFD2.
DECIMAL & PREFIX E.G. &49152
ASCII  " PREFIX E.G. "TEXT"
BINARY % PREFIX E.G. %10101110


USE RUN/STOP TO ABORT AND THE SPACE
BAR TO STOP/START MEMORY DUMPS ETC.









          MEGAMON COMMANDS

COMMAND:  MINI-ASSEMBLER
FORMAT:   A [ADDR[MNEMONIC]]
          * [ADDR[MNEMONIC]]
EXAMPLE:  A C000 LDA #$20
FUNCTION: ASSEMBLES <MNEMONIC> TO 
MEMORYLOCATION DESIGNATED BY <ADDR>.
THE NEXT AVAILABLE MEMORY LOCATION IS 
THEN DISPLAYED. IF <ADDR> OR <MNEMONIC>
IS MISSING, THE COMMAND IS IGNORED, AND
THE NORMAL MONITOR PROMPT RETURNS.







COMMAND:  SET/DISPLAY BREAKPOINTS
FORMAT:   B [BP#[ADDR]]
EXAMPLE:  B 0 C000
FUNCTION: ALLOWS THE USER TO SET UP TO
8 "BREAK POINTS" IN A ML PROGRAM BY    
REPLACING THE BYTE AT <ADDR> WITH A BRK
INSTRUCTION. THE BYTE AT <ADDR> IS     
SAVED, AND CAN BE REPLACED BY USING THE
"K" (KILL BREAKPOINT) COMMAND. <BP#>   
SPECIFIES THE BREAKPOINT NUMBER, AND   
CAN BE BETWEEN 0-7. IF NO PARAMETERS   
ARE GIVEN, THE CURRENT BREAKPOINTS ARE 
DISPLAYED.

COMMAND:  COMPARE MEMORY BLOCKS
FORMAT:   C START END TARGET
EXAMPLE:  C 1000 2000 C000
FUNCTION: COMPARES THE MEMORY BETWEEN  
<START>-<END> WITH <TARGET>, AND PRINTS
ANY DIFFERENCES FOUND.


COMMAND:  DISASSEMBLE MEMORY
FORMAT:   D [START[END]]
EXAMPLE:  D A474 A500
FUNCTION: DISPLAYS A DISASSEMBLY OF THE
MEMORY BETWEEN <START>-<END>, IF BOTH  
PARAMETERS ARE SPECIFIED. IF ONLY      
<START> IS GIVEN, THE SINGLE           
INSTRUCTION AT THAT LOCATION IS        
DISPLAYED. IF NO PARAMETERS ARE 
SPECIFIED, THE INSTRUCTION AT THE
CURRENT PC IS DISPLAYED.











COMMAND:  MEMORY DISPLAY WITH CHECKSUM
FORMAT:   E [START[END]]
EXAMPLE:  E 5F60 6000
FUNCTION: DISPLAYS MEMORY BETWEEN      
<START> AND <END> IN HEX FORMAT, 8     
BYTESTO A LINE. AT THE END OF EACH LINE
A 1-BYTE LINE CHECKSUM IS DISPLAYED.   
AFTER THE DISPLAY IS COMPLETE, A 2-BYTE
TOTAL CHECKSUM IS SHOWN. IF ONLY 1     
PARAMETER IS GIVEN, THE 8 BYTES        
FOLLOWING <START> ARE DISPLAYED. IF NO 
PARAMETERS ARE GIVEN, THE 8 BYTES      
FOLLOWING THE CURRENT PC ARE SHOWN.

COMMAND:  FILL MEMORY BLOCK WITH BYTE
FORMAT:   F START END BYTE
EXAMPLE:  F C000 CFFF 0
FUNCTION: FILLS ALL MEMORY BETWEEN     
<START> AND <END> WITH <BYTE>. IF BYTE 
ISN'T SPECIFIED IT DEFAULTS TO 00.


COMMAND:  EXECUTE PROGRAM
FORMAT:   G [ADDR]
EXAMPLE:  G C800
FUNCTION: PERFORMS A JSR TO <ADDR> IF  
GIVEN. IF NOT SPECIFIED, A JSR TO THE  
CURRENT PC TAKES PLACE. A USER PROGRAM 
MUST END WITH AN RTS OR BRK INSTRUCTION
TO RETURN TO THE MONITOR.


COMMAND:  HUNT MEMORY FOR DATA
FORMAT:   H START END [NBR/STRING]
EXAMPLE:  H C000 C800 "TXT" 0 "MORE" 20
FUNCTION: SEARCHES MEMORY BETWEEN      
<START> AND <END> FOR THE STRING AND/OR
NUMBER SEQUENCE GIVEN. ÉF A MATCH IS   
FOUND, THE ALL LOCATIONS OF THE        
OCCURANCE ARE DISPLAYED.




COMMAND:  SET/DISPLAY IRQ VECTOR
FORMAT:   I [ADDR]
EXAMPLE:  I CF00
FUNCTION: ALLOWS THE USER TO DEFINE A  
ROUTINE TO BE SERVICED BY THE 1/60 SEC.
PROCESSOR INTERRUPT. THE ROUTINE SHOULD
(NORMALLY) END WITH A JMP $EA31        
INSTRUCTION. IF <ADDR> IS NOT GIVEN,   
THE CURRENT IRQ VECTOR (NORMALLY $EA31)
IS DISPLAYED.

COMMAND:  RESET MONITOR
FORMAT:   J
EXAMPLE:  J
FUNCTION: RE-INITIALIZES THE MONITOR   
AND DISPLAYS THE BOOT-UP SCREEN. SOME  
OF THE FUNCTIONS PERFORMED: IRQ IS     
RESET TO $EA31, ALL BREAKPOINTS ARE    
CLEARED, THE PSEUDO-REGISTERS ARE SET  
TO THEIR DEFAULT VALUES AND THE        
SCREEN/TEXT COLORS ARE RETURNED TO     
THEIR DEFAULT SETTINGS.

COMMAND:  "KILL" (RESET) A BREAKPOINT
FORMAT:   K [BP#]
EXAMPLE:  K 0
FUNCTION: RESETS THE BREAKPOINT        
SPECIFIED BY <BP#>. SPECIFICALLY, IT   
REMOVES THE BRK INSTRUCTION PLACED BY  
THE B (BREAKPOINT) COMMAND, AND        
REPLACES IT WITH IT'S FORMER CONTENTS. 
IF <BP#> IS NOT GIVEN, THE STATUS OF   
ALL 8 AVAILABLE BREAKPOINTS IS SHOWN.












COMMAND:  LOAD A FILE FROM DISK OR TAPE
FORMAT:   L "FILENAME" [DEVICE[ADDR]]
EXAMPLE:  L "A FILE"
FUNCTION: LOADS A FILE FROM DISK OR    
TAPE INTO MEMORY. IF <DEVICE> IS NOT   
GIVEN, THE CURRENT DEFAULT IS USED (SEE
THE "^" COMMAND FOR INFO ON THE DEFAULT
DEVICE). IF <ADDR> IS NOT GIVEN, THE   
FILE IS LOADED AT IT'S INTERNAL        
"LOAD ADDRESS". IF GIVEN, THE FILE WILL
BE FORCE-LOADED STARTING AT <ADDR>.











COMMAND:  MEMORY DUMP IN HEX & ASCII
FORMAT:   M [START[END]]
EXAMPLE   M A000 A400
FUNCTION: DISPLAYS THE CONTENTS OF     
MEMORY BETWEEN <START> AND <END> IN HEX
AND ASCII, 8 BYTES TO A LINE. IF THE   
DISPLAY IS GOING TO THE PRINTER,       
NUMBERS0-31 AND 128-159 (DECIMAL) ARE  
CONVERTED TO "."'S BEFORE BEING        
DISPLAYED. IF GOING TO SCREEN, ONLY THE
CARRIAGE      RETURN (13 AND 141) IS   
CONVERTED - ALL OTHER BYTES ARE        
DISPLAYED AS IF IN "QUOTE MODE".       
AS WITH THE "E" COMMAND, ALL PARAMETERS
ARE OPTIONAL.







COMMAND:  DYNAMIC MEMORY SCAN
FORMAT:   N ADDR
EXAMPLE:  N A0
FUNCTION: DISPLAYS THE MEMORY CONTENTS 
BETWEEN <ADDR> AND <ADDR>+$1F AT THE   
TOP OF THE SCREEN, AND UPDATES THIS    
DISPLAY CONTINUOUSLY. THIS IS USEFUL   
FOR EXAMINING HARDWARE LOCATIONS AND   
STORAGE AREAS FOR INTERRUPT ROUTINES   
(THE EXAMPLE SHOWS THE MEMORY USED BY  
THE KERNAL REAL-TIME CLOCK). THE SPACE 
BAR WILL "FREEZE" THE DISPLAY AND      
PRESSING RUN/STOP TERMINATES THE SCAN.









COMMAND:  OUTPUT REDIRECTION
FORMAT:   O [DEVICE[S.A.["TEXT"]]]
EXAMPLE   O 4 4
FUNCTION: OPENS A CHANNEL TO THE DEVICE
SPECIFIED, AND REDIRECTS ALL MONITOR   
OUTPUT TO THIS DEVICE. ALL PARAMETERS  
ARE OPTIONAL, AND IF NONE ARE GIVEN THE
OUTPUT IS DIRECTED BACK TO THE SCREEN. 
NOTE THAT THE N,W,P,@, AND ^ COMMANDS  
RESET OUTPUT REDIRECTION.












COMMAND:  DISPLAY DISK DIRECTORY
FORMAT:   P ["DIR MASK"[DEVICE]]
EXAMPLE:  P "MON*"
FUNCTION: DISPLAYS THE DISK DIRECTORY  
ON <DEVICE> USING <"DIR MASK"> AS A    
DIRECTORY DISPLAY MASK (SEE YOUR DISK  
MANUAL FOR DETAILS ON THIS). IF        
<"DIR MASK"> IS NOT GIVEN, THE ENTIRE  
DIRECTORY IS DISPLAYED, IF <DEVICE> IS 
OMITTED, THE CURRENT DEFAULT IS USED.  
THIS COMMAND CAN ONLY BE USED ON       
DEVICES 8 AND ABOVE, OTHERWISE THE     
COMMAND IS IGNORED.









COMMAND:  EXIT MONITOR (COLD START)
FORMAT:   Q [ADDR]
EXAMPLE:  Q
FUNCTION: RETURNS CONTROL BACK TO BASIC
AFTER PERFORMING A "POWER ON" RESET.   
<ADDR> IS USUALLY NOT GIVEN, BUT IF IT 
IS, THE MONITOR WILL SIMPLY JUMP TO THE
LOCATION GIVEN. (THE COLD START VECTOR 
CAN BE CHANGED - SEE THE "^" COMMAND).













COMMAND:  DISPLAY/CHANGE REGISTERS
FORMAT:   R [REGNAME VALUE]
EXAMPLE:  R A 20
FUNCTION: DISPLAYS THE CURRENT MONITOR 
"PSEUDO REGISTERS" THAT ARE RESTORED   
BEFORE EXECUTING THE G,Q, OR X         
COMMANDS.THIS COMMAND CAN ALSO BE USED 
TO CHANGE SINGLE REGISTERS BY          
SPECIFYING A REGISTER NAME             
(A,X,Y,S,P OR *) AND A NEW VALUE.      
THE REGISTER DISPLAY CONSISTSOF A      
BANNER WITH THE REGISTER VALUES        
DISPLAYED UNDERNEATH IT. THE STATUS    
REGISTER IS FURTHER BROKEN DOWN INTO   
IT'S RESPECTIVE FLAG VALUES, WITH A    
REVERSED LETTER REPRESENTING A 'SET'   
CONDITION.





COMMAND:  SAVE MEMORY TO DEVICE
FORMAT:   S "FILENAME" DEVICE START END
EXAMPLE:  S "TESTFILE" 8 C200 C3F0
FUNCTION: SAVES THE BLOCK OF MEMORY    
BETWEEN <START> AND <END> TO <DEVICE>. 
ALL PARAMETERS MUST BE GIVEN.

COMMAND:  MOVE (TRANSFER) MEMORY BLOCK
FORMAT:   T START END DESTINATION
EXAMPLE:  T A000 A400 C000
FUNCTION: PERFORMS A NON-DESTRUCTIVE   
MOVE OF THE MEMORY BETWEEN <START> AND 
<END> TO <DESTINATION>. IF THE BLOCKS  
OVERLAP, THE COMMAND WILL AUTOMATICALLY
PERFORM THE TRANSFER IN THE NESSESARY  
DIRECTION TO PRESERVE THE DATA.






COMMAND:  USER-DEFINABLE COMMAND
FORMAT:   U [ANYTHING]
EXAMPLE:  U
FUNCTION: THIS COMMAND IS OPEN-ENDED,  
WAITING FOR YOU TO IMPLIMENT. IT'S     
VECTOR MAY BE DEFINED BY USING THE 'V' 
COMMAND OR IN THE CONFIGURATION MODE.  
FOR DIRECTIONS ON IMPLIMENTATION, REFER
TO THE ARTICLE.

COMMAND:  DEFINE USER VECTOR
FORMAT:   V [ADDR]
EXAMPLE:  V C000
FUNCTION: SETS THE USER (U) COMMAND    
EXECUTION VECTOR TO <ADDR>. (THIS CAN  
ALSO BE DONE IN CONFIGURATION MODE).   
IF NO <ADDR> IS GIVEN, THE CURRENT USER
VECTOR IS DISPLAYED.




COMMAND:  SINGLE-STEP (WALK) PROGRAM
FORMAT:   W [ADDR[AR[XR[YR[SP[SR]]]]]]
EXAMPLE:  W C000
FUNCTION: THIS IS PERHAPS ONE OF THE   
MOST USEFUL MONITOR COMMANDS. IT ALLOWS
YOU TO SINGLE-STEP A MACHINE LANGUAGE  
PROGRAM. WHEN THIS COMMAND IS EXECUTED,
THE MONITOR GOES INTO "WALK MODE",     
DISPLAYING THE REGISTERS, THE          
INSTRUCTION TO BE EXECUTED, AND SOME   
DIRECTIONS. FOR MORE INFO, REFER TO THE
ARTICLE.










COMMAND:  EXIT MONITOR (WARM START)
FORMAT:   X [ADDR]
EXAMPLE:  X
FUNCTION: BASICALLY THE SAME AS THE "Q"
COMMAND, EXECPT THE MONITOR TERMINATES 
TO THE BASIC WARM START ("READY")      
VECTOR. THE WARM START CAN BE CHANGED  
IN THE CONFIGURATION MODE. CAUTION MANY
ML OPERATIONS CHANGE THE BASIC POINTERS
AND USING X TO EXIT THE MONITOR CAN    
LOCK UP THE COMPUTER.

COMMAND:  SET TEXT & SCREEN COLORS
FORMAT:   Z TEXT [BACKGND[BORDER]]
EXAMPLE:  Z 1 0
FUNCTION: ALLOWS YOU TO SET THE TEXT   
AND SCREEN COLORS TO YOUR LIKING. THE  
<TEXT> COLOR MUST BE GIVEN, AND        
<BACKGND> AND <BORDER> ARE OPTIONAL.   
COLORS RANGE FROM 0-15 (DECIMAL).


COMMAND:  COMMENT LINE
FORMAT:   % [ANYTHING]
EXAMPLE   % THIS IS A COMMENT
FUNCTION: NONE. THE TEXT AFTER THE "%" 
IS IGNORED. (USEFUL FOR NULLIFYING     
LINES WHEN USING THE SCREEN EDITOR TO  
MOVE FROM PLACE TO PLACE)


COMMAND:  CONVERT NUMBER TO OTHER FORMS
FORMAT:   # [NUMBER]
EXAMPLE:  # 34F0
FUNCTION: ALLOWS YOU TO CONVERT A      
NUMBER IN ONE FORM TO THE FOUR STANDARD
MONITOR FORMS - HEX, DECIMAL, ASCII    
AND BINARY. THIS COMMAND WILL DISPLAY A
LINE CONTAINING THESE EQUIVILENTS FOR  
THE NUMBER GIVEN. 




COMMAND:  ADD NUMBERS
FORMAT:   + NBR1 NBR2
EXAMPLE:  + 400 &120
FUNCTION: ADDS THE TWO NUMBERS TOGETHER
USING UNSIGNED 16-BIT ARITHMETIC, AND  
DISPLAYS THE RESULT IN HEX, DECIMAL,   
ASCII AND BINARY                       
(AS WITH THE "#" COMMAND).

COMMAND:  SUBTRACT NUMBERS
FORMAT:   - NBR1 NBR2
EXAMPLE   - 130 C82F
FUNCTION: SUBRACTS <NBR1> FROM <NBR2>  
USING UNSIGNED 16-BIT ARITHMETIC, AND  
PRINTS THE RESULT IN HEX, DECIMAL,     
ASCII AND BINARY (EG: # AND + COMMANDS)
BOTH THE "+" AND "-" COMMANDS WILL NOT 
DISPLAY ANY CARRY RESULTING FROM THEIR 
OPERATION.



COMMAND:  DISPLAY HELP FILE
FORMAT:   ? ["FILENAME"[DEVICE]]
EXAMPLE:  ?
FUNCTION: NORMALLY PRINTS THE "DEFAULT"
HELP FILE WHICH YOU ARE READING RIGHT  
NOW IN PAGINATED (22 LINES/PG) FORMAT. 
IF <"FILENAME"> IS SPECIFIED, THAT FILE
WILL BE PRINTED, ASSUMING IT EXISTS AND
THAT IT IS A SEQENTIAL FILE (TYPE SEQ).
IF <DEVICE> IS NOT GIVEN, THE DEFAULT  
IS ASSUMED. IF YOU DO NOT WISH TO VIEW 
THE ENTIRE HELP FILE, PRESSING RUN/STOP
WILL ABORT THIS COMMAND. NOTE THAT IF  
PARAMETERS ARE GIVEN, THE FILE         
SPECIFIED WILL BECOME THE "DEFAULT"    
HELP FILE (THIS CAN ALSO BE SET IN     
CONFIGURATION MODE).





COMMAND:  I/O TO DISK COMMAND CHANNEL
FORMAT:   @ ["DISKCMD"[DEVICE]]
EXAMPLE:  @ "N:NEW DISK,00"
FUNCTION: ACTS MUCH LIKE THE COMMODORE 
DISK WEDGE, ALLOWING YOU TO EITHER     
CHECK THE STATUS OF THE DEFAULT DISK   
CHANNEL (NO PARAMETERS), OR SEND A DISK
COMMAND TO A DISK <DEVICE>. IF <DEVICE>
IS NOT GIVEN, THE DEFAULT IS ASSUMED.  
IF THE   <DEVICE> NUMBER IS <8, THE    
COMMAND IS IGNORED. NOTE THAT YOU CAN  
CHECK THE STATUS OF A DRIVE OTHER THAN 
THE DEFAULT BY SPECIFIYING A           
"NULL STRING"; E.G.  @ "" 9








COMMAND:  MODIFY MEMORY
FORMAT:   : [ADDR[BYTES]]
EXAMPLE:  : C800 "X" $50 &120 %11010
FUNCTION: ALLOWS YOU TO CHANGE THE     
CONTENTS OF MEMORY TO ANY DESIRED VALUE
(0-FF HEX). NOTE THAT THE "E" AND "M"  
COMMANDS PREFIX THEIR DISPLAYS WITH    
A ":", ALLOWING YOU TO USE THE SCREEN  
EDITOR TO EDIT A MEMORY DISPLAY. IF    
<ADDR> OR <BYTES> ARE OMITTED, THE     
COMMAND IS IGNORED AND THE NORMAL      
MONITOR PROMPT RETURNS, OTHERWISE THE  
NEXT AVAILABLE ADDRESS IS DISPLAYED    
AS A PROMPT.








COMMAND:  PUT TEXT IN MEMORY
FORMAT:   ! [ADDR["TEXT"]]
EXAMPLE:  ! C000 "TEXT AT $C000"
FUNCTION: SIMILAR IN WAYS TO THE ":"   
COMMAND, BUT ALLOWS AN ASCII STRING    
TO BE PUT DIRECTLY INTO MEMORY (INSTEAD
OF NUMERIC DATA). PARAMETER HANDLING IS
THE SAME AS THE ":" COMMAND.

COMMAND:  "MASS" REGISTER CHANGE
FORMAT:   ; [PC[AR[XR[YR[SP[SR]]]]]]
EXAMPLE:  ; C000 10 0 0 E0 0
FUNCTION: USED TO SET THE MONITOR'S    
INTERNAL "PSEUDO REGISTERS" THAT ARE   
RESTORED BEFORE THE G,Q,W, OR X        
COMMANDS ARE EXECUTED. USUALLY, YOU    
WOULD USE THE "R" COMMAND TO OBTAIN A  
REGISTER VALUE DISPLAY (WHICH IS       
PREFIXED BY A ";" FOR YOUR CONVINIENCE)
AND THEN USE THE SCREEN EDITOR TO      
MODIFY THE DESIRED REGISTERS.

COMMAND:  ENTER CONFIGURATION MODE
FORMAT:   ^
EXAMPLE:  ^
FUNCTION: THIS COMMAND IS USED TO ENTER
THE MONITOR'S CONFIGURATION SCREEN,    
WHERE SEVERAL MISCELLANEOUS PARAMETERS 
SUCH AS THE DEFAULT I/O DEVICE, HELP   
FILE NAME, WARM,COLD AND USER VECTORS, 
HELP FILE NAME, ET CETRA CAN BE SET AND
PERMANANTLY SAVED TO DISK OR TAPE. FOR 
MORE INFORMATION, REFER TO THE ARTICLE.











OTHER USEFUL INFORMATION:

ON SPECIFIYING PARAMETERS: STRING      
PARAMETERS (SUCH AS FILENAMES) MUST BE 
ENTERED BETWEEN DOUBLE QUOTES (").     
ADDRESSES AND BYTE PARAMETERS CAN BE   
ENTERED IN ANY ONE OF FOUR FORMS:

HEXDECIMAL: OPTIONAL $ PREFIX; $C000
   DECIMAL:  & PREFIX: E.G. &49152
     ASCII:  " PREFIX; E.G. "A"
    BINARY:  % PREFIX; E.G. %1010010111










OUTPUT CONTROL: FOR COMMANDS THAT COULD
POTENTIALLY PRODUCE VOLUMINOUS OUTPUT, 
THE SPACE BAR CAN BE USED TO HALT THE  
COMMAND OUTPUT, AND THE RUN/STOP KEY   
CAN BE USED TO ABORT IT. THE COMMANDS  
THAT THIS WORKS FOR ARE C,D,E,H, AND M.


NOTES ON OUTPUT REDIRECTION: MOST      
COMMANDS WILL WORK NORMALLY WHEN THE   
"O" COMMAND IS USED TO REDIRECT OUTPUT,
BUT SOME COMMANDS OBJECT TO THIS,      
NAMELY THE N,P,W,@ AND ^ COMMANDS.     
THESE COMMANDS WILL USUALLY RESET      
OUTPUT REDIRECTION.







"NEXT ADDRESS" PROMPTING - THE A,:,    
AND ! COMMANDS WILL DISPLAY THE NEXT   
AVAILABLE MEMORY LOCATION PREFIXED WITH
THEIR RESPECTIVE COMMAND SYMBOLS AS A  
PROMPT AFTER THEY ARE DONE EXECUTING.  
SIMPLY PRESS <RETURN> AFTER THIS PROMPT
TO RETURN TO THE NORMAL MONITOR PROMPT 
IF YOU DO NOT WISH TO ENTER MORE DATA. 
THE W AND ^ ARE MORE COMPLEX COMMANDS, 
AND HAVE THEIR OWN SPECIAL PROMPTS.


THE END !!!!!