MORFROP IDNT 1,0 NOPAGE NOFORMAT NOLIST * INCLUDE MACROS.

INC * NOFORMAT LIST ADDRMASK SET $0FFFFFE ADRMASK EQU * ADRMSK DC.L ADDRMASK * * ??BTS2(DEST,SOURCE,LEN) AND ??BTT2(DEST,SOURCE,FILL,LEN) BOTH MASK DEST BY * SOURCE, ??BTS2 LEAVES VALUES NOT MASKED ALONE, ??BTT2 REPLACES NON-MASKED VALU ES * WITH FILL * IIBTS2 EQU * XDEF IIBTS2,DDBTS2,DIBTS2,IDBTS2 MOVEA.L 12(A7),A0 MOVE.L (A0),D0 MOVEA.L 8(A7),A1 MOVE.L (A1),D1 BRA.S INBTS2 IDBTS2 EQU * MOVEA.L 12(A7),A0 MOVE.L (A0),D0 MOVE.L 8(A7),D1 BRA.S INBTS2 DIBTS2 EQU * MOVE.L 12(A7),D0 MOVEA.L 8(A7),A1 MOVE.L (A1),D1 BRA.S INBTS2 DDBTS2 EQU * MOVE.L 12(A7),D0 MOVE.L 8(A7),D1 INBTS2 EQU * MOVEA.L 4(A7),A1 MOVE.L (A1),D2 SUBQ.L #1,D2 LSL.L #1,D2 AND.L ADRMSK(PC),D0 BEQ.S BTS2NO0DST MOVEA.L D0,A0 ANDI.B #$FE,D1 MOVEA.L D1,A1 FOR.L D0 = #0 TO D2 BY #2 DO.S CMPI.W #0,0(A1,D0.L) BNE.S BTS2NOT0 MOVE.W #$FFF0,0(A0,D0.L) BTS2NOT0 EQU * ENDF BTS2NO0DST EQU * FNRET 3 * * IIBTT2 EQU *

XDEF IIBTT2,DDBTT2,DIBTT2,IDBTT2 MOVEA.L 16(A7),A0 MOVE.L (A0),D0 MOVEA.L 12(A7),A1 MOVE.L (A1),D1 BRA.S INBTT2 IDBTT2 EQU * MOVEA.L 16(A7),A0 MOVE.L (A0),D0 MOVE.L 12(A7),D1 BRA.S INBTT2 DIBTT2 EQU * MOVE.L 16(A7),D0 MOVEA.L 12(A7),A1 MOVE.L (A1),D1 BRA.S INBTT2 DDBTT2 EQU * MOVE.L 16(A7),D0 MOVE.L 12(A7),D1 INBTT2 EQU * MOVEA.L 8(A7),A1 MOVE.L (A1),D3 MOVEA.L 4(A7),A1 MOVE.L (A1),D2 SUBQ.L #1,D2 LSL.L #1,D2 AND.L ADRMSK(PC),D0 BEQ.S BTS2NO0DST MOVEA.L D0,A0 ANDI.B #$FE,D1 MOVEA.L D1,A1 FOR.L D0 = #0 TO D2 BY #2 DO.S MOVE.W D3,0(A0,D0.L) CMPI.W #0,0(A1,D0.L) BNE.S BTT2NOT0 MOVE.W #$FFF0,0(A0,D0.L) BTT2NOT0 EQU * ENDF BTT2NO0DST EQU * FNRET 4 * * * CALL ?ASNTB(ASINTBL), ?SQRTB(SQRTBL), SETSHF(SHIFTCOUNT) * IASNTB EQU * XDEF IASNTB,DASNTB,SETSHF,ISQRTB,DSQRTB MOVEA.L 4(A7),A0 MOVE.L (A0),D0 BRA.S INSTBL DASNTB EQU * MOVE.L 4(A7),D0 INSTBL EQU * AND.L ADRMSK(PC),D0 MOVE.L D0,ASINTABLE CLR.L D0 BEQ.S ISOK * ISQRTB EQU * MOVEA.L 4(A7),A0

MOVE.L (A0),D0 BRA.S INQTBL DSQRTB EQU * MOVE.L 4(A7),D0 INQTBL EQU * AND.L ADRMSK(PC),D0 MOVE.L D0,SQRTABLE CLR.L D0 BEQ.S ISOK * SETSHF EQU * MOVEA.L 4(A7),A0 MOVE.L (A0),D0 CMPI.L #0,D0 BGE.S GR0 MOVEQ.L #0,D0 GR0: MOVE.L D0,D1 LSR.L #2,D0 LSL.L #2,D0 CMP.L D0,D1 BEQ.S ISOK ADDQ.L #4,D0 ISOK: MOVE.L D0,SHIFTCOUNT LSR.L #1,D0 MOVE.L D0,USHIFTCOUNT FNRET1 * ASINTABLE DC.L 0 SQRTTABLE EQU * SQRTABLE DC.L 0 SHIFTCOUNT DC.L 0 USHIFTCOUNT DC.L 0 * * CALL ??ASIN(DST/REF,SRC,LEN) * IIASIN EQU * XDEF IIASIN,DDASIN,DIASIN,IDASIN MOVEA.L 12(A7),A0 MOVE.L (A0),D0 MOVEA.L 8(A7),A1 MOVE.L (A1),D1 BRA.S INASIN IDASIN EQU * MOVEA.L 12(A7),A0 MOVE.L (A0),D0 MOVE.L 8(A7),D1 BRA.S INASIN DIASIN EQU * MOVE.L 12(A7),D0 MOVEA.L 8(A7),A1 MOVE.L (A1),D1 BRA.S INASIN DDASIN EQU * MOVE.L 12(A7),D0 MOVE.L 8(A7),D1 INASIN EQU * MOVEA.L 4(A7),A1 MOVE.L (A1),D2 SAVREG SUBQ.L #1,D2

LSL.L #1,D2 AND.L ADRMSK(PC),D0 BEQ.L ASINNO0DST MOVEA.L D0,A0 AND.L ADRMSK(PC),D1 MOVEA.L D1,A2 MOVEA.L ASINTABLE(PC),A1 MOVEA.L SQRTTABLE(PC),A3 MOVE.L SHIFTCOUNT(PC),D4 MOVE.L USHIFTCOUNT(PC),D5 FOR.L D0 = #0 TO D2 BY #2 DO.S CLR.L D1 MOVE.W 0(A0,D0.L),D3 BTST.L #15,D3 BNE.S SSUPPRESS BTST.L #14,D3 BEQ.S SNOSUP MOVE.W #$3FFF,D1 BRA.S SSUPPRESS SNOSUP MOVE.W 0(A2,D0.L),D1 ANDI.L #$3FFF,D1 ADD.W D1,D1 MOVE.W 0(A1,D1.L),D1 BTST.L #0,D3 BEQ.S NOTB14 NEG.W D1 ADD.W #8192,D1 NOTB14 EQU * LSR.W #1,D3 CMP.W #0,D3 BEQ.S SFIRST SUBI.W #1,D3 SADDAG: ADD.L #8192,D1 DBRA D3,SADDAG SFIRST: CMP.W #0,D4 BEQ.S SNOSHIFT LSR.L D4,D1 SNOSHIFT: ANDI.L #$FFFFFFFE,D1 ** SQRT LOOKUP IS HERE MOVE.W 0(A3,D1.W),D1 CMP.W #0,D5 BEQ.S SSUPPRESS LSL.L D5,D1 SSUPPRESS EQU * MOVE.W D1,0(A0,D0.L) ENDF ASINNO0DST EQU * RSTREG FNRET 3 * IIACOS EQU * XDEF IIACOS,DDACOS,DIACOS,IDACOS MOVEA.L 12(A7),A0 MOVE.L (A0),D0 MOVEA.L 8(A7),A1 MOVE.L (A1),D1 BRA.S INACOS IDACOS EQU * MOVEA.L 12(A7),A0

MOVE.L (A0),D0 MOVE.L 8(A7),D1 BRA.S INACOS DIACOS EQU * MOVE.L 12(A7),D0 MOVEA.L 8(A7),A1 MOVE.L (A1),D1 BRA.S INACOS DDACOS EQU * MOVE.L 12(A7),D0 MOVE.L 8(A7),D1 INACOS EQU * MOVEA.L 4(A7),A1 MOVE.L (A1),D2 SAVREG SUBQ.L #1,D2 LSL.L #1,D2 AND.L ADRMSK(PC),D0 BEQ.S ASINNO0DST MOVEA.L D0,A0 AND.L ADRMSK(PC),D1 MOVEA.L D1,A2 MOVEA.L ASINTABLE(PC),A1 MOVEA.L SQRTTABLE(PC),A3 MOVE.L SHIFTCOUNT(PC),D4 MOVE.L USHIFTCOUNT(PC),D5 FOR.L D0 = #0 TO D2 BY #2 DO.S CLR.L D1 MOVE.W 0(A0,D0.L),D3 BTST.L #15,D3 BNE.S CSUPPRESS MOVE.W #$3FFF,D1 BTST.L #14,D3 BEQ.S CNOSUP * MOVE.W #$3FFF,D1 BRA.S CSUPPRESS CNOSUP SUB.W 0(A2,D0.L),D1 ;Table is ASIN**2, do ACOS**2 as 1 - ? ANDI.L #$3FFF,D1 ADD.W D1,D1 MOVE.W 0(A1,D1.L),D1 BTST.L #0,D3 ;is quadrant number odd? BEQ.S B14NOT ;NO, do no correction NEG.W D1 ;even quadrant (odd quad. number) correction ADD.W #8192,D1 ISB14 EQU * B14NOT EQU * LSR.W #1,D3 CMP.W #0,D3 BEQ.S CFIRST SUBI.W #1,D3 CADDAG: ADD.L #8192,D1 DBRA D3,CADDAG CFIRST: CMP.W #0,D5 BEQ.S CNOSHIFT LSR.L D4,D1 CNOSHIFT: ANDI.L #$FFFFFFFE,D1 ** SQRT LOOKUP IS HERE MOVE.W 0(A3,D1.W),D1 CMP.W #0,D5

BEQ.S CSUPPRESS LSL.L D5,D1 CSUPPRESS EQU * MOVE.W D1,0(A0,D0.L) ENDF BRA.L ASINNO0DST * * IIFDIF EQU * XDEF IIFDIF,DDFDIF,DIFDIF,IDFDIF MOVEA.L 12(A7),A0 MOVE.L (A0),D0 MOVEA.L 8(A7),A1 MOVE.L (A1),D1 BRA.S INFDIF IDFDIF EQU * MOVEA.L 12(A7),A0 MOVE.L (A0),D0 MOVE.L 8(A7),D1 BRA.S INFDIF DIFDIF EQU * MOVE.L 12(A7),D0 MOVEA.L 8(A7),A1 MOVE.L (A1),D1 BRA.S INFDIF DDFDIF EQU * MOVE.L 12(A7),D0 MOVE.L 8(A7),D1 INFDIF EQU * MOVEA.L 4(A7),A1 MOVE.L (A1),D2 SAVREG SUBQ.L #1,D2 LSL.L #1,D2 AND.L ADRMSK(PC),D0 BEQ.S FDIFNO0DST MOVEA.L D0,A0 AND.L ADRMSK(PC),D1 MOVEA.L D1,A2 * MOVEA.L ASINTABLE(PC),A1 * MOVEA.L SQRTTABLE(PC),A3 * MOVE.L SHIFTCOUNT(PC),D4 * MOVE.L USHIFTCOUNT(PC),D5 FOR.L D0 = #0 TO D2 BY #2 DO.S CLR.L D1 CLR.L D3 MOVE.W 0(A0,D0.L),D3 BTST.L #15,D3 BNE.S FSUPPRESS BTST.L #14,D3 BEQ.S FNOSUP MOVE.W #$3FFF,D1 BRA.S FSUPPRESS FNOSUP MOVE.W 0(A2,D0.L),D1 ANDI.W #$3FFF,D1 MOVE.W 2(A2,D0.L),D3 ANDI.W #$3FFF,D3 SUB.W D1,D3 * BVS.S FSETHI

BMI.S FSET0 MOVE.W D3,D1 BRA.S FSUPPRESS *FSETHI MOVE.W #$3FFF,D1 * BRA.S FSUPPRESS FSET0 CLR.W D1 FSUPPRESS EQU * MOVE.W D1,0(A0,D0.L) ENDF FDIFNO0DST EQU * BRA.L ASINNO0DST * * IIBDIF EQU * XDEF IIBDIF,DDBDIF,DIBDIF,IDBDIF MOVEA.L 12(A7),A0 MOVE.L (A0),D0 MOVEA.L 8(A7),A1 MOVE.L (A1),D1 BRA.S INBDIF IDBDIF EQU * MOVEA.L 12(A7),A0 MOVE.L (A0),D0 MOVE.L 8(A7),D1 BRA.S INBDIF DIBDIF EQU * MOVE.L 12(A7),D0 MOVEA.L 8(A7),A1 MOVE.L (A1),D1 BRA.S INBDIF DDBDIF EQU * MOVE.L 12(A7),D0 MOVE.L 8(A7),D1 INBDIF EQU * MOVEA.L 4(A7),A1 MOVE.L (A1),D2 SAVREG SUBQ.L #1,D2 LSL.L #1,D2 AND.L ADRMSK(PC),D0 BEQ.S BDIFNO0DST MOVEA.L D0,A0 AND.L ADRMSK(PC),D1 MOVEA.L D1,A2 * MOVEA.L ASINTABLE(PC),A1 * MOVEA.L SQRTTABLE(PC),A3 * MOVE.L SHIFTCOUNT(PC),D4 * MOVE.L USHIFTCOUNT(PC),D5 FOR.L D0 = #0 TO D2 BY #2 DO.S CLR.L D1 CLR.L D3 MOVE.W 0(A0,D0.L),D3 BTST.L #15,D3 BNE.S BSUPPRESS BTST.L #14,D3 BEQ.S BNOSUP MOVE.W #$3FFF,D1 BRA.S BSUPPRESS BNOSUP MOVE.W 0(A2,D0.L),D1

ANDI.W #$3FFF,D1 MOVE.W 2(A2,D0.L),D3 ANDI.W #$3FFF,D3 SUB.W D3,D1 * BVS.S BSETHI BMI.S BSET0 BRA.S BSUPPRESS *BSETHI MOVE.W #$3FFF,D1 * BRA.S BSUPPRESS BSET0 CLR.W D1 BSUPPRESS EQU * MOVE.W D1,0(A0,D0.L) ENDF BDIFNO0DST EQU * BRA.L ASINNO0DST * * IIFDFO EQU * XDEF IIFDFO,DDFDFO,DFODFO,IDFDFO MOVEA.L 12(A7),A0 MOVE.L (A0),D0 MOVEA.L 8(A7),A1 MOVE.L (A1),D1 BRA.S INFDFO IDFDFO EQU * MOVEA.L 12(A7),A0 MOVE.L (A0),D0 MOVE.L 8(A7),D1 BRA.S INFDFO DFODFO EQU * MOVE.L 12(A7),D0 MOVEA.L 8(A7),A1 MOVE.L (A1),D1 BRA.S INFDFO DDFDFO EQU * MOVE.L 12(A7),D0 MOVE.L 8(A7),D1 INFDFO EQU * MOVEA.L 4(A7),A1 MOVE.L (A1),D2 SAVREG SUBQ.L #1,D2 LSL.L #1,D2 AND.L ADRMSK(PC),D0 BEQ.S FDFONO0DST MOVEA.L D0,A0 AND.L ADRMSK(PC),D1 MOVEA.L D1,A2 * MOVEA.L ASINTABLE(PC),A1 * MOVEA.L SQRTTABLE(PC),A3 * MOVE.L SHIFTCOUNT(PC),D4 * MOVE.L USHIFTCOUNT(PC),D5 FOR.L D0 = #0 TO D2 BY #2 DO.S CLR.L D1 CLR.L D3 MOVE.W 0(A0,D0.L),D3 BTST.L #15,D3 BNE.S FOSUPPRESS BTST.L #14,D3

BEQ.S FONOSUP MOVE.W #$3FFF,D1 BRA.S FOSUPPRESS FONOSUP MOVE.W 0(A2,D0.L),D1 ANDI.W #$7FFF,D1 MOVE.W 2(A2,D0.L),D3 ANDI.W #$7FFF,D3 SUB.W D1,D3 ADDI.W #$2000,D3 BMI.S FOSET0 MOVE.W D3,D1 BRA.S FOSUPPRESS FOSET0 CLR.W D1 FOSUPPRESS EQU * MOVE.W D1,0(A0,D0.L) ENDF FDFONO0DST EQU * BRA.L ASINNO0DST * * IIBDFO EQU * XDEF IIBDFO,DDBDFO,DIBDFO,IDBDFO MOVEA.L 12(A7),A0 MOVE.L (A0),D0 MOVEA.L 8(A7),A1 MOVE.L (A1),D1 BRA.S INBDFO IDBDFO EQU * MOVEA.L 12(A7),A0 MOVE.L (A0),D0 MOVE.L 8(A7),D1 BRA.S INBDFO DIBDFO EQU * MOVE.L 12(A7),D0 MOVEA.L 8(A7),A1 MOVE.L (A1),D1 BRA.S INBDFO DDBDFO EQU * MOVE.L 12(A7),D0 MOVE.L 8(A7),D1 INBDFO EQU * MOVEA.L 4(A7),A1 MOVE.L (A1),D2 SAVREG SUBQ.L #1,D2 LSL.L #1,D2 AND.L ADRMSK(PC),D0 BEQ.S BDFONO0DST MOVEA.L D0,A0 AND.L ADRMSK(PC),D1 MOVEA.L D1,A2 * MOVEA.L ASINTABLE(PC),A1 * MOVEA.L SQRTTABLE(PC),A3 * MOVE.L SHIFTCOUNT(PC),D4 * MOVE.L USHIFTCOUNT(PC),D5 FOR.L D0 = #0 TO D2 BY #2 DO.S CLR.L D1 CLR.L D3 MOVE.W 0(A0,D0.L),D3

BTST.L #15,D3 BNE.S BOSUPPRESS BTST.L #14,D3 BEQ.S BONOSUP MOVE.W #$3FFF,D1 BRA.S BOSUPPRESS BONOSUP MOVE.W 0(A2,D0.L),D1 ANDI.W #$3FFF,D1 MOVE.W 2(A2,D0.L),D3 ANDI.W #$3FFF,D3 SUB.W D3,D1 ADDI.W #$2000,D1 BMI.S BOSET0 BRA.S BOSUPPRESS BOSET0 CLR.W D1 BOSUPPRESS EQU * MOVE.W D1,0(A0,D0.L) ENDF BDFONO0DST EQU * BRA.L ASINNO0DST * * IIADIF EQU * XDEF IIADIF,DDADIF,DIADIF,IDADIF MOVEA.L 12(A7),A0 MOVE.L (A0),D0 MOVEA.L 8(A7),A1 MOVE.L (A1),D1 BRA.S INADIF IDADIF EQU * MOVEA.L 12(A7),A0 MOVE.L (A0),D0 MOVE.L 8(A7),D1 BRA.S INADIF DIADIF EQU * MOVE.L 12(A7),D0 MOVEA.L 8(A7),A1 MOVE.L (A1),D1 BRA.S INADIF DDADIF EQU * MOVE.L 12(A7),D0 MOVE.L 8(A7),D1 INADIF EQU * MOVEA.L 4(A7),A1 MOVE.L (A1),D2 SAVREG SUBQ.L #1,D2 LSL.L #1,D2 AND.L ADRMSK(PC),D0 BEQ.S ADIFNO0DST MOVEA.L D0,A0 AND.L ADRMSK(PC),D1 MOVEA.L D1,A2 * MOVEA.L ASINTABLE(PC),A1 * MOVEA.L SQRTTABLE(PC),A3 * MOVE.L SHIFTCOUNT(PC),D4 * MOVE.L USHIFTCOUNT(PC),D5 FOR.L D0 = #0 TO D2 BY #2 DO.S CLR.L D1

CLR.L D3 MOVE.W 0(A0,D0.L),D3 BTST.L #15,D3 BNE.S ASUPPRESS BTST.L #14,D3 BEQ.S ANOSUP MOVE.W #$3FFF,D1 BRA.S ASUPPRESS ANOSUP MOVE.W 0(A2,D0.L),D1 ANDI.W #$3FFF,D1 MOVE.W 2(A2,D0.L),D3 ANDI.W #$3FFF,D3 SUB.W D3,D1 BMI.S AFLIP BRA.S ASUPPRESS AFLIP NEG.W D1 ASUPPRESS EQU * MOVE.W D1,0(A0,D0.L) ENDF ADIFNO0DST EQU * BRA.L ASINNO0DST * **qzqzqzqzqzqzqz ** ** FORTRAN callable routines ?TPYX2(ARRAY, Xbegin, Xend, Xstep(+/-1), NX, ** Ybegin, Yend, Ystep(+/-1), IT) ** where ? = I or D, D(irect) means ARRAY is the array, I(ndirect) means ARRAY i s ** a pointer to the array. The array is two-dimensional, with NX being the numb er ** of entries on the first dimension. A rectangular region is processed, starti ng ** at (Xbegin,Ybegin) and proceeding along with X varying most rapidly to ** (Xend,Yend). If Xbegin < Xend then Xstep should be -1, and if Ybegin < Yend ** then Ystep should be -1; else the step variables should be +1. The array is ** supposed to be a quadrant value array which is being filled. Values of -2 in ** the array are as-yet-untagged points which can be tagged with IT if they fall ** within the rectangular region. *ITPYX2 EQU * * XDEF ITPYX2,DTPYX2 * MOVEA.L 36(A7),A0 * MOVE.L (A0),D0 * BRA.S INTPYX2 *DTPYX2 EQU * * MOVE.L 36(A7),D0 *INTPYX2 EQU * * SAVREG * AND.L ADRMSK(PC),D0 * BEQ.L TPYXNO0DST * MOVEA.L D0,A1 ** * MOVEA.L 32(A5),A2 * MOVE.L (A2),D1 * SUBQ.L #1,D1 * ADD.L D1,D1 * MOVEA.L 28(A5),A2 * MOVE.L (A2),D2 * SUBQ.L #1,D2 * ADD.L D2,D2 * MOVEA.L 24(A5),A2

* MOVE.L (A2),D3 * ADD.L D3,D3 * MOVEA.L 20(A5),A2 * MOVE.L (A2),D0 * ADD.L D0,D0 ** * MOVEA.L 16(A5),A2 * MOVE.L (A2),D7 * SUBQ.L #1,D7 * CLR.L D4 * SUB.L D0,D4 *TPYXYBLOOP EQU * * ADD.L D0,D4 * DBRA D7,TPYXYBLOOP ** * MOVEA.L 12(A5),A2 * MOVE.L (A2),D7 * SUBQ.L #1,D7 * CLR.L D5 * SUB.L D0,D5 *TPYXYELOOP EQU * * ADD.L D0,D5 * DBRA D7,TPYXYELOOP ** * MOVEA.L 8(A5),A2 * MOVE.L (A2),D7 * MOVE.L D0,D6 * TST.L D7 * BPL.S TPYXYST * NEG.L D6 *TPYXYST EQU * * ADD.L D6,D5 ** * MOVEA.L 4(A5),A2 * MOVE.L (A2),D7 ** ** Setup is done, all registers have been loaded. The processing loops follow. ** *TPYXLOOPBACK EQU * * MOVEA.L A1,A2 * ADDA.L D4,A2 * TST.L D3 * BMI.S TPYXNEGINC * FOR.L A0 = D1 TO D2 BY D3 * DO.S * CMPI.W #-2,0(A2,A0.L) * BNE.S TPYXSKIPIT * MOVE.W D7,0(A2,A0.L) *TPYXSKIPIT EQU * * ENDF * BRA.S TPYXENDIF ** *TPYXNEGINC EQU * * NEG.L D3 * FOR.L A0 = D1 DOWNTO D2 BY D3 * DO.S * CMPI.W #-2,0(A2,A0.L) * BNE.S TPYXSKIMIT * MOVE.W D7,0(A2,A0.L) *TPYXSKIMIT EQU *

* ENDF * NEG.L D3 *TPYXENDIF EQU * ** * CMP.L D4,D5 * BEQ.S TPYXOUT * ADD.L D6,D4 * BRA TPYXLOOPBACK ** *TPYXOUT EQU * *TPYXNO0DST EQU * *TQYXNO0DST EQU * * RSTREG * FNRET 9 ** ** FORTRAN callable routines ?TQYX2(ARRAY, Xbegin, Xend, Xstep(+/-1), NX, ** Ybegin, Yend, Ystep(+/-1), IT) ** where ? = I or D, D(irect) means ARRAY is the array, I(ndirect) means ARRAY i s ** a pointer to the array. The array is two-dimensional, with NX being the numb er ** of entries on the first dimension. A rectangular region is processed, starti ng ** at (Xbegin,Ybegin) and proceeding along with X varying most rapidly to ** (Xend,Yend). If Xbegin < Xend then Xstep should be -1, and if Ybegin < Yend ** then Ystep should be -1; else the step variables should be +1. The array is ** supposed to be a quadrant value array which is being filled. Values of -2 in ** the array are as-yet-untagged points which can be tagged with IT if they fall ** within the rectangular region and meet the criterion. The criterion is that ** they be contiguously reachable without hitting a points tagged with -1 or hig her ** value. *ITQYX2 EQU * * XDEF ITQYX2,DTQYX2 * MOVEA.L 36(A7),A0 * MOVE.L (A0),D0 * BRA.S INTQYX2 *DTQYX2 EQU * * MOVE.L 36(A7),D0 *INTQYX2 EQU * * SAVREG * AND.L ADRMSK(PC),D0 * BEQ TQYXNO0DST * MOVEA.L D0,A1 ** * MOVEA.L 32(A5),A2 * MOVE.L (A2),D1 * SUBQ.L #1,D1 * ADD.L D1,D1 * MOVEA.L 28(A5),A2 * MOVE.L (A2),D2 * SUBQ.L #1,D2 * ADD.L D2,D2 * MOVEA.L 24(A5),A2 * MOVE.L (A2),D3 * ADD.L D3,D3 * MOVEA.L 20(A5),A2 * MOVE.L (A2),D0 * ADD.L D0,D0 **

* MOVEA.L 16(A5),A2 * MOVE.L (A2),D7 * SUBQ.L #1,D7 * CLR.L D4 * SUB.L D0,D4 *TQYXYBLOOP EQU * * ADD.L D0,D4 * DBRA D7,TQYXYBLOOP ** * MOVEA.L 12(A5),A2 * MOVE.L (A2),D7 * SUBQ.L #1,D7 * CLR.L D5 * SUB.L D0,D5 *TQYXYELOOP EQU * * ADD.L D0,D5 * DBRA D7,TQYXYELOOP ** * MOVEA.L 8(A5),A2 * MOVE.L (A2),D7 * MOVE.L D0,D6 * TST.L D7 * BPL.S TQYXYST * NEG.L D6 *TQYXYST EQU * * ADD.L D6,D5 ** * MOVEA.L 4(A5),A2 * MOVE.L (A2),D7 ** ** Setup is done, all registers have been loaded. The processing loops follow. ** *TQYXLOOPBACK EQU * * MOVEA.L A1,A2 * ADDA.L D4,A2 ** * TST.L D3 * BMI.S TQYXNEGINC * FOR.L A0 = D1 TO D2 BY D3 * DO.S * MOVE.W 0(A2,A0.L),D0 * CMPI.W #-1,D0 * BGE.S TQYXNEXTY * CMPI.W #-2,D0 * BNE.S TQYXSKIPIT * MOVE.W D7,0(A2,A0.L) *TQYXSKIPIT EQU * * ENDF * BRA.S TQYXENDIF ** *TQYXNEGINC EQU * * NEG.L D3 * FOR.L A0 = D1 DOWNTO D2 BY D3 * DO.S * MOVE.W 0(A2,A0.L),D0 * CMPI.W #-1,D0 * BGE.S TQYXNEXTY * CMPI.W #-2,D0 * BNE.S TQYXSKIMIT * MOVE.W D7,0(A2,A0.L)

*TQYXSKIMIT EQU * * ENDF *TQYXNEXTY EQU * * NEG.L D3 *TQYXENDIF EQU * ** * CMP.L D4,D5 * BEQ.S TQYXOUT * ADD.L D6,D4 * BRA TQYXLOOPBACK ** *TQYXOUT EQU * *TQXYNO0DST EQU * * BRA TPYXNO0DST ** ** ** FORTRAN callable routines ?TQXY2(ARRAY, Xbegin, Xend, Xstep(+/-1), NX, ** Ybegin, Yend, Ystep(+/-1), IT) ** where ? = I or D, D(irect) means ARRAY is the array, I(ndirect) means ARRAY i s ** a pointer to the array. The array is two-dimensional, with NX being the numb er ** of entries on the first dimension. A rectangular region is processed, starti ng ** at (Xbegin,Ybegin) and proceeding along with Y varying most rapidly to ** (Xend,Yend). If Xbegin < Xend then Xstep should be -1, and if Ybegin < Yend ** then Ystep should be -1; else the step variables should be +1. The array is ** supposed to be a quadrant value array which is being filled. Values of -2 in ** the array are as-yet-untagged points which can be tagged with IT if they fall ** within the rectangular region and meet the criterion. The criterion is that ** they be contiguously reachable without hitting a points tagged with -1 or hig her ** value. *ITQXY2 EQU * * XDEF ITQXY2,DTQXY2 * MOVEA.L 36(A7),A0 * MOVE.L (A0),D0 * BRA.S INTQXY2 *DTQXY2 EQU * * MOVE.L 36(A7),D0 *INTQXY2 EQU * * SAVREG * AND.L ADRMSK(PC),D0 * BEQ TQXYNO0DST * MOVEA.L D0,A1 ** * MOVEA.L 32(A5),A2 * MOVE.L (A2),D1 * SUBQ.L #1,D1 * ADD.L D1,D1 * MOVEA.L 28(A5),A2 * MOVE.L (A2),D2 * SUBQ.L #1,D2 * ADD.L D2,D2 * MOVEA.L 24(A5),A2 * MOVE.L (A2),D3 * ADD.L D3,D3 * MOVEA.L 20(A5),A2 * MOVE.L (A2),D0 * ADD.L D0,D0

** * MOVEA.L 16(A5),A2 * MOVE.L (A2),D7 * SUBQ.L #1,D7 * CLR.L D4 * SUB.L D0,D4 *TQXYYBLOOP EQU * * ADD.L D0,D4 * DBRA D7,TQXYYBLOOP ** * MOVEA.L 12(A5),A2 * MOVE.L (A2),D7 * SUBQ.L #1,D7 * CLR.L D5 * SUB.L D0,D5 *TQXYYELOOP EQU * * ADD.L D0,D5 * DBRA D7,TQXYYELOOP ** * MOVEA.L 8(A5),A2 * MOVE.L (A2),D7 * MOVE.L D0,D6 * TST.L D7 * BPL.S TQXYYST * NEG.L D6 *TQXYYST EQU * * ADD.L D6,D5 * MOVEA.L 4(A5),A2 * MOVE.L (A2),D7 ** ** Setup is done, all registers have been loaded. The processing loops follow. ** * MOVEA.L D4,A3 * TST.L D3 * BMI.S TQXYNEGINC * FOR.L A0 = D1 TO D2 BY D3 * DO.S * MOVEA.L A1,A2 * ADDA.L A0,A2 *TQXYLOOPBACK EQU * * MOVE.W 0(A2,D4.L),D0 * CMPI.W #-1,D0 * BGE.S TQXYNEXTX * CMPI.W #-2,D0 * BNE.S TQXYSKIPIT * MOVE.W D7,0(A2,A0.L) *TQXYSKIPIT EQU * * CMP.L D4,D5 * BEQ.S TQXYOUT * ADD.L D6,D4 * BRA TQXYLOOPBACK *TQXYOUT EQU * *TQXYNEXTX EQU * * MOVE.L A3,D4 * ENDF * BRA.S TQXYENDIF ** *TQXYNEGINC EQU * * NEG.L D3 * FOR.L A0 = D1 DOWNTO D2 BY D3

* DO.S * MOVEA.L A1,A2 * ADDA.L A0,A2 *TQXYLOOMBACK EQU * * MOVE.W 0(A2,D4.L),D0 * CMPI.W #-1,D0 * BGE.S TQXYNEXMX * CMPI.W #-2,D0 * BNE.S TQXYSKIMIT * MOVE.W D7,0(A2,A0.L) *TQXYSKIMIT EQU * * CMP.L D4,D5 * BEQ.S TQXYOUTM * ADD.L D6,D4 * BRA TQXYLOOMBACK *TQXYOUTM EQU * *TQXYNEXMX EQU * * MOVE.L A3,D4 * ENDF ** NEG.L D3 *TQXYENDIF EQU * ** * BRA TPYXNO0DST ** *** FORTRAN callable routines ?TPXY2(ARRAY, Xbegin, Xend, Xstep(+/-1), NX, *** Ybegin, Yend, Ystep(+/-1), IT) *** where ? = I or D, D(irect) means ARRAY is the array, I(ndirect) means ARRAY is *** a pointer to the array. The array is two-dimensional, with NX being the num ber *** of entries on the first dimension. A rectangular region is processed, start ing *** at (Xbegin,Ybegin) and proceeding along with Y varying most rapidly to *** (Xend,Yend). If Xbegin < Xend then Xstep should be -1, and if Ybegin < Yend *** then Ystep should be -1; else the step variables should be +1. The array is *** supposed to be a quadrant value array which is being filled. Values of -2 i n *** the array are as-yet-untagged points which can be tagged with IT if they fal l *** within the rectangular region. ** ** ?TPXY2 does the same things as ?TPYX2, so don't duplicate code - just branch ** to other code ... *ITPXY2 EQU * * BRA ITPYX2 *DTPXY2 EQU * * BRA DTPYX2 * XDEF ITPXY2,DTPXY2 ** **ITPXY2 EQU * ** XDEF ITPXY2,DTPXY2 ** MOVEA.L 36(A7),A0 ** MOVE.L (A0),D0 ** BRA.S INTPXY2 **DTPXY2 EQU * ** MOVE.L 36(A7),D0 **INTPXY2 EQU * ** SAVREG ** AND.L ADRMSK(PC),D0 ** BEQ TPXYNO0DST

** MOVEA.L D0,A1 ** ** MOVEA.L 32(A5),A2 ** MOVE.L (A2),D1 ** SUBQ.L #1,D1 ** ADD.L D1,D1 ** MOVEA.L 28(A5),A2 ** MOVE.L (A2),D2 ** SUBQ.L #1,D2 ** ADD.L D2,D2 ** MOVEA.L 24(A5),A2 ** MOVE.L (A2),D3 ** ADD.L D3,D3 ** MOVEA.L 20(A5),A2 ** MOVE.L (A2),D0 ** ADD.L D0,D0 ** ** MOVEA.L 16(A5),A2 ** MOVE.L (A2),D7 ** SUBQ.L #1,D7 ** CLR.L D4 ** SUB.L D0,D4 **TPXYYBLOOP EQU * ** ADD.L D0,D4 ** DBRA D7,TPXYYBLOOP ** ** MOVEA.L 12(A5),A2 ** MOVE.L (A2),D7 ** SUBQ.L #1,D7 ** CLR.L D5 ** SUB.L D0,D5 **TPXYYELOOP EQU * ** ADD.L D0,D5 ** DBRA D7,TPXYYELOOP ** ** MOVEA.L 8(A5),A2 ** MOVE.L (A2),D7 ** MOVE.L D0,D6 ** TST.L D7 ** BPL.S TPXYYST ** NEG.L D6 **TPXYYST EQU * ** ADD.L D6,D5 ** ** MOVEA.L 4(A5),A2 ** MOVE.L (A2),D7 *** *** Setup is done, all registers have been loaded. The processing loops follow. *** ** MOVEA.L D4,A3 ** TST.L D3 ** BMI.S TPXYNEGINC ** FOR.L A0 = D1 TO D2 BY D3 ** DO.S ** MOVEA.L A1,A2 ** ADDA.L A0,A2 **TPXYLOOPBACK EQU * ** CMPI.W #-2,0(A2,D4.L) ** BNE.S TPXYSKIPIT ** MOVE.W D7,0(A2,A0.L)

**TPXYSKIPIT EQU * ** CMP.L D4,D5 ** BEQ.S TPXYOUT ** ADD.L D6,D4 ** BRA TPXYLOOPBACK **TPXYOUT EQU * ** MOVE.L A3,D4 ** ENDF ** BRA.S TPXYENDIF ** **TPXYNEGINC EQU * ** NEG.L D3 ** FOR.L A0 = D1 DOWNTO D2 BY D3 ** DO.S ** MOVEA.L A1,A2 ** ADDA.L A0,A2 **TPXYLOOMBACK EQU * ** CMPI.W #-2,0(A2,D4.L) ** BNE.S TPXYSKIMIT ** MOVE.W D7,0(A2,A0.L) **TPXYSKIMIT EQU * ** CMP.L D4,D5 ** BEQ.S TPXYOUTM ** ADD.L D6,D4 ** BRA TPXYLOOMBACK **TPXYOUTM EQU * ** MOVE.L A3,D4 ** ENDF *** NEG.L D3 **TPXYENDIF EQU * *** ** BRA TPYXNO0DST *** ** ** FORTRAN callable routines ?TPYX5(ARRAY, Xbegin, Xend, Xstep(+/-1), NX, ** Ybegin, Yend, Ystep(+/-1), IT) ** where ? = I or D, D(irect) means ARRAY is the array, I(ndirect) means ARRAY i s ** a pointer to the array. The array is two-dimensional, with NX being the numb er ** of entries on the first dimension. A rectangular region is processed, starti ng ** at (Xbegin,Ybegin) and proceeding along with X varying most rapidly to ** (Xend,Yend). If Xbegin < Xend then Xstep should be -1, and if Ybegin < Yend ** then Ystep should be -1; else the step variables should be +1. The array is ** supposed to be a quadrant value array which is being filled. Values of -2 in ** the array are as-yet-untagged points which can be tagged with IT if they fall ** within the rectangular region. *ITPYX5 EQU * * XDEF ITPYX5,DTPYX5 * MOVEA.L 36(A7),A0 * MOVE.L (A0),D0 * BRA.S INTPYX5 *DTPYX5 EQU * * MOVE.L 36(A7),D0 *INTPYX5 EQU * * SAVREG * AND.L ADRMSK(PC),D0 * BEQ.L T5YXNO0DST * MOVEA.L D0,A1

** * MOVEA.L 32(A5),A2 * MOVE.L (A2),D1 * SUBQ.L #1,D1 * ADD.L D1,D1 * MOVEA.L 28(A5),A2 * MOVE.L (A2),D2 * SUBQ.L #1,D2 * ADD.L D2,D2 * MOVEA.L 24(A5),A2 * MOVE.L (A2),D3 * ADD.L D3,D3 * MOVEA.L 20(A5),A2 * MOVE.L (A2),D0 * ADD.L D0,D0 ** * MOVEA.L 16(A5),A2 * MOVE.L (A2),D7 * SUBQ.L #1,D7 * CLR.L D4 * SUB.L D0,D4 *T5YXYBLOOP EQU * * ADD.L D0,D4 * DBRA D7,T5YXYBLOOP ** * MOVEA.L 12(A5),A2 * MOVE.L (A2),D7 * SUBQ.L #1,D7 * CLR.L D5 * SUB.L D0,D5 *T5YXYELOOP EQU * * ADD.L D0,D5 * DBRA D7,T5YXYELOOP ** * MOVEA.L 8(A5),A2 * MOVE.L (A2),D7 * MOVE.L D0,D6 * TST.L D7 * BPL.S T5YXYST * NEG.L D6 *T5YXYST EQU * * ADD.L D6,D5 ** * MOVEA.L 4(A5),A2 * MOVE.L (A2),D7 ** ** Setup is done, all registers have been loaded. The processing loops follow. ** *T5YXLOOPBACK EQU * * MOVEA.L A1,A2 * ADDA.L D4,A2 * TST.L D3 * BMI.S T5YXNEGINC * FOR.L A0 = D1 TO D2 BY D3 * DO.S * CMPI.W #-2,0(A2,A0.L) * BGT.S T5YXSKIPIT * CMPI.W #-5,0(A2,A0.L) * BLT.S T5YXSKIPIT * MOVE.W D7,0(A2,A0.L)

*T5YXSKIPIT EQU * * ENDF * BRA.S T5YXENDIF ** *T5YXNEGINC EQU * * NEG.L D3 * FOR.L A0 = D1 DOWNTO D2 BY D3 * DO.S * CMPI.W #-2,0(A2,A0.L) * BGT.S T5YXSKIMIT * CMPI.W #-5,0(A2,A0.L) * BLT.S T5YXSKIMIT * MOVE.W D7,0(A2,A0.L) *T5YXSKIMIT EQU * * ENDF * NEG.L D3 *T5YXENDIF EQU * ** * CMP.L D4,D5 * BEQ.S T5YXOUT * ADD.L D6,D4 * BRA T5YXLOOPBACK ** *T5YXOUT EQU * *T5YXNO0DST EQU * * BRA TPYXOUT ** ** ** ?TPXY5 does the same things as ?TPYX5, so don't duplicate code - just branch ** to other code ... *ITPXY5 EQU * * BRA ITPYX2 *DTPXY5 EQU * * BRA DTPYX2 * XDEF ITPXY5,DTPXY5 **qzqzqzqzqzqzqz * * FORTRAN callable routines ?SPYX2(ARRAY, Xbegin, Xend, NX, * Ybegin, Yend, IT) * where ? = I or D, D(irect) means ARRAY is the array, I(ndirect) means ARRAY is * a pointer to the array. The array is two-dimensional, with NX being the numbe r * of entries on the first dimension. A rectangular region is processed, startin g * at (Xbegin,Ybegin) and proceeding along with X varying most rapidly to * (Xend,Yend). If Xbegin < Xend then Xstep should be -1, and if Ybegin < Yend * then Ystep should be -1; else the step variables should be +1. The array is * supposed to be a quadrant value array which is being filled. Values of -2 in * the array are as-yet-untagged points which can be tagged with IT if they fall * within the rectangular region. * * Xstep and Ystep no longer used - routines now test Xbegin and Xend to see whic h * is larger and set Xstep appropriately, same for Ystep re: Ybegin and Yend. * ISPYX2 EQU * XDEF ISPYX2,DSPYX2 MOVEA.L 28(A7),A0 MOVE.L (A0),D0 BRA.S INSPYX2

DSPYX2 EQU * MOVE.L 28(A7),D0 INSPYX2 EQU * SAVREG AND.L ADRMSK(PC),D0 BEQ.L SPYXNO0DST MOVEA.L D0,A1 * MOVEA.L 24(A5),A2 MOVE.L (A2),D1 SUBQ.L #1,D1 ADD.L D1,D1 MOVEA.L 20(A5),A2 MOVE.L (A2),D2 SUBQ.L #1,D2 ADD.L D2,D2 MOVEQ.L #2,D3 CMP.L D1,D2 BPL.S SPYX2DX NEG.L D3 SPYX2DX EQU * MOVEA.L 16(A5),A2 MOVE.L (A2),D0 ADD.L D0,D0 * MOVEA.L 12(A5),A2 MOVE.L (A2),D7 SUBQ.L #1,D7 CLR.L D4 SUB.L D0,D4 SPYXYBLOOP EQU * ADD.L D0,D4 DBRA D7,SPYXYBLOOP * MOVEA.L 8(A5),A2 MOVE.L (A2),D7 SUBQ.L #1,D7 CLR.L D5 SUB.L D0,D5 SPYXYELOOP EQU * ADD.L D0,D5 DBRA D7,SPYXYELOOP * MOVE.L D0,D6 CMP.L D4,D5 BPL.S SPYX2DY NEG.L D6 SPYX2DY EQU * ADD.L D6,D5 * MOVEA.L 4(A5),A2 MOVE.L (A2),D7 * * Setup is done, all registers have been loaded. The processing loops follow. * SPYXLOOPBACK EQU * MOVEA.L A1,A2 ADDA.L D4,A2 TST.L D3 BMI.S SPYXNEGINC

FOR.L A0 = D1 TO D2 BY D3 DO.S CMPI.W #-2,0(A2,A0.L) BNE.S SPYXSKIPIT MOVE.W D7,0(A2,A0.L) SPYXSKIPIT EQU * ENDF BRA.S SPYXENDIF * SPYXNEGINC EQU * NEG.L D3 FOR.L A0 = D1 DOWNTO D2 BY D3 DO.S CMPI.W #-2,0(A2,A0.L) BNE.S SPYXSKIMIT MOVE.W D7,0(A2,A0.L) SPYXSKIMIT EQU * ENDF NEG.L D3 SPYXENDIF EQU * * CMP.L D4,D5 BEQ.S SPYXOUT ADD.L D6,D4 BRA SPYXLOOPBACK * SPYXOUT EQU * SPYXNO0DST EQU * SQYXNO0DST EQU * RSTREG FNRET 7 * * FORTRAN callable routines ?SQYX2(ARRAY, Xbegin, Xend, NX, * Ybegin, Yend, IT) * where ? = I or D, D(irect) means ARRAY is the array, I(ndirect) means ARRAY is * a pointer to the array. The array is two-dimensional, with NX being the numbe r * of entries on the first dimension. A rectangular region is processed, startin g * at (Xbegin,Ybegin) and proceeding along with X varying most rapidly to * (Xend,Yend). If Xbegin < Xend then Xstep should be -1, and if Ybegin < Yend * then Ystep should be -1; else the step variables should be +1. The array is * supposed to be a quadrant value array which is being filled. Values of -2 in * the array are as-yet-untagged points which can be tagged with IT if they fall * within the rectangular region and meet the criterion. The criterion is that * they be contiguously reachable without hitting a points tagged with -1 or high er * value. ISQYX2 EQU * XDEF ISQYX2,DSQYX2 MOVEA.L 28(A7),A0 MOVE.L (A0),D0 BRA.S INSQYX2 DSQYX2 EQU * MOVE.L 28(A7),D0 INSQYX2 EQU * SAVREG AND.L ADRMSK(PC),D0 BEQ SQYXNO0DST MOVEA.L D0,A1

* MOVEA.L 24(A5),A2 MOVE.L (A2),D1 SUBQ.L #1,D1 ADD.L D1,D1 MOVEA.L 20(A5),A2 MOVE.L (A2),D2 SUBQ.L #1,D2 ADD.L D2,D2 MOVEQ.L #2,D3 CMP.L D1,D2 BPL.S SQYX2DX NEG.L D3 SQYX2DX EQU * MOVEA.L 16(A5),A2 MOVE.L (A2),D0 ADD.L D0,D0 * MOVEA.L 12(A5),A2 MOVE.L (A2),D7 SUBQ.L #1,D7 CLR.L D4 SUB.L D0,D4 SQYXYBLOOP EQU * ADD.L D0,D4 DBRA D7,SQYXYBLOOP * MOVEA.L 8(A5),A2 MOVE.L (A2),D7 SUBQ.L #1,D7 CLR.L D5 SUB.L D0,D5 SQYXYELOOP EQU * ADD.L D0,D5 DBRA D7,SQYXYELOOP * MOVE.L D0,D6 CMP.L D4,D5 BPL.S SQYX2DY NEG.L D6 SQYX2DY EQU * ADD.L D6,D5 * MOVEA.L 4(A5),A2 MOVE.L (A2),D7 * * Setup is done, all registers have been loaded. The processing loops follow. * SQYXLOOPBACK EQU * MOVEA.L A1,A2 ADDA.L D4,A2 * TST.L D3 BMI.S SQYXNEGINC FOR.L A0 = D1 TO D2 BY D3 DO.S MOVE.W 0(A2,A0.L),D0 CMPI.W #-1,D0 BGE.S SQYXNEXTY CMPI.W #-2,D0

BNE.S SQYXSKIPIT MOVE.W D7,0(A2,A0.L) SQYXSKIPIT EQU * ENDF BRA.S SQYXENDIF * SQYXNEGINC EQU * NEG.L D3 FOR.L A0 = D1 DOWNTO D2 BY D3 DO.S MOVE.W 0(A2,A0.L),D0 CMPI.W #-1,D0 BGE.S SQYXNEXTY CMPI.W #-2,D0 BNE.S SQYXSKIMIT MOVE.W D7,0(A2,A0.L) SQYXSKIMIT EQU * ENDF SQYXNEXTY EQU * NEG.L D3 SQYXENDIF EQU * * CMP.L D4,D5 BEQ.S SQYXOUT ADD.L D6,D4 BRA SQYXLOOPBACK * SQYXOUT EQU * SQXYNO0DST EQU * BRA SPYXNO0DST * * * FORTRAN callable routines ?SQXY2(ARRAY, Xbegin, Xend, NX, * Ybegin, Yend, IT) * where ? = I or D, D(irect) means ARRAY is the array, I(ndirect) means ARRAY is * a pointer to the array. The array is two-dimensional, with NX being the numbe r * of entries on the first dimension. A rectangular region is processed, startin g * at (Xbegin,Ybegin) and proceeding along with Y varying most rapidly to * (Xend,Yend). If Xbegin < Xend then Xstep should be -1, and if Ybegin < Yend * then Ystep should be -1; else the step variables should be +1. The array is * supposed to be a quadrant value array which is being filled. Values of -2 in * the array are as-yet-untagged points which can be tagged with IT if they fall * within the rectangular region and meet the criterion. The criterion is that * they be contiguously reachable without hitting a points tagged with -1 or high er * value. ISQXY2 EQU * XDEF ISQXY2,DSQXY2 MOVEA.L 28(A7),A0 MOVE.L (A0),D0 BRA.S INSQXY2 DSQXY2 EQU * MOVE.L 28(A7),D0 INSQXY2 EQU * SAVREG AND.L ADRMSK(PC),D0 BEQ SQXYNO0DST MOVEA.L D0,A1

* MOVEA.L 24(A5),A2 MOVE.L (A2),D1 SUBQ.L #1,D1 ADD.L D1,D1 MOVEA.L 20(A5),A2 MOVE.L (A2),D2 SUBQ.L #1,D2 ADD.L D2,D2 MOVEQ.L #2,D3 CMP.L D1,D2 BPL.S SQXY2DX NEG.L D3 SQXY2DX EQU * MOVEA.L 20(A5),A2 MOVE.L (A2),D0 ADD.L D0,D0 * MOVEA.L 12(A5),A2 MOVE.L (A2),D7 SUBQ.L #1,D7 CLR.L D4 SUB.L D0,D4 SQXYYBLOOP EQU * ADD.L D0,D4 DBRA D7,SQXYYBLOOP * MOVEA.L 8(A5),A2 MOVE.L (A2),D7 SUBQ.L #1,D7 CLR.L D5 SUB.L D0,D5 SQXYYELOOP EQU * ADD.L D0,D5 DBRA D7,SQXYYELOOP * MOVE.L D0,D6 CMP.L D4,D5 BPL.S SQXY2DY NEG.L D6 SQXY2DY EQU * ADD.L D6,D5 MOVEA.L 4(A5),A2 MOVE.L (A2),D7 * * Setup is done, all registers have been loaded. The processing loops follow. * MOVEA.L D4,A3 TST.L D3 BMI.S SQXYNEGINC FOR.L A0 = D1 TO D2 BY D3 DO.S MOVEA.L A1,A2 ADDA.L A0,A2 SQXYLOOPBACK EQU * MOVE.W 0(A2,D4.L),D0 CMPI.W #-1,D0 BGE.S SQXYNEXTX CMPI.W #-2,D0 BNE.S SQXYSKIPIT

MOVE.W D7,0(A2,A0.L) SQXYSKIPIT EQU * CMP.L D4,D5 BEQ.S SQXYOUT ADD.L D6,D4 BRA SQXYLOOPBACK SQXYOUT EQU * SQXYNEXTX EQU * MOVE.L A3,D4 ENDF BRA.S SQXYENDIF * SQXYNEGINC EQU * NEG.L D3 FOR.L A0 = D1 DOWNTO D2 BY D3 DO.S MOVEA.L A1,A2 ADDA.L A0,A2 SQXYLOOMBACK EQU * MOVE.W 0(A2,D4.L),D0 CMPI.W #-1,D0 BGE.S SQXYNEXMX CMPI.W #-2,D0 BNE.S SQXYSKIMIT MOVE.W D7,0(A2,A0.L) SQXYSKIMIT EQU * CMP.L D4,D5 BEQ.S SQXYOUTM ADD.L D6,D4 BRA SQXYLOOMBACK SQXYOUTM EQU * SQXYNEXMX EQU * MOVE.L A3,D4 ENDF * NEG.L D3 SQXYENDIF EQU * * BRA SPYXNO0DST * ** FORTRAN callable routines ?SPXY2(ARRAY, Xbegin, Xend, Xstep(+/-1), NX, ** Ybegin, Yend, Ystep(+/-1), IT) ** where ? = I or D, D(irect) means ARRAY is the array, I(ndirect) means ARRAY i s ** a pointer to the array. The array is two-dimensional, with NX being the numb er ** of entries on the first dimension. A rectangular region is processed, starti ng ** at (Xbegin,Ybegin) and proceeding along with Y varying most rapidly to ** (Xend,Yend). If Xbegin < Xend then Xstep should be -1, and if Ybegin < Yend ** then Ystep should be -1; else the step variables should be +1. The array is ** supposed to be a quadrant value array which is being filled. Values of -2 in ** the array are as-yet-untagged points which can be tagged with IT if they fall ** within the rectangular region. * * ?SPXY2 does the same things as ?SPYX2, so don't duplicate code - just branch * to other code ... ISPXY2 EQU * BRA ISPYX2 DSPXY2 EQU * BRA DSPYX2

XDEF ISPXY2,DSPXY2 * *ISPXY2 EQU * * XDEF ISPXY2,DSPXY2 * MOVEA.L 28(A7),A0 * MOVE.L (A0),D0 * BRA.S INSPXY2 *DSPXY2 EQU * * MOVE.L 28(A7),D0 *INSPXY2 EQU * * SAVREG * AND.L ADRMSK(PC),D0 * BEQ SPXYNO0DST * MOVEA.L D0,A1 * * MOVEA.L 24(A5),A2 * MOVE.L (A2),D1 * SUBQ.L #1,D1 * ADD.L D1,D1 * MOVEA.L 20(A5),A2 * MOVE.L (A2),D2 * SUBQ.L #1,D2 * ADD.L D2,D2 * MOVEQ.L #2,D3 * CMP.L D1,D2 * BPL.S SPXY2DX * NEG.L D3 *SPXY2DX EQU * * MOVEA.L 16(A5),A2 * MOVE.L (A2),D0 * ADD.L D0,D0 * * MOVEA.L 12(A5),A2 * MOVE.L (A2),D7 * SUBQ.L #1,D7 * CLR.L D4 * SUB.L D0,D4 *SPXYYBLOOP EQU * * ADD.L D0,D4 * DBRA D7,SPXYYBLOOP * * MOVEA.L 8(A5),A2 * MOVE.L (A2),D7 * SUBQ.L #1,D7 * CLR.L D5 * SUB.L D0,D5 *SPXYYELOOP EQU * * ADD.L D0,D5 * DBRA D7,SPXYYELOOP * * MOVE.L D0,D6 * CMP.L D4,D5 * BPL.S SPXY2DY * NEG.L D6 *SPXY2DY EQU * * ADD.L D6,D5 * * MOVEA.L 4(A5),A2 * MOVE.L (A2),D7 **

** Setup is done, all registers have been loaded. The processing loops follow. ** * MOVEA.L D4,A3 * TST.L D3 * BMI.S SPXYNEGINC * FOR.L A0 = D1 TO D2 BY D3 * DO.S * MOVEA.L A1,A2 * ADDA.L A0,A2 *SPXYLOOPBACK EQU * * CMPI.W #-2,0(A2,D4.L) * BNE.S SPXYSKIPIT * MOVE.W D7,0(A2,A0.L) *SPXYSKIPIT EQU * * CMP.L D4,D5 * BEQ.S SPXYOUT * ADD.L D6,D4 * BRA SPXYLOOPBACK *SPXYOUT EQU * * MOVE.L A3,D4 * ENDF * BRA.S SPXYENDIF * *SPXYNEGINC EQU * * NEG.L D3 * FOR.L A0 = D1 DOWNTO D2 BY D3 * DO.S * MOVEA.L A1,A2 * ADDA.L A0,A2 *SPXYLOOMBACK EQU * * CMPI.W #-2,0(A2,D4.L) * BNE.S SPXYSKIMIT * MOVE.W D7,0(A2,A0.L) *SPXYSKIMIT EQU * * CMP.L D4,D5 * BEQ.S SPXYOUTM * ADD.L D6,D4 * BRA SPXYLOOMBACK *SPXYOUTM EQU * * MOVE.L A3,D4 * ENDF ** NEG.L D3 *SPXYENDIF EQU * ** * BRA SPYXNO0DST ** * * FORTRAN callable routines ?SPYX5(ARRAY, Xbegin, Xend, NX, * Ybegin, Yend, IT) * where ? = I or D, D(irect) means ARRAY is the array, I(ndirect) means ARRAY is * a pointer to the array. The array is two-dimensional, with NX being the numbe r * of entries on the first dimension. A rectangular region is processed, startin g * at (Xbegin,Ybegin) and proceeding along with X varying most rapidly to * (Xend,Yend). If Xbegin < Xend then Xstep should be -1, and if Ybegin < Yend * then Ystep should be -1; else the step variables should be +1. The array is * supposed to be a quadrant value array which is being filled. Values of -2 in * the array are as-yet-untagged points which can be tagged with IT if they fall * within the rectangular region.

ISPYX5 EQU * XDEF ISPYX5,DSPYX5 MOVEA.L 28(A7),A0 MOVE.L (A0),D0 BRA.S INSPYX5 DSPYX5 EQU * MOVE.L 28(A7),D0 INSPYX5 EQU * SAVREG AND.L ADRMSK(PC),D0 BEQ.L S5YXNO0DST MOVEA.L D0,A1 * MOVEA.L 24(A5),A2 MOVE.L (A2),D1 SUBQ.L #1,D1 ADD.L D1,D1 MOVEA.L 20(A5),A2 MOVE.L (A2),D2 SUBQ.L #1,D2 ADD.L D2,D2 MOVEQ.L #2,D3 CMP.L D1,D2 BPL.S SPYX5DX NEG.L D3 SPYX5DX EQU * MOVEA.L 16(A5),A2 MOVE.L (A2),D0 ADD.L D0,D0 * MOVEA.L 12(A5),A2 MOVE.L (A2),D7 SUBQ.L #1,D7 CLR.L D4 SUB.L D0,D4 S5YXYBLOOP EQU * ADD.L D0,D4 DBRA D7,S5YXYBLOOP * MOVEA.L 8(A5),A2 MOVE.L (A2),D7 SUBQ.L #1,D7 CLR.L D5 SUB.L D0,D5 S5YXYELOOP EQU * ADD.L D0,D5 DBRA D7,S5YXYELOOP * MOVE.L D0,D6 CMP.L D4,D5 BPL.S SPYX5DY NEG.L D6 SPYX5DY EQU * ADD.L D6,D5 * MOVEA.L 4(A5),A2 MOVE.L (A2),D7 * * Setup is done, all registers have been loaded. The processing loops follow. *

S5YXLOOPBACK EQU * MOVEA.L A1,A2 ADDA.L D4,A2 TST.L D3 BMI.S S5YXNEGINC FOR.L A0 = D1 TO D2 BY D3 DO.S CMPI.W #-2,0(A2,A0.L) BGT.S S5YXSKIPIT CMPI.W #-5,0(A2,A0.L) BLT.S S5YXSKIPIT MOVE.W D7,0(A2,A0.L) S5YXSKIPIT EQU * ENDF BRA.S S5YXENDIF * S5YXNEGINC EQU * NEG.L D3 FOR.L A0 = D1 DOWNTO D2 BY D3 DO.S CMPI.W #-2,0(A2,A0.L) BGT.S S5YXSKIMIT CMPI.W #-5,0(A2,A0.L) BLT.S S5YXSKIMIT MOVE.W D7,0(A2,A0.L) S5YXSKIMIT EQU * ENDF NEG.L D3 S5YXENDIF EQU * * CMP.L D4,D5 BEQ.S S5YXOUT ADD.L D6,D4 BRA S5YXLOOPBACK * S5YXOUT EQU * S5YXNO0DST EQU * BRA SPYXOUT * * * ?SPXY5 does the same things as ?SPYX5, so don't duplicate code - just branch * to other code ... ISPXY5 EQU * BRA ISPYX2 DSPXY5 EQU * BRA DSPYX2 XDEF ISPXY5,DSPXY5 * ** ** FORTRAN callable routines ?SPYX6(ARRAY, Xbegin, Xend, NX, ** Ybegin, Yend, IT) ** where ? = I or D, D(irect) means ARRAY is the array, I(ndirect) means ARRAY i s ** a pointer to the array. The array is two-dimensional, with NX being the numb er ** of entries on the first dimension. A rectangular region is processed, starti ng ** at (Xbegin,Ybegin) and proceeding along with X varying most rapidly to ** (Xend,Yend). If Xbegin < Xend then Xstep should be -1, and if Ybegin < Yend ** then Ystep should be -1; else the step variables should be +1. The array is

** supposed to be a quadrant value array which is being filled. Values of -2 in ** the array are as-yet-untagged points which can be tagged with IT if they fall ** within the rectangular region. *ISPYX6 EQU * * XDEF ISPYX6,DSPYX6 * MOVEA.L 28(A7),A0 * MOVE.L (A0),D0 * BRA.S INSPYX6 *DSPYX6 EQU * * MOVE.L 28(A7),D0 *INSPYX6 EQU * * SAVREG * AND.L ADRMSK(PC),D0 * BEQ.L S6YXNO0DST * MOVEA.L D0,A1 ** * MOVEA.L 24(A5),A2 * MOVE.L (A2),D1 * SUBQ.L #1,D1 * ADD.L D1,D1 * MOVEA.L 20(A5),A2 * MOVE.L (A2),D2 * SUBQ.L #1,D2 * ADD.L D2,D2 * MOVEQ.L #2,D3 * CMP.L D1,D2 * BPL.S SPYX6DX * NEG.L D3 *SPYX6DX EQU * * MOVEA.L 16(A5),A2 * MOVE.L (A2),D0 * ADD.L D0,D0 ** * MOVEA.L 12(A5),A2 * MOVE.L (A2),D7 * SUBQ.L #1,D7 * CLR.L D4 * SUB.L D0,D4 *S6YXYBLOOP EQU * * ADD.L D0,D4 * DBRA D7,S6YXYBLOOP ** * MOVEA.L 8(A5),A2 * MOVE.L (A2),D7 * SUBQ.L #1,D7 * CLR.L D5 * SUB.L D0,D5 *S6YXYELOOP EQU * * ADD.L D0,D5 * DBRA D7,S6YXYELOOP ** * MOVE.L D0,D6 * CMP.L D4,D5 * BPL.S SPYX6DY * NEG.L D6 *SPYX6DY EQU * * ADD.L D6,D5 ** * MOVEA.L 4(A5),A2 * MOVE.L (A2),D7

** ** Setup is done, all registers have been loaded. The processing loops follow. ** *S6YXLOOPBACK EQU * * MOVEA.L A1,A2 * ADDA.L D4,A2 * TST.L D3 * BMI.S S6YXNEGINC * FOR.L A0 = D1 TO D2 BY D3 * DO.S * CMPI.W #-2,0(A2,A0.L) * BGT.S S6YXSKIPIT * CMPI.W #-6,0(A2,A0.L) * BLT.S S6YXSKIPIT * MOVE.W D7,0(A2,A0.L) *S6YXSKIPIT EQU * * ENDF * BRA.S S6YXENDIF ** *S6YXNEGINC EQU * * NEG.L D3 * FOR.L A0 = D1 DOWNTO D2 BY D3 * DO.S * CMPI.W #-2,0(A2,A0.L) * BGT.S S6YXSKIMIT * CMPI.W #-6,0(A2,A0.L) * BLT.S S6YXSKIMIT * MOVE.W D7,0(A2,A0.L) *S6YXSKIMIT EQU * * ENDF * NEG.L D3 *S6YXENDIF EQU * ** * CMP.L D4,D5 * BEQ.S S6YXOUT * ADD.L D6,D4 * BRA S6YXLOOPBACK ** *S6YXOUT EQU * *S6YXNO0DST EQU * * BRA SPYXOUT ** ** ** ?SPXY6 does the same things as ?SPYX6, so don't duplicate code - just branch ** to other code ... *ISPXY6 EQU * * BRA ISPYX2 *DSPXY6 EQU * * BRA DSPYX2 * XDEF ISPXY6,DSPXY6 ** * * * FORTRAN callable routines ?GTYX2(ARRAY, ARRAY2, Xbegin, Xend, NX, * Ybegin, Yend, COMPVAL, IT) * where ? = I or D, D(irect) means ARRAY is the array, I(ndirect) means ARRAY is * a pointer to the array. The arrays are two-dimensional, with NX being the num ber * of entries on the first dimension. A rectangular region is processed, startin g

* at (Xbegin,Ybegin) and proceeding along with X varying most rapidly to * (Xend,Yend). The array is * supposed to be a quadrant value array which is being filled. Values of -2 in * the array are as-yet-untagged points which can be tagged with IT if they fall * within the rectangular region AND IF SARRAY(I,J) IS .GT. THAN COMPVAL IGTYX2 EQU * XDEF IGTYX2,DGTYX2 MOVEA.L 36(A7),A0 MOVE.L (A0),D0 MOVEA.L 32(A7),A0 MOVE.L (A0),D1 BRA.S INGTYX2 DGTYX2 EQU * MOVE.L 36(A7),D0 MOVE.L 32(A7),D1 INGTYX2 EQU * SAVREG PUSH.L A6 AND.L ADRMSK(PC),D0 BEQ.L GTYXNO0DST MOVEA.L D0,A1 AND.L ADRMSK(PC),D1 BEQ.L GTYXNO0DST MOVEA.L D1,A4 * MOVEA.L 28(A5),A2 MOVE.L (A2),D1 SUBQ.L #1,D1 ADD.L D1,D1 MOVEA.L 24(A5),A2 MOVE.L (A2),D2 SUBQ.L #1,D2 ADD.L D2,D2 MOVEQ.L #2,D3 CMP.L D1,D2 BPL.S GTYX2DX NEG.L D3 GTYX2DX EQU * MOVEA.L 20(A5),A2 MOVE.L (A2),D0 ADD.L D0,D0 * MOVEA.L 16(A5),A2 MOVE.L (A2),D7 SUBQ.L #1,D7 CLR.L D4 SUB.L D0,D4 GTYXYBLOOP EQU * ADD.L D0,D4 DBRA D7,GTYXYBLOOP * MOVEA.L 12(A5),A2 MOVE.L (A2),D7 SUBQ.L #1,D7 CLR.L D5 SUB.L D0,D5 GTYXYELOOP EQU * ADD.L D0,D5 DBRA D7,GTYXYELOOP *

MOVEA.L 8(A5),A2 MOVE.L (A2),A6 MOVE.L D0,D6 CMP.L D4,D5 BPL.S GTYXYST NEG.L D6 GTYXYST EQU * ADD.L D6,D5 * MOVEA.L 4(A5),A2 MOVE.L (A2),D7 * * Setup is done, all registers have been loaded. The processing loops follow. * GTYXLOOPBACK EQU * MOVEA.L A1,A2 ADDA.L D4,A2 MOVEA.L A4,A3 ADDA.L D4,A3 TST.L D3 BMI.S GTYXNEGINC FOR.L A0 = D1 TO D2 BY D3 DO.S CMPI.W #-2,0(A2,A0.L) BNE.S GTYXSKIPIT CMPA.W 0(A3,A0.L),A6 BGT.S GTYXENDIF MOVE.W D7,0(A2,A0.L) GTYXSKIPIT EQU * ENDF BRA.S GTYXENDIF * GTYXNEGINC EQU * NEG.L D3 FOR.L A0 = D1 DOWNTO D2 BY D3 DO.S CMPI.W #-2,0(A2,A0.L) BNE.S GTYXSKIMIT CMPA.W 0(A3,A0.L),A6 BGT.S GTYXEND1F MOVE.W D7,0(A2,A0.L) GTYXSKIMIT EQU * ENDF GTYXEND1F EQU * NEG.L D3 GTYXENDIF EQU * * CMP.L D4,D5 BEQ.S GTYXOUT ADD.L D6,D4 BRA GTYXLOOPBACK * GTYXOUT EQU * GTYXNO0DST EQU * LTYXOUT EQU * LTYXNO0DST EQU * POP.L A6 RSTREG FNRET 9 *

* FORTRAN callable routines ?LTYX2(ARRAY, ARRAY2, Xbegin, Xend, NX, * Ybegin, Yend, COMPVAL, IT) * where ? = I or D, D(irect) means ARRAY is the array, I(ndirect) means ARRAY is * a pointer to the array. The arrays are two-dimensional, with NX being the num ber * of entries on the first dimension. A rectangular region is processed, startin g * at (Xbegin,Ybegin) and proceeding along with X varying most rapidly to * (Xend,Yend). The array is * supposed to be a quadrant value array which is being filled. Values of -2 in * the array are as-yet-untagged points which can be tagged with IT if they fall * within the rectangular region AND IF SARRAY(I,J) IS .LT. THAN COMPVAL ILTYX2 EQU * XDEF ILTYX2,DLTYX2 MOVEA.L 36(A7),A0 MOVE.L (A0),D0 MOVEA.L 32(A7),A0 MOVE.L (A0),D1 BRA.S INLTYX2 DLTYX2 EQU * MOVE.L 36(A7),D0 MOVE.L 32(A7),D1 INLTYX2 EQU * SAVREG PUSH.L A6 AND.L ADRMSK(PC),D0 BEQ.L LTYXNO0DST MOVEA.L D0,A1 AND.L ADRMSK(PC),D1 BEQ.L LTYXNO0DST MOVEA.L D1,A4 * MOVEA.L 28(A5),A2 MOVE.L (A2),D1 SUBQ.L #1,D1 ADD.L D1,D1 MOVEA.L 24(A5),A2 MOVE.L (A2),D2 SUBQ.L #1,D2 ADD.L D2,D2 MOVEQ.L #2,D3 CMP.L D1,D2 BPL.S LTYX2DX NEG.L D3 LTYX2DX EQU * MOVEA.L 20(A5),A2 MOVE.L (A2),D0 ADD.L D0,D0 * MOVEA.L 16(A5),A2 MOVE.L (A2),D7 SUBQ.L #1,D7 CLR.L D4 SUB.L D0,D4 LTYXYBLOOP EQU * ADD.L D0,D4 DBRA D7,LTYXYBLOOP * MOVEA.L 12(A5),A2 MOVE.L (A2),D7

SUBQ.L #1,D7 CLR.L D5 SUB.L D0,D5 LTYXYELOOP EQU * ADD.L D0,D5 DBRA D7,LTYXYELOOP * MOVEA.L 8(A5),A2 MOVE.L (A2),A6 MOVE.L D0,D6 CMP.L D4,D5 BPL.S LTYXYST NEG.L D6 LTYXYST EQU * ADD.L D6,D5 * MOVEA.L 4(A5),A2 MOVE.L (A2),D7 * * Setup is done, all registers have been loaded. The processing loops follow. * LTYXLOOPBACK EQU * MOVEA.L A1,A2 ADDA.L D4,A2 MOVEA.L A4,A3 ADDA.L D4,A3 TST.L D3 BMI.S LTYXNEGINC FOR.L A0 = D1 TO D2 BY D3 DO.S CMPI.W #-2,0(A2,A0.L) BNE.S LTYXSKIPIT CMPA.W 0(A3,A0.L),A6 BLT.S LTYXENDIF MOVE.W D7,0(A2,A0.L) LTYXSKIPIT EQU * ENDF BRA.S LTYXENDIF * LTYXNEGINC EQU * NEG.L D3 FOR.L A0 = D1 DOWNTO D2 BY D3 DO.S CMPI.W #-2,0(A2,A0.L) BNE.S LTYXSKIMIT CMPA.W 0(A3,A0.L),A6 BLT.S LTYXEND1F MOVE.W D7,0(A2,A0.L) LTYXSKIMIT EQU * ENDF LTYXEND1F EQU * NEG.L D3 LTYXENDIF EQU * * CMP.L D4,D5 BEQ LTYXOUT ADD.L D6,D4 BRA LTYXLOOPBACK * *

* FORTRAN callable routines ?GTYXR(ARRAY, ARRAY2, Xbegin, Xend, NX, * Ybegin, Yend, COMPVAL, IT) * where ? = I or D, D(irect) means ARRAY is the array, I(ndirect) means ARRAY is * a pointer to the array. The arrays are two-dimensional, with NX being the num ber * of entries on the first dimension. A rectangular region is processed, startin g * at (Xbegin,Ybegin) and proceeding along with X varying most rapidly to * (Xend,Yend). The array issupposed to be a quadrant value array * which is being filled. Values of -2 to -5 in * the array are as-yet-untagged points which can be filled with IT if they fall * within the rectangular region AND IF SARRAY(I,J) IS .LE. THAN COMPVAL IGTYXR EQU * ILEYXR EQU * XDEF IGTYXR,DGTYXR,ILEYXR,DLEYXR MOVEA.L 36(A7),A0 MOVE.L (A0),D0 MOVEA.L 32(A7),A0 MOVE.L (A0),D1 BRA.S INGTYXR DGTYXR EQU * DLEYXR EQU * MOVE.L 36(A7),D0 MOVE.L 32(A7),D1 INGTYXR EQU * SAVREG PUSH.L A6 AND.L ADRMSK(PC),D0 BEQ.L GTYXNO0DST MOVEA.L D0,A1 AND.L ADRMSK(PC),D1 BEQ.L GTYXNO0DST MOVEA.L D1,A4 * MOVEA.L 28(A5),A2 MOVE.L (A2),D1 SUBQ.L #1,D1 ADD.L D1,D1 MOVEA.L 24(A5),A2 MOVE.L (A2),D2 SUBQ.L #1,D2 ADD.L D2,D2 MOVEQ.L #2,D3 CMP.L D1,D2 BPL.S GTYXRDX NEG.L D3 GTYXRDX EQU * MOVEA.L 20(A5),A2 MOVE.L (A2),D0 ADD.L D0,D0 * MOVEA.L 16(A5),A2 MOVE.L (A2),D7 SUBQ.L #1,D7 CLR.L D4 SUB.L D0,D4 GTYXYBLROP EQU * ADD.L D0,D4 DBRA D7,GTYXYBLROP *

MOVEA.L 12(A5),A2 MOVE.L (A2),D7 SUBQ.L #1,D7 CLR.L D5 SUB.L D0,D5 GTYXYELROP EQU * ADD.L D0,D5 DBRA D7,GTYXYELROP * MOVEA.L 8(A5),A2 MOVE.L (A2),A6 MOVE.L D0,D6 CMP.L D4,D5 BPL.S GTYXYSR NEG.L D6 GTYXYSR EQU * ADD.L D6,D5 * MOVEA.L 4(A5),A2 MOVE.L (A2),D7 * * Setup is done, all registers have been loaded. The processing loops follow. * GTYXLROPBACK EQU * MOVEA.L A1,A2 ADDA.L D4,A2 MOVEA.L A4,A3 ADDA.L D4,A3 TST.L D3 BMI.S GTYXRNEGINC FOR.L A0 = D1 TO D2 BY D3 DO.S CMPA.W 0(A3,A0.L),A6 BLE.S GTYXSKRPIT CMPI.W #-2,0(A2,A0.L) BGT.S GTYXSKRPIT CMPI.W #-6,0(A2,A0.L) BLT.S GTYXSKRPIT MOVE.W D7,0(A2,A0.L) GTYXSKRPIT EQU * ENDF BRA.S GTYXRENDIF * GTYXRNEGINC EQU * NEG.L D3 FOR.L A0 = D1 DOWNTO D2 BY D3 DO.S CMPA.W 0(A3,A0.L),A6 BLE.S GTYXSKRMIT CMPI.W #-2,0(A2,A0.L) BGT.S GTYXSKRMIT CMPI.W #-6,0(A2,A0.L) BLT.S GTYXSKRMIT MOVE.W D7,0(A2,A0.L) GTYXSKRMIT EQU * ENDF NEG.L D3 GTYXRENDIF EQU * * CMP.L D4,D5

BEQ ADD.L BRA *

GTYXOUT D6,D4 GTYXLROPBACK

BRA GTYXOUT * * FORTRAN callable routines ?LTYXR(ARRAY, ARRAY2, Xbegin, Xend, NX, * Ybegin, Yend, COMPVAL, IT) * where ? = I or D, D(irect) means ARRAY is the array, I(ndirect) means ARRAY is * a pointer to the array. The arrays are two-dimensional, with NX being the num ber * of entries on the first dimension. A rectangular region is processed, startin g * at (Xbegin,Ybegin) and proceeding along with X varying most rapidly to * (Xend,Yend). The array is * supposed to be a quadrant value array which is being filled. Values of -2 in * the array are as-yet-untagged points which can be tagged with IT if they fall * within the rectangular region AND IF SARRAY(I,J) IS .GE. THAN COMPVAL ILTYXR EQU * IGEYXR EQU * XDEF ILTYXR,DLTYXR,IGEYXR,DGEYXR MOVEA.L 36(A7),A0 MOVE.L (A0),D0 MOVEA.L 32(A7),A0 MOVE.L (A0),D1 BRA.S INLTYXR DLTYXR EQU * DGEYXR EQU * MOVE.L 36(A7),D0 MOVE.L 32(A7),D1 INLTYXR EQU * SAVREG PUSH.L A6 AND.L ADRMSK(PC),D0 BEQ.L LTYXNO0DST MOVEA.L D0,A1 AND.L ADRMSK(PC),D1 BEQ.L LTYXNO0DST MOVEA.L D1,A4 * MOVEA.L 28(A5),A2 MOVE.L (A2),D1 SUBQ.L #1,D1 ADD.L D1,D1 MOVEA.L 24(A5),A2 MOVE.L (A2),D2 SUBQ.L #1,D2 ADD.L D2,D2 MOVEQ.L #2,D3 CMP.L D1,D2 BPL.S LTYXRDX NEG.L D3 LTYXRDX EQU * MOVEA.L 20(A5),A2 MOVE.L (A2),D0 ADD.L D0,D0 * MOVEA.L 16(A5),A2 MOVE.L (A2),D7 SUBQ.L #1,D7

CLR.L D4 SUB.L D0,D4 LTYXYBLROP EQU * ADD.L D0,D4 DBRA D7,LTYXYBLROP * MOVEA.L 12(A5),A2 MOVE.L (A2),D7 SUBQ.L #1,D7 CLR.L D5 SUB.L D0,D5 LTYXYELROP EQU * ADD.L D0,D5 DBRA D7,LTYXYELROP * MOVEA.L 8(A5),A2 MOVE.L (A2),A6 MOVE.L D0,D6 CMP.L D4,D5 BPL.S LTYXYSR NEG.L D6 LTYXYSR EQU * ADD.L D6,D5 * MOVEA.L 4(A5),A2 MOVE.L (A2),D7 * * Setup is done, all registers have been loaded. The processing loops follow. * LTYXLROPBACK EQU * MOVEA.L A1,A2 ADDA.L D4,A2 MOVEA.L A4,A3 ADDA.L D4,A3 TST.L D3 BMI.S LTYXRNEGINC FOR.L A0 = D1 TO D2 BY D3 DO.S CMPA.W 0(A3,A0.L),A6 BGE.S LTYXSKRPIT CMPI.W #-2,0(A2,A0.L) BGT.S LTYXSKRPIT CMPI.W #-6,0(A2,A0.L) BLT.S LTYXSKRPIT MOVE.W D7,0(A2,A0.L) LTYXSKRPIT EQU * ENDF BRA.S LTYXRENDIF * LTYXRNEGINC EQU * NEG.L D3 FOR.L A0 = D1 DOWNTO D2 BY D3 DO.S CMPA.W 0(A3,A0.L),A6 BGE.S LTYXSKRMIT CMPI.W #-2,0(A2,A0.L) BGT.S LTYXSKRMIT CMPI.W #-6,0(A2,A0.L) BLT.S LTYXSKRMIT MOVE.W D7,0(A2,A0.L)

LTYXSKRMIT EQU * ENDF NEG.L D3 LTYXRENDIF EQU * * CMP.L D4,D5 BEQ LTYXOUT ADD.L D6,D4 BRA LTYXLROPBACK * * * FORTRAN callable FUNCTIONS ?CNT26(ARRAY, Xbegin, Xend, NX, Ybegin, Yend) * where ? = I or D, D(irect) means ARRAY is the array, I(ndirect) means ARRAY is * a pointer to the array. The array is two-dimensional, with NX being the numbe r * of entries on the first dimension. A rectangular region is processed, startin g * at (Xbegin,Ybegin) and proceeding along with X varying most rapidly to * (Xend,Yend). ICNT26 EQU * XDEF ICNT26,DCNT26 MOVEA.L 24(A7),A0 MOVE.L (A0),D0 BRA.S INCNT26 DCNT26 EQU * MOVE.L 24(A7),D0 INCNT26 EQU * SAVREG AND.L ADRMSK(PC),D0 BEQ.L CNT2NO0DST MOVEA.L D0,A1 * MOVEA.L 20(A5),A2 MOVE.L (A2),D1 SUBQ.L #1,D1 ADD.L D1,D1 MOVEA.L 16(A5),A2 MOVE.L (A2),D2 SUBQ.L #1,D2 ADD.L D2,D2 MOVEQ.L #2,D3 CMP.L D1,D2 BPL.S CNT26DX NEG.L D3 CNT26DX EQU * MOVEA.L 12(A5),A2 MOVE.L (A2),D0 ADD.L D0,D0 * MOVEA.L 8(A5),A2 MOVE.L (A2),D7 SUBQ.L #1,D7 CLR.L D4 SUB.L D0,D4 CNT2YBLOOP EQU * ADD.L D0,D4 DBRA D7,CNT2YBLOOP * MOVEA.L 4(A5),A2 MOVE.L (A2),D7

SUBQ.L #1,D7 CLR.L D5 SUB.L D0,D5 CNT2YELOOP EQU * ADD.L D0,D5 DBRA D7,CNT2YELOOP * MOVE.L D0,D6 CMP.L D4,D5 BPL.S CNT26DY NEG.L D6 CNT26DY EQU * ADD.L D6,D5 CLR.L D7 * * * Setup is done, all registers have been loaded. The processing loops follow. * CNT2LOOPBACK EQU * MOVEA.L A1,A2 ADDA.L D4,A2 TST.L D3 BMI.S CNT2NEGINC FOR.L A0 = D1 TO D2 BY D3 DO.S CMPI.W #-2,0(A2,A0.L) BGT.S CNT2SKIPIT CMPI.W #-6,0(A2,A0.L) BLT.S CNT2SKIPIT ADDQ.L #1,D7 CNT2SKIPIT EQU * ENDF BRA.S CNT2ENDIF * CNT2NEGINC EQU * NEG.L D3 FOR.L A0 = D1 DOWNTO D2 BY D3 DO.S CMPI.W #-2,0(A2,A0.L) BGT.S CNT2SKIMIT CMPI.W #-6,0(A2,A0.L) BLT.S CNT2SKIMIT ADDQ.L #1,D7 CNT2SKIMIT EQU * ENDF NEG.L D3 CNT2ENDIF EQU * * CMP.L D4,D5 BEQ.S CNT2OUT ADD.L D6,D4 BRA CNT2LOOPBACK * CNT2OUT EQU * LEA.L CNT2CRUD(PC),A2 MOVE.L D7,(A2) CNT2NO0DST EQU * RSTREG MOVE.L CNT2CRUD(PC),D0 FNRET 6

CNT2CRUD DC.L 0 * * BASE DS.L 1 DS.W 1 Q1STORAGE * ZZZZZ EQU * END