.TITLE	TRANSFER
	.NLIST	BIN,BEX
	.LIST	TTM
	.IDENT	/BCZ/
 
	.MCALL	QIOW$S,EXIT$S,FINIT$,WRITE$,OPEN$W,ASTX$S
	.MCALL	FDBDF$,FDAT$A,FDRC$A,FDOP$R,NMBLK$,WSIG$S
	.MCALL	CLOSE$,FSRSZ$,ALUN$S,GCMLB$,CSI$,CSI$SW
	.MCALL	CSI$ND,CSI$SV,GCML$,CSI$1,CSI$2,QIOW$
	.MCALL	DIR$,FDBK$A,FDAT$R,FDOFF$,NBOFF$,WTSE$S
	.MCALL	MRKT$,CMKT$,READ$,OPEN$R,GET$
 
	NBOFF$	DEF$L
	FDOFF$	DEF$L
 
TIOMSG:	QIOW$	IO.WVB,1,20.,,,,<ERTMO,ERTMOE,40>
CHRCQ:	QIOW$	IO.WAL,2,20.,,,,<CTRLQ,1,0>
CHRCS:	QIOW$	IO.WAL,2,20.,,,,<CTRLS,1,0>
CHKTBF:	QIOW$	SF.GMC,2,20.,,,,<SETBF,2>
UNSTND:	QIOW$	IO.WVB,1,20.,,,,<UNERR,UNERRE,40>
STATS:	QIOW$	IO.WLB,1,20.,,,,<OUTSTS,0,40>
NORPA:	QIOW$	SF.SMC,1,10.,,ISB,,<UNSET,2>	; TURN OFF RPA
RPAON:	QIOW$	SF.SMC,1,30,,ISB,,<SETTER,2>	; SET TERM RPA AGAIN
UNSTRM:	QIOW$	SF.SMC,2,10.,,ISB,,<UNSET,2>	; TURN OFF RPA
SETREM:	QIOW$	SF.SMC,2,30,,ISB,,<SETTER,2>	; SET TERM RPA AGAIN
NWLIN1:	QIOW$	IO.WVB,1,30,,ISB,,<NEWLN,1,0>
NWLIN2:	QIOW$	IO.WVB,2,30,,ISB,,<NEWLN,1,0>
ASTQIO:	QIOW$	IO.ATA,1,30,,ISB,,<INCHR>
ASTRAN:	QIOW$	IO.ATA,2,30,,ISB,,<RCVAST>
ASTOUT:	QIOW$	IO.ATA,2,30,,ISB,,<OUTCHR>
ASTDET:	QIOW$	IO.DET,2,20
MARKTM:	MRKT$	,10.,2,TIMR
CANTIM:	CMKT$
 
START:	QIOW$S	#IO.WVB,#1,#10.,,,,<#MSG1,#MSG1E,#40>
	JSR	PC,GETLUN
	DIR$	#RPAON
	DIR$	#ASTQIO
	QIOW$S	#SF.GMC,#2,#30,,#ISB,,<#UNSTUP,#6>
	QIOW$S	#SF.SMC,#2,#20.,,#ISB,,<#SETUP,#6>
	DIR$	#ASTOUT
 
STAR0$:	DIR$	#SETREM
	DIR$	#ASTDET
	DIR$	#ASTOUT
	DIR$	#NWLIN2
	CLR	TOTBLK			; CLEAR STATUS INFO
	CLR	CRCTOT			;
	CLR	RCRCER			;
	CLRB	TST1			; CLEAN UP FLAGS
	CLRB	TST2			;
	CLRB	TRNFLG			;
	CLRB	FORFLG			;
	CLRB	TRMFLG			;
	MOVB	#1,TIMOUT		; SET TIMOUT FLAG
 
STAR1$:	WSIG$S				; WAIT FOR SIG EVENT
5$:	CMPB	#1,TST1			; IS FLAG SET FOR MENU GENERATION?
	BNE	COMPG			; NO, BRANCH TO COMPG
	CMPB	#1,TRNFLG
	BNE	10$
	CLRB	TST1
	MOVB	#1,STATFG
	BR	COMPG
10$:	CLR	R5			; CLEAR REGISTER THAT WILL STORE ANS
	QIOW$S	#IO.RPR,#1,#20.,,,,<#STOREP,#1,,#FYLTR,#FYLTRE,#0>
;
;	TEST FOR R5:
;
;	0 - GO BACK TO TRANSPARENCY MODE
;	1 - TRANSMIT FILE WITH RECV RUNNING
;	2 - RECEIVE (FROM RECV)
;	3 - EXIT
;
;   NOTE:  THE NEXT LINES ARE NOT IMPLIMENTED IN VER 2.5 OF TRANS
;
;	4 - TRANSMIT FILE WITHOUT RECV (FOREIGN COMPUTER MODE)
;	5 - RECORD (FOREIGN COMPUTER MODE)
;	ANYTHING ELSE - REPROMPT
;
	MOVB	STOREP,R5
	BIC	#260,R5			; CLEAR ASCII BITS TO GET BIN NUMBER
	CMP	R5,#3			; IS IT GREATER THAN 5
	BGT	10$			; YES, INVALID RESPONSE. REPROMPT
	ASL	R5			; DOUBLE NUMBER TO PUT ON WORD BOUNDARY
	CLRB	TST1			; CLEAR TST1 FLAG SETTING
	JMP	@JMPTBL(R5)		; JUMP TO CORRECT AREA FROM JMPTBL
 
COMPG:	CMPB	#1,TST2			; CHECK FOR OTHER CODES
	BNE	STAR1$			; NOTHING FROM RECV. GOTO STAR1$
	CLRB	TST2			; CLEAR RECV FLAG
	TSTB	TIMOUT
	BEQ	5$
	DIR$	#CANTIM
	CLRB	TIMOUT
5$:	JSR	PC,TRNOFF		; JUMP TO ROUTINE TO REMOVE TRANSPAR.
	MOV	#BUFTMP,R1
	MOV	CHRCT2,R4
	JSR	PC,CRC			; GO TO CRC ROUTINE
	CMP	CRCOUT,#0		; CHECK FOR CRC ERROR
	BEQ	20$			; SUCCESS, GO TO 20$
	CMP	CRCONT,#5		; HAS CRC FAILED 5 TIMES IN A ROW
	BLT	10$			; NO, CONTINUE
	JSR	PC,FAILCR		; YES, CHECK IF SHOULD CONTINUE
10$:	INC	CRCTOT			; INCREMENT CRC TOTAL ERROR COUNTER
	INC	CRCONT			; INCREMENT CRC TEST ERROR COUNTER
	MOV	#"F2,HEADER		; WRITE ERROR MSG HEADER
	MOV	#2,CHRCT1		; 2 CHARS IN BUFF
	JSR	PC,SNDOUT		; GO TO SNDOUT ROUTINE
	JMP	STAR1$			; GO BACK AND WAIT FOR MORE
20$:	CLR	CRCONT			; CLEAR CRC COUNTER
	MOV	#BUFTMP,R1		; MOVE TEMPORARY BUFFER ADDR INTO R1
	MOVB	1(R1),R5		; MOVE NUMBER CODE INTO R5
	BIC	#60,R5			; CLR BITS TO READ NUMBER
	ASL	R5			; MULTIPLY BY TWO (WORD ALIGN)
	CMPB	#'F,(R1)		; FAILURE?
	BNE	30$			; NO, GO TO 30$
	JMP	@FAILUR(R5)		; JMP TO OFFSET OF FAILUR
30$:	CMPB	#'S,(R1)		; IS THIS A SUCCESS?
	BNE	40$			; NO, GO TO 40$
	CLR	RCRCER			; CLEAR RECV CRC ERROR COUNT
	JMP	@SUCESS(R5)		; JMP TO OFFSET OF SUCESS
40$:	DIR$	#UNSTND			; WRITE OUT NON STANDARD MSG (THIS 
					; SHOULD NEVER OCCUR!)
	JMP	STAR0$			; RETURN TO TRANSPARENCY MODE
 
S0$:	MOV	#"S4,HEADER		; LOAD FILE MSG HEADER
	READ$	#FILNM1,#BUFFER,#512.,,#23.	; READ IN BLOCK
	BCC	30$			; BRANCH IF NO ERROR TO F2$
	CMPB	#IE.EOF,F.ERR(R0)	; IS ERROR END OF FILE?
	BNE	10$			; NO, BRANCH TO 10$
	MOV	#"S1,HEADER		; YES, TELL RECEIVER
	MOV	#2,CHRCT1		; 2 CHARS IN BUFF
	JSR	PC,SNDOUT		; AND SEND IT OUT
	QIOW$S	#IO.WVB,#1,#10.,,#ISB,,<#MSG2,#MSG2E,#40>  ; SEND SUCCESS MSG
	JMP	STAR0$			; GO BACK TO TRANSPARANCY MODE
10$:	MOV	#"F1,HEADER		; MOVE ERROR CODE INTO HEADER
20$:	MOV	#2,CHRCT1		; 2 CHARS IN BUFF
	JSR	PC,SNDOUT		; AND SEND IT OUT
	JMP	STAR1$			; WAIT FOR RETURN
30$:	INC	BLKTRN			; INCREMENT BLOCK COUNT
	WTSE$S	#23.			; WAIT FOR READ TO COMPLETE
	MOV	#514.,CHRCT1
	JSR	PC,SNDOUT
	JMP	STAR1$
 
F2$:	INC	CRCTOT			; INCREMENT TOTAL CRC ERROR COUNTER
	INC	RCRCER			; INCREMENT RECV CRC ERROR COUNTER
	CMP	RCRCER,#5		; MORE THAN 5 IN A ROW?
	BNE	20$
	QIOW$S	#IO.RPR!TF.RAL,#1,#20.,,,,<#YESNO,#1,,#ERCRC,#ERCRCE,#0>
	MOVB	YESNO,R5
	BICB	#240,R5
	CMPB	#'Y,R5
	BNE	10$
	JMP	TERMIN
10$:	CLR	RCRCER
20$:	JSR	PC,SNDOUT		; SEND OUT BLOCK
	JMP	STAR1$			; GO BACK AND WAIT FOR REPLY
 
S1$:	QIOW$S	#IO.WVB,#1,#10.,,#ISB,,<#MSG2,#MSG2E,#40>  ; SEND SUCCESS MSG
	MOV	#FILNM1,R2		; MOVE FDB INTO R2
	MOV	HIBK,F.HIBK(R2)		; SET UP FDB BEFORE CLOSING
	MOV	HIBK+2,F.HIBK+2(R2)	;
	MOV	EFBK,F.EFBK(R2)		;
	MOV	EFBK+2,F.EFBK+2(R2)	;
	MOV	FFBY,F.FFBY(R2)		;
	CLOSE$	#FILNM1			; AND THEN CLOSE FILE
	JMP	STAR0$			; GO BACK TO TRANSPARENCY MODE
 
S2$:	DIR$	#NORPA
	GCML$	#GCMBK1,#PROMT1,#PRMCT1
	CSI$1	#CSIBK1,GCMBK1+G.CMLD+2,GCMBK1+G.CMLD
	CSI$2	#CSIBK1,OUTPUT
	FINIT$
	DIR$	#RPAON			; SET TERM RPA AGAIN
	FDOP$R	#FILNM1,#3,#CSIBK1+C.DSDS,,#FO.RD	; READ ACCESS TO FILE
	OPEN$R	#FILNM1,,,#FD.RWM	; OPEN FILE FOR READ ACCESS
	BCC	10$			; NO ERROR, BRANCH TO 10$
	QIOW$S	#IO.WVB,#1,#20.,,,,<#EROPN2,#EROP2E,#40>  ; PRINT OUT ERROR MSG
	MOV	#"F0,HEADER		; LOAD ERROR MSG INTO HEADER
	MOV	#2,CHRCT1		; 2 CHARS IN BUFF
	JSR	PC,SNDOUT		; AND SEND IT OUT
	JMP	STAR1$			; GO BACK AND WAIT
10$:	DIR$	#UNSTRM
	MOVB	#2,TRNFLG
	CLR	BLKTRN			; CLEAR BLOCK COUNT
	MOV	#FILNM1,R1		; MOVE FDB ADDRESS TO R1
	MOV	#BUFFER,R2		; MOVE BUFFER ADDRESS TO R2
	MOVB	F.RTYP(R1),(R2)+	; MOVE IMPORTANT FILE PARAMETERS
	MOVB	F.RATT(R1),(R2)+	; FROM THE BUFFER INTO THE FDB
	MOVB	F.RSIZ(R1),(R2)+	; SO WHEN THE FILE IS OPEN ON THE
	MOVB	F.RSIZE+1(R1),(R2)+	; TRANS END, IT WILL HAVE THE SAME
	MOVB	F.FFBY(R1),(R2)+	; INFORMATION AS THE ORIGINAL FILE
	MOVB	F.FFBY+1(R1),(R2)+	; I.E. IF IT IS CONTIGUOUS ON RECV
	MOVB	F.RCTL(R1),(R2)+	; END, IT WILL BE CONTIGUOUS ON
	MOVB	F.EOBB(R1),(R2)+	; THE TRANS END. INFORMATION ALSO
	MOVB	F.EOBB+1(R1),(R2)+	; NEEDED TO GET STATUS
	MOVB	F.HIBK(R1),(R2)+	;
	MOVB	F.HIBK+1(R1),(R2)+	;
	MOVB	F.HIBK+2(R1),(R2)+	;
	MOVB	F.HIBK+3(R1),(R2)+	;
	MOVB	F.EFBK(R1),(R2)+	;	
	MOVB	F.EFBK+1(R1),(R2)+	;
	MOVB	F.EFBK+2(R1),(R2)+
	MOVB	F.EFBK+3(R1),(R2)
	MOV	F.HIBK+2(R1),TOTBLK	; STORE TOTAL BLOCKSIZE FOR STATUS
	MOV	#"S3,HEADER		; LOAD SUCCESS MSG INTO HEADER
	MOV	#19.,CHRCT1		; SENDING OUT 19 BYTES
	JSR	PC,SNDOUT		; AND SEND IT OUT
	JMP	STAR1$			; GO BACK AND WAIT
 
S3$:	DIR$	#NORPA
	GCML$	#GCMBK1,#PROMT1,#PRMCT1
	CSI$1	#CSIBK1,GCMBK1+G.CMLD+2,GCMBK1+G.CMLD
	CSI$2	#CSIBK1,OUTPUT
	FINIT$
	DIR$	#RPAON			; SET TERM RPA AGAIN
	MOV	#FILNM1,R1		; MOVE FDB ADDRESS TO R1
	MOV	#BUFTMP,R2		; MOVE BUFFER ADDRESS TO R2
	INC	R2
	INC	R2
	MOVB	(R2)+,F.RTYP(R1)	; MOVE IMPORTANT FILE PARAMETERS
	MOVB	(R2)+,F.RATT(R1)	; FROM THE BUFFER INTO THE FDB
	MOVB	(R2)+,F.RSIZ(R1)	; SO WHEN THE FILE IS OPEN ON THE
	MOVB	(R2)+,F.RSIZE+1(R1)	; TRANS END, IT WILL HAVE THE SAME
	MOVB	(R2)+,FFBY		; INFORMATION AS THE ORIGINAL FILE
	MOVB	(R2)+,FFBY+1		; I.E. IF IT IS CONTIGUOUS ON RECV
	MOVB	(R2)+,F.RCTL(R1)	; END, IT WILL BE CONTIGUOUS ON
	MOVB	(R2)+,F.EOBB(R1)	; THE TRANS END. INFORMATION ALSO
	MOVB	(R2)+,F.EOBB+1(R1)	; NEEDED TO GET STATUS
	MOVB	(R2)+,HIBK		;
	MOVB	(R2)+,HIBK+1		;
	MOVB	(R2)+,HIBK+2		;
	MOVB	(R2)+,HIBK+3		;
	MOVB	(R2)+,EFBK		;	
	MOVB	(R2)+,EFBK+1		;
	MOVB	(R2)+,EFBK+2		;
	MOVB	(R2),EFBK+3		;
	MOV	HIBK+2,TOTBLK		; STORE TOTAL BLOCKSIZE FOR STATUS
	CMP	#512.,F.RSIZ(R1)	; IS RECORD SIZE 512 BYTES?
	BNE	10$			; NO, JUST OPEN FILE NORMALLY
	CMPB	#1,F.RTYP(R1)		; SHOULD FILE BE CONTIGUOUS?
	BNE	10$			; NO, JUST OPEN FILE NORMALLY
	MOV	HIBK+2,CNTG	; MOVE SIZE OF CONTIG FILE INTO CNTG
	FDAT$R	#FILNM1,#R.FIX,,#512.,CNTG,#1	; MAKE FILE CONTIGUOUS
10$:	FDOP$R	#FILNM1,#3,#CSIBK1+C.DSDS,,#FO.WRT	; WRITE ACCESS TO FILE
	OPEN$W	#FILNM1,,,#FD.RWM	; AND OPEN FILE
	BCC	20$			; NO ERROR, BRANCH TO 20$
	MOV	#"F0,HEADER		; LOAD ERROR MSG INTO HEADER
	BR	30$			; BRANCH TO 30$
20$:	CLR	BLKTRN			; CLEAR BLOCK COUNT
	MOV	#"S0,HEADER		; LOAD SUCCESS MSG INTO HEADER
30$:	MOV	#2,CHRCT1		; 2 CHARS IN BUFF
	JSR	PC,SNDOUT		; AND SEND IT OUT
	JMP	STAR1$			; GO BACK AND WAIT
 
S4$:	MOV	#512.,R3
	MOV	#BUFFER,R2
	MOV	#BUFTMP,R1
	INC	R1
	INC	R1
10$:	MOVB	(R1)+,(R2)+
	SOB	R3,10$
	MOV	#2,CHRCT1		; 2 CHARS IN BUFF
	WRITE$	#FILNM1,#BUFFER,#512.,,#24.	; WRITE BLOCK TO FILE
	BCC	20$			; NO ERROR, BRANCH TO 20$
	MOV	#"F0,HEADER		; LOAD ERROR MSG INTO HEADER
	JSR	PC,SNDOUT		; AND SEND IT OUT
	JMP	STAR1$			; GO BACK AND WAIT
20$:	WTSE$S	#24.			; WAIT FOR WRITE TO COMPLETE
	INC	BLKTRN			; INCREMENT BLOCK COUNTER
	MOV	#"S0,HEADER		; MOVE SUCCESS CODE INTO HEADER
	JSR	PC,SNDOUT		; SEND IT OUT
	JMP	STAR1$			; WAIT FOR REPLY
 
F0$:	CMPB	TRNFLG,#1		; IS THIS THE RECEIVING END?
	BEQ	10$			; YES, BRANCH TO 10$
	JMP	F3$			; NO, THEN TERMINATE FOR FATAL ERROR
10$:	QIOW$S	#IO.WVB,#1,#20.,,,,<#EROPN1,#EROP1E,#40>	; PRINT OUT ERROR MSG
	JMP	STAR0$			; GO BACK TO TRANSPARENCY MODE
 
F1$:	CMPB	TRNFLG,#1		; IS THIS THE RECEIVING END?
	BEQ	10$			; YES, BRANCH TO 10$
	JMP	F3$			; NO, THEN TERMINATE FOR FATAL ERROR
10$:	QIOW$S	#IO.WVB,#1,#20.,,,,<#EREAD,#EREADE,#40>	; PRINT OUT ERROR MSG
	CLOSE$	#FILNM1			; CLOSE FILE
	JMP	STAR0$			; GO BACK TO TRANSPARENCY MODE
 
F3$:	DIR$	#UNSTND
	CLOSE$	#FILNM1			; CLOSE FILE
	JMP	STAR0$
 
;FOREN:	DIR$	#NORPA
;	GCML$	#GCMBK2,#PROMT1,#PRMCT1
;	CSI$1	#CSIBK2,GCMBK2+G.CMLD+2,GCMBK2+G.CMLD
;	CSI$2	#CSIBK2,OUTPUT
;	FINIT$
;	MOVB	#1,TRNFLG		; SET FILE TRANSFER FLAG
;	DIR$	#RPAON			; SET TERM RPA AGAIN
;	CMPB	#'2,STOREP		; IS THIS FILE TO BE TRANSMITTED?
;	BEQ	10$			; YES, BRANCH TO 10$
;	QIOW$S	#IO.WVB,#1,#10.,,,,<#NTYET,#NTYETE,#40>	; *** TO BE REMOVED
;	JMP	STAR0$					; *** TO BE CHANGED
;10$:	FDOP$R	#FILNM2,#4,#CSIBK2+C.DSDS,,#FO.RD!FA.SHR	; SET UP FDB
;	OPEN$R	#FILNM2			; OPEN THE FILE
;	BCC	20$			; OKAY, THEN GOTO 20$
;	QIOW$S	#IO.WVB,#1,#10.,,,,<#EROPN2,#EROP2E,#40>	; WRITE FAILURE MSG
;	JMP	STAR0$			; CAN'T OPEN FILE. GO TO STAR0$
;20$:	GET$	#FILNM2,#BUFFER,#512.	; GET RECORD FROM FILE
;	BCS	30$			; ON ERROR, GO TO 30$
;	MOV	F.NRBD(R0),R1		; STORE CHAR COUNT IN R1
;	QIOW$S	#IO.WAL,#2,#10.,,,,<#BUFFER,R1,#53> ; SEND OUT
;	CMPB	STATFG,#1		; IS STATFG SET?
;	BNE	20$			; NO, GET NEXT RECORD
;	JSR	PC,STATUS		; GO TO STATUS ROUTINE
;	BR	20$			; GET NEXT RECORD
;30$:	CMPB	#IE.EOF,F.ERR(R0)	; DID IT READ EOF?
;	BNE	40$			; NO, GO TO 40$
;	CLOSE$	#FILNM2			; CLOSE FILE
;	QIOW$S	#IO.WVB,#1,#10.,,,,<#MSG2,#MSG2E,#40>  ; WRITE SUCCESS MSG
;	JMP	STAR0$			; GO BACK TO TRANSPARENCY MODE
;40$:	QIOW$S	#IO.WVB,#1,#10.,,,,<#EREAD,#EREADE,#40>	; WRITE FAILURE MSG
;	CLOSE$	#FILNM2			; CLOSE FILE
;	JMP	STAR0$			; GO BACK TO TRANSPARENCY MODE
 
EXIT:	QIOW$S	#SF.SMC,#2,#10.,,#ISB,,<#UNSTUP,#6.>
	DIR$	#NORPA
	EXIT$S
 
TERMIN:	QIOW$S	#IO.WVB,#1,#30,,#ISB,,<#ERR3,#ERR3E,#40>  ; PRINT MESSAGE
	CLOSE$	#FILNM1			; CLOSE FILES ON THIS END
	CLOSE$	#FILNM2			;
	CMPB	#1,FORFLG		; IS THIS FOREIGN MODE?
	BEQ	10$			; YES, GO TO 10$
	MOV	#"F3,HEADER		; MOVE TERMINATE INTO HEADER
	MOV	#2,CHRCT1		; TWO CHARS
	JSR	PC,SNDOUT		; AND SEND IT
10$:	CMPB	#1,TRMFLG		; CHECK TRMFLG
	BEQ	20$			; FLAG SET, GO BACK TO START
	JMP	EXIT			; NOT SET, EXIT TRANS
20$:	JMP	STAR0$			; AND EXIT
 
FAILCR:	DIR$	#NORPA			; TURN RPA OFF
	CLR	R5
	QIOW$S	#IO.RPR!TF.RAL,#1,#20.,,,,<#YESNO,#1,,#CRCER,#CRCERE,#0>
	MOVB	YESNO,R5
	BICB	#240,R5			; IF LOWER CASE THEN CHANGE
	CMPB	#'Y,R5			; IS ANSWER CONTINUE?
	BNE	TERMIN			; NO, THEN GO TO TERMIN
	CLR	CRCONT			; CLEAR CRC ERR COUNTER
	RTS	PC			; AND RETURN
 
RCV1$:	MOVB	#2,TRNFLG		; SET TRANSFER FLAG
	MOVB	#2,TST1			; CHANGE TST1 FLAG SETTING
	MOV	#"S2,HEADER		; ASK FOR FILENAME FROM RECV
	MOV	#2,CHRCT1		; 2 CHARS IN BUFF
	JSR	PC,SNDOUT		; GO TO SNDOUT ROUTINE
	JMP	STAR1$			; GO BACK AND WAIT
 
TRNSPR:	MOV	#HEADER,BUFPNT
	MOV	#BUFOUT,BUFOPT
	CLR	R1
10$:	DEC	TMPCNT		; HAVE WE REACHED END OF DATA IN BUFFER?
	BGE	20$		; NO, GO TO 20$
	MOV	R1,BUFOPT
	RTS	PC		; YES, RETURN
20$:	BITB	#200,@BUFPNT
	BNE	30$
	CMPB	@BUFPNT,#0
	BEQ	30$
	CMPB	@BUFPNT,#33
	BLE	50$		; YES, GO TO 50$
30$:	MOVB	@BUFPNT,@BUFOPT
40$:	INC	BUFPNT
	INC	BUFOPT
	INC	R1
	BR	10$		; GO TO 10$
50$:	MOVB	#33,@BUFOPT
	INC	BUFOPT
	INC	R1
	MOVB	@BUFPNT,@BUFOPT
	BISB	#100,@BUFOPT
	BR	40$		; GO TO 40$
 
GCMBK1:	GCMLB$	,FIL
	CSI$
	.EVEN
 
GCMBK2:	GCMLB$	,FIL
	CSI$
	.EVEN
 
GETLUN:	GCML$	#LUNBLK,#PROMT2,#PRMCT2
	MOV	#LUNBUF,R1
	CMP	#"HE,(R1)
	BNE	10$
	MOV	#"XX,(R1)
	QIOW$S	#IO.WVB,#1,#10.,,,,<#MESS1,#MES1E,#40>
	QIOW$S	#IO.RPR,#1,#20.,,,,<#YESNO,#1,,#CONMSG,#CONEND,#0>
	QIOW$S	#IO.WVB,#1,#11.,,,,<#MESS2,#MES2E,#40>
	BR	GETLUN
10$:	MOV	#LUNBUF,R0
	CMP	#"TT,(R0)
	BEQ	20$
	CMP	#"EX,(R0)
	BEQ	15$
12$:	QIOW$S	#IO.WVB,#1,#10.,,,,<#ERR4,#ERR4E,#40>
15$:	JMP	EXIT
20$:	MOV	#LUNBUF+2,R0
	MOV	(R0),R3
	CALL	$COTB
	MOV	R1,R2
	TST	R2
	BNE	30$
	CMPB	#'0,R3
	BNE	12$	
30$:	ALUN$S	#2.,#"TT,R2
	RTS	PC
 
LUNBLK:	GCMLB$	,LUN,LUNBUF,,,10.
	.EVEN
 
LUNBUF:	.BLKB	10.
	.EVEN
 
CSIBK1:	.BLKB	C.SIZE
	.EVEN
 
CSIBK2:	.BLKB	C.SIZE
	.EVEN
 
FILNM1:	FDBDF$
	FDBK$A	BUFFER,512.,,20.
	FDBF$A
	FSRSZ$	1
 
FILNM2:	FDBDF$
	FDRC$A	,BUFFER,512.
	FSRSZ$	1
 
TIMR:	TST	(SP)+			; SET STACK RIGHT
	CLRB	TST1
	CLRB	TST2
	CLRB	TRNFLG
	CLRB	TRMFLG
	DIR$	#TIOMSG			; PRINT OUT MESSAGE
	ASTX$S				; RETURN
 
TRNOFF:	MOV	CHRCT2,R1
	MOV	#BUFTMP,BFTPNT		; MOV ADR OF BUFTMP INTO POINTER
	MOV	#BUFTMP,TBFPNT		; MOV ADR OF BUFTMP INTO TMP POINTER
	CLRB	TRNTST
10$:	CMPB	TRNTST,#1
	BEQ	15$
	CMPB	@TBFPNT,#33
	BNE	20$
	BITB	#200,CHAR
	BNE	20$
	MOVB	#1,TRNTST
	BR	30$
15$:	CLRB	TRNTST
	BICB	#100,@TBFPNT
20$:	MOVB	@TBFPNT,@BFTPNT
	INC	BFTPNT
30$:	INC	TBFPNT
	SOB	R1,10$
	MOV	BFTPNT,CHRCT2
	SUB	#BUFTMP,CHRCT2
	RTS	PC
 
CRC:	MOV	R4,TMPCNT	; R4 HOLDS # OF CHARS IN BUFFER
10$:	MOV	R1,CRCPNT	; MOVE ADR OF BUFFER TO POINTER CRCPNT
	CLR	R1		; CLEAR R1 TO PREPARE FOR CHAR INPUT
20$:	MOVB	@CRCPNT,R2	; GET CHAR TO BE PROCESSED
	INC	CRCPNT		; SET CRCPNT TO NEXT CHAR
	MOV	POLYNO,R3	; GET CRC POLYNOMIAL
	MOV	#8.,R5		; NUMBER OF BITS PER CHAR
30$:	CLC			; ZERO TO BE SHIFTED IN
	ROR	R1		; DIVIDE RESIDUE BY 2
	ROR	R2		; DIVIDE CHAR BY 2
	BVC	40$		; BRANCH IF NO XOR REQUIRED
	XOR	R3,R1		; ADJUST RESIDUE
40$:	SOB	R5,30$		; CONTINUE UNTIL 8 BITS DONE
	SOB	R4,20$		; CONTINUE UNTIL ALL CHARS ARE DONE
	MOV	R1,CRCOUT	; MOVE RESIDUE TO BE OUTPUTTED
	MOV	#CRCOUT,R1	;
	MOVB	(R1)+,@CRCPNT	; INTO THE OUTPUT BUFFER
	INC	CRCPNT		;
	MOVB	(R1),@CRCPNT	;
50$:	ADD	#2,TMPCNT	; ADD IN CRC CHAR COUNT
	RTS	PC		; RETURN
 
STATUS:	CLR	R5		; CLEAR R5 FOR INPUT
	CLRB	STATFG		; CLEAR STATUS FLAG
;	CMPB	STOREP,#'2	; WAS THIS FOREIGN TRANSMIT?
;	BNE	1$		; NO, GO TO 1$
;	QIOW$S	#IO.RPR!TF.RAL,#1,#20.,,,,<#YESNO,#1,,#PROMT5,#PRMCT5,#0>
;	MOVB	#1,FORFLG	; SET FOREIGN FLAG
;	BR	3$		; CONTINUE
;1$:	CMPB	STOREP,#'4	; WAS THIS FOREIGN RECEIVE?
;	BNE	2$		; NO, GO TO 2$
;	QIOW$S	#IO.RPR!TF.RAL,#1,#20.,,,,<#YESNO,#1,,#PROMT6,#PRMCT6,#0>
;	MOVB	#1,FORFLG	; SET FOREIGN FLAG
;	BR	3$		; CONTINUE
2$:	QIOW$S	#IO.RPR!TF.RAL,#1,#20.,,,,<#YESNO,#1,,#PROMT3,#PRMCT3,#0>
3$:	MOVB	YESNO,R5	; STORE RESULT IN R5
	BICB	#260,R5		; CLEAR ASCII BITS TO GET BIN NUMBER
	CMPB	R5,#0		; STATUS?
	BEQ	20$		; YES, GO TO 20$
	CMPB	R5,#2		; IS IT A VALID CHARACTER?
	BGT	20$		; NOT VALID, JUST TYPE STATUS THEN CONTINUE
	CMPB	R5,#2		; SHOULD WE EXIT TRANS?
	BEQ	10$		; YES, GO TO 10$
	MOVB	#1,TRMFLG	; SET TRMFLG
	JMP	TERMIN		; NO, JUMP TO TERMIN ROUTINE
10$:	JMP	TERMIN		; JUMP TO EXIT ROUTINE
20$:	CMPB	#1,FORFLG	; IS THIS A FOREIGN TRANSFER?
	BNE	30$		; NO, GO TO 30$
	CLRB	FORFLG		; YES, CLEAR FOREIGN FLAG
	RTS	PC		; AND CONTINUE TRANSFER
30$:	MOV	R0,-(SP)	; SAVE R0
	MOV	R1,-(SP)	; SAVE R1
	MOV	R2,-(SP)	; SAVE R2
	MOV	#BLKTRN,R2	; MOVE STATUS INFO INTO R2
	MOV	#HLDSTS,R1	; MOVE STATUS TEXT INTO R1
	MOV	#OUTSTS,R0	; MOVE STORAGE AREA INTO R0
	CALL	$EDMSG		; CALL SYSTEM MESSAGE ROUTINE
	MOV	R1,STATS+Q.IOPL+2	; GET CHAR COUNT INTO QIO
	DIR$	#STATS		; OUTPUT STATUS
	MOV	(SP)+,R2	; RESTORE R2
	MOV	(SP)+,R1	; RESTORE R1
	MOV	(SP)+,R0	; RESTORE R0
	RTS	PC		; RETURN
 
SNDOUT:	cmpb	trnchr,#6
	bne	5$
	clrb	trnchr
	br	7$
5$:	CMPB	STATFG,#1	; SHOULD WE PRINT STATUS/EXIT MSG?
	BNE	10$		; NOPE, CONTINUE
7$:	JSR	PC,STATUS	; YES, GO TO STATUS ROUTINE
10$:	MOV	#HEADER,R1	; MOVE HEADER ADDR INTO R1 FOR CRC
	MOV	CHRCT1,R4
	JSR	PC,CRC		; GET THE CRC
	JSR	PC,TRNSPR	; ADD IN THE TRANSPARENCY
	QIOW$S	#IO.WAL,#2,#21.,,,,<#SOHTXT,#1,#0>	; SEND START OF MSG CHAR
	QIOW$S	#IO.WAL,#2,#21.,,,,<#BUFOUT,BUFOPT,#0>	; SEND OUT HEADER
	QIOW$S	#IO.WAL,#2,#21.,,,,<#EOTTXT,#1,#0>	; SEND END OF MSG CHAR
	RTS	PC		; RETURN
 
 
CNTRLC:	TSTB	(SP)+
	QIOW$S	#IO.WVB,#1,#30,,#ISB,,<#ERR3,#ERR3E,#40>  ; PRINT MESSAGE
	CLOSE$	#FILNM1			; CLOSE FILES ON THIS END
	CLOSE$	#FILNM2			;
	MOV	#"F3,HEADER		; MOVE TERMINATE INTO HEADER
	MOV	#2,CHRCT1		; TWO CHARS
	JSR	PC,SNDOUT		; AND SEND IT
	CLRB	TST1			; CLEAN UP FLAGS
	CLRB	TST2			;
	DIR$	#ASTDET
	DIR$	#ASTOUT
	CLRB	TRNFLG
	CLRB	FORFLG			;
	CLRB	TRMFLG			;
	ASTX$S
 
OUTCHR:	DIR$	#CHRCS
	MOVB	#1,BUFTST
10$:	MOVB	(SP)+,CHAR
15$:	QIOW$S	#IO.WAL,#1,#10.,,,,<#CHAR,#1,#0>
	DIR$	#CHKTBF
	CMPB	BUFCHK,#5
	BLT	80$
70$:	ASTX$S
80$:	CMPB	STPALL,#1
	BEQ	70$
	CMPB	BUFCHK,#1
	BGT	70$
	CLRB	BUFTST
	DIR$	#CHRCQ
	ASTX$S	
 
RCVAST:	DIR$	#CHKTBF
	CMPB	BUFCHK,#5
	BLT	10$
	DIR$	#CHRCS
	MOVB	#1,BUFTST
10$:	MOVB	(SP)+,CHAR
	CMPB	#1,SOHTST
	BEQ	40$
	CMPB	#1,CHAR
	BNE	60$
	MOV	#BUFTMP,BFTPNT
	MOVB	#1,SOHTST
	BR	60$
40$:	CMPB	#4,CHAR
	BNE	50$
	MOV	BFTPNT,CHRCT2
	SUB	#BUFTMP,CHRCT2
	CLRB	SOHTST
	MOVB	#1,TST2
	BR	60$
50$:	MOVB	CHAR,@BFTPNT
	INC	BFTPNT
60$:	CMPB	#1,BUFTST
	BEQ	80$
	DIR$	#CHKTBF
	CMPB	BUFCHK,#5
	BLT	70$
	DIR$	#CHRCS
	MOVB	#1,BUFTST
70$:	ASTX$S
80$:	CMPB	BUFCHK,#1
	BGT	70$
	CLRB	BUFTST
	DIR$	#CHRCQ
	ASTX$S	
 
INCHR:	DIR$	#CHKTBF
	CMPB	BUFCHK,#5
	BLT	10$
	DIR$	#CHRCS
	MOVB	#1,BUFTST
10$:	MOVB	(SP)+,CHAR
	BICB	#200,CHAR
	CMPB	CTRLS,CHAR
	BEQ	60$
	CMPB	#12,CHAR
	BEQ	15$
	CMPB	#6,CHAR
	BNE	20$
	MOVB	#1,TST1
15$:	ASTX$S
20$:	CMPB	TRNFLG,#1
	BEQ	15$
	BLT	30$
	CMPB	CHAR,#15
	BNE	30$
	DIR$	#ASTDET
	DIR$	#ASTRAN
	MOVB	#1,TRNFLG
	DIR$	#NWLIN1
	DIR$	#MARKTM
	BR	70$
30$:	CMPB	CTRLQ,CHAR
	BNE	70$
	CMPB	#1,STPALL
	BNE	15$
	CLRB	STPALL
	br	70$
60$:	dir$	#chrcs
	cmpb	#1,trnflg
	bne	65$
	cmpb	#1,buftst
	beq	80$
	dir$	#chrcq
	astx$s
65$:	MOVB	#1,STPALL
	BR	80$
70$:	QIOW$S	#IO.WAL,#2,#10.,,,,<#CHAR,#1,#0>
80$:	ASTX$S
 
FAILUR:	.WORD	F0$		; ERROR DURING OPEN
	.WORD	F1$		; ERROR DURING READ
	.WORD	F2$		; CRC ERROR
	.WORD	F3$		; TERMINATE RECV
 
SUCESS:	.WORD	S0$		; SUCCESSFULL TRANSFER.
	.WORD	S1$		; FILE TRANSFER COMPLETE
	.WORD	S2$		; OPEN FILE AT RECV
	.WORD	S3$		; FILE HEADER TYPE MESSAGE
	.WORD	S4$		; FILE TEXT TYPE MESSAGE
 
JMPTBL:	.WORD	STAR0$		; BACK TO TRANSPARENCY MODE
	.WORD	S2$		; TRANSMIT FILE TO RECV
	.WORD	RCV1$		; RECEIVE FILE WITH RECV RUNNING
	.WORD	EXIT		; EXIT TRANS
;
;   NOTE:  THE NEXT TWO FEATURES ARE NOT IMPLIMENTED IN VER 2.5 OF TRANS
;
;	.WORD	FOREN		; TRANSMIT FILE WITHOUT RECV
;	.WORD	FOREN		; RECORD MODE
 
POLYNO:	.WORD	102010		; POLYNOMIAL FOR DETERMINING CRC
BUFPNT:	.WORD	0		; VARIABLE USED AS POINTER INTO BUFFER
BFTPNT:	.WORD	0
TBFPNT:	.WORD	0
CRCPNT:	.WORD	0
TMPCNT:	.WORD	0
BUFOPT:	.WORD	0
CRCONT:	.WORD	0
BLKTRN:	.WORD	0
TOTBLK:	.WORD	0
CRCTOT:	.WORD	0
RCRCER:	.WORD	0
YESNO:	.BYTE	0
TRMFLG:	.BYTE	0
FORFLG:	.BYTE	0
STOREP:	.BYTE	0
trnchr:	.byte	0
SOHTXT:	.BYTE	1
EOTTXT:	.BYTE	4
SOHTST:	.BYTE	0
TIMOUT:	.BYTE	1
TRNFLG:	.BYTE	0
TRNTST:	.BYTE	0
	.EVEN
STATFG:	.BYTE	0
STPALL:	.BYTE	0
BUFTST:	.BYTE	0
	.EVEN
CTRLQ:	.BYTE	17.
CTRLS:	.BYTE	19.
SETBF:	.BYTE	TC.TBF
BUFCHK:	.BYTE	0
HEADER:	.BLKB	2
BUFFER:	.BLKB	512.			; SPACE FOR INPUT BUFFER
CRCOUT:	.BLKB	2 
BUFTMP:	.BLKB	1024.			; SPACE FOR TEMPORARY BUFFER
BUFOUT:	.BLKB	1024.			; SPACE FOR OUTPUT BUFFER
typahd:	.blkb	36.
typnt:	.word	0
CHRCT1:	.WORD	0
CHRCT2:	.WORD	0
TST1:	.BYTE	0
TST2:	.BYTE	0
CNTG:	.WORD	-5.
HIBK:	.BLKB	4
EFBK:	.BLKB	4
FFBY:	.BLKB	2
CHAR:	.BYTE	0
	.EVEN
ISB:	.BLKB	4
SETTER:	.BYTE	TC.BIN
	.BYTE	1
UNSET:	.BYTE	TC.BIN
	.BYTE	0
 
SETUP:	.BYTE	TC.SLV
	.BYTE	1
	.BYTE	TC.ACR
	.BYTE	0
	.BYTE	TC.8BC
	.BYTE	1
UNSTUP:	.BYTE	TC.SLV
	.BYTE	0
	.BYTE	TC.ACR
	.BYTE	0
	.BYTE	TC.8BC
	.BYTE	0
NEWLN:	.BYTE	15
	.EVEN
HLDSTS:	.ASCII	<15><12>/  %M OUT OF %M BLOCKS TRANSFERRED./
	.ASCIZ	/ TOTAL CRC FAILURES = %M/<15><12>
OUTSTS:	.BLKB	80.
CRCER:	.ASCII	<15><12><7>/ *** CRC HAS FAILED FIVE TIMES IN A ROW ***/
	.ASCII	<15><12><12>! *** CONTINUE ? (Y/N) ==> !
	CRCERE=.-CRCER
ERCRC:	.ASCII	<15><12>/ CRC FAILED REMOTELY /
	ERCRCE=.-ERCRC
EROPN1:	.ASCII	<15><12><7>/ *** ERROR OPENING REMOTE FILE. ***/
	.ASCII	<15><12><7>
	EROP1E=.-EROPN1
EROPN2:	.ASCII	<15><12><7>/ *** ERROR OPENING LOCAL FILE. ***/
	.ASCII	<15><12><7>
	EROP2E=.-EROPN2
EREAD:	.ASCII	<15><12><7>/ *** ERROR DURING READ. TRANSFER TERMINATED. ***/
	.ASCII	<15><12><7>
	EREADE=.-EREAD
CONMSG:	.ASCII	<15><12>/ *** ENTER ANY CHARACTER TO CONTINUE ==> /
	CONEND=.-CONMSG
NTYET:	.ASCII	<7><15><12><12>/ *** OPTION NOT YET IMPLEMENTED ***/<15><12><12>
	NTYETE=.-NTYET
PROMT1:	.ASCII	<15><12><12>/   ENTER LOCAL FILENAME.EXT ==> /
	PRMCT1=.-PROMT1
PROMT2:	.ASCII	<15><12><12>/ ENTER PORT NUMBER (TT/<156><156>/), /
	.ASCII	/ HE FOR HELP OR EX TO EXIT ==> /
	PRMCT2=.-PROMT2
PROMT3:	.ASCII	<15><12><12>/	0 - SHOW STATUS THEN CONTINUE/<15><12>
	.ASCII	/	1 - TERMINATE FILE TRANSFER AND RETURN TO/
	.ASCII	/ TRANSPARENCY MODE/<15><12>
	.ASCII	/	2 - TERMINATE FILE TRANSFER THEN EXIT/<15><12><12>
	.ASCII	/   ENTER MODE NUMBER ==> /
	PRMCT3=.-PROMT3
PROMT5:	.ASCII	<15><12><12>/	0 - CONTINUE/<15><12>
	.ASCII	/	1 - TERMINATE FILE TRANSFER AND RETURN TO/
	.ASCII	/ TRANSPARENCY MODE/<15><12>
	.ASCII	/	2 - TERMINATE FILE TRANSFER THEN EXIT/<15><12><12>
	.ASCII	/   ENTER MODE NUMBER ==> /
	PRMCT5=.-PROMT5
PROMT6:	.ASCII	<15><12><12>/	0 - CONTINUE/<15><12>
	.ASCII	/	1 - TERMINATE RECORD MODE AND RETURN TO/
	.ASCII	/ TRANSPARENCY MODE/<15><12>
	.ASCII	/	2 - TERMINATE RECORD MODE THEN EXIT/<15><12><12>
	.ASCII	/   ENTER MODE NUMBER ==> /
	PRMCT6=.-PROMT6
MSG1:	.ASCII	<15><12><12>
	.ASCII	/       ***** WELCOME TO TRANS (V2.5) *****/<15><12>
	MSG1E=.-MSG1
FYLTR:	.ASCII	<15><12><12>/	0 - GO BACK TO TRANSPARENCY MODE/<15><12>
	.ASCII	/	1 - TRANSMIT FILE WITH RECV RUNNING/<15><12>
	.ASCII	/	2 - RECEIVE (FROM RECV)/<15><12>
	.ASCII	/	3 - EXIT/<15><12><12>
;	.ASCII	/	4 - TRANSMIT FILE WITHOUT RECV (FOREIGN COMPUTER MODE)/<15><12>
;	.ASCII	/	5 - RECORD (FOREIGN COMPUTER MODE)/<15><12>
	.ASCII	/   ENTER MODE NUMBER ==> /
	FYLTRE=.-FYLTR
MSG2:	.ASCII	<15><12><12><7>/TRANSFER COMPLETE/<7><15><12><12>
	MSG2E=.-MSG2
ERTMO:	.ASCII	<15><12><7>/   *****     TIME OUT ERROR      *****/
	.ASCII	<15><12>/   ***** RECV MAY NOT BE RUNNING *****/
	.ASCII	<15><12>/   ***** TYPE CTRL F TO CONTINUE *****/
	ERTMOE=.-ERTMO
UNERR:	.ASCII	<15><12><7>/   *****  UNKNOWN ERROR IN RECV  *****/
	.ASCII	<15><12>/   *****       RECV ABORTED      *****/
	.ASCII	<15><12>/   ***** TYPE CTRL F TO CONTINUE *****/
	UNERRE=.-UNERR
ERR3:	.ASCII	<15><12><12><7>/    *****  OUTPUT ABORTED  *****/<15><12>
	.ASCII	/    ***** ALL FILES CLOSED *****/<15><12><12>
	ERR3E=.-ERR3
MESS1:	.ASCII	<15><12>
	.ASCII	/***** TRANS TRANSFERS SOURCE CODE FROM ONE/
	.ASCII	/ COMPUTER TO ANOTHER *****/
	.ASCII	<15><12><12>
	.ASCII	/***** INSTRUCTIONS: /<15><12>/   1) TYPE/
	.ASCII	/ TERMINAL NUMBER OF PORT ON LOCAL COMPUTER TO BE/<15><12>
	.ASCII	/      CONNECTED TO REMOTE COMPUTER./<15><12><12>
	.ASCII	/   2) ANY CHARACTER TYPED ON YOUR TERMINAL/
	.ASCII	/ IS NOW TRANSMITTED TO/<15><12>
	.ASCII	/      THE REMOTE COMPUTER/<15><12><12>
	.ASCII	/   3) TO ENTER COMMAND MODE :  /<15><12>
	.ASCII	/      /<141>/) TYPE CONTROL F.  (TYPE THE F KEY WHILE /<15><12>
	.ASCII	/         HOLDING DOWN THE CTRL KEY)/<15><12>
	.ASCII	/         A MENU WILL BE TYPED OUT AND YOU WILL BE PROMPTED/
	.ASCII	<15><12>
	.ASCII	/         FOR A NUMBER./<15><12><12>
	.ASCII	/   4) CONTROL F CAN BE TYPED AT ANY TIME.  DURING FILE/
	.ASCII	/ TRANSFER./<15><12>
	.ASCII	/      WITH RECV RUNNING, YOU CAN GET STATUS INFORMATION ON/
	.ASCII	/ NUMBER OF/<15><12>
	.ASCII	/      BLOCKS TRANSFERRED AND TOTAL NUMBER OF CRC FAILURES./
	.ASCII	<15><12><12>
	MES1E=.-MESS1
MESS2:	.ASCII	<15><12><12>/ MODES:/<15><12><12>
	.ASCII	/  TRANSPARENCY :  ALL CHARACTERS TYPED AT TERMINAL ARE /
	.ASCII	/PASSED/<15><12>
	.ASCII	/      TO THE REMOTE COMPUTER./<15><12><12>
	.ASCII	/  TRANSMIT WITH RECV :  TRANSFER A FILE FROM LOCAL /
	.ASCII	/COMPUTER TO A REMOTE/<15><12>
	.ASCII	/      COMPUTER WHICH HAS RECV RUNNING./
	.ASCII	<15><12><12>
;	.ASCII	/  TRANSMIT WITHOUT RECV :  TRANSFER A FILE FROM LOCAL /
;	.ASCII	/COMPUTER TO A REMOTE/<15><12>
;	.ASCII	/      COMPUTER WHICH DOESN'T HAVE RECV /
;	.ASCII	/RUNNING./<15><12>
;	.ASCII	/      (POSSIBLY AN EDITOR OR SOME OTHER 'CHARACTER-/
;	.ASCII	/CATCHER' RUNNING REMOTELY)./<15><12><12>
	.ASCII	/  RECEIVE WITH RECV :  TRANSFER A FILE FROM REMOTE /
	.ASCII	/COMPUTER TO LOCAL/<15><12>
	.ASCII	/      COMPUTER WHERE RECV RUNNING /
	.ASCII	/AT THE REMOTE SITE./<15><12><12>
;	.ASCII	/  RECORD :  CATCH ALL CHARACTERS COMING FROM REMOTE COMPUTER/
;	.ASCII	/ AND STORE/<15><12>
;	.ASCII	/      IN A FILE./<15><12><12>
	.ASCII	/  EXIT :  EXIT TRANS./<15><12><12>
	MES2E=.-MESS2
ERR4:	.ASCII	<15><12>
	.ASCII	<7>/    ***** ERROR IN LOGICAL UNIT ASSIGNMENT *****/
	.ASCII	<15><12>
	.ASCII	/       ***** TASK EXITING *****/
	.ASCII	<15><12><15><12>
	ERR4E=.-ERR4
	.EVEN
	.END	START