LIB = /lib
DD = tmp

CC = cc
CCFLAGS = -O
USRINC = /usr/include/

LD = -ld
LDFLAGS = -x

.c.o:
	$(CC) -c $(CCFLAGS) $<
	$(LD) -r $(LDFLAGS) $*.o
	mv a.out $*.o

AS = -as

.s.o:
	$(AS) -o $*.o $<
	$(LD) -r $(LDFLAGS) $*.o
	mv a.out $*.o

FC = fc

.f.o:
	$(FC) -c $<
	$(LD) -r $(LDFLAGS) $*.o
	mv a.out $*.o

AR = ar


#------
# libf.a: Create libf.a in local directory, from rt1 and rt2 directories.
#------
libf.a:	rt1/abs.o rt1/aimag.o rt1/aint.o rt1/alog10.o \
	rt1/amax0.o rt1/amax1.o rt1/amin0.o rt1/amin1.o \
	rt1/amod.o rt1/atan.o rt1/ccos.o rt1/cexp.o rt1/clog.o \
	rt1/cmplx.o rt1/conjg.o rt1/csin.o rt1/csqrt.o

libf.a:	rt1/dble.o rt1/dccos.o rt1/dcexp.o rt1/dclog.o \
	rt1/dcsin.o rt1/dcsqrt.o rt1/dim.o rt1/dimag.o \
	rt1/float.o rt1/iabs.o rt1/idim.o rt1/idint.o \
	rt1/ierr.o rt1/ifix.o rt1/isign.o

libf.a:	rt1/mod.o rt1/real.o rt1/sign.o rt1/sngl.o rt1/tanh.o \
	rt1/alog.o rt1/atan2.o rt1/cabs.o rt1/cos.o \
	rt1/exp.o rt1/sin.o rt1/sqrt.o \
	rt2/ctime.o rt2/getarg.o rt2/nice.o \
	rt2/rand.o rt2/setfil.o rt2/uio.o

libf.a:
	-rm -f libf.a tmp.a
	$(AR) r tmp.a rt1/abs.o rt1/aimag.o rt1/aint.o rt1/alog10.o \
			rt1/amax0.o rt1/amax1.o rt1/amin0.o rt1/amin1.o
	$(AR) r tmp.a rt1/amod.o rt1/atan.o rt1/ccos.o rt1/cexp.o rt1/clog.o \
			rt1/cmplx.o rt1/conjg.o rt1/csin.o rt1/csqrt.o
	$(AR) r tmp.a rt1/dble.o rt1/dccos.o rt1/dcexp.o rt1/dclog.o \
			rt1/dcsin.o rt1/dcsqrt.o rt1/dim.o rt1/dimag.o
	$(AR) r tmp.a rt1/float.o rt1/iabs.o rt1/idim.o rt1/idint.o \
			rt1/ierr.o rt1/ifix.o rt1/isign.o
	$(AR) r tmp.a rt1/mod.o rt1/real.o rt1/sign.o rt1/sngl.o rt1/tanh.o
	$(AR) r tmp.a rt1/alog.o rt1/atan2.o rt1/cabs.o rt1/cos.o \
			rt1/exp.o rt1/sin.o rt1/sqrt.o
	$(AR) r tmp.a rt2/ctime.o rt2/getarg.o rt2/nice.o \
			rt2/rand.o rt2/setfil.o rt2/uio.o
	-chmod 644 tmp.a
	mv tmp.a libf.a


#------
# filib.a: Create filib.a in local directory, from io & rt directories.
#------
filib.a: rt/r1.o rt/r2.o rt/r3.o rt/r4.o rt/r5.o rt/r6.o rt/r7.o rt/r8.o rt/r9.o \
	rt/ra.o rt/rb.o rt/rc.o rt/rd.o rt/re.o rt/rf.o rt/rg.o rt/rh.o rt/rx.o \
	io/io.o

filib.a:
	-rm -f filib.a tmp.a
	$(AR) r tmp.a io/io.o \
		rt/r1.o rt/r2.o rt/r3.o rt/r4.o rt/r5.o rt/r6.o rt/r7.o rt/r8.o rt/r9.o
	$(AR) r tmp.a rt/ra.o rt/rb.o rt/rc.o rt/rd.o rt/re.o rt/rf.o rt/rg.o rt/rh.o rt/rx.o
	-chmod 644 tmp.a
	mv tmp.a filib.a


#------
# fr0.o: Create fr0.0 in local directory, from rt/r0.o.
#------
fr0.o:	rt/r0.o
	cp rt/r0.o fr0.o
	-chmod 644 fr0.o


#------
# install: Create libf.a, if it isn't already, and move it to $(LIB)/libf.a.
#	   Also create and install filib.a & fr0.0.
#------
install: libf.a filib.a fr0.o
	-mv $(LIB)/libf.a $(LIB)/$(DD)libf.a
	-mv $(LIB)/filib.a $(LIB)/$(DD)filib.a
	-mv $(LIB)/fr0.o $(LIB)/$(DD)fr0.o
	mv libf.a $(LIB)/libf.a
	mv filib.a $(LIB)/filib.a
	mv fr0.o $(LIB)/fr0.o
	-chown bin $(LIB)/libf.a $(LIB)/filib.a $(LIB)/fr0.o
	-rm -f $(LIB)/$(DD)libf.a $(LIB)/$(DD)filib.a $(LIB)/$(DD)fr0.o
	ls -l $(LIB)/libf.a $(LIB)/filib.a $(LIB)/fr0.o


#------
# clean: Remove all created .o files.
#------
clean:
	-rm -f rt1/abs.o rt1/aimag.o rt1/aint.o rt1/alog10.o \
			rt1/amax0.o rt1/amax1.o rt1/amin0.o rt1/amin1.o
	-rm -f rt1/amod.o rt1/atan.o rt1/ccos.o rt1/cexp.o rt1/clog.o \
			rt1/cmplx.o rt1/conjg.o rt1/csin.o rt1/csqrt.o
	-rm -f rt1/dble.o rt1/dccos.o rt1/dcexp.o rt1/dclog.o \
			rt1/dcsin.o rt1/dcsqrt.o rt1/dim.o rt1/dimag.o
	-rm -f rt1/float.o rt1/iabs.o rt1/idim.o rt1/idint.o \
			rt1/ierr.o rt1/ifix.o rt1/isign.o
	-rm -f rt1/mod.o rt1/real.o rt1/sign.o rt1/sngl.o rt1/tanh.o
	-rm -f rt1/alog.o rt1/atan2.o rt1/cabs.o rt1/cos.o \
			rt1/exp.o rt1/sin.o rt1/sqrt.o
	-rm -f rt2/ctime.o rt2/getarg.o rt2/nice.o \
			rt2/rand.o rt2/setfil.o rt2/uio.o
	-rm -f rt/r1.o rt/r2.o rt/r3.o rt/r4.o rt/r5.o rt/r6.o rt/r7.o rt/r8.o rt/r9.o
	-rm -f rt/ra.o rt/rb.o rt/rc.o rt/rd.o rt/re.o rt/rf.o rt/rg.o rt/rh.o rt/rx.o
	-rm -f io/io.o rt/r0.o


#------
# Dependencies for indiv files.
#------
rt1/abs.o:	rt1/abs.s
rt1/aimag.o:	rt1/aimag.s
rt1/aint.o:	rt1/aint.s
rt1/alog10.o:	rt1/alog10.s
rt1/amax0.o:	rt1/amax0.s
rt1/amax1.o:	rt1/amax1.s
rt1/amin0.o:	rt1/amin0.s
rt1/amin1.o:	rt1/amin1.s

rt1/amod.o:	rt1/amod.s
rt1/atan.o:	rt1/atan.s
rt1/ccos.o:	rt1/ccos.f
rt1/cexp.o:	rt1/cexp.f
rt1/clog.o:	rt1/clog.f
rt1/cmplx.o:	rt1/cmplx.s
rt1/conjg.o:	rt1/conjg.s
rt1/csin.o:	rt1/csin.f
rt1/csqrt.o:	rt1/csqrt.f

rt1/dble.o:	rt1/dble.s
rt1/dccos.o:	rt1/dccos.f
rt1/dcexp.o:	rt1/dcexp.f
rt1/dclog.o:	rt1/dclog.f
rt1/dcsin.o:	rt1/dcsin.f
rt1/dcsqrt.o:	rt1/dcsqrt.f
rt1/dim.o:	rt1/dim.s
rt1/dimag.o:	rt1/dimag.s

rt1/float.o:	rt1/float.s
rt1/iabs.o:	rt1/iabs.s
rt1/idim.o:	rt1/idim.s
rt1/idint.o:	rt1/idint.s
rt1/ierr.o:	rt1/ierr.s
rt1/ifix.o:	rt1/ifix.s
rt1/isign.o:	rt1/isign.s

rt1/mod.o:	rt1/mod.s
rt1/real.o:	rt1/real.s
rt1/sign.o:	rt1/sign.s
rt1/sngl.o:	rt1/sngl.s
rt1/tanh.o:	rt1/tanh.f

rt1/alog.o:	rt1/alog.s
rt1/atan2.o:	rt1/atan2.s
rt1/cabs.o:	rt1/cabs.s
rt1/cos.o:	rt1/cos.s
rt1/exp.o:	rt1/exp.s
rt1/sin.o:	rt1/sin.s
rt1/sqrt.o:	rt1/sqrt.s

rt2/ctime.o: rt2/ctime.s
rt2/getarg.o: rt2/getarg.s
rt2/nice.o: rt2/nice.s
rt2/rand.o: rt2/rand.s
rt2/setfil.o: rt2/setfil.s
rt2/uio.o: rt2/uio.s

rt/r0.o:	rt/r0.s

rt/r1.o:	rt/r1.s
rt/r2.o:	rt/r2.s
rt/r3.o:	rt/r3.s
rt/r4.o:	rt/r4.s
rt/r5.o:	rt/r5.s
rt/r6.o:	rt/r6.s
rt/r7.o:	rt/r7.s
rt/r8.o:	rt/r8.s
rt/r9.o:	rt/r9.s
rt/ra.o:	rt/ra.s
rt/rb.o:	rt/rb.s
rt/rc.o:	rt/rc.s
rt/rd.o:	rt/rd.s
rt/re.o:	rt/re.s
rt/rf.o:	rt/rf.s
rt/rg.o:	rt/rg.s
rt/rh.o:	rt/rh.s
rt/rx.o:	rt/rx.s

io/io.o:	io/io1.s io/io2.s io/io3.s io/io4.s io/io5.s io/io6.s io/io7.s io/iox.s
	cat io/io1.s io/io2.s io/io3.s io/io4.s io/io5.s io/io6.s io/io7.s io/iox.s \
		> io/xxio.s
	$(AS) -o io/io.o io/xxio.s
	$(LD) -r $(LDFLAGS) io/io.o
	mv a.out io/io.o
	rm -f io/xxio.s
t/r4.s
rt/r5.o:	rt/r5.s
rt/r6.o:	rt/r6.s
rt/r7.o:	rt/r7.s
rt/r8.o:	rt/r8.s
rt/r9.o:	rt/r9.s
rt/ra.o:	rt/ra.s
rt/rb.o:	rt/rb.s
rt/rc.o:	rt/rc.s
rt/rd.o:	rt/rd.s
rt/re.o:	rt/re.s
rt/rf.o:	rt/rf.s
rt/rg.o:	rt/rg.s
rt/rh.o:	rt/rh.s
rt/rx.o:	rt/rx.s

io/io.o:	io/io1.s io/io2.s io/io3.s io/io4.s io/io5.s io/io6.s io/io7.s io/iox.s
	cat io/io1.s io/io2.s io/io3.s io/io4.s io/io5.s io/io6.s io/io7.s io/iox.s \
		> io/xxio.s
	$(AS) -o io/io.o io// fortran runtime startup
/ calls main and provides error
/ messages

.globl	main
.globl	pdec
.globl	temp
.globl	rerr

.globl	trace
.globl	fptrap


.comm	erret,2
.comm	argp,2

ldfps	= 170100^tst

	sys	signal; 4; fptrap
	ldfps	$5400
	sys	signal; 8.; fperr
	mov	sp,argp
	mov	$main,r4
	jmp	*(r4)+

fperr:
	jsr	r5,rerr; 998.

rerr:
	mov	(r5)+,r1
	tst	erret
	beq	1f
	jsr	pc,erret
1:
	mov	$2,r0
	sys	write; m1; m2-m1
	jsr	r5,pdec
	mov	$2,r0
	sys	write; m2; 1
	jsr	pc,trace
	sys	exit

pdec:
	clr	r0
	div	$10.,r0
	mov	r1,-(sp)
	mov	r0,r1
	beq	1f
	jsr	r5,pdec
1:
	mov	(sp)+,r0
	add	$'0,r0
	movb	r0,temp
	mov	$2,r0
	sys	write; temp; 1
	rts	r5

m1:
	<Runtime error >
m2:
	<\n>
.even
.bss
temp:	.=.+16.
ps	= 170100^tst

	sys	signal; 4; fptrap
	ldfps	$5400
	sys	signal; 8.; fperr
	mov	sp,argp
	mov	$main,r4
	jmp	*(r4)+

fperr:
	jsr	r5,rerr; 998.

rerr:
	mov	(r5)+,r1
	tst	erret
	beq	1f
	jsr	pc,erret
1:
	mov	$2,r0
	sys	write; m1; m2-m1
	jsr	r5,pdec
	mov	$2,r0
	sys	write; m2; 1
	jsr	pc,trace
	sys	exit

pdec:
	clr	r0
	div	$10.,r0
	mov	r1/
/

/ r1 -- fortran runtime

.globl	gas1
.globl	gas2
.globl	gas4
.globl	gas8
.globl	stop
.globl	lval
.globl	rval4
.globl	rval8
.globl	do1
.globl	do12
.globl	do14
.globl	do2
.globl	do22
.globl	do24
.globl	goto
.globl	cgoto
.globl	cagoto
.globl	agoto

.globl	rerr

gas8:
	mov	8.(sp),r0
	mov	(sp)+,(r0)+
	mov	(sp)+,(r0)+
	br	1f

gas1:
	movb	(sp)+,*(sp)+
	jmp	*(r4)+

gas2:
	mov	(sp)+,*(sp)+
	jmp	*(r4)+

gas4:
	mov	4(sp),r0
1:
	mov	(sp)+,(r0)+
	mov	(sp)+,(r0)
	tst	(sp)+
	jmp	*(r4)+

stop:
	sys	exit

lval:
	mov	(r4)+,-(sp)
	jmp	*(r4)+

rval8:
	mov	(r4)+,r0
	add	$8.,r0
	mov	-(r0),-(sp)
	mov	-(r0),-(sp)
	mov	-(r0),-(sp)
	mov	-(r0),-(sp)
	jmp	*(r4)+

rval4:
	mov	(r4)+,r0
	mov	2(r0),-(sp)
	mov	(r0),-(sp)
	jmp	*(r4)+

do22:
	mov	(sp)+,r1
	br	1f

do12:
	mov	$1,r1
1:
	mov	(sp)+,r2
	mov	(sp)+,r0
	add	r1,(r0)
	cmp	(r0),r2
	bgt	goto
	tst	(r4)+
	jmp	*(r4)+

do24:
do2:
	mov	(sp)+,r2
	mov	(sp)+,r1
	br	1f

do14:
do1:
	clr	r2
	mov	$1,r1
1:
	mov	4(sp),r0
	add	r1,2(r0)
	adc	r2
	add	r2,(r0)
	cmp	(r0)+,(sp)+
	bgt	1f
	blt	2f
	cmp	(r0),(sp)
	bhi	1f
2:
	cmp	(sp)+,(sp)+
	tst	(r4)+
	jmp	*(r4)+

1:
	cmp	(sp)+,(sp)+
goto:
	mov	(r4),r4
	jmp	*(r4)+

cgoto:
	tst	(sp)+
	mov	(sp)+,r0
	asl	r0
	add	r4,r0
1:
	tst	(r4)+
	beq	gotoe
	cmp	r0,r4
	bne	1b
	mov	-(r0),r4
	jmp	*(r4)+
cagoto:
	tst	(sp)+
	mov	(sp)+,r0
1:
	tst	(r4)
	beq	gotoe
	cmp	r0,(r4)+
	bne	1b
	mov	r0,r4
	jmp	*(r4)+

agoto:
	tst	(sp)+
	mov	(sp)+,r4
	jmp	*(r4)+

gotoe:
	jsr	r5,rerr; 14.

2
	mov	$1,r1
1:
	mov	4(sp),r0
	add	r1,2(r0)
	adc	r2
	add	r2,(r0)
	cmp	(r0)+,(sp)+
	bgt	1f
	blt	2f
	cmp	(r0),/
/

/ r2 -- comparison of 4-byte integers

.globl	ilt4
.globl	ile4
.globl	ieq4
.globl	ine4
.globl	ige4
.globl	igt4
.globl	lan2
.globl	lor2
.globl	lnt2
.globl	ieq2
.globl	ile2
.globl	igt2
.globl	ige2
.globl	leq2
.globl	ine2
.globl	ilt2
.globl	lne2
.globl	leq1
.globl	lne1

ilt4:
	jsr	pc,compar
	blt	one
	br	zero
	blo	one
	br	zero

ile4:
	jsr	pc,compar
	ble	one
	br	zero
	blos	one
	br	zero

ieq4:
	jsr	pc,compar
	beq	one
	br	zero
	beq	one
	br	zero

ine4:
	jsr	pc,compar
	bne	one
	br	zero
	bne	one
	br	zero

ige4:
	jsr	pc,compar
	bge	one
	br	zero
	bhis	one
	br	zero

igt4:
	jsr	pc,compar
	bgt	one
	br	zero
	bhi	one
	br	zero

one:
	mov	$1,(sp)
	jmp	*(r4)+

zero:
	clr	(sp)
	jmp	*(r4)+

compar:
	mov	(sp)+,r0
	mov	(sp)+,r1
	mov	(sp)+,r2
	cmp	(sp)+,r1
	beq	1f
	jmp	(r0)
1:
	cmp	(sp),r2
	jmp	4(r0)

lor2:
	bis	(sp)+,(sp)
	jmp	*(r4)+

lan2:
	tst	(sp)+
	bne	1f
	clr	(sp)
1:
	jmp	*(r4)+

lnt2:
	tst	(sp)
	beq	one
	br	zero

ieq2:
leq2:
	cmp	(sp)+,(sp)
	beq	one
	br	zero

ilt2:	cmp	(sp)+,(sp)
	bgt	one
	br	zero

ile2:
	cmp	(sp)+,(sp)
	bge	one
	br	zero

igt2:
	cmp	(sp)+,(sp)
	blt	one
	br	zero

ige2:
	cmp	(sp)+,(sp)
	ble	one
	br	zero

ine2:
lne2:
	cmp	(sp)+,(sp)
	bne	one
	br	zero

leq1:
	cmpb	(sp)+,(sp)
	beq	one
	br	zero

lne1:
	cmpb	(sp)+,(sp)
	bne	one
	br	zero

,r1
	beq	1f
	jmp	(r0)
1:
	cmp	(sp),r2
	jmp	4(r0)

lor2:
	bis	(sp)+,(sp)
	jmp	*(r4)+

lan2:
	tst	(sp)+
	bne	1f
	clr	(sp)
1:
	jmp	*(r4)+

lnt2:
	tst	(sp)
	beq	one
	br	zero

ieq2:
leq2:
	cmp	(sp)+,(sp)
	beq	one
	br	zero

ilt2:	cmp	(sp)+,(sp)
	bgt	one
	br	zero

ile2:
	cmp	(sp)+,(sp)
	/
/

/ r3 -- comparisons

.globl	lif2
.globl	lif1
.globl	rif4
.globl	iif2
.globl	iif4
.globl	rif8

lif2:
lif1:
	tst	(sp)+
	bne	1f
	mov	(r4),r4
	jmp	*(r4)+
1:
	tst	(r4)+
	jmp	*(r4)+

rif8:
	setd
	tstf	(sp)+
	cfcc
	br	2f

iif4:
rif4:
	mov	(sp)+,r0
	mov	(sp)+,r1
	tst	r0
	bne	2f
	tst	r1
	cln
	br	2f

iif2:
	tst	(sp)+
2:
	bmi	1f
	beq	2f
	tst	(r4)+
2:
	tst	(r4)+
1:
	mov	(r4),r4
	jmp	*(r4)+

	one
	br	zero

ieq2:
leq2:
	cmp	(sp)+,(sp)
	beq	one
	br	zero

ilt2:	cmp	(sp)+,(sp)
	bgt	one
	br	zero

ile2:
	cmp	(sp)+,(sp)
	/
/

/ r4 -- short integer arithmetic

.globl	iad2
.globl	isb2
.globl	imp2
.globl	idv2
.globl	i2i4
.globl	i1i4
.globl	i4i2
.globl	i4i1
.globl	ing2
.globl	rval2
.globl	rval1
.globl	l2l1

iad2:
	add	(sp)+,(sp)
	jmp	*(r4)+

isb2:
	sub	(sp)+,(sp)
	jmp	*(r4)+

imp2:
	mov	(sp)+,r1
	mul	(sp)+,r1
	mov	r1,-(sp)
	jmp	*(r4)+

idv2:
	mov	2(sp),r1
	sxt	r0
	div	(sp)+,r0
	mov	r0,(sp)
	jmp	*(r4)+

i4i2:
i4i1:
	tst	(sp)+
	jmp	*(r4)+

i1i4:
	movb	(sp),r0
	mov	r0,(sp)
i2i4:
	tst	(sp)
	sxt	-(sp)
	jmp	*(r4)+

ing2:
	neg	(sp)
	jmp	*(r4)+

rval2:
	mov	*(r4)+,-(sp)
	jmp	*(r4)+

rval1:
	movb	*(r4)+,r0
	mov	r0,-(sp)

l2l1:
	jmp	*(r4)+

i1i4
.globl	i4i2
.globl	i4i1
.globl	ing2
.globl	rval2
.globl	rval1
.globl	l2l1

iad2:
	add	(sp)+,(sp)
	jmp	*(r4)+

isb2:
	sub	(sp)+,(sp)
	jmp	*(r4)+

imp2:
	mov	(sp)+,r1
	mul	(sp)+,r1
	mov	r1,-(sp)
	jmp	*(r4)+

idv2:
	mov	2(sp),r1
	sxt	r0
	div	(sp)+,r0
	mov	r0,(sp)
	jmp	*(r4)+

i4i2:
i4i1:
	tst	(sp)+
	jmp	*(r4)+

i1i4:
	movb	(sp),r0
	mov	r0,(sp)
i2i4:
	tst	(sp)
	sxt	-(sp)
	jmp	*(r4)+

ing2:
	neg	(sp)
	j/
/

/ r5 -- long integer arithmetic

.globl	iad4
.globl	isb4
.globl	imp4
.globl	idv4
.globl	ing4
.globl	rerr

iad4:
	jsr	pc,load
	addf	fr0,fr1
	br	store

isb4:
	jsr	pc,load
	subf	fr0,fr1
	br	store

imp4:
	jsr	pc,load
	mulf	fr0,fr1
	br	store

idv4:
	jsr	pc,load
	divf	fr0,fr1

store:
	movfi	fr1,-(sp)
	jmp	*(r4)+

load:
	mov	(sp)+,r0
	setd
	setl
	movif	(sp)+,fr0
	movif	(sp)+,fr1
	jmp	(r0)

ing4:
	neg	(sp)
	neg	2(sp)
	sbc	(sp)
	jmp	*(r4)+

	mov	r0,(sp)
i2i4:
	tst	(sp)
	sxt	-(sp)
	jmp	*(r4)+

ing2:
	neg	(sp)
	j/
/

/ r6 -- real arithmetic

.globl	rad4
.globl	rad8
.globl	rsb4
.globl	rsb8
.globl	rmp4
.globl	rmp8
.globl	rdv4
.globl	rdv8
.globl	rng4
.globl	rng8
.globl	r4r8
.globl	r8r4
.globl	i4r4
.globl	i2r4
.globl	r4i4
.globl	r8i2
.globl	i2r8
.globl	r4i2
.globl	i4r8
.globl	r8i4
.globl	rerr

rad8:
	setd
	br	1f
rad4:
	setf
1:
	movf	(sp)+,fr0
	addf	(sp)+,fr0
	br	store

rsb8:
	setd
	br	1f
rsb4:
	setf
1:
	movf	(sp)+,fr0
	negf	fr0
	addf	(sp)+,fr0
	br	store

rmp8:
	setd
	br	1f
rmp4:
	setf
1:
	movf	(sp)+,fr0
	mulf	(sp)+,fr0
	br	store

rdv8:
	setd
	br	1f
rdv4:
	setf
1:
	movf	(sp)+,fr1
	movf	(sp)+,fr0
	divf	fr1,fr0

store:
	movf	fr0,-(sp)
	jmp	*(r4)+

rng8:
	setd
	br	1f
rng4:
	setf
1:
	negf	(sp)
	jmp	*(r4)+

r8r4:
	setd
	br	1f
r4r8:
	setf
1:
	movf	(sp)+,fr0
	movfo	fr0,-(sp)
	jmp	*(r4)+

i2r8:
	seti
	br	1f

i4r8:
	setl
1:
	setd
	br	2f

i2r4:
	seti
	br	1f

i4r4:
	setl
1:
	setf
2:
	movif	(sp)+,fr0
	movf	fr0,-(sp)
	jmp	*(r4)+

r8i2:
	seti
	br	1f

r8i4:
	setl
1:
	setd
	br	2f

r4i2:
	seti
	br	1f

r4i4:
	setl
1:
	setf
2:
	movf	(sp)+,fr0
	movfi	fr0,-(sp)
	jmp	*(r4)+

v4:
	setf
1:
	movf	(sp)+,fr1
	movf	(sp)+,fr0
	divf	fr1,fr0

store:
	movf	fr0,-(sp)
	jmp	*(r4)+

rng8:
	setd
	br	1f
rng4:
	setf
1:
	negf	(sp)
	jmp	*(r4)+

r8r4:
	setd
	br	1f
r4r8:
	setf
1:
	movf	(sp)+,fr0
	movfo	fr0,-(sp)
	jmp	*(r4)+

i2r8:
	seti
	br	1f

i4r8:
	setl
1:
	setd
	br	2f

i2r4:
	seti
	br	1f

i4r4:
	setl
1:
	setf
2:
	movif	(sp)+,fr0
	movf	fr0,-(sp)
	jmp	*(r4)+

r8i2:
	seti
	br	1f

r8i4:
	setl
1:
	setd
	br	2f

r4i2:
	seti
	br	1f

r4i4:
	setl
1:
	setf
2:
	movf	(sp)+,f/
/

/ r7 -- fortran runtime

achk	= 1 / 1 to check array bounds
.globl	lvalp
.globl	rval1p
.globl	rval2p
.globl	rval4p
.globl	rval8p
.globl	alval
.globl	alvalp
.globl	arval
.globl	arvalp

.globl	rerr

lvalp:
	mov	r3,r0
	add	(r4)+,r0
	mov	(r0)+,-(sp)
	jmp	*(r4)+

rval1p:
	mov	r3,r0
	add	(r4)+,r0
	movb	*(r0)+,-(sp)
	jmp	*(r4)+

rval2p:
	mov	r3,r0
	add	(r4)+,r0
	mov	*(r0)+,-(sp)
	jmp	*(r4)+

rval4p:
	mov	r3,r0
	add	(r4)+,r0
	mov	(r0),r0
	cmp	(r0)+,(r0)+
	mov	-(r0),-(sp)
	mov	-(r0),-(sp)
	jmp	*(r4)+

rval8p:
	setd
	mov	r3,r0
	add	(r4)+,r0
	movf	*(r0)+,fr0
	movf	fr0,-(sp)
	jmp	*(r4)+

alval:
	jsr	r5,getsub; 1
	mov	(r4)+,-(sp)
	add	r1,(sp)
	jmp	*(r4)+

arvalp:
	jsr	r5,getsub; 0
	mov	r3,r2
	add	(r4)+,r2
	mov	(r2),r2
	br	1f

arval:
	jsr	r5,getsub; 1
	mov	(r4)+,r2
1:
	add	r2,r1
	mov	-(r0),r2
	asr	r2
	bcc	1f
	movb	(r1),-(sp)
	jmp	*(r4)+
1:
	add	(r0),r1
1:
	mov	-(r1),-(sp)
	sob	r2,1b
	jmp	*(r4)+

getsub:
	tst	(sp)+
	mov	(r4)+,r0
	mov	(r0)+,r2
	clr	r1
	tst	(r0)+
1:
	tst	(sp)+
	dec	(sp)
	add	(sp)+,r1
	mpy	(r0)+,r1
	sob	r2,1b

	tst	(r5)+
	beq	2f
	mov	r1,-(sp)
	mov	-2(r4),r0
	mov	(r0)+,r2
	inc	r2
	mov	$1,r1
1:
	mpy	(r0)+,r1
	sob	r2,1b
.if achk
	cmp	r1,(sp)
	bhi	1f
	jsr	r5,rerr; 15.
.endif
1:
	mov	(sp)+,r1

2:
	jmp	(r5)

alvalp:
	jsr	r5,getsub; 0
	mov	r3,r0
	add	(r4)+,r0
	mov	(r0),-(sp)
	add	r1,(sp)
	jmp	*(r4)+
c	1f
	movb	(r1),-(sp)
	jmp	*(r4)+
1:
	add	(r0),r1
1:
	mov	-(r1),-(sp)
	sob	r2,1b
	jmp	*(r4)+

getsub:
	tst	(sp)+
	mov	(r4)+,r0
	mov	(r0)+,r2
	clr	r1
	tst	(r0)+
1:
	tst	(sp)+
	dec	(sp)
	add	(sp)+,r1
	mpy	(r0)+,r1
	sob	r/
/

/ r8 - fortran runtime -- powers of integers

.globl	ipi2

ipi2:
	tst	(sp)+
	mov	(sp)+,r0
	bge	1f
	clr	(sp)
	jmp	*(r4)+
1:
	mov	(sp)+,r1
	mov	r3,-(sp)
	mov	$1,r3
1:
	tst	r0
	beq	1f
	asr	r0
	bcc	2f
	mpy	r1,r3
2:
	mpy	r1,r1
	br	1b
1:
	mov	r3,r1
	mov	(sp)+,r3
	mov	r1,-(sp)
	jmp	*(r4)+

r4)+
c	1f
	movb	(r1),-(sp)
	jmp	*(r4)+
1:
	add	(r0),r1
1:
	mov	-(r1),-(sp)
	sob	r2,1b
	jmp	*(r4)+

getsub:
	tst	(sp)+
	mov	(r4)+,r0
	mov	(r0)+,r2
	clr	r1
	tst	(r0)+
1:
	tst	(sp)+
	dec	(sp)
	add	(sp)+,r1
	mpy	(r0)+,r1
	sob	r/
/

one = 40200
/  r9 -- fortran runtime -- real**integer

.globl	ipi4
.globl	rpi4
.globl	rpi8

.globl	rerr

ipi4:
	setf
	setl
	movif	4(sp),fr0
	movf	fr0,4(sp)
	jsr	r5,1f
	movfi	fr1,-(sp)
	jmp	*(r4)+

rpi4:
	setf
	br	2f

rpi8:
	setd
2:
	jsr	r5,1f
	movf	fr1,-(sp)
	jmp	*(r4)+

1:
	cmp	(sp)+,(sp)+		/ jsr + msp of i4
	mov	(sp)+,r0
	movf	$one,fr1
	movf	(sp)+,fr0
	tst	r0
	bgt	1f
	cfcc
	beq	9f
	tst	r0
	beq	3f
	divf	fr0,fr1
	movf	fr1,fr0
	neg	r0
	movf	$one,fr1
1:
	asr	r0
	bcc	2f
	mulf	fr0,fr1
2:
	tst	r0
	beq	3f
	mulf	fr0,fr0
	br	1b
3:
	jmp	(r5)

9:
	jsr	r5, rerr; 17.
ger

.globl	ipi4
.globl	rpi4
.globl	rpi8

.globl	rerr

ipi4:
	setf
	setl
	movif	4(sp),fr0
	movf	fr0,4(sp)
	jsr	r5,1f
	movfi	fr1,-(sp)
	jmp	*(r4)+

rpi4:
	setf
	br	2f

rpi8:
	setd
2:
	jsr	r5,1f
	movf	fr1,-(sp)
	jmp	*(r4)+

1:
	cmp	(sp)+,(sp)+		/ jsr + msp of i4
	mov	(sp)+,r0
	movf	$one,fr1
	movf	(sp)+,fr0
	tst	r0
	bgt	1f
	cfcc
	beq	9f
	tst	r0
	beq	3f
	divf	fr0,fr1
	movf	fr1,fr0
	neg	r0
	movf	$one,fr1
1:
	asr	r0
	bcc	2f
	mulf	fr0,fr1
2:
	tst	r0
	beq	3f
	m/
/

/ ra -- fortran runtime --  real ** real

.globl	rpr4
.globl	rpr8

.globl	log
.globl	exp
.globl	rerr

rpr8:
	setd
	br	1f

rpr4:
	setf

1:
	seti
	movf	(sp)+,fr1
	movf	(sp)+,fr0
	cfcc
	beq	3f			/ 0**x
	movf	fr1,-(sp)
	jsr	pc,log
	bes	error
	mulf	(sp)+,fr0
	jsr	pc,exp
	bes	error
2:
	movf	fr0,-(sp)
	jmp	*(r4)+

3:
	tstf	r1
	cfcc
	bgt	2b

error:
	jsr	r5,rerr; 17.

0
	bgt	1f
	cfcc
	beq	9f
	tst	r0
	beq	3f
	divf	fr0,fr1
	movf	fr1,fr0
	neg	r0
	movf	$one,fr1
1:
	asr	r0
	bcc	2f
	mulf	fr0,fr1
2:
	tst	r0
	beq	3f
	m/ rb -- funct/subr stuff

.globl	call
.globl	callp
.globl	retrn
.globl	lino
.globl	entry
.globl	trace
.globl	pdec
.globl	temp
.globl	stsp
.globl	ent,lin,disp

callp:
	mov	(r4)+,r0
	add	r3,r0
	mov	(r0),r0
	br	1f

call:
	mov	(r4)+,r0
1:
	mov	disp,-(sp)
	mov	lin,-(sp)
	mov	ent,-(sp)
	mov	sp,disp
	mov	r3,-(sp)
	mov	(r4)+,r3
	mov	r4,-(sp)
	mov	r0,r4
	mov	(r4)+,-(sp)		/ lv of funct
	jmp	*(r4)+

retrn:
	mov	r3,r0
	mov	(sp)+,r1		/ lv of funct
	mov	(sp)+,r4
	mov	(sp)+,r3
	mov	(sp)+,ent
	mov	(sp)+,lin
	mov	(sp)+,disp
	mov	(r0),sp
	tst	(r4)+		/ arg count
	mov	(r4)+,r0		/ return byte count
	inc	r0
	bic	$1,r0
	add	r0,r1
1:
	sub	$2,r0
	blt	1f
	mov	-(r1),-(sp)
	br	1b
1:
	jmp	*(r4)+

stsp:
	mov	sp,*(r4)+
	jmp	*(r4)+

lino:
	mov	(r4)+,lin
	jmp	*(r4)+

entry:
	mov	(r4)+,ent
	jmp	*(r4)+

trace:
	mov	(sp)+,r2
1:
	mov	ent,r1
	jsr	r5,pstr
	mov	$2,r0
	sys	write; m1; 1
	mov	lin,r1
	jsr	r5,pdec
	mov	$2,r0
	sys	write; m2; 1
	tst	disp
	beq	1f
	mov	disp,sp
	mov	(sp)+,ent
	mov	(sp)+,lin
	mov	(sp)+,disp
	br	1b
1:
	jmp	(r2)

pstr:
	tst	r1
	bne	1f
	mov	$m3,r1
1:
	movb	(r1)+,temp
	beq	1f
	mov	$2,r0
	sys	write; temp; 1
	br	1b
1:
	rts	r5

.data
m1:	< >
m2:	<\n>
m3:	<.main.\0>
.even
.bss
disp:	.=.+2
lin:	.=.+2
ent:	.=.+2
r4)+
	jmp	*(r4)+

lino:
	mov	(r4)+,lin
	jmp	*(r4)+

entry:
	mov	(r4)+,ent
	jmp	*(r4)+

trace:
	mov	(sp)+,r2
1:
	mov	ent,r1
	jsr	r5,pstr
	mov	$2,r0
	sys	write; m1; 1
	mov	lin,r1
	jsr	r5,pdec
	mov	$2,r0
	sys	write; m2; 1
	tst	disp
	beq	1f
	mov	disp,sp
	mov	(sp)+,ent
	mov	(sp)+,lin
	mov	(sp)+,disp
	br	1b
1:
	jmp	(r2)

pstr:
	tst	r1
/
/

/ rc -- complex arithmetic

.globl	c8c16
.globl	c16c8
.globl	i4c8
.globl	r4c8
.globl	r8c8
.globl	i4c16
.globl	r4c16
.globl	r8c16
.globl	cad8
.globl	csb8
.globl	cmp8
.globl	cdv8
.globl	cng8
.globl	cad16
.globl	csb16
.globl	cmp16
.globl	cdv16
.globl	cng16
.globl	rval16
.globl	rval16p
.globl	gas16
.globl	ceq8
.globl	cne8
.globl	ceq16
.globl	cne16

.globl	cpi8
.globl	cpi16

one = 040200
a = r2
b = r3
c = r4
d = r5

e = r0
f = r1

gas16:
	mov	16.(sp),r0
	setd
	movf	(sp)+,a
	movf	(sp)+,b
	tst	(sp)+
	movf	a,(r0)+
	movf	b,(r0)+
	jmp	*(r4)+

rval16p:
	mov	r3,r0
	add	(r4)+,r0
	mov	(r0),r0
	br	1f

rval16:
	mov	(r4)+,r0
1:
	setd
	movf	(r0)+,a
	movf	(r0)+,b
	movf	b,-(sp)
	movf	a,-(sp)
	jmp	*(r4)+

cad16:
	setd
	br	1f

cad8:
	setf
1:
	jsr	pc,garg
	addf	a,e
	addf	b,f
	br	sarg

csb16:
	setd
	br	1f

csb8:
	setf
1:
	jsr	pc,garg
	subf	a,e
	negf	e
	subf	b,f
	negf	f
	br	sarg

cmp16:
	setd
	br	1f

cmp8:
	setf
1:
	jsr	pc,garg
	mulf	a,e
	mulf	b,f
	subf	f,e
	mulf	d,a
	mulf	c,b
	movf	a,f
	addf	b,f

sarg:
	movf	f,-(sp)
	movf	e,-(sp)
	jmp	*(r4)+

cdv16:
	setd
	br	1f

cdv8:
	setf
1:
divide:
	jsr	pc,garg
	absf	e
	absf	f
	cmpf	e,f
	cfcc
	blt	1f

/ algorithm #1 |c| > |d|

	movf	d,e
	divf	c,e		/ r = d/c
	movf	d,f
	mulf	e,f
	addf	c,f		/ x = c+rd
	movf	f,c
	movf	a,f
	mulf	e,f
	negf	f
	addf	b,f
	mulf	b,e
	addf	a,e
	divf	c,e
	divf	c,f
	br	sarg

/ algorithm #2 |c| < |d|

1:
	movf	c,e
	divf	d,e		/ r = c/d
	movf	c,f
	mulf	e,f
	addf	d,f		/ x = d+rc
	movf	f,c
	movf	b,f
	mulf	e,f
	subf	a,f
	mulf	a,e
	addf	b,e
	divf	c,e
	divf	c,f
	br	sarg

cng16:
	setd
	br	1f

cng8:
	setf
1:
	movf	(sp)+,a
	negf	a
	negf	(sp)
	movf	a,-(sp)
	jmp	*(r4)+

/ setup the following registers
/ (a,bi) +o (c,di) -> (e+fi)
/ a,b,c,d are input
/ e,f are output and also contain
/ c,d on input

garg:
	mov	(sp)+,r0
	movf	(sp)+,e
	movf	e,c
	movf	(sp)+,f
	movf	f,d
	movf	(sp)+,a
	movf	(sp)+,b
	jmp	(r0)

i4c8:
	setf
	br	1f

i4c16:
	setd
1:
	setl
	movif	(sp)+,fr0
	br	2f

r4c8:
	setf
	br	1f

r8c16:
	setd
1:
	movf	(sp)+,fr0
	br	2f

r4c16:
	setd
	br	1f

r8c8:
	setf
1:
	movof	(sp)+,fr0
2:
	clrf	-(sp)
	movf	fr0,-(sp)
	jmp	*(r4)+

c16c8:
	setd
	br	1f

c8c16:
	setf
1:
	movf	(sp)+,r0
	movf	(sp)+,r1
	movfo	r1,-(sp)
	movfo	r0,-(sp)
	jmp	*(r4)+

ceq16:
	setd
	br	1f
ceq8:
	setf
1:
	mov	$1,r1
	br	2f

cne16:
	setd
	br	1f

cne8:
	setf
1:
	clr	r1
2:
	jsr	pc,garg
	cmpf	c,a
	cfcc
	bne	1f
	cmpf	d,b
	cfcc
	beq	2f
1:
	inc	r1
	bic	$2,r1
2:
	mov	r1,-(sp)
	jmp	*(r4)+

cpi8:
	setf
	br	1f

cpi16:
	setd
1:
	clr	r0
	tst	(sp)+
	mov	(sp)+,r1
	bge	1f
	inc	r0
	neg	r1
1:
	movf	(sp)+,fr0
	movf	fr0,fr4
	movf	(sp)+,fr0
	movf	fr0,fr5
	movf	$one,fr0
	clrf	fr1
1:
	dec	r1
	bmi	1f
	movf	fr0,fr2
	movf	fr1,fr3
	mulf	fr4,fr0
	mulf	fr4,fr1
	mulf	fr5,fr2
	mulf	fr5,fr3
	subf	fr3,fr0
	addf	fr2,fr1
	br	1b
1:
	tst	r0
	beq	1f
	clrf	-(sp)
	movf	$one,fr2
	movf	fr2,-(sp)
	movf	fr1,-(sp)
	movf	fr0,-(sp)
	jmp	divide
1:
	movf	fr1,-(sp)
	movf	fr0,-(sp)
	jmp	*(r4)+
bic	$2,r1
2:
	mov	r1,-(sp)
	jmp	*(r4)+

cpi8:
	setf
	br	1f

cpi16:
	setd
1:
	clr	r0
	tst	(sp)+
	mov	(sp)+,r1
	bge	1f
	inc	r0
	neg	r1
1:
	movf	(sp)+,fr0
	movf	fr0,fr4
	movf	(sp)+,fr0
	movf	/
/

/ rd -- short list I/O do loop

.globl	slist1
.globl	slist2
.globl	slist3

.globl	temp

slist1:
	mov	(r4)+,r0
	mov	(r0)+,r2
	mov	$1,r1
1:
	mpy	(r0)+,r1
	sob	r2,1b
	mov	$temp,r2
	mov	r1,(r2)+
	clr	(r2)+
	mov	(r0)+,(r2)+
	jmp	*(r4)+

slist2:
	mov	(r4)+,r0
	dec	temp
	ble	1f
	mov	r0,r4
1:
	jmp	*(r4)+

slist3:
	mov	$temp+2,r0
	add	(r0)+,(sp)
	add	(r0),-(r0)
	jmp	*(r4)+

tf
	br	1f

cpi16:
	setd
1:
	clr	r0
	tst	(sp)+
	mov	(sp)+,r1
	bge	1f
	inc	r0
	neg	r1
1:
	movf	(sp)+,fr0
	movf	fr0,fr4
	movf	(sp)+,fr0
	movf	/
/

/ re -- comparison of 8-byte quantities

.globl	rle8
.globl	rlt8
.globl	req8
.globl	rne8
.globl	rge8
.globl	rgt8
rlt8:
	jsr	pc,compar
	blt	one
	br	zero

rle8:
	jsr	pc,compar
	ble	one
	br	zero

req8:
	jsr	pc,compar
	beq	one
	br	zero

rne8:
	jsr	pc,compar
	bne	one
	br	zero

rge8:
	jsr	pc,compar
	bge	one
	br	zero

rgt8:
	jsr	pc,compar
	bgt	one
	br	zero

one:
	mov	$1,-(sp)
	jmp	*(r4)+

zero:
	clr	-(sp)
	jmp	*(r4)+

compar:
	setd
	mov	(sp)+,r0
	movf	(sp)+,fr0
	cmpf	(sp)+,fr0
	cfcc
	jmp	(r0)

sp)+,fr0
	movf	/
/

/ rf -- real comparisons

.globl	rlt4
.globl	rle4
.globl	req4
.globl	rne4
.globl	rge4
.globl	rgt4

rlt4:
	jsr	pc,compar
	blt	one
	br	zero

rle4:
	jsr	pc,compar
	ble	one
	br	zero

req4:
	jsr	pc,compar
	beq	one
	br	zero

rne4:
	jsr	pc,compar
	bne	one
	br	zero

rge4:
	jsr	pc,compar
	bge	one
	br	zero

rgt4:
	jsr	pc,compar
	bgt	one
	br	zero

one:
	mov	$1,-(sp)
	jmp	*(r4)+

zero:
	clr	-(sp)
	jmp	*(r4)+

compar:
	mov	(sp)+,r0
	setf
	movf	(sp)+,r0
	cmpf	(sp)+,r0
	cfcc
	jmp	(r0)

cfcc
	jmp	(r0)

sp)+,fr0
	movf	/
/

/ rg -- assignments

.globl	gmv1
.globl	gmv2
.globl	gmv4
.globl	gmv8
.globl	gmv16
.globl	stst

gmv1:
	movb	(sp)+,*(r4)+
	jmp	*(r4)+

gmv2:
stst:
	mov	(sp)+,*(r4)+
	jmp	*(r4)+

gmv4:
	mov	(r4)+,r0
	mov	(sp)+,(r0)+
	mov	(sp)+,(r0)+
	jmp	*(r4)+

gmv8:
	setd
	movf	(sp)+,fr0
	movf	fr0,*(r4)+
	jmp	*(r4)+

gmv16:
	setd
	mov	(r4)+,r0
	movf	(sp)+,fr0
	movf	fr0,(r0)+
	movf	(sp)+,fr0
	movf	fr0,(r0)+
	jmp	*(r4)+

.globl	gmv1p
.globl	gmv2p
.globl	gmv4p
.globl	gmv8p
.globl	gmv16p

gmv1p:
	mov	(r4)+,r0
	add	r3,r0
	movb	(sp)+,*(r0)+
	jmp	*(r4)+

gmv2p:
	mov	(r4)+,r0
	add	r3,r0
	mov	(sp)+,*(r0)+
	jmp	*(r4)+

gmv4p:
	mov	(r4)+,r0
	add	r3,r0
	mov	(r0),r0
	mov	(sp)+,(r0)+
	mov	(sp)+,(r0)+
	jmp	*(r4)+

gmv8p:
	setd
	mov	(r4)+,r0
	add	r3,r0
	movf	(sp)+,fr0
	movf	fr0,*(r0)+
	jmp	*(r4)+

gmv16p:
	setd
	mov	(r4)+,r0
	add	r3,r0
	mov	(r0),r0
	movf	(sp)+,fr0
	movf	fr0,(r0)+
	movf	(sp)+,fr0
	movf	fr0,(r0)+
	jmp	*(r4)+

	jmp	*(r4)+

.globl	gmv1p
.globl	gmv2p
.globl	gmv4p
.globl	gmv8p
.globl	gmv16p

gmv1p:
	mov	(r4)+,r0
	add	r3,r0
	mo/
/

/ rh -- simple array l/r values

achk	= 1 / 1 to check array bounds
.globl	gal1
.globl	gal2
.globl	gal4
.globl	gal8
.globl	gal16
.globl	gar1
.globl	gar2
.globl	gar4
.globl	gar8
.globl	gar16

.globl	rerr

gal1:
	tst	(sp)+
	dec	(sp)
	br	1f

gal2:
	tst	(sp)+
	dec	(sp)
	asl	(sp)
	br	1f

gal4:
	tst	(sp)+
	dec	(sp)
	asl	(sp)
	asl	(sp)
	br	1f

gal8:
	tst	(sp)+
	dec	(sp)
	asl	(sp)
	asl	(sp)
	asl	(sp)
	br	1f

gal16:
	tst	(sp)+
	dec	(sp)
	asl	(sp)
	asl	(sp)
	asl	(sp)
	asl	(sp)

1:
	cmp	(sp),(r4)+
.if achk
	bhis	9f
.endif
	add	(r4)+,(sp)
	jmp	*(r4)+

9:
	jsr	r5,rerr; 15.
	4

gar1:
	tst	(sp)+
	dec	(sp)
	cmp	(sp),(r4)+
.if achk
	bhis	9b
.endif
	add	(r4)+,(sp)
	movb	*(sp)+,r0
	mov	r0,-(sp)
	jmp	*(r4)+

gar2:
	tst	(sp)+
	dec	(sp)
	asl	(sp)
	cmp	(sp),(r4)+
.if achk
	bhis	9b
.endif
	add	(r4)+,(sp)
	mov	*(sp)+,-(sp)
	jmp	*(r4)+

gar4:
	tst	(sp)+
	dec	(sp)
	mov	(sp)+,r0
	asl	r0
	asl	r0
	cmp	r0,(r4)+
.if achk
	bhis	9b
.endif
	add	(r4)+,r0
	cmp	(r0)+,(r0)+
	mov	-(r0),-(sp)
	mov	-(r0),-(sp)
	jmp	*(r4)+

gar8:
	setd
	tst	(sp)+
	dec	(sp)
	asl	(sp)
	asl	(sp)
	asl	(sp)
	cmp	(sp),(r4)+
.if achk
	bhis	9b
.endif
	add	(r4)+,(sp)
	movf	*(sp)+,fr0
	movf	fr0,-(sp)
	jmp	*(r4)+

gar16:
	setd
	tst	(sp)+
	dec	(sp)
	mov	(sp)+,r0
	asl	r0
	asl	r0
	asl	r0
	asl	r0
	cmp	r0,(r4)+
.if achk
	bhis	9b
.endif
	add	(r4)+,r0
	movf	(r0)+,fr0
	movf	(r0)+,fr1
	movf	fr1,-(sp)
	movf	fr0,-(sp)
	jmp	*(r4)+

r0
	asl	r0
	asl	r0
	cmp	r0,(r4)+
.if achk
	bhis	9b
.endif
	add	(r4)+,r0
	cmp	(r0)+,(r0)+
	mov	-(r0),-(sp)
	mov	-(r0),-(sp)
	jmp	*(r4)+

gar8:
	setd
	tst	(sp)+/
/

/ rtx -- last routine

.globl	ecore

	.bss

ecore:

.if achk
	bhis	9b
.endif
	add	(r4)+,(sp)
	movf	*(sp)+,fr0
	movf	fr0,-(sp)
	jmp	*(r4)+

gar16:
	setd
	tst	(sp)+
	dec	(sp)
	mov	(sp)+,r0
	asl	r0
	asl	r0
	asl	r0
	asl	r0
	cmp	r0,(r4)+
.if achk
	bhis	9b
.endif
	add	(r4)+,r0
	movf	(r0)+,fr0
	movf	(r0)+,fr1
	movf	fr1,-(sp)
	movf	fr0,-(sp)
	jmp	*(r4)+

r0
	asl	r0
	asl	r0
	cmp	r0,(r4)+
.if achk
	bhis	9b
.endif
	add	(r4)+,r0
	cmp	(r0)+,(r0)+
	mov	-(r0),-(sp)
	mov	-(r0),-(sp)
	jmp	*(r4)+

gar8:
	setd
	tst	(sp)+/
/

/ abs & dabs fortran functions

.globl	abs.
.globl	dabs.

.globl	retrn
.globl	temp

dabs.:	temp
	.+2
	setd
	br	1f

abs.:	temp
	.+2
	setf
1:
	movf	*2(r3),r0
	absf	r0
	movf	r0,temp
	jmp	retrn
l	r0
	asl	r0
	asl	r0
	asl	r0
	cmp	r0,(r4)+
.if achk
	bhis	9b
.endif
	add	(r4)+,r0
	movf	(r0)+,fr0
	movf	(r0)+,fr1
	movf	fr1,-(sp)
	movf	fr0,-(sp)
	jmp	*(r4)+

r0
	asl	r0
	asl	r0
	cmp	r0,(r4)+
.if achk
	bhis	9b
.endif
	add	(r4)+,r0
	cmp	(r0)+,(r0)+
	mov	-(r0),-(sp)
	mov	-(r0),-(sp)
	jmp	*(r4)+

gar8:
	setd
	tst	(sp)+/
/

/ aimag fortran function

.globl	aimag.

.globl	rval8p
.globl	retrn
.globl	temp

aimag.:	temp
	rval8p; 2
	.+2
	setf
	tstf	(sp)+
	movf	(sp)+,r0
	movf	r0,temp
	jmp	retrn
vf	r0,temp
	jmp	retrn
l	r0
	asl	r0
	asl	r0
	asl	r0
	cmp	r0,(r4)+
.if achk
	bhis	9b
.endif
	add	(r4)+,r0
	movf	(r0)+,fr0
	movf	(r0)+,fr1
	movf	fr1,-(sp)
	movf	fr0,-(sp)
	jmp	*(r4)+

r0
	asl	r0
	asl	r0
	cmp	r0,(r4)+
.if achk
	bhis	9b
.endif
	add	(r4)+,r0
	cmp	(r0)+,(r0)+
	mov	-(r0),-(sp)
	mov	-(r0),-(sp)
	jmp	*(r4)+

gar8:
	setd
	tst	(sp)+/
/

/ aint fortran function

.globl	aint.
.globl	temp

one = 40200

.globl	retrn

aint.:	temp
	.+2
	setf
	movf	*2(r3),r0
	modf	$one,r0
	movf	r1,temp
	jmp	retrn

	jmp	retrn
vf	r0,temp
	jmp	retrn
l	r0
	asl	r0
	asl	r0
	asl	r0
	cmp	r0,(r4)+
.if achk
	bhis	9b
.endif
	add	(r4)+,r0
	movf	(r0)+,fr0
	movf	(r0)+,fr1
	movf	fr1,-(sp)
	movf	fr0,-(sp)
	jmp	*(r4)+

r0
	asl	r0
	asl	r0
	cmp	r0,(r4)+
.if achk
	bhis	9b
.endif
	add	(r4)+,r0
	cmp	(r0)+,(r0)+
	mov	-(r0),-(sp)
	mov	-(r0),-(sp)
	jmp	*(r4)+

gar8:
	setd
	tst	(sp)+/
/

/ alog & log fortran functions

.globl	alog.
.globl	dlog.

.globl	log
.globl	retrn
.globl	rerr
.globl	temp

dlog.:	temp
	.+2
	setd
	br	1f

alog.:	temp
	.+2
	setf
1:
	seti
	movf	*2(r3),r0
	jsr	pc,log
	bes	1f
	movf	r0,temp
	jmp	retrn

1:
	jsr	r5,rerr; 1
endif
	add	(r4)+,r0
	movf	(r0)+,fr0
	movf	(r0)+,fr1
	movf	fr1,-(sp)
	movf	fr0,-(sp)
	jmp	*(r4)+

r0
	asl	r0
	asl	r0
	cmp	r0,(r4)+
.if achk
	bhis	9b
.endif
	add	(r4)+,r0
	cmp	(r0)+,(r0)+
	mov	-(r0),-(sp)
	mov	-(r0),-(sp)
	jmp	*(r4)+

gar8:
	setd
	tst	(sp)+/
/

/ alog10 & dlog10 fortran functions

.globl	dlog10.
.globl	alog10.

.globl	log
.globl	retrn
.globl	rerr
.globl	temp

dlog10.:temp
	.+2
	setd
	br	1f

alog10.:temp
	.+2
	setf
1:
	movf	*2(r3),r0
	jsr	pc,log
	bes	1f
	mulf	const,r0
	movf	r0,temp
	jmp	retrn

1:
	jsr	r5,rerr; 1

const:	37736;55730;124467;24146
movf	fr1,-(sp)
	movf	fr0,-(sp)
	jmp	*(r4)+

r0
	asl	r0
	asl	r0
	cmp	r0,(r4)+
.if achk
	bhis	9b
.endif
	add	(r4)+,r0
	cmp	(r0)+,(r0)+
	mov	-(r0),-(sp)
	mov	-(r0),-(sp)
	jmp	*(r4)+

gar8:
	setd
	tst	(sp)+/
/

/ max0 & amax0 fortran functions

.globl	amax0.
.globl	max0.

.globl	retrn
.globl	temp

max0.:	temp
	.+2
	mov	pc,r2
	br	1f

amax0.:	temp
	.+2
	clr	r2
1:
	setf
	setl
	mov	*2(sp),r0		/ arg count
	mov	r3,r1
	tst	(r1)+			/ argpp
	movif	*(r1)+,r1
	br	2f
1:
	movif	*(r1)+,r0
	cmpf	r0,r1
	cfcc
	ble	2f
	movf	r0,r1
2:
	dec	r0
	bgt	1b
	tst	r2
	bne	1f
	movf	r1,temp
	br	2f
1:
	movfi	r1,temp
2:
	jmp	retrn
s	9b
.endif
	add	(r4)+,r0
	cmp	(r0)+,(r0)+
	mov	-(r0),-(sp)
	mov	-(r0),-(sp)
	jmp	*(r4)+

gar8:
	setd
	tst	(sp)+/
/

/ max1, amax1 & dmax1 fortran functions

.globl	amax1.
.globl	dmax1.
.globl	max1.

.globl	retrn
.globl	temp

max1.:	temp
	.+2
	setl
	setf
	mov	pc,r2		/ integer flag
	br	2f

dmax1.:	temp
	.+2
	setd
	br	1f

amax1.:	temp
	.+2
	setf
1:
	clr	r2		/ integer flag
2:
	mov	*2(sp),r0		/ arg count
	mov	r3,r1
	tst	(r1)+			/ argpp
	movf	*(r1)+,r1
	br	2f
1:
	movf	*(r1)+,r0
	cmpf	r0,r1
	cfcc
	ble	2f
	movf	r0,r1
2:
	dec	r0
	bgt	1b
	tst	r2
	bne	1f
	movf	r1,temp
	br	2f
1:
	movfi	r1,temp
2:
	jmp	retrn
r8:
	setd
	tst	(sp)+/
/

/ min0 & amin0 fortran functions

.globl	amin0.
.globl	min0.

.globl	retrn
.globl	temp

min0.:	temp
	.+2
	mov	pc,r2
	br	1f

amin0.:	temp
	.+2
	clr	r2
1:
	setf
	setl
	mov	*2(sp),r0		/ arg count
	mov	r3,r1
	tst	(r1)+			/ argpp
	movif	*(r1)+,r1
	br	2f
1:
	movif	*(r1)+,r0
	cmpf	r0,r1
	cfcc
	bge	2f
	movf	r0,r1
2:
	dec	r0
	bgt	1b
	tst	r2
	bne	1f
	movf	r1,temp
	br	2f
1:
	movfi	r1,temp
2:
	jmp	retrn
,r1
2:
	dec	r0
	bgt	1b
	tst	r2
	bne	1f
	movf	r1,temp
	br	2f
1:
	movfi	r1,temp
2:
	jmp	retrn
r8:
	setd
	tst	(sp)+/
/

/ min1, amin1 & dmin1 fortran functions

.globl	amin1.
.globl	dmin1.
.globl	min1.

.globl	retrn
.globl	temp

min1.:	temp
	.+2
	setl
	setf
	mov	pc,r2
	br	2f

dmin1.:	temp
	.+2
	setd
	br	1f

amin1.:	temp
	.+2
	setf
1:
	clr	r2
2:
	mov	*2(sp),r0		/ arg count
	mov	r3,r1
	tst	(r1)+			/ argpp
	movf	*(r1)+,r1
	br	2f
1:
	movf	*(r1)+,r0
	cmpf	r0,r1
	cfcc
	bge	2f
	movf	r0,r1
2:
	dec	r0
	bgt	1b
	tst	r2
	bne	1f
	movf	r1,temp
	br	2f
1:
	movfi	r1,temp
2:
	jmp	retrn
1:
	movfi	r1,temp
2:
	jmp	retrn
r8:
	setd
	tst	(sp)+/
/

/ amod & dmod fortran functions

.globl	amod.
.globl	dmod.

.globl	retrn
one = 40200
.globl	temp
.globl	rerr

dmod.:	temp
	.+2
	setd
	br	1f

amod.:	temp
	.+2
	setf
1:
	cmp	*2(sp),$2
	bne	1f
	movf	*2(r3),r0
	movf	r0,r2
	movf	*4(r3),r1
	divf	r1,r2
	modf	$one,r2
	mulf	r1,r3
	subf	r3,r0
	movf	r0,temp
	jmp	retrn

1:
	jsr	r5,rerr; 2
	cmpf	r0,r1
	cfcc
	bge	2f
	movf	r0,r1
2:
	dec	r0
	bgt	1b
	tst	r2
	bne	1f
	movf	r1,temp
	br	2f
1:
	movfi	r1,temp
2:
	jmp	retrn
1:
	movfi	r1,temp
2:
	jmp	retrn
r8:
	setd
	tst	(sp)+/
/

/ atan & datan fortran functions

.globl	atan.
.globl	datan.

.globl	atan
.globl	retrn
.globl	temp

datan.:	temp
	.+2
	setd
	br	1f

atan.:	temp
	.+2
	setf
1:
	movf	*2(r3),r0
	jsr	pc,atan
	movf	r0,temp
	jmp	retrn
r0,r2
	movf	*4(r3),r1
	divf	r1,r2
	modf	$one,r2
	mulf	r1,r3
	subf	r3,r0
	movf	r0,temp
	jmp	retrn

1:
	jsr	r5,rerr; 2
	cmpf	r0,r1
	cfcc
	bge	2f
	movf	r0,r1
2:
	dec	r0
	bgt	1b
	tst	r2
	bne	1f
	movf	r1,temp
	br	2f
1:
	movfi	r1,temp
2:
	jmp	retrn
1:
	movfi	r1,temp
2:
	jmp	retrn
r8:
	setd
	tst	(sp)+/
/

/ atan2 & datan2 fortran functions

.globl	atan2.
.globl	datan2.

.globl	retrn
.globl	rerr
.globl	temp
.globl	atan2

datan2.:	temp
	.+2
	setd
	br	1f

atan2.:	temp
	.+2
	setf
1:
	cmp	*2(sp),$2
	bne	1f
	movf	*2(r3),r0
	movf	*4(r3),r1
	jsr	pc,atan2
	movf	r0,temp
	jmp	retrn
1:
	jsr	r5,rerr; 3
r0,temp
	jmp	retrn

1:
	jsr	r5,rerr; 2
	cmpf	r0,r1
	cfcc
	bge	2f
	movf	r0,r1
2:
	dec	r0
	bgt	1b
	tst	r2
	bne	1f
	movf	r1,temp
	br	2f
1:
	movfi	r1,temp
2:
	jmp	retrn
1:
	movfi	r1,temp
2:
	jmp	retrn
r8:
	setd
	tst	(sp)+/
/

/ cabs fortran function

.globl	cabs.
.globl	dcabs.

.globl	sqrt
.globl	retrn
.globl	rerr
.globl	temp

dcabs.:	temp
	.+2
	setd
	br	1f

cabs.:	temp
	.+2
	setf
1:
	mov	2(r3),r1
	movf	(r1)+,r0
	movf	(r1)+,r1
	jsr	pc,hypot
	bes	1f
	movf	r0,temp
	jmp	retrn
1:
	jsr	r5,rerr; 4
hypot:
	movf	fr1,-(sp)
	absf	fr0
	absf	fr1
	cmpf	fr0,fr1
	cfcc
	bne	1f
	movf	$one,fr0
	br	3f
1:
	blt	2f
	movf	fr0,-(sp)
	movf	fr