.TITLE	SRDLST-LIST THE DIRECTORY
	.IDENT	/V2.3/		;14-NOV-79				;+++002
;+									;**-1
;
;**SRD--SORT DIRECTORY
;
;THIS MODULE CREATS A SELECTIVE LISTING OF THE FILE
;
;
; THIS TASK WILL SORT A RSX11M DIRECTORY
;THEN CREATE A LISTING WITH MANY SELECTION OPTIONS
;
;THIS IS THE MAIN ROUTINE, AND IS PURE.
;
;
;-
;
;SYSTEM MACRO CALLS
;
	.MCALL	FHDOF$,CALLR,DIR$,QIOW$S,WTSE$S,PUT$S
	FHDOF$	DEF$L
DTSTR:	.BYTE	40,2,'-,3,'-,2,' ,2,':,2,' ,0
	.BYTE	'(,-1,'),' ,' ,' ,0					;+++002
	.EVEN
FUTABL:
	.BYTE	H.UFAT+F.EFBK+2	;FCS'S END OF FILE
	.BYTE	12.,40,40	;SIZE,LEADING CHAR,TRAILING CHAR
	.WORD	SIZECV		;CONVERTION ROUTINE
	.BYTE	H.PROG,10.,'[,']
	.WORD	UICCV	;OWNER UIC CONVERSTION
	.BYTE	H.FNUM,16.,'(,')	;FILE NUMBER
	.WORD	FIDCV
	.BYTE	H.FPRO,22.,'[,']
	.WORD	FPROCV
	.WORD	0		;END OF TABLE
;
FPSTR:	.ASCIZ	/RWED/
TERMRS:	.ASCII	\;\		;FILE-NAME FIELD TERMINATOR
UICTRM:	.BYTE	0		;UIC FIELD TERMINATOR
	.EVEN
;
SRDLST::
;
	BIT	#OWSW,SWMSK$	;DOING OWNER SELECT
	BEQ	LSTDIR		;EQ - NO
	BIT	#OWSUPL,S2MSK$	;WAS AN OWNER STRING SUPPLIED
	BNE	LSTDIR		;NE - YES
	MOV	#OWBUF$,R0	;NO - USE CURRENT UFD AS OWNER STRING
	CALL	UFDCNV		;CONVERT UFD
	CLRB	(R0)		;TERMINATE STRING
;
;DIRECTORY IS SORTED,NOW GENERATE LISTING
;
LSTDIR:
	BIC	#HDSW,S2MSK$	;FLAG HEADER NOT PRINTED		;+++002
	MOV	DIRBF$,R5	;SET START OF DIRECTORY BUFFER
	BIT	#SUSW,SWMSK$	;WILL SUMMARY LINE BE INCLUDED
	BEQ	UNPACK		;EQ - NO
	CLR	BLKUSE		;YES - CLEAR SUMMARY ACCUMULATORS
	CLR	BLKUSE+2
	CLR	BLKALL
	CLR	BLKALL+2
	CLR	FILCNT
UNPACK:
	TST	(R5)		;ANY THING REMAINING TO UN-PACK?
	BNE	10$		;CONTINUE
	CALL	SUMARY		;PRINT SUMMARY IF SELECTED AND RETURN
	RETURN
;
10$:
	MOV	R5,READHD+Q.IOPL ;SET FILE ID POINTER INCASE HEADER IS NEEDE
	MOV	LSTFDB+F.NRBD+2,R0 ;SET TO POINT AT START OF REC
	ADD	#D.FNAM,R5	;POINT AT FILE-NAME PORTION
;
	MOV	#3,R3		;NUMBER OF WORDS IN NAME
	MOV	R5,-(SP)		;SAVE FILE POINTER
20$:
	MOV	(R5)+,R1	;GET A RADIX-50 WORD
	CALL	$C5TA		;CONVERT TO ASCII
	DEC	R3		;COUNT NUMBER OF ENTRIES DONE
	BGT	20$		;BR IF STILL DOING NAME
	BMI	30$		;BR IF JUST DID TYPE
	MOVB	#'.,(R0)+	;SEPARATE NAME AND TYPE
	BR	20$		;---AND DO TYPE
30$:
	MOVB	#';,(R0)+	;SEPARATE TYPE AND VERSION
	MOV	(R5)+,R1	;NOW GET VERSION
	CLR	R2		;SET ZERO SUPPRESS FLAG
	CALL	$CBOMG		;CONVERT TO ASCII
	MOV	(SP)+,R5		;RESTORE FILE POINTER
;
CKSV:
	BIT	#SVSW,SWMSK$	;ONLY 1 VERSION WANTED?
	BEQ	30$		;BR IF NO
	MOV	R5,R3		;COPY CURRENT NAME
	SUB	#D.SIZ,R3	;BACK UP 1 ENTRY
	MOV	R5,R1		;GET CURRENT AGAIN
	MOV	#4,R2		;SIZE OF NAME
10$:
	CMP	(R3)+,(R1)+	;NAMES THE SAME?
	BNE	30$		;BR IF NO-LIST IT
	SOB	R2,10$		;DO ALL 4
20$:
	JMP	FAIL			;MATCH FAILED
30$:
	BIT	#HVSW,SWMSK$	;SELECTING VERSIONS HIGHER THAN?
	BEQ	CKSE		;BR IF NO
	MOV	LVNUM$,R1	;GET LOWEST VERSION TO SELECT
	BNE	40$		;BR IF USER GAVE VALUE
	MOV	#2,R1		;ELSE USE 2 AS LOW LIMIT
40$:
	CMP	<D.VER-D.FNAM>(R5),R1 ;VERSION HIGH ENOUGH?
	BLO	20$		;BR IF NO- FAILED
;
CKSE:
	BIT	#SESW,SWMSK$	;IS THIS A SELECTIVE LIST?
	BEQ	CKDA		;BR IF NO-CK FOR DATE SELECTION
	MOV	#SEBUF$,R2	;SET SELECTION STRING ADDRESS
	MOV	#TERMRS,R3	;SET FIELD TERMINTORS
	MOV	LSTFDB+F.NRBD+2,R1 ;SET START OF NAME
	CALL	MATCHI		;CHECK FILE/SELECT MATCH
	BCC	CKDA		;CC - CHECK DATE
	JMP	FAIL			;OTHERWISE FAILED
;
CKDA:
	CALL	HDREAD			;READ HEADER IF NECESSARY
;
	BIT	#DASW,SWMSK$	;DOING DATESELECTION?
	BEQ	CKOW		;EQ - NO CHECK OWNER
	MOVB	HDBUF$,R1	;GET OFFSET TO IDENT AREA IN HEADER
	ASL	R1		;MAKE AWORD OFFSET
	ADD	#HDBUF$+I.CRDT,R1  ;POINT AT CREATION DATE
;
10$:
	BIT	#RVSW,SWMSK$	;DOING REVISION DATE SELECTION		;+++002
	BEQ	20$		;NO - DATE POSITION CORRECT		;+++002
	ADD	#I.RVDT-I.CRDT,R1  ;POINT AT REVISION DATE		;+++002
	TST	(R1)		;IS THIS FILE BEING CREATED
	BNE	20$		;NO - OK
	JMP	NEXT		;FORGET IT!
20$:									;+++002
	CALL	CNVDAT		;CONVERT DATE TO INTEGER
	MOV	DABUF$,R1	;GET TARGET
	BIT	#AFSW,SWMSK$	;AFTER DATE SELECTION
	BNE	30$		;BR IF YES
	BIT	#BESW,SWMSK$	;BEFORE DATE?
	BEQ	40$		;BR IF NO
	MOV	R2,-(SP)	;EXCHANGE
	MOV	R1,R2		;
	MOV	(SP)+,R1	;R1 AND R2
30$:
	CMP	R2,R1		;
	BHI	CKOW		;BR IF NOT
40$:
	CMP	R1,R2		;DATES THE SAME
	BEQ	CKOW		;EQ - YES
	JMP	FAILNH		;NO - FAIL, NO HEADER READ
;
CKOW:
	BIT	#OWSW,SWMSK$	;DOING OWNER SELECT
	BEQ	SUCESS		;EQ - NO LIST FILE
	MOV	R0,-(SP)	;SAVE CURRENT BUFFER PTR
	MOVB	#'[,(R0)+	;DELIMIT OWNER FIELD
	MOV	HDBUF$+H.PROG,R1 ;GET FILE OWNER
	CALL	UICCV		;CONVERT TO ASCII
	MOVB	#'],(R0)+	;DELIMIT
	CLRB	(R0)+			;TERMINATE
	MOV	(SP)+,R0	;GET FIELD START
	MOV	R0,R1		;IN R1
	MOV	#UICTRM,R3	;GET FIELD TERMINATORS
	MOV	#OWBUF$,R2	;GET OWNER SELECT STRING
	CALL	MATCHI		;MATCH IT AGAINST OWNER
	BCC	SUCESS		;CC - WE HAVE A MATCH LIST IT
;
;MATCH FAILED - SUCCESS IF /NE WAS SELECTED
;
FAIL:
	BIT	#NESW,SWMSK$		;/NE ?
	BEQ	NEXT			;EQ - NO SO DONT LIST IT
	CALL	HDREAD			;READ HEADER IF NECESSARY
	BR	LSTENT			;AND LIST ENTRY
FAILNH:
	BIT	#NESW,SWMSK$
	BNE	LSTENT
NEXT:
	ADD	#<D.SIZ-D.FNAM>,R5
	JMP	UNPACK			;TRY NEXT NAME
;
;MATCH SUCCEEDED
;
SUCESS:
	BIT	#NESW,SWMSK$		;/NE ?
	BNE	NEXT			;NE - YES DONT LIST IT
LSTENT:
	BIT	#HDSW,S2MSK$	;HAS HEADER BEEN LISTED?		;+++002
	BNE	LSTE1		;BR IF YES
	BIS	#<HDSW!FLSW>,S2MSK$	;FLAG AS PRINTED		;+++002
	SUB	#D.FNAM,R5	;BACK UP TO DO THIS 1 AGAIN
	MOV	LSTFDB+F.NRBD+2,R0 ;RESET POINTER TO TOP OF BUFFER
	MOV	#" *,(R0)+	;FLAG NEW ENTRY
	MOV	#"* ,(R0)+	;THAT MAKES LISTING EASIER TO READ
	MOV	<UFDFDB+F.FNB+N.DVNM>,(R0)+ ;COPY DEVICE NAME	;**NEW**
	MOV	<UFDFDB+F.FNB+N.UNIT>,R1 ;GET UNIT NUMBER	;**NEW**
	ASR	R1						;**NEW**
	ASR	R1						;**NEW**
	ASR	R1			;DIVIDE BY 10(OCTAL)	;**NEW**
	BEQ	10$		;BR IF UNIT LESS THAN 10(OCTAL)	;**NEW**
	ADD	#'0,R1		;MAKE PRINTABLE			;**NEW**
	MOVB	R1,(R0)+	;INSERT INTO LISTING		;**NEW**
10$:
	MOV	<UFDFDB+F.FNB+N.UNIT>,R1 ;GET UNIT BACK		;**NEW**
	BIC	#177770,R1	;REDUCE TO <0-7>		;**NEW**
	ADD	#'0,R1		;ADD IN ASCII BIAS		;**NEW**
	MOVB	R1,(R0)+	;INSERT IN LISTING		;**NEW**
	MOVB	#':,(R0)+	;NOW DELINIT DEVICE NAME	;**NEW**
	CALL	UFDCNV		;CONVERT UFD NAME FOR LISTING
	MOVB	#' ,(R0)+	;SEPARATE
	MOV	#DATIM$,R1	;POINT AT DATE & TIME
20$:	MOVB	(R1)+,(R0)+	;FILL IN DATE
	CMP	R1,#<DATIM$+16.> ;FINISH DATE?
	BLO	20$		;BR IF NO
	CALL	PUTLST		;PRINT THAT
	JMP	UNPACK		;DO FILE LISTING AGAIN
;
LSTE1:
	BIT	#<FUSW!BESW!AFSW!RVSW>,SWMSK$ ;FULL LISTING		;+++002
	BEQ	60$		;BR IF NO
	MOV	LSTFDB+F.NRBD+2,R1;START OF LINE BUF
	ADD	#20.,R1		;POINT AT END OF NAME FIELD
	MOV	#DTSTR,R2	;DATE-TIME FORMAT STRING
	MOVB	HDBUF$,R3		;GET HEADER IDENT AREA
	ASL	R3
	ADD	#HDBUF$+I.CRDT,R3	;POINT AT CREATION DATE
;
1$:
	BIT	#RVSW,SWMSK$		;DOING REVISION DATE
	BEQ	2$
	ADD	#I.RVDT-I.CRDT,R3	;POINT AT REVISION DATE
	TST	(R3)			;IS FILE BEING CREATED?
	BNE	2$			;NE - NO
	JMP	NEXT		;FORGET IT!
2$:
	MOVB	(R2),(R0)+	;SPACE FILL
	CMP	R0,R1		;FULL?
	BLO	2$		;BR WHEN FIELD NOT FULL
	MOVB	(R2)+,(R0)+	;ONE MORE
4$:
	MOVB	(R2)+,R1	;GET NEXT SIZE
	BEQ	8$
6$:
	MOVB	(R3)+,(R0)+	;COPY DATE
	SOB	R1,6$		;COUNT FIELD
	MOVB	(R2)+,(R0)+	;TERMINATOR
	BR	4$
8$:
	MOVB	(R2)+,(R0)+	;MOVE IN DATE TYPE FIELD		;+++002
	BGT	8$		;GT - MORE TO DO			;+++002
	BEQ	9$		;EQ - DONE				;+++002
	MOVB	#'C,-1(R0)	;ASSUME CREATION DATE TYPE		;+++002
	BIT	#RVSW,SWMSK$	;IS IT REVISION DATE			;+++002
	BEQ	8$		;EQ - NO				;+++002
	MOVB	#'R,-1(R0)	;YES - SET REVISION DATE TYPE		;+++002
	BR	8$							;+++002
9$:									;+++002
	BIT	#FUSW,SWMSK$	;REALLY BIG LISTING
	BEQ	PUT1		;LIST THAT MUCH
	MOV	#FUTABL,R3	;FORMAT TABLE ADDRESS
10$:
	MOVB	(R3)+,R4	;PICK UP NEXT OFFSET
	BEQ	60$		;BR WHEN END
	ADD	#HDBUF$,R4	;ADJ FOR ADDRESS OF BUFFER
	MOVB	(R3)+,R1	;PICK UP SIZE OF FIELD
20$:
	MOV	R1,R2		;COPY THAT
	ADD	R0,R2		;FIND HOW BIG THE LINE WILL BE
	MOV	LINSZ$,-(SP)	;PUSH MAX SIZE OF RECORD
	ADD	LSTFDB+F.NRBD+2,(SP) ;ADD IN START OF RECORD
	CMP	R2,(SP)+	;WILL IT GET TOO BIG?
	BLOS	30$		;BR IF NO
	CALL	PUTLST		;WRITE IT OUT
	MOV	(PC)+,(R0)+	;INSERT SOME SPACE
	.BYTE	40,40		;2 SPACES
	BR	20$		;TRY AGAIN
30$:
	MOV	R2,-(SP)	;PUSH END OF BUFFER
	MOVB	(R3)+,(R0)+	;INSERT LEADING CHAR
	BNE	40$		;BR IF NOT A NULL
	DEC	R0		;BACK UP OVER NULL
40$:
	MOVB	(R3)+,-(SP)	;SAVE TRAILING CHAR FOR LATER
	MOV	(R4)+,R1		;PICK UP 16 BIT ARG
	CALL	@(R3)+		;DISPATCH TO ROUTINE
	MOVB	(SP)+,(R0)+	;COPY TRAILING CHAR
	MOV	(SP)+,R1	;GET END OF FIELD ADDRESS
50$:
	CMP	R0,R1		;IS RECORD UP TO END OF FIELD
	BHIS	10$		;BR WHEN FIELD IS FULL
	MOVB	#40,(R0)+	;SPACE FILL
	BR	50$		;TRY AGAIN
60$:
PUT1:
	CALL	PUTLST		;OUTPUT THE LINE
	BIT	#SUSW,SWMSK$	;IS SUMMARY SELECTED
	BEQ	1$		;EQ - NO
	BIT	#FUSW,SWMSK$	;WERE BLOCK COMPUTATIONS ALREADY DONE
	BNE	1$		;NE - YES
	MOV	#HDBUF$+H.UFAT+F.EFBK+2,R4 ;NO DO THEM NOW
	MOV	(R4)+,R1
	CALL	SIZECV
1$:
	BIT	#SDSW,SWMSK$	;DOING SELECTIVE DELETE?
	BEQ	60$		;BR IF NO
	BIT	#DESW,SWMSK$	;ALWAYS DELETE
	BNE	5$		;YES-DON'T BOTHER TO ASK
	CLRB	LINBUF		;ERASE ANY PREVIOUS YES'S
	QIOW$S	#IO.RVB,MOLUN,#17.,,#IOSB$,,<#LINBUF,#4>
	TSTB	IOSB$		;ANY ERR-MUST BE EOF
	BGT	3$		;BR IF NO ERR
	RETURN			;*** EXIT THIS RUN ###
3$:
	BICB	#40,LINBUF		;ALLOW LOWER CASE Y	;002
	CMPB	#'Y,LINBUF	;ANSWER YES
	BNE	60$
5$:
	MOV	R5,R0		;COPY PLCE IN DIRECTORY BUFFER
	ADD	#D.VER+2-D.FNAM,R0
	MOV	#UFDFDB+F.FNB+N.FVER+2,R1 ;POINT AT FILE NAME BLOCK END
	MOV	#<D.SIZ/2>,R2		;SET NUMBER OF WORDS IN DIRECTORY ENTRY
10$:
	MOV	-(R0),-(R1)	;COPY THE DATA
	SOB	R2,10$		;DO ALL
	MOV	#UFDFDB,R0	;POINT AT FDB PROPER
	MOV	SAVDID,F.FNB+N.DID(R0) ;RESTORE
	MOV	SAVDID+2,F.FNB+N.DID+2(R0) ;DIRECTORY ID
	MOV	SAVUNM,F.FNB+N.UNIT(R0) ;DEVICE UNIT NUMBER
	MOV	SAVDVN,F.FNB+N.DVNM(R0) ;---AND FINALLY NAME
	CALL	.DLFNB
	BCC	60$		;BR IF DELETE WORKED
	DIAG	FDEL		;ISSUE DIAGNOSTIC MESSAGE
60$:
	JMP	NEXT		;DO THE NEXT
;
;HEADER READ ROUTINE
;
HDREAD:
	BIT	#<FUSW!DASW!SUSW!OWSW>,SWMSK$ ;DO WE NEED HEADER
	BEQ	60$		;BR IF NO
10$:				;REFERENCE LABEL
	DIR$	#READHD		;READ THE FILE HEADER
	BCC	20$
	CALL	$ALERR
	BR	10$
20$:
	WTSE$S	#EFN1
	TSTB	IOSB$		;DID READ WORK?
	BGT	60$		;BR IF YES
	DIAG	HDRE		;HEADER READ ERR
	CALL	PUTLST			;PRINT FILE NAME
	MOV	#NEXT,(SP)		;RETURN TO NEXT NAME PATH
60$:
	RETURN
;
;CONVERSION AND MATCHING ROUTINES
;
UFDCNV:
	MOVB	#'[,(R0)+	;SET UIC DELIMITER
	MOV	UFDFDB+F.FNAM,R1 ;GET DIRECTORY NAME
	CALL	20$		;CONVERT GROUP NAME TO ENGLISH
	MOVB	#',,(R0)+	;SEPARATE GROUP & USER
	MOV	UFDFDB+F.FNAM+2,R1 ;GET OTHER HALF OF NAME
	CALL	20$		;CONVERT PROGRAMMER NUMBER
	MOVB	#'],(R0)+	;TERMINATE UIC
	RETURN
20$:	MOV	R0,-(SP)	;SAVE START POINT
	CALL	$C5TA		;CHANGE TO ENGLISH
	MOV	(SP)+,R2	;GET TOP OF LIST
	DEC	R0		;BACK UP TO LAST CHAR IN STRING
30$:	CMPB	R2,R0		;ALL DONE?
	BHIS	50$		;BR IF DONE
	CMPB	#'0,(R2)	;LEADING ZERO?
	BNE	50$		;BR IF NO
	MOVB	1(R2),(R2)	;MOVE UP STRING
	MOVB	2(R2),1(R2)	;...
	DEC	R0		;SHORTEN STRING
	BR	30$		;TRY FOR MORE
50$:	INC	R0		;RESET POINTER PAST STRING
	RETURN
;
SIZECV:
	BIT	#SUSW,SWMSK$	;IS SUMMARY LINE INCLUDED
	BEQ	10$		;EQ - NO
	MOV	R4,R2		;YES - COPY FILE HEADER POINTER F.FFBY
	INC	FILCNT		;BUMP FILE COUNT
	ADD	-(R2),BLKUSE+2	;UPDATE BLOCKS USED
	ADC	BLKUSE
	ADD	-(R2),BLKUSE
	ADD	-(R2),BLKALL+2	;AND BLOCKS ALLOCATED
	ADC	BLKALL
	ADD	-(R2),BLKALL
10$:
	TST	(R4)		;IS FIRST FREE BYTE ZERO
	BNE	20$		;NE - NO BLOCKS USED IS CORRECT
	DEC	R1		;CORRECT BLOCKS USED
	BGE	15$
	INC	R1
	BR	20$
15$:
	SUB	#1,BLKUSE+2	;AND TOTAL USED
	SBC	BLKUSE
20$:
	CLR	R2		;SET ZERO SUPPRESS FLAG
	CALL	$CBDMG		;CONVERT TO ASCII
	MOV	<F.HIBK-<F.EFBK+2>>(R4),R1 ;GET HIEST ALLOCATED
	MOVB	#'/,(R0)+	;INSERT A SEPARTOR
	CLR	R2		;ZERO SUPPRESS
	CALLR	$CBDMG		;COVERT AND RETURN
;
UICCV:	MOV	R1,-(SP)	;SAVE UIC
	CLRB	R1		;REMOVE PROGRAMMER NUMBER
	SWAB	R1		;GET PROGECT INTO LO BYTE
	CLR	R2		;SUPPRESS ZERO'S
	CALL	$CBOMG		;CONVERT THAT MUCH
	CLR	R1		;GET READY FOR UNSIGNED---
	BISB	(SP)+,R1	; MOVE BYTE OF PROGRAMMER NUMBER
	CLR	R2		;ZERO SUPPRESS
	MOVB	#',,(R0)+	;SEPARATE WITH COMMA
	CALLR	$CBOMG		;COVERT FOR OUTPUT
;
FIDCV:
	CLR	R2		;SUPPRESS ZEROS
	CALL	$CBOMG		;CONVERT TO OCTAL
	MOVB	#',,(R0)+	;SEPARATE
	MOV	(R4),R1	;GET SEQ NUMBER
	CALLR	$CBOMG		;CONVERT THAT
;
FPROCV:
	MOV	#4,R2		;NUMBER OF FILELDS TO CONVERT
10$:	MOV	#FPSTR,R3	;FORMAT STRING
20$:	ASR	R1		;MOVE 1 BIT INTO C
	BCS	30$		;BR IF NOT ACTIVE
	MOVB	(R3),(R0)+	;INSERT A DESRIPTOR CHAR
30$:	INC	R3		;ADJ FORMAT STRING
	TSTB	(R3)		;END OF LIST
	BNE	20$		;BR IF NO
	MOVB	#',,(R0)+	;INSERT A SEPARATOR
	SOB	R2,10$		;LOOP?
	DEC	R0		;NO-BACK UP OVER LAST COMMA
	RETURN
;
;PUTLST---PUT A RECORD INTO LISTING FILE
;
PUTLST:
	SUB	LSTFDB+F.NRBD+2,R0 ;FIND LENGTH OF LINE
	MOV	R0,LSTFDB+F.NRBD ;SET LENGTH INTO FDB
	PUT$S	#LSTFDB		;WRITE THE LINE
	BCC	10$
	FERR	PUTE		;???CAN'T DO PUT???
10$:	MOV	F.NRBD+2(R0),R0 ;GET RECORD BUFFER
	RETURN
;
;PRINT SUMMARY LINE IF SELECTED
;
SUMARY:
	BIT	#SUSW,SWMSK$	;IS SUMMARY INCLUDED
	BEQ	10$		;EQ - NO
	BIT	#HDSW,S2MSK$	;HAVE ANY FILES BEEN LISTED
	BEQ	10$		;EQ - NO
	MOV	LSTFDB+F.NRBD+2,R0 ;SET OUTPUT BUFFER
	MOV	#FMTTAB,R1	;GET FORMAT TABLE FOR $EDMSG
	MOV	#FMTARG,R2	;AND ARGUMENT BLOCK
	CALL	$EDMSG		;EDIT THE MESSAGE
	CALL	PUTLST		;PRINT IT
10$:
	RETURN
	.END