à WORË SHEEÔ MANAGMENÔ ROUTINES
à HANDLÅ SPREADSHEEÔ "IÎ MEMORY¢ STORAGE
à COPYRIGHÔ GLENÎ EVERHARÔ 1983
C
C ALL RIGHTS RESERVED
C
à WSSEÔ - INITIALIZÅ STORAGÅ TÏ STARÔ CONDITIONS
	SUBROUTINÅ WSSET
	INCLUDÅ 'VKLUGPRM.FTN'
à EXPECÔ IMPLEMENTATIOÎ TÏ USÅ Á COMMOÎ BITMAÐ ANÄ PROVIDÅ Á VARIABLE
à NCEÌ TÏ TELÌ HO× MANÙ CELLÓ ARÅ IÎ USE
C NEXT BITMAPS IMPLEMENT FVLD
	LOGICAL*1 FV1(BRRCL),FV2(BRRCL),FV4(BRRCL)
	LOGICAL*1 LBITS(8)
	COMMON/BITS/LBITS
	COMMON/FVLDM/FV1,FV2,FV4
C THE FOLLOWING BITMAP IS FOR TYPE ARRAY, AND INTEGER ARRAY IS FOR
C TYPES OF AC'S STORAGE:
	LOGICAL*1 ITYP(BRRCL)
	INTEGER*2 IATYP(27)
	COMMON/TYP/IATYP,ITYP
C NEXT WORD TBL IS FORMAT BLK POINTERS; MAKE IT A NEW PARAMETER HOW
C LONG IT IS. 128 BY 256 ARRAY HAS 64 WORDS WORTH.
	INTEGER*2 FMTBLK(LFMTBK)
	COMMON/FMTBK/FMTBLK
C NEXT TABLE IS VALUE BLKS. AGAIN FOR 128 BY 256 IT'S 512 WORDS.
	INTEGER*2 VALBLK(LVALBK)
	COMMON/VLBK/VALBLK
C
C NEXT ARE BUFFERS FOR HOLDING VALUES, AND MEMORY OCCUPANCY WORDS
C FOR EACH GIVING THE BLK # IN USE FOR THESE TABLES
C
C
C VALUE BLOCKS: VBKPOL IN NUMBER.
	INTEGER*2 VBKMEM(VBKPOL)
	LOGICAL*1 VBKBUF(512,VBKPOL)
	COMMON/VALBUF/VBKMEM,VBKBUF
C FORMAT BLOCK (ONE ONLY, 512 BYTES, BUT ORGANIZED AS 45 FORMAT
C AREAS WITH USE COUNT, DATA. SINCE IT'S HARD TO ACCESS THE USE COUNT
C AS INTEGERS EASILY WITH RECORDS 11 BYTES LONG (2 BYTES USE CNT FOLLOWED
C BY 9 BYTES DATA), MAKE 2 ARRAYS
	INTEGER*2 FMTREF(45)
	LOGICAL*1 FMTDAT(9,45)
	COMMON/FMTBFR/FMTREF,FMTDAT
	LOGICAL*1 DVF(12),DFMT(10)
	EQUIVALENCE(DVF(2),DFMT(1))
	COMMON/DVFMT/DVFMT
C CHECK THE ABOVE COMMON DEF FOR DEFAULT FORMAT IN SPREDSHT MAIN PGM
C
C FORMULA STORAGE BUFFERS. HERE BUFFERS ARE 32 BYTES LONG SO
C EQUIVALENCED INTEGER OPERATIONS WILL WORK...
C
C FRMBLK BLOCKS-USED MAP COVERS DISK AND MEM BLKS
C FRMMEM COVERS OCCUPANCY OF MEMORY
C FRMBFR IS DATA OF FORMULAE IN MEMORY AND IS ORGANIZED IN BLOCKS
	INTEGER*2 FRMBLK(FBSZ),FRMMEM(FMSZ)
	LOGICAL*1 FRMBFR(512,FMSZ)
	COMMON/FRBFR/FRMBLK,FRMMEM,FRMBFR
C NOTE 1ST DIMENSION VARIES FASTEST...
C
	COMMON /NCEL/NCEL
	IBP=1
	DO 2 N=1,9
2	FMTDAT(N,1)=DFMT(N)
	FMTREF(1)=1
	DO 3 N=2,45
3	FMTREF(N)=0
	DO 1 N=1,8
	LBITS(N)=128/IBP
1	IBP=IBP+IBP
	DO 4 N=1,BRRCL
C CLEAR BITMAPS NOW
	FV1(N)=0
	FV2(N)=0
	FV4(N)=0
4	ITYP(N)=0
	DO 5 N=1,VBKPOL
	VBKMEM(N)=0
	DO 5 M=1,512
5	VBKBUF(M,N)=0
	DO 6 N=1,FMSZ
	FRMMEM(N)=0
	DO 6 M=1,512
6	FRMBFR(M,N)=0
	DO 7 N=1,FBSZ
7	FRMBLK(N)=0
	DO 8 N=1,27
8	IATYP(N)=2
C TYPE 2 IS REALS (DEFAULT)
	NCEL=0
	RETURN
	END
C
C TYPGET - GET TYPE(RRW,RCL) ARRAY WORDS BACK
	SUBROUTINE TYPGET(ID1,ID2,IVAL)
C RETURN TYPE(ID1,ID2) IN IVAL, BUT NOT REALLY...
	INCLUDE 'VKLUGPRM.FTN'
C NEXT BITMAPS IMPLEMENT FVLD
	LOGICAL*1 FV1(BRRCL),FV2(BRRCL),FV4(BRRCL)
	LOGICAL*1 LBITS(8)
	COMMON/BITS/LBITS
	COMMON/FVLDM/FV1,FV2,FV4
C THE FOLLOWING BITMAP IS FOR TYPE ARRAY, AND INTEGER ARRAY IS FOR
C TYPES OF AC'S STORAGE:
	LOGICAL*1 ITYP(BRRCL)
	INTEGER*2 IATYP(27)
	COMMON/TYP/IATYP,ITYP
C NEXT WORD TBL IS FORMAT BLK POINTERS; MAKE IT A NEW PARAMETER HOW
C LONG IT IS. 128 BY 256 ARRAY HAS 64 WORDS WORTH.
	INTEGER*2 FMTBLK(LFMTBK)
	COMMON/FMTBK/FMTBLK
C NEXT TABLE IS VALUE BLKS. AGAIN FOR 128 BY 256 IT'S 512 WORDS.
	INTEGER*2 VALBLK(LVALBK)
	COMMON/VLBK/VALBLK
C
C NEXT ARE BUFFERS FOR HOLDING VALUES, AND MEMORY OCCUPANCY WORDS
C FOR EACH GIVING THE BLK # IN USE FOR THESE TABLES
C
C
C VALUE BLOCKS: VBKPOL IN NUMBER.
	INTEGER*2 VBKMEM(VBKPOL)
	LOGICAL*1 VBKBUF(512,VBKPOL)
	COMMON/VALBUF/VBKMEM,VBKBUF
C FORMAT BLOCK (ONE ONLY, 512 BYTES, BUT ORGANIZED AS 45 FORMAT
C AREAS WITH USE COUNT, DATA. SINCE IT'S HARD TO ACCESS THE USE COUNT
C AS INTEGERS EASILY WITH RECORDS 11 BYTES LONG (2 BYTES USE CNT FOLLOWED
C BY 9 BYTES DATA), MAKE 2 ARRAYS
	INTEGER*2 FMTREF(45)
	LOGICAL*1 FMTDAT(9,45)
	COMMON/FMTBFR/FMTREF,FMTDAT
C FORMULA STORAGE BUFFERS. HERE BUFFERS ARE 32 BYTES LONG SO
C EQUIVALENCED INTEGER OPERATIONS WILL WORK...
C
C FRMBLK BLOCKS-USED MAP COVERS DISK AND MEM BLKS
C FRMMEM COVERS OCCUPANCY OF MEMORY
C FRMBFR IS DATA OF FORMULAE IN MEMORY AND IS ORGANIZED IN BLOCKS
	INTEGER*2 FRMBLK(FBSZ),FRMMEM(FMSZ)
	LOGICAL*1 FRMBFR(512,FMSZ)
C NOTE 1ST DIMENSION VARIES FASTEST...
	COMMON/FRBFR/FRMBLK,FRMMEM,FRMBFR
	LOGICAL*1 ITST
	IF(ID1.LE.27.AND.ID2.LE.1)GOTO 1000
	ID=(ID2-1)*RRW+ID1
	IBT=(ID-1)/8
	IBIT=((ID-1).AND.7)+1
	ITST=ITYP(IBT).AND.LBITS(IBIT)
	IVAL=2
	IF(ITST.NE.0)IVAL=4
	RETURN
1000	CONTINUE
C AN AC. RETURN FULL TYPE WORD
	IVAL=IATYP(ID1)
	RETURN
	END
C
C TYPSET - STORE IVAL IN TYPE(RRW,RCL) ARRAY
	SUBROUTINE TYPSET(ID1,ID2,IVAL)
	INCLUDE 'VKLUGPRM.FTN'
C NEXT BITMAPS IMPLEMENT FVLD
	LOGICAL*1 FV1(BRRCL),FV2(BRRCL),FV4(BRRCL)
	LOGICAL*1 LBITS(8)
	COMMON/BITS/LBITS
	COMMON/FVLDM/FV1,FV2,FV4
C THE FOLLOWING BITMAP IS FOR TYPE ARRAY, AND INTEGER ARRAY IS FOR
C TYPES OF AC'S STORAGE:
	LOGICAL*1 ITYP(BRRCL)
	INTEGER*2 IATYP(27)
	COMMON/TYP/IATYP,ITYP
C NEXT WORD TBL IS FORMAT BLK POINTERS; MAKE IT A NEW PARAMETER HOW
C LONG IT IS. 128 BY 256 ARRAY HAS 64 WORDS WORTH.
	INTEGER*2 FMTBLK(LFMTBK)
	COMMON/FMTBK/FMTBLK
C NEXT TABLE IS VALUE BLKS. AGAIN FOR 128 BY 256 IT'S 512 WORDS.
	INTEGER*2 VALBLK(LVALBK)
	COMMON/VLBK/VALBLK
C
C NEXT ARE BUFFERS FOR HOLDING VALUES, AND MEMORY OCCUPANCY WORDS
C FOR EACH GIVING THE BLK # IN USE FOR THESE TABLES
C
C
C VALUE BLOCKS: VBKPOL IN NUMBER.
	INTEGER*2 VBKMEM(VBKPOL)
	LOGICAL*1 VBKBUF(512,VBKPOL)
	COMMON/VALBUF/VBKMEM,VBKBUF
C FORMAT BLOCK (ONE ONLY, 512 BYTES, BUT ORGANIZED AS 45 FORMAT
C AREAS WITH USE COUNT, DATA. SINCE IT'S HARD TO ACCESS THE USE COUNT
C AS INTEGERS EASILY WITH RECORDS 11 BYTES LONG (2 BYTES USE CNT FOLLOWED
C BY 9 BYTES DATA), MAKE 2 ARRAYS
	INTEGER*2 FMTREF(45)
	LOGICAL*1 FMTDAT(9,45)
	COMMON/FMTBFR/FMTREF,FMTDAT
C FORMULA STORAGE BUFFERS. HERE BUFFERS ARE 32 BYTES LONG SO
C EQUIVALENCED INTEGER OPERATIONS WILL WORK...
C
C FRMBLK BLOCKS-USED MAP COVERS DISK AND MEM BLKS
C FRMMEM COVERS OCCUPANCY OF MEMORY
C FRMBFR IS DATA OF FORMULAE IN MEMORY AND IS ORGANIZED IN BLOCKS
	INTEGER*2 FRMBLK(FBSZ),FRMMEM(FMSZ)
	LOGICAL*1 FRMBFR(512,FMSZ)
C NOTE 1ST DIMENSION VARIES FASTEST...
	COMMON/FRBFR/FRMBLK,FRMMEM,FRMBFR
	LOGICAL*1 ITST,ITST2
	ID=(ID2-1)*RRW+ID1
	IBT=(ID-1)/8
	IBIT=((ID-1).AND.7)+1
	ITST2=.NOT.LBITS(IBIT)
	ITST2=ITYP(IBT).AND.ITST2
	ITST=ITYP(IBT).OR.LBITS(IBIT)
	ITYP(IBT)=ITST2
	IF(IVAL.NE.-2.AND.IVAL.NE.2)ITYP(IBT)=ITST
	IF(ID2.GT.1.OR.ID1.GT.27)RETURN
	IATYP(ID1)=IVAL
	RETURN
	END
C
C FVLDGT - RETURN FVLD BYTE GIVEN 2 DIMS OF ITS "LOCATION"
	SUBROUTINE FVLDGT(ID1,ID2,IVAL)
	INTEGER*2 ID1,ID2
	LOGICAL*1 IVAL
	INCLUDE 'VKLUGPRM.FTN'
C NEXT BITMAPS IMPLEMENT FVLD
	LOGICAL*1 FV1(BRRCL),FV2(BRRCL),FV4(BRRCL)
	LOGICAL*1 LBITS(8)
	COMMON/BITS/LBITS
	COMMON/FVLDM/FV1,FV2,FV4
C THE FOLLOWING BITMAP IS FOR TYPE ARRAY, AND INTEGER ARRAY IS FOR
C TYPES OF AC'S STORAGE:
	LOGICAL*1 ITYP(BRRCL)
	INTEGER*2 IATYP(27)
	COMMON/TYP/IATYP,ITYP
C NEXT WORD TBL IS FORMAT BLK POINTERS; MAKE IT A NEW PARAMETER HOW
C LONG IT IS. 128 BY 256 ARRAY HAS 64 WORDS WORTH.
	INTEGER*2 FMTBLK(LFMTBK)
	COMMON/FMTBK/FMTBLK
C NEXT TABLE IS VALUE BLKS. AGAIN FOR 128 BY 256 IT'S 512 WORDS.
	INTEGER*2 VALBLK(LVALBK)
	COMMON/VLBK/VALBLK
C
C NEXT ARE BUFFERS FOR HOLDING VALUES, AND MEMORY OCCUPANCY WORDS
C FOR EACH GIVING THE BLK # IN USE FOR THESE TABLES
C
C
C VALUE BLOCKS: VBKPOL IN NUMBER.
	INTEGER*2 VBKMEM(VBKPOL)
	LOGICAL*1 VBKBUF(512,VBKPOL)
	COMMON/VALBUF/VBKMEM,VBKBUF
C FORMAT BLOCK (ONE ONLY, 512 BYTES, BUT ORGANIZED AS 45 FORMAT
C AREAS WITH USE COUNT, DATA. SINCE IT'S HARD TO ACCESS THE USE COUNT
C AS INTEGERS EASILY WITH RECORDS 11 BYTES LONG (2 BYTES USE CNT FOLLOWED
C BY 9 BYTES DATA), MAKE 2 ARRAYS
	INTEGER*2 FMTREF(45)
	LOGICAL*1 FMTDAT(9,45)
	COMMON/FMTBFR/FMTREF,FMTDAT
C FORMULA STORAGE BUFFERS. HERE BUFFERS ARE 32 BYTES LONG SO
C EQUIVALENCED INTEGER OPERATIONS WILL WORK...
C
C FRMBLK BLOCKS-USED MAP COVERS DISK AND MEM BLKS
C FRMMEM COVERS OCCUPANCY OF MEMORY
C FRMBFR IS DATA OF FORMULAE IN MEMORY AND IS ORGANIZED IN BLOCKS
	INTEGER*2 FRMBLK(FBSZ),FRMMEM(FMSZ)
	LOGICAL*1 FRMBFR(512,FMSZ)
C NOTE 1ST DIMENSION VARIES FASTEST...
	COMMON/FRBFR/FRMBLK,FRMMEM,FRMBFR
	LOGICAL*1 I1,I2,I4
	ID=(ID2-1)*RRW+ID1
	IBT=(ID-1)/8
	IBIT=((ID-1).AND.7)+1
	I1=FV1(IBT).AND.LBITS(IBIT)
	I2=FV2(IBT).AND.LBITS(IBIT)
	I4=FV4(IBT).AND.LBITS(IBIT)
	IVL=0
	IF(I1.NE.0)IVL=1
	IF(I2.NE.0)IVL=IVL+2
	IF(I3.NE.0)IVL=-IVL
	IVAL=IVL
C READS OFF FVLD BYTE FROM 3 BITS, HIGH ONE IS SIGN. TREAT AS SIGN-
C MAGNITUDE NUMBER IN RANGE -3 TO +3,
	RETURN
	END
C
C FVLDST - SET THE BYTE IN FVLD ARRAY
	SUBROUTINE FVLDST(ID1,ID2,IVAL)
	INCLUDE 'VKLUGPRM.FTN'
C NEXT BITMAPS IMPLEMENT FVLD
	LOGICAL*1 FV1(BRRCL),FV2(BRRCL),FV4(BRRCL)
	LOGICAL*1 LBITS(8)
	COMMON/BITS/LBITS
	COMMON/FVLDM/FV1,FV2,FV4
C THE FOLLOWING BITMAP IS FOR TYPE ARRAY, AND INTEGER ARRAY IS FOR
C TYPES OF AC'S STORAGE:
	LOGICAL*1 ITYP(BRRCL)
	INTEGER*2 IATYP(27)
	COMMON/TYP/IATYP,ITYP
C NEXT WORD TBL IS FORMAT BLK POINTERS; MAKE IT A NEW PARAMETER HOW
C LONG IT IS. 128 BY 256 ARRAY HAS 64 WORDS WORTH.
	INTEGER*2 FMTBLK(LFMTBK)
	COMMON/FMTBK/FMTBLK
C NEXT TABLE IS VALUE BLKS. AGAIN FOR 128 BY 256 IT'S 512 WORDS.
	INTEGER*2 VALBLK(LVALBK)
	COMMON/VLBK/VALBLK
C
C NEXT ARE BUFFERS FOR HOLDING VALUES, AND MEMORY OCCUPANCY WORDS
C FOR EACH GIVING THE BLK # IN USE FOR THESE TABLES
C
C
C VALUE BLOCKS: VBKPOL IN NUMBER.
	INTEGER*2 VBKMEM(VBKPOL)
	LOGICAL*1 VBKBUF(512,VBKPOL)
	COMMON/VALBUF/VBKMEM,VBKBUF
C FORMAT BLOCK (ONE ONLY, 512 BYTES, BUT ORGANIZED AS 45 FORMAT
C AREAS WITH USE COUNT, DATA. SINCE IT'S HARD TO ACCESS THE USE COUNT
C AS INTEGERS EASILY WITH RECORDS 11 BYTES LONG (2 BYTES USE CNT FOLLOWED
C BY 9 BYTES DATA), MAKE 2 ARRAYS
	INTEGER*2 FMTREF(45)
	LOGICAL*1 FMTDAT(9,45)
	COMMON/FMTBFR/FMTREF,FMTDAT
C FORMULA STORAGE BUFFERS. HERE BUFFERS ARE 32 BYTES LONG SO
C EQUIVALENCED INTEGER OPERATIONS WILL WORK...
C
C FRMBLK BLOCKS-USED MAP COVERS DISK AND MEM BLKS
C FRMMEM COVERS OCCUPANCY OF MEMORY
C FRMBFR IS DATA OF FORMULAE IN MEMORY AND IS ORGANIZED IN BLOCKS
	INTEGER*2 FRMBLK(FBSZ),FRMMEM(FMSZ)
	LOGICAL*1 FRMBFR(512,FMSZ)
C NOTE 1ST DIMENSION VARIES FASTEST...
	COMMON/FRBFR/FRMBLK,FRMMEM,FRMBFR
	LOGICAL*1 I1,I2,I4,IVV
	ID=(ID2-1)*RRW+ID1
	IBT=(ID-1)/8
	IBIT=((ID-1).AND.7)+1
C ZERO ALL 3 FVLD BITS FIRST
	FV1(IBT)=FV1(IBT).AND..NOT.LBITS(IBIT)
	FV2(IBT)=FV2(IBT).AND..NOT.LBITS(IBIT)
	FV4(IBT)=FV4(IBT).AND..NOT.LBITS(IBIT)
	IVV=IABS(IVAL)
	I3=0
	IF(IVAL.LT.0)I3=1
	I2=IVV.AND.2
	I1=IVV.AND.1
C NOTE WE ASSUME HEAVILY THAT LOGICAL OPERATIONS WORK BY BINARY
C ANDS AND ORS IN DATA.
	IF(I1.NE.0)FV1(IBT)=FV1(IBT).OR.LBITS(IBIT)
	IF(I2.NE.0)FV2(IBT)=FV2(IBT).OR.LBITS(IBIT)
	IF(I3.NE.0)FV3(IBT)=FV3(IBT).OR.LBITS(IBIT)
	RETURN
	END
C
C VBLGET - GET BYTE OF 3 DIM VBLS ARRAY, ORIGINALLY
C  DIMENSIONED (8,RRW,RCL). HANDLE BY CALLING XVBLGT TO GET
C  CORRECT 8 BYTE VARIABLE, AND PULLING OUT CORRECT ONE
	SUBROUTINE VBLGET(ID1,ID2,ID3,IVAL)
	INTEGER*2 ID1,ID2,ID3
	LOGICAL*1 IVAL,LL(8)
	REAL*8 XX
	EQUIVALENCE(LL(1),XX)
	CALL XVBLGT(ID2,ID3,XX)
	IVAL=LL(ID1)
	RETURN
	END
C VBLSET - SET BYTE OF 3 DIM VBLS ARRAY, ORIGINALLY
C  DIMENSIONED (8,RRW,RCL). HANDLE BY CALLING XVBLST TO GET
C  CORRECT 8 BYTE VARIABLE, AND PUTTING IN CORRECT ONE
	SUBROUTINE VBLSET(ID1,ID2,ID3,IVAL)
	INTEGER*2 ID1,ID2,ID3
	LOGICAL*1 IVAL,LL(8)
	REAL*8 XX
	EQUIVALENCE(LL(1),XX)
C GET THE DESIRED 8 BYTES, THEN CHANGE THE ONE WE WANT. THEN...
	CALL XVBLGT(ID2,ID3,XX)
	LL(ID1)=IVAL
C PUT BACK THE 8 BYTES.
	CALL XVBLST(ID2,ID3,XX)
	RETURN
	END
C
C JVBLGT - GET INTEGER*4 WORD OF 3 DIM VBLS ARRAY, ORIGINALLY
C  DIMENSIONED (2,RRW,RCL). HANDLE BY CALLING XVBLGT TO GET
C  CORRECT 8 BYTE VARIABLE, AND PULLING OUT CORRECT ONE
	SUBROUTINE JVBLGT(ID1,ID2,ID3,IVAL)
	INTEGER*2 ID1,ID2,ID3
	INTEGER*4 IVAL,LL(2)
	REAL*8 XX
	EQUIVALENCE(LL(1),XX)
	CALL XVBLGT(ID2,ID3,XX)
	IVAL=LL(ID1)
	RETURN
	END
C JVBLST - SET I*4 WORD OF 3 DIM VBLS ARRAY, ORIGINALLY
C  DIMENSIONED (2,RRW,RCL). HANDLE BY CALLING XVBLST TO GET
C  CORRECT 8 BYTE VARIABLE, AND PUTTING IN CORRECT ONE
	SUBROUTINE JVBLST(ID1,ID2,ID3,IVAL)
	INTEGER*2 ID1,ID2,ID3
	INTEGER*4 IVAL,LL(2)
	REAL*8 XX
	EQUIVALENCE(LL(1),XX)
C GET THE DESIRED 8 BYTES, THEN CHANGE THE ONES WE WANT. THEN...
	CALL XVBLGT(ID2,ID3,XX)
	LL(ID1)=IVAL
C PUT BACK THE 8 BYTES.
	CALL XVBLST(ID2,ID3,XX)
	RETURN
	END
C
C
C XVBLST - STORE 8 BYTES IN VARIABLES ARRAY
C GIVEN DIMENSIONS FOR LOCATING THEM
	SUBROUTINE XVBLST(ID1,ID2,XX)
	INTEGER*2 ID1,ID2
	REAL*8 XX
	INCLUDE 'VKLUGPRM.FTN'
C NEXT BITMAPS IMPLEMENT FVLD
	LOGICAL*1 FV1(BRRCL),FV2(BRRCL),FV4(BRRCL)
	LOGICAL*1 LBITS(8)
	COMMON/BITS/LBITS
	COMMON/FVLDM/FV1,FV2,FV4
C THE FOLLOWING BITMAP IS FOR TYPE ARRAY, AND INTEGER ARRAY IS FOR
C TYPES OF AC'S STORAGE:
	LOGICAL*1 ITYP(BRRCL)
	INTEGER*2 IATYP(27)
	COMMON/TYP/IATYP,ITYP
C NEXT WORD TBL IS FORMAT BLK POINTERS; MAKE IT A NEW PARAMETER HOW
C LONG IT IS. 128 BY 256 ARRAY HAS 64 WORDS WORTH.
	INTEGER*2 FMTBLK(LFMTBK)
	COMMON/FMTBK/FMTBLK
C NEXT TABLE IS VALUE BLKS. AGAIN FOR 128 BY 256 IT'S 512 WORDS.
	INTEGER*2 VALBLK(LVALBK)
	COMMON/VLBK/VALBLK
C
C NEXT ARE BUFFERS FOR HOLDING VALUES, AND MEMORY OCCUPANCY WORDS
C FOR EACH GIVING THE BLK # IN USE FOR THESE TABLES
C
C
C VALUE BLOCKS: VBKPOL IN NUMBER.
	INTEGER*2 VBKMEM(VBKPOL),VSEL,VOPN
	REAL*8 VBKBUF(64,VBKPOL)
	COMMON/VALBUF/VBKMEM,VBKBUF
C FORMAT BLOCK (ONE ONLY, 512 BYTES, BUT ORGANIZED AS 45 FORMAT
C AREAS WITH USE COUNT, DATA. SINCE IT'S HARD TO ACCESS THE USE COUNT
C AS INTEGERS EASILY WITH RECORDS 11 BYTES LONG (2 BYTES USE CNT FOLLOWED
C BY 9 BYTES DATA), MAKE 2 ARRAYS
	INTEGER*2 FMTREF(45)
	LOGICAL*1 FMTDAT(9,45),LWK
	COMMON/FMTBFR/FMTREF,FMTDAT
C FORMULA STORAGE BUFFERS. HERE BUFFERS ARE 32 BYTES LONG SO
C EQUIVALENCED INTEGER OPERATIONS WILL WORK...
C
C FRMBLK BLOCKS-USED MAP COVERS DISK AND MEM BLKS
C FRMMEM COVERS OCCUPANCY OF MEMORY
C FRMBFR IS DATA OF FORMULAE IN MEMORY AND IS ORGANIZED IN BLOCKS
	INTEGER*2 FRMBLK(FBSZ),FRMMEM(FMSZ)
	LOGICAL*1 FRMBFR(512,FMSZ)
C NOTE 1ST DIMENSION VARIES FASTEST...
	COMMON/FRBFR/FRMBLK,FRMMEM,FRMBFR
	ID=(ID2-1)*RRW+ID1
	CALL FVLDGT(ID1,ID2,LWK)
	IF(LWK.LE.0)RETURN
	LBLK=((ID-1)/64)+1
	DO 1 N=1,LVALBK
	RETURN
1	IF(VALVLK(N).EQ.LBLK)GOTO 2
CCCCCCCCCCCCCCCCCCCCCCCC
CCCC ADD FOR XVBLST
	RETURN
	DO 21 N=1,LVALBK
	IF(VALBLK(N).EQ.0)GOTO 22
21	CONTINUE
	RETURN
22	CONTINUE
	VALBLK(N)=LBLK
C CLAIM EMPTY SYSTEM BLOCK
	DO 23 M=1,VBKPOL
23	IF(VBKMEM(M).LE.0)GOTO 24
	GOTO 25
24	CONTINUE
	VBKMEM(M)=N
	DO 27 MM=1,64
27	VBKBUF(MM,M)=0.
C RETURN ZEROED BUFFERS
25	CONTINUE
CCCCCCCCCCCCCCCCCCCCCCCC
C	RETURN
2	CONTINUE
C NOTE: IF RESULT NOT IN LISTS YET, RETURN 0
	NBK=N
	NLST=0
	DO 3 N=1,VBKPOL
	IF(VALBLK(N).GT.0)NLST=NLST+1
C KEEP TRACK OF PARTIALLY EMPTY SCRATCH CORE AREAS
3	IF(VBKMEM(N).EQ.VALBLK(NBK))GOTO 4
	IF(NLST.LT.VBKPOL) GOTO 5
C ALL MEM FULL --- HAVE TO SWAP OUT SOMETHING
	VSEL=VSEL+1
	IF(VSEL.GT.VBKPOL.OR.VSEL.LT.1)VSEL=1
5	IF(VOPN.NE.0)GOTO 6
C VICTIM JUST ROTATES AMONG BUFFERS IN MEMORY...
	VOPN=1
	OPEN(UNIT=8,FILE="VALS.DAT",RANDOM,BLKSIZE=512)
C FORM OF OPEN STMT IS WRONG IN DETAIL BUT FIX UP AS NEEDED...
6	CONTINUE
	IF(NLST.GE.VBKPOL)WRITE(8'VALBLK(NBK))(VBKBUF(IV,VSEL),IV=1,64)
	READ(8'LBLK)(VBKBUF(IV,VSEL),IV=1,64)
	VBKMEM(VSEL)=LBLK
	N=VSEL
4	CONTINUE
	LINBK=((ID-1).AND.63)+1
	VBKMEM(LINBK,N)=XX
	RETURN
	END
C
C XVBLGT - LOAD 8 BYTES GIVEN DIMENSIONS FOR GETTING THEM
C 2 DIM ARRAY, DIM'D (RRW,RCL)
	SUBROUTINE XVBLGT(ID1,ID2,XX)
	INTEGER*2 ID1,ID2
	REAL*8 XX
	INCLUDE 'VKLUGPRM.FTN'
C NEXT BITMAPS IMPLEMENT FVLD
	LOGICAL*1 FV1(BRRCL),FV2(BRRCL),FV4(BRRCL)
	LOGICAL*1 LBITS(8)
	COMMON/BITS/LBITS
	COMMON/FVLDM/FV1,FV2,FV4
C THE FOLLOWING BITMAP IS FOR TYPE ARRAY, AND INTEGER ARRAY IS FOR
C TYPES OF AC'S STORAGE:
	LOGICAL*1 ITYP(BRRCL)
	INTEGER*2 IATYP(27)
	COMMON/TYP/IATYP,ITYP
C NEXT WORD TBL IS FORMAT BLK POINTERS; MAKE IT A NEW PARAMETER HOW
C LONG IT IS. 128 BY 256 ARRAY HAS 64 WORDS WORTH.
	INTEGER*2 FMTBLK(LFMTBK)
	COMMON/FMTBK/FMTBLK
C NEXT TABLE IS VALUE BLKS. AGAIN FOR 128 BY 256 IT'S 512 WORDS.
	INTEGER*2 VALBLK(LVALBK)
	COMMON/VLBK/VALBLK
C
C NEXT ARE BUFFERS FOR HOLDING VALUES, AND MEMORY OCCUPANCY WORDS
C FOR EACH GIVING THE BLK # IN USE FOR THESE TABLES
C
C
C VALUE BLOCKS: VBKPOL IN NUMBER.
	INTEGER*2 VBKMEM(VBKPOL),VSEL,VOPN
	REAL*8 VBKBUF(64,VBKPOL)
	COMMON/VALBUF/VBKMEM,VBKBUF
C FORMAT BLOCK (ONE ONLY, 512 BYTES, BUT ORGANIZED AS 45 FORMAT
C AREAS WITH USE COUNT, DATA. SINCE IT'S HARD TO ACCESS THE USE COUNT
C AS INTEGERS EASILY WITH RECORDS 11 BYTES LONG (2 BYTES USE CNT FOLLOWED
C BY 9 BYTES DATA), MAKE 2 ARRAYS
	INTEGER*2 FMTREF(45)
	LOGICAL*1 FMTDAT(9,45)
	COMMON/FMTBFR/FMTREF,FMTDAT
C FORMULA STORAGE BUFFERS. HERE BUFFERS ARE 32 BYTES LONG SO
C EQUIVALENCED INTEGER OPERATIONS WILL WORK...
C
C FRMBLK BLOCKS-USED MAP COVERS DISK AND MEM BLKS
C FRMMEM COVERS OCCUPANCY OF MEMORY
C FRMBFR IS DATA OF FORMULAE IN MEMORY AND IS ORGANIZED IN BLOCKS
	INTEGER*2 FRMBLK(FBSZ),FRMMEM(FMSZ)
	LOGICAL*1 FRMBFR(512,FMSZ),LWK
C NOTE 1ST DIMENSION VARIES FASTEST...
	COMMON/FRBFR/FRMBLK,FRMMEM,FRMBFR
	ID=(ID2-1)*RRW+ID1
	XX=0.
	CALL FVLDGT(ID1,ID2,LWK)
	IF(LWK.LE.0)RETURN
	LBLK=((ID-1)/64)+1
	DO 1 N=1,LVALBK
	RETURN
1	IF(VALVLK(N).EQ.LBLK)GOTO 2
	RETURN
2	CONTINUE
C NOTE: IF RESULT NOT IN LISTS YET, RETURN 0
	NBK=N
	NLST=0
	DO 3 N=1,VBKPOL
	IF(VALBLK(N).GT.0)NLST=NLST+1
C KEEP TRACK OF PARTIALLY EMPTY SCRATCH CORE AREAS
3	IF(VBKMEM(N).EQ.VALBLK(NBK))GOTO 4
	IF(NLST.LT.VBKPOL) GOTO 5
C ALL MEM FULL --- HAVE TO SWAP OUT SOMETHING
	VSEL=VSEL+1
	IF(VSEL.GT.VBKPOL.OR.VSEL.LT.1)VSEL=1
5	IF(VOPN.NE.0)GOTO 6
C VICTIM JUST ROTATES AMONG BUFFERS IN MEMORY...
	VOPN=1
	OPEN(UNIT=8,FILE="VALS.DAT",RANDOM,BLKSIZE=512)
C FORM OF OPEN STMT IS WRONG IN DETAIL BUT FIX UP AS NEEDED...
6	CONTINUE
	IF(NLST.GE.VBKPOL)WRITE(8'VALBLK(NBK))(VBKBUF(IV,VSEL),IV=1,64)
	READ(8'LBLK)(VBKBUF(IV,VSEL),IV=1,64)
	VBKMEM(VSEL)=LBLK
	N=VSEL
4	CONTINUE
	LINBK=((ID-1).AND.63)+1
	XX=VBKMEM(LINBK,N)
C
	RETURN
	END