DIRECTORY Basics, CCDUtils, CD, CDSymbolicObjects, Core, CoreBlock, CoreFrame, CoreLibrary, CoreName, IFUCoreCells, IFUCoreCtl, IFUCoreDrive, IO, Lists, PLAOps, PW, PWCore, PWPins, REFBit, Rope;

IFUCoreCtlPreCharge: CEDAR PROGRAM
IMPORTS Basics, CCDUtils, CD, CDSymbolicObjects, CoreBlock, CoreFrame, CoreName, IFUCoreCells, IFUCoreDrive, IO, Lists, PLAOps, PW, PWCore, PWPins, REFBit, Rope
EXPORTS IFUCoreCtl =
BEGIN

ROPE:				TYPE	= Core.ROPE;
CellType:			TYPE	= Core.CellType;
Wire:				TYPE	= Core.Wire;
Frame:			TYPE	= CoreFrame.Frame;
PLADescription:	TYPE	= IFUCoreCtl.PLADescription;
Connection:		TYPE	= IFUCoreCtl.Connection;
PLAType:		TYPE	= IFUCoreDrive.PLAType;
Drive:				TYPE	= IFUCoreDrive.Drive;
Drives:			TYPE	= IFUCoreDrive.Drives;
DriveRec:			TYPE	= IFUCoreDrive.DriveRec;
RowType:		TYPE	= IFUCoreDrive.RowType;
Dir:				TYPE	= IFUCoreDrive.Dir;
DrGate:			TYPE	= IFUCoreDrive.DrGate;
Ph:				TYPE	= IFUCoreDrive.Ph;
Polarity:			TYPE	= IFUCoreDrive.Polarity;

Signal:	SIGNAL = CODE;

MakeHotPLA,
MakePreChargedPLA:	PUBLIC PROC[desc: PLADescription] = {
log.PutF["\n Make PreCharged/Hot PLA %g", IO.rope[desc.name]];
ZeroUnusedTTTOutputs	[desc];
DefinePLARows				[desc];
DressInDrs					[desc];
MakeOutDrs					[desc];
MakePla						[desc]};

DressInDrs: PROC [desc: PLADescription] = {
desc.inDrs _ CONS[ NEW[DriveRec _ [drRowType: xfooter]], desc.inDrs];
FOR list: Drives _ desc.inDrs, list.rest WHILE list.rest#NIL DO REPEAT
FINISHED => list.rest _ CONS [NEW[DriveRec _ [drRowType: xheader]], NIL] ENDLOOP};

ZeroUnusedTTTOutputs: PROC [desc: PLADescription ] = {
maskTerm: PLAOps.Term _ PLAOps.CopyTerm[desc.ttt.termList.begin];
log.PutRope["\n Zero unused TTT outputs"];
FOR i: CARDINAL IN [0..maskTerm.out.wdSize)
DO maskTerm.out[i] _ PLAOps.initOutQrtWz ENDLOOP;
FOR index: INT IN [0..desc.smlToBigOut.size) DO
pos: INT _ desc.smlToBigOut[index];
PLAOps.SetOutQrt[one, maskTerm, REFBit.Desc[desc.ttt.out].bitForm[pos].firstBit] ENDLOOP;
FOR term: PLAOps.Term _ desc.ttt.termList.begin, term.next WHILE term#NIL DO
FOR i: CARDINAL IN [0..maskTerm.out.wdSize) DO
term.out[i].d _ Basics.BITAND[term.out[i].d, maskTerm.out[i].d] ENDLOOP ENDLOOP };

PreChargedParams: TYPE = RECORD[
minConnSpace:		INT				_ 2,		-- SPACING rows between driver rows;
insPerExtra:			INT				_ 10,		-- SPACING cols between extra columns;
outsPerExtra:			INT				_ 10,
nextTerm:			PLAOps.Term 	_ NIL,	-- specific parameter
nextConn:			INT				_ 0,		-- specific parameter
rows:					REF RowsRec	_ NIL ];	-- specific parameter
RowsRec:			TYPE = RECORD[SEQUENCE size: CARDINAL OF REF RowRec];
RowRec:				TYPE = RECORD[
dr:					REF DriveRec,
type:				RowType,
and:				ColSeqRef,
or:					ColSeqRef ];
ColSeqRef:			TYPE = REF ColSeqRec;
ColSeqRec:			TYPE = RECORD[SEQUENCE size: CARDINAL OF NormalCellType];

DefinePLARows: PROC [desc: PLADescription] = {
pp:			REF PreChargedParams _ NEW[PreChargedParams _ [
nextTerm:	desc.ttt.termList.begin,
nextConn:	desc.connSeq.size-1,
insPerExtra:	IF desc.plaType = hot THEN 10000 ELSE 10]]; --extra AND column undefined
firstRow:		BOOL _ TRUE;
index:			INT _ 0;
termUp:		BOOL _ TRUE;
nofOuts:		INT _ MAX[Lists.ListLength[desc.plaOutNames], desc.nofOrCols];
nofIns:		INT _ Lists.ListLength[desc.plaInNames];
cRowsLeft:	INT _ Lists.ListLength[desc.plaOutNames];
dRowsLeft:	INT _ desc.ttt.termList.length;
hRowsLeft:	INT;
dRowsLeft	_ MAX[dRowsLeft, cRowsLeft*(pp.minConnSpace)];
hRowsLeft	_ MAX[1, (dRowsLeft+ desc.termsPerHeader/2)/desc.termsPerHeader];
log.PutRope["\n Assign precharged/hot pla row types"];
desc.data _ pp;
desc.nofAndCols	_ nofIns/2	+ (nofIns/2	-1) / pp.insPerExtra;
desc.nofOrCols	_ nofOuts	+ (nofOuts	-1) / pp.outsPerExtra;
pp.rows			_ NEW[RowsRec[cRowsLeft+dRowsLeft+2*hRowsLeft]];
index _ pp.rows.size-1;	-- start at the top
WHILE hRowsLeft#0 DO	-- actually one more header is appended afterwards
RperH: INT _ (cRowsLeft+dRowsLeft+hRowsLeft + hRowsLeft/2)/hRowsLeft;
IF firstRow
THEN	firstRow_FALSE
ELSE	{pp.rows[index] _ NextRow[desc, xfooter]; index_index-1};
pp.rows[index] _ NextRow[desc, header];
index_index-1; RperH_RperH-1; hRowsLeft_hRowsLeft-1;
WHILE RperH > 0 DO
CperD, DperC: INT;
CperD _ MAX[1, (cRowsLeft + dRowsLeft/2)/dRowsLeft];
DperC _ MAX[1, (dRowsLeft + cRowsLeft/2)/cRowsLeft];
IF DperC < pp.minConnSpace OR
(CperD>1) AND (pp.minConnSpace>0) THEN ERROR;
RperH _ RperH - CperD - DperC;
WHILE CperD > 0 DO
pp.rows[index]	_ NextRow[desc, conn];
index_index-1; cRowsLeft_cRowsLeft-1; CperD_CperD-1;
ENDLOOP;
termUp _ TRUE;
WHILE DperC > 0 DO
pp.rows[index] _ NextRow[desc, IF termUp THEN dataUp ELSE dataDn];
index_index-1; dRowsLeft_dRowsLeft-1; DperC_DperC-1;
termUp _ NOT termUp;
ENDLOOP;
ENDLOOP;
ENDLOOP;
IF index#0 THEN ERROR;
pp.rows[index] _ NextRow[desc, footer]};

NextRow: PROC [desc: PLADescription, type: RowType] RETURNS[row: REF RowRec] = {
pp: REF PreChargedParams _ NARROW[desc.data];
andIndex, orIndex, index:	INT _ 0;
data:		PLAOps.Term;
conn:		Connection;
row		_ NEW[RowRec	_ [type: type]];
row.and	_ NEW[ColSeqRec[desc.nofAndCols]];
IF desc.nofOrCols#0 THEN row.or _ NEW[ColSeqRec[desc.nofOrCols]];
SELECT type FROM
header			=>	{ };
conn				=>	{conn	_ NextConnection[desc];	row.dr _ conn.dr};
dataUp, dataDn	=> {
data	_ NextDataTerm[desc];
row.dr _ NIL;
IF data=NIL THEN type _ row.type _ blank};
ENDCASE;
FOR index IN[0..desc.nofAndCols) DO
IF (index+1) MOD (pp.insPerExtra+1) = 0
THEN					row.and[index]	 _ extra
ELSE	{
SELECT type FROM
dataUp, dataDn	=> SELECT PLAOps.GetInQrt
[data, REFBit.Desc[desc.ttt.data].bitForm[andIndex].firstBit] FROM
zero		=>	row.and[index]	_ left;
one		=>	row.and[index]	_ right;
ENDCASE	=>	row.and[index]	_ nc;
conn		=>	IF conn.isOutput OR conn.index#andIndex
THEN			row.and[index]		_ nc
ELSE	IF conn.isLeftSide
THEN		row.and[index]	_ left
ELSE		row.and[index]	_ right;
ENDCASE	=>	  row.and[index]   _ nc;
andIndex_andIndex+1 } ENDLOOP;
IF desc.nofOrCols#0 THEN FOR index IN[0..desc.nofOrCols) DO
IF (index+1) MOD (pp.outsPerExtra+1) = 0
THEN					row.or[index]		 _ extra
ELSE	{
row.or[index]	_ nc;
IF orIndex < desc.smlToBigOut.size THEN {
IF (type=dataUp OR type=dataDn) AND PLAOps.GetOutQrt
[data, REFBit.Desc[desc.ttt.out].bitForm[desc.smlToBigOut[orIndex]].firstBit]=one
THEN	row.or[index] _ left;
IF type=conn AND conn.isOutput AND conn.index=desc.smlToBigOut[orIndex]
THEN	row.or[index] _ left };
orIndex_orIndex+1 } ENDLOOP};

NextDataTerm: PROC [desc: PLADescription] RETURNS[term: PLAOps.Term] = {
pp: REF PreChargedParams _ NARROW[desc.data];
term _ pp.nextTerm;
IF term#NIL THEN pp.nextTerm _ pp.nextTerm.next};

NextConnection: PROC [desc: PLADescription] RETURNS[conn: Connection] = {
pp: REF PreChargedParams _ NARROW[desc.data];
conn _ desc.connSeq[pp.nextConn];
pp.nextConn _ pp.nextConn-1};

MakeOutDrs: PROC[desc: PLADescription] = {
pp:	REF PreChargedParams _ NARROW[desc.data];
last:	INT	_ pp.rows.size+pp.minConnSpace;
FOR driverIndex: INT DECREASING IN [0..pp.rows.size) DO
type: RowType _ pp.rows[driverIndex].type;
SELECT type FROM
header, xfooter, footer	=> {
IF (last-driverIndex) <= pp.minConnSpace THEN ERROR;
last _ driverIndex+pp.minConnSpace;
desc.outDrs _
CONS[NEW[DriveRec _ [plaType: desc.plaType, drRowType: type]], desc.outDrs]};
blank, dataUp, dataDn 	=> {
IF (last-driverIndex) <= pp.minConnSpace THEN LOOP;
desc.outDrs _
CONS[NEW[DriveRec _ [plaType: desc.plaType, drRowType: type]], desc.outDrs]};
conn 						=> {
IF (last-driverIndex) <= pp.minConnSpace THEN ERROR;
last _ driverIndex;
desc.outDrs _ CONS[pp.rows[driverIndex].dr, desc.outDrs]}
ENDCASE	=> ERROR;
ENDLOOP};

MakePla: PROC[desc: PLADescription] = {
name:	ROPE _ CoreName.RopeNm[desc.name.Cat["Body"]];
IF (desc.outBodyCT _ CoreFrame.ReadFrameCache[name])=NIL THEN {
cellType:	Core.CellType;
tiles:		REF TileVarieties _ GetPLATiles[desc.plaType];
pp:		REF PreChargedParams _ NARROW[desc.data];
refPhase: Ph _ unk;
rowList: PW.ListOb _ NIL;
log.PutRope["\n Assemble precharged/hot pla row cells"];
FOR rowIndex: INT IN [0..pp.rows.size) DO
objects: PW.ListOb _ NIL;
row: REF RowRec _ pp.rows[rowIndex];
IF pp.rows[rowIndex].dr#NIL THEN refPhase _ pp.rows[rowIndex].dr.ref.ph;
objects _ CONS[tiles.glue[row.type][leftSide], objects];
FOR index: INT IN [0..row.and.size) DO
objects _ CONS[tiles.and[row.type][row.and[index]], objects] ENDLOOP;
IF desc.nofOrCols#0 THEN {
objects _ CONS[tiles.glue[row.type][between], objects];
FOR index: INT IN [0..row.or.size) DO
objects _ CONS[tiles.or[row.type][row.or[index]], objects] ENDLOOP;
objects _ CONS[tiles.glue[row.type][rightSide], objects] };
rowList _ CONS[PW.AbutListX[PW.Reverse[objects]], rowList]
ENDLOOP;
desc.body _ PW.AbutListY[PW.Reverse[rowList]];
ApplyNames[desc];
cellType _ PWCore.FromLayoutWithoutPublic[desc.body];
CoreBlock.MarkSides[cellType, desc.capSides];
[ ] _ CoreName.CellNm[cellType, name];
desc.outBodyCT _ CoreFrame.NewFrameCell[0, name,  [first: left, cell: cellType] ];
CoreFrame.WriteFrameCache[desc.outBodyCT]};
desc.body _ CCDUtils.Layout[desc.outBodyCT]};

in0:			ROPE	_ CoreName.RopeNm["in0"];
in1:			ROPE	_ CoreName.RopeNm["in1"];
out:			ROPE	_ CoreName.RopeNm["out"];
fire:			ROPE	_ CoreName.RopeNm["Fire"];
fireControlV:	ROPE	_ CoreName.RopeNm["FireControlV"];
notPreChg:	ROPE	_ CoreName.RopeNm["NotPreChg"];
VDD:			ROPE	_ CoreName.RopeNm["VDD"];
GND:			ROPE	_ CoreName.RopeNm["GND"];
ApplyNames: PROC[desc: PLADescription] = {
TileSize: PROC[obj: CD.Object] RETURNS[size: CD.Position] = 
{IF obj=NIL THEN RETURN[[0, 0]]; RETURN[CD.InterestSize[obj]]};
pp:			REF PreChargedParams _ NARROW[desc.data];
tiles:			REF TileVarieties _ GetPLATiles[desc.plaType];
leftSize:		INT _ TileSize[tiles.glue	[blank]	[leftSide]].x;
andWidth:	INT _ TileSize[tiles.and		[blank]	[nc]].x;
extraWidth:	INT _ TileSize[tiles.and		[blank]	[extra]].x;
headHt:		INT _ TileSize[tiles.glue	[header]	[rightSide]].y;
xfootHt:		INT _ TileSize[tiles.glue	[xfooter]	[rightSide]].y;
rowHt:		INT _ TileSize[tiles.glue	[blank]	[rightSide]].y;
renameProc:	PWPins.ChangePinProc ~ {
old: ROPE _ CoreName.RopeNm[CDSymbolicObjects.GetName[oldPin]];
side:	CoreBlock.Sides;
loc:	INT;
newPin _ oldPin;
[side, loc] _ CoreBlock.GetInstSideLoc[desc.body, newPin];
SELECT old FROM
GND	=> RETURN;
VDD	=> RETURN;
out	=> {
name: ROPE;
yPos:	INT;
FOR oIndex: INT IN [0..pp.rows.size) DO
SELECT pp.rows[oIndex].type FROM
header, footer	=> {yPos _ yPos + headHt;	LOOP};
xfooter			=> {yPos _ yPos + xfootHt;	LOOP};
dataUp, dataDn 	=> {yPos _ yPos + rowHt;		LOOP};
blank				=> {yPos _ yPos + rowHt;		LOOP};
conn				=> {IF loc < yPos THEN Signal[]};
ENDCASE			=> Signal[];
yPos _ yPos + rowHt;
IF loc > yPos THEN LOOP;
name _ IFUCoreDrive.DriveName[pp.rows[oIndex].dr, nin];
CDSymbolicObjects.SetName[newPin, name]; RETURN ENDLOOP;
Signal[]};
in0,
in1	=> {
name: ROPE;
list:	LIST OF ROPE _ desc.plaInNames;
xpos: INT;
xpos _  (loc - leftSize)/(pp.insPerExtra*andWidth+extraWidth);
xpos _  (loc - leftSize - extraWidth*xpos)/(andWidth/2);
WHILE xpos>1 DO
IF list=NIL THEN RETURN;
list _ list.rest.rest; xpos _ xpos-2 ENDLOOP;
name _ IF xpos=0 THEN list.first ELSE list.rest.first;
IF (xpos=0)#(old=in0) THEN Signal[];
CDSymbolicObjects.SetName[newPin, name]; 
RETURN};
fire			=> CDSymbolicObjects.SetName[newPin, "PhB"];
fireControlV	=> CDSymbolicObjects.SetName[newPin, "FireControlV"];	-- to conn pad
notPreChg	=> CDSymbolicObjects.SetName[newPin, "NotPreChg"];		-- to conn pad
ENDCASE => RETURN};
desc.body _ PWPins.ChangePins[desc.body, renameProc]};

tileBuffer:		REF TileVarieties;
hotTileBuffer:	REF TileVarieties;
TileVarieties:		TYPE = RECORD[glue: REF GlueTiles, and, or: REF NormalTiles];
GlueTiles:		TYPE = ARRAY RowType OF ARRAY GlueCellType		OF CD.Object;
GlueCellType:	TYPE = {leftSide, between, rightSide};
NormalTiles:		TYPE = ARRAY RowType OF ARRAY NormalCellType	OF CD.Object;
NormalCellType:	TYPE = {left, right, nc, extra};

GetPLATiles: PROC[type: PLAType] RETURNS[tiles: REF TileVarieties] = {
tiles _ SELECT type FROM
hot		=> GetHotPLATiles[],
ENDCASE	=> GetPreChargedPLATiles[]};

GetPreChargedPLATiles: PROC RETURNS[tiles: REF TileVarieties] = {
Get: PROC[name: ROPE] RETURNS[CD.Object] = 
{RETURN[PW.Get[design: library.design, name: name ]]};
library: CoreLibrary.Library _ IFUCoreCells.library;
IF tileBuffer # NIL THEN RETURN[tileBuffer];
log.PutRope["\n Initialize precharged PLA tiles"];
tiles		_ tileBuffer _ NEW[TileVarieties];
tiles.glue	_ NEW[GlueTiles];
tiles.and	_ NEW[NormalTiles];
tiles.or	_ NEW[NormalTiles];

tiles.glue	[xfooter][leftSide]	_ Get[	"XLeftSide" ];
tiles.glue	[xfooter][between]	_ Get[	"XBetween" ];
tiles.glue	[xfooter][rightSide]	_ Get[	"XOrEx" ];
tiles.and	[xfooter][nc]			_ Get[	"XAnd" ];
tiles.and	[xfooter][extra]		_ Get[	"XAndEx" ];
tiles.or	[xfooter][nc]			_ Get[	"XOr" ];
tiles.or	[xfooter][extra]		_ Get[	"XOrEx" ];

tiles.glue	[header][leftSide]	_ Get[	"HLeftSide" ];
tiles.glue	[header][between]	_ Get[	"HBetween" ];
tiles.glue	[header][rightSide]	_ Get[	"HRightSide" ];
tiles.and	[header][nc]			_ Get[	"HAnd" ];
tiles.and	[header][extra]		_ Get[	"HAndEx" ];
tiles.or	[header][nc]			_ Get[	"HOr" ];
tiles.or	[header][extra]		_ Get[	"HOrEx" ];

tiles.glue	[footer][leftSide]		_ PW.FlipY[	tiles.glue	[header][leftSide]	];
tiles.glue	[footer][between]	_ PW.FlipY[	tiles.glue	[header][between]	];
tiles.glue	[footer][rightSide]	_ PW.FlipY[	tiles.glue	[header][rightSide]	];
tiles.and	[footer][nc]			_ PW.FlipY[	tiles.and	[header][nc]			];
tiles.and	[footer][extra]		_ PW.FlipY[	tiles.and	[header][extra]		];
tiles.or	[footer][nc]			_ PW.FlipY[	tiles.or	[header][nc]			];
tiles.or	[footer][extra]		_ PW.FlipY[	tiles.or	[header][extra]		];

tiles.glue	[blank][leftSide]		_ Get[	"BLeftSide" ];
tiles.glue	[blank][between]	_ Get[	"BBetween" ];
tiles.glue	[blank][rightSide]	_ Get[	"BOrEx" ];
tiles.and	[blank][nc]			_ Get[	"BAnd" ];
tiles.and	[blank][extra]		_ Get[	"BAndEx" ];
tiles.or	[blank][nc]			_ Get[	"BOr" ];
tiles.or	[blank][extra]		_ Get[	"BOrEx" ];

tiles.glue	[conn][leftSide]		_ Get[	"BLeftSide" ];
tiles.glue	[conn][between]		_ Get[	"BBetween" ];
tiles.glue	[conn][rightSide]	_ Get[	"CRightSide" ];
tiles.and	[conn][left]			_ Get[	"CAndLt" ];
tiles.and	[conn][right]		_ Get[	"CAndRt" ];
tiles.and	[conn][nc]			_ Get[	"BAnd" ];
tiles.and	[conn][extra]			_ Get[	"BAndEx" ];
tiles.or	[conn][left]			_ Get[	"COr" ];
tiles.or	[conn][nc]			_ Get[	"COrNC" ];
tiles.or	[conn][extra]			_ Get[	"COrEx" ];

tiles.glue	[dataUp][leftSide]	_ Get[	"DLeftSide" ];
tiles.glue	[dataUp][between]	_ Get[	"DBetween" ];
tiles.glue	[dataUp][rightSide]	_ Get[	"DRightSide" ];
tiles.and	[dataUp][left]		_ Get[	"DAndLt" ];
tiles.and	[dataUp][right]		_ Get[	"DAndRt" ];
tiles.and	[dataUp][nc]			_ Get[	"DAnd" ];
tiles.and	[dataUp][extra]		_ Get[	"DAndEx" ];
tiles.or	[dataUp][left]		_ Get[	"DOr" ];
tiles.or	[dataUp][nc]			_ Get[	"DOrNC" ];
tiles.or	[dataUp][extra]		_ Get[	"DOrEx" ];

tiles.glue	[dataDn][leftSide]	_				tiles.glue	[dataUp][leftSide];
tiles.glue	[dataDn][between]	_ PW.FlipY[	tiles.glue	[dataUp][between]	];
tiles.glue	[dataDn][rightSide]	_ PW.FlipY[	tiles.glue	[dataUp][rightSide]	];
tiles.and	[dataDn][left]		_				tiles.and	[dataUp][left];
tiles.and	[dataDn][right]		_				tiles.and	[dataUp][right];
tiles.and	[dataDn][nc]			_				tiles.and	[dataUp][nc];
tiles.and	[dataDn][extra]		_				tiles.and	[dataUp][extra];
tiles.or	[dataDn][left]		_ PW.FlipY[	tiles.or	[dataUp][left]		];
tiles.or	[dataDn][nc]			_ PW.FlipY[	tiles.or	[dataUp][nc]			];
tiles.or	[dataDn][extra]		_ PW.FlipY[	tiles.or	[dataUp][extra]		];
RETURN[tiles]};

GetHotPLATiles: PROC RETURNS[tiles: REF TileVarieties] = {
Get: PROC[name: ROPE] RETURNS[CD.Object] = 
{RETURN[PW.Get[design: library.design, name: name ]]};
library: CoreLibrary.Library _ IFUCoreCells.library;
IF hotTileBuffer # NIL THEN RETURN[hotTileBuffer];
log.PutRope["\n Initialize hot PLA tiles"];
tiles		_ hotTileBuffer _ NEW[TileVarieties];
tiles.glue	_ NEW[GlueTiles];
tiles.and	_ NEW[NormalTiles];
tiles.or	_ NEW[NormalTiles];

tiles.glue	[header][leftSide]	_ Get[	"HPlaHLeftSide" ];
tiles.glue	[header][between]	_ Get[	"HPlaHBetween" ];
tiles.glue	[header][rightSide]	_ Get[	"HPlaHRightSide" ];
tiles.and	[header][nc]			_ Get[	"HPlaHAnd" ];
tiles.or	[header][nc]			_ Get[	"HPlaHOr" ];
tiles.or	[header][extra]		_ Get[	"HPlaHOrEx" ];

tiles.glue	[footer][leftSide]		_ PW.FlipY[	tiles.glue	[header][leftSide]	];
tiles.glue	[footer][between]	_ PW.FlipY[	tiles.glue	[header][between]	];
tiles.glue	[footer][rightSide]	_ PW.FlipY[	tiles.glue	[header][rightSide]	];
tiles.and	[footer][nc]			_ PW.FlipY[	tiles.and	[header][nc]			];
tiles.or	[footer][nc]			_ PW.FlipY[	tiles.or	[header][nc]			];
tiles.or	[footer][extra]		_ PW.FlipY[	tiles.or	[header][extra]		];

tiles.glue	[blank][leftSide]		_ Get[	"HPlaBLeftSide" ];
tiles.glue	[blank][between]	_ Get[	"HPlaBBetween" ];
tiles.glue	[blank][rightSide]	_ Get[	"HPlaBRightSide" ];
tiles.and	[blank][nc]			_ Get[	"HPlaBAnd" ];
tiles.or	[blank][nc]			_ Get[	"BOr" ];
tiles.or	[blank][extra]		_ Get[	"HPlaBOrEx" ];

tiles.glue	[conn][leftSide]		_ Get[	"HPlaBLeftSide" ];
tiles.glue	[conn][between]		_ Get[	"HPlaBBetween" ];
tiles.glue	[conn][rightSide]	_ Get[	"HPlaCRightSide" ];
tiles.and	[conn][left]			_ Get[	"CAndLt" ];
tiles.and	[conn][right]		_ Get[	"CAndRt" ];
tiles.and	[conn][nc]			_ Get[	"BAnd" ];
tiles.or	[conn][left]			_ Get[	"COr" ];
tiles.or	[conn][nc]			_ Get[	"COrNC" ];
tiles.or	[conn][extra]			_ Get[	"HPlaCOrEx" ];

tiles.glue	[dataUp][leftSide]	_ Get[	"HPlaDLeftSide" ];
tiles.glue	[dataUp][between]	_ Get[	"HPlaDBetween" ];
tiles.glue	[dataUp][rightSide]	_ Get[	"HPlaDRightSide" ];
tiles.and	[dataUp][left]		_ Get[	"DAndLt" ];
tiles.and	[dataUp][right]		_ Get[	"DAndRt" ];
tiles.and	[dataUp][nc]			_ Get[	"DAnd" ];
tiles.or	[dataUp][left]		_ Get[	"DOr" ];
tiles.or	[dataUp][nc]			_ Get[	"DOrNC" ];
tiles.or	[dataUp][extra]		_ Get[	"HPlaDOrEx" ];

tiles.glue	[dataDn][leftSide]	_				tiles.glue	[dataUp][leftSide];
tiles.glue	[dataDn][between]	_ PW.FlipY[	tiles.glue	[dataUp][between]	];
tiles.glue	[dataDn][rightSide]	_ PW.FlipY[	tiles.glue	[dataUp][rightSide]	];
tiles.and	[dataDn][left]		_				tiles.and	[dataUp][left];
tiles.and	[dataDn][right]		_				tiles.and	[dataUp][right];
tiles.and	[dataDn][nc]			_				tiles.and	[dataUp][nc];
tiles.and	[dataDn][extra]		_				tiles.and	[dataUp][extra];
tiles.or	[dataDn][left]		_ PW.FlipY[	tiles.or	[dataUp][left]		];
tiles.or	[dataDn][nc]			_ PW.FlipY[	tiles.or	[dataUp][nc]			];
tiles.or	[dataDn][extra]		_ PW.FlipY[	tiles.or	[dataUp][extra]		];
RETURN[tiles]};
log: IO.STREAM _ CoreFrame.GetLog[];

END. 



IFUCoreCtlPreCharge.mesa, 
Copyright c 1986 by Xerox Corporation.  All rights reserved.
Last Edited by Curry, July 18, 1986 10:44:02 am PDT

rowList _ CONS[PW.SharedAbutListX[PW.Reverse[objects]], rowList]
desc.body _ PW.SharedAbutListY[PW.Reverse[rowList]];




�ÊɘšÏbÐblœ™Jš
œ<™<Jš
œ3™3—J™JšÏk	œ…
ŸœŸœ˜Â
J˜š�œŸœ
Ÿ˜"JšŸœfŸœŸœ˜ 
JšŸœ
˜Jš
Ÿ˜J˜JšŸœŸœŸœ
˜JšœŸœ˜!Jšœ	Ÿœ
˜Jšœ	Ÿœ˜ JšœŸœ˜1Jšœ
Ÿœ˜*Jšœ
Ÿœ˜&Jšœ
Ÿœ˜$Jšœ
Ÿœ˜%JšœŸœ˜)Jšœ
Ÿœ˜&JšœŸœ˜ Jšœ
Ÿœ˜%JšœŸœ˜JšœŸœ˜)J˜JšœŸœŸœ
˜J˜Jš
�˜šÏnœŸœ
Ÿœ˜8Jšœ*Ÿœ˜>Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜—J˜š 
œŸœ˜+Jšœ
ŸœŸœ/˜EšŸœ&ŸœŸœ
Ÿ˜FJš
ŸœŸœ
Ÿœ#ŸœŸœ˜R——J˜š œŸœ˜6Jš
œA˜AJš
œ*˜*šŸœŸœ
Ÿœ˜+JšŸœ'Ÿœ
˜1—šŸœŸœ
ŸœŸ˜/JšœŸœ˜#JšœQŸœ
˜Y—šŸœ8ŸœŸœ
Ÿ˜LšŸœŸœ
ŸœŸ˜.JšœŸœ#Ÿœ
Ÿœ˜R———J˜šœŸœŸœ
˜ JšœŸœ
Ïc$˜@JšœŸœ¡&˜CJšœŸœ	˜JšœŸœ¡˜5JšœŸœ
¡˜.Jšœ
ŸœŸœ¡˜4—Jš
œŸœŸœ
ŸœŸœ
Ÿœ
Ÿœ	˜@šœŸœŸœ
˜JšœŸœ
˜Jš
œ˜Jš
œ˜Jš
œ˜—Jšœ
ŸœŸœ˜"Jšœ
ŸœŸœ
ŸœŸœ
Ÿœ˜FJ˜š 
œŸœ˜.šœŸœŸœ˜5Jš
œ"˜"Jš
œ˜Jšœ
ŸœŸœŸœ¡˜U—JšœŸœŸœ
˜Jšœ	Ÿœ˜Jšœ	ŸœŸœ
˜Jšœ
ŸœŸœ5˜HJšœ	Ÿœ%˜1JšœŸœ&˜4JšœŸœ˜*JšœŸœ
˜JšœŸœ)˜8JšœŸœ<˜KJš
œ6˜6Jš
œ˜Jš
œ<˜<Jš
œ:˜:JšœŸœ+˜:Jšœ¡˜+šŸœ
Ÿœ
¡2˜GJšœŸœ;˜EšŸœ	˜JšŸœ
Ÿ˜JšŸœ:˜>—Jš
œ'˜'Jš
œ4˜4šŸœŸ˜JšœŸœ
˜JšœŸœ)˜4JšœŸœ)˜4šŸœŸ˜Jšœ
ŸœŸœ
Ÿœ
˜-—Jš
œ˜šŸœŸ˜Jš
œ%˜%Jš
œ4˜4JšŸœ
˜—Jšœ	Ÿœ
˜šŸœŸ˜JšœŸœŸœŸœ	˜BJš
œ4˜4Jšœ	Ÿœ˜JšŸœ
˜—JšŸœ
˜—JšŸœ
˜—JšŸœ	Ÿœ
Ÿœ
˜Jš
œ(˜(—J˜š œŸœ'ŸœŸœ˜PJšœŸœŸœ˜-JšœŸœ˜"Jš
œ˜Jš
œ˜JšœŸœ˜"Jšœ
Ÿœ˜*JšŸœŸœ
Ÿœ˜AšŸœŸ˜Jš
œ˜Jš
œ;˜;š
œ˜Jš
œ˜Jšœ	Ÿœ
˜
JšŸœŸœ
Ÿœ˜*—JšŸœ
˜—šŸœŸœŸ˜#šŸœŸœ˜'JšŸœ˜ šŸœ˜šŸœŸ˜šœŸœOŸ˜kJš
œ˜Jš
œ˜JšŸœ˜—šœ	ŸœŸœ˜0JšŸœ˜šŸœ
Ÿœ˜JšŸœ˜JšŸœ˜——JšŸœ˜#—JšœŸœ
˜———š	ŸœŸœ
ŸœŸœŸ˜;šŸœŸœ˜(JšŸœ˜ šŸœ˜Jš
œ˜šŸœ!Ÿœ˜)šŸœŸœŸœ˜4Jš
œQ˜QJšŸœ˜—šŸœŸœŸœ%˜GJšŸœ˜——JšœŸœ˜———J˜—š œŸœŸœ˜HJšœŸœŸœ˜-Jš
œ˜JšŸœŸœ
Ÿœ!˜1—J˜š œŸœŸœ˜IJšœŸœŸœ˜-Jš
œ!˜!Jš
œ˜—J˜š 
œŸœ˜*JšœŸœŸœ˜-JšœŸœ ˜)šŸœŸœŸ˜7Jš
œ*˜*šŸœŸ˜š
œ˜JšŸœ'Ÿœ
Ÿœ
˜4Jš
œ#˜#š
œ
˜
JšŸœ
ŸœE˜M——š
œ˜JšŸœ'Ÿœ
Ÿœ
˜3š
œ
˜
JšŸœ
ŸœE˜M——š
œ˜JšŸœ'Ÿœ
Ÿœ
˜4Jš
œ˜JšœŸœ'˜9—JšŸœŸœ
˜—JšŸœ˜	——J˜š œŸœ˜'JšœŸœ*˜4šŸœ3Ÿœ
Ÿ˜?Jš
œ˜JšœŸœ+˜6JšœŸœŸœ˜.Jš
œ˜Jšœ	Ÿœ
Ÿœ
˜Jš
œ8˜8šŸœŸœ
ŸœŸ˜)Jšœ	Ÿœ
Ÿœ
˜JšœŸœ˜$JšŸœŸœ
Ÿœ(˜HJšœ
Ÿœ*˜8šŸœŸœ
ŸœŸ˜&Jšœ
Ÿœ/Ÿœ
˜E—šŸœŸœ˜Jšœ
Ÿœ)˜7šŸœŸœ
ŸœŸ˜%Jšœ
Ÿœ-Ÿœ
˜C—Jšœ
Ÿœ-˜;—Jšœ
Ÿœ
ŸœŸœ™@Jšœ
Ÿœ
ŸœŸœ˜:JšŸœ
˜—JšœŸœŸœ™4JšœŸœŸœ˜.Jš
œ˜Jš
œ5˜5Jš
œ-˜-Jš
œ&˜&Jš
œR˜RJš
œ+˜+—Jš
œ-˜-—J˜JšœŸœ˜%JšœŸœ˜%JšœŸœ˜%JšœŸœ˜'JšœŸœ#˜5JšœŸœ ˜/JšŸœŸœ˜%JšŸœŸœ˜%J™š 
œŸœ˜*š
 œŸœŸœ	ŸœŸœ
˜<Jš
œ
ŸœŸœ
Ÿœ
Ÿœ
Ÿœ
Ÿœ˜?—JšœŸœŸœ˜/Jšœ	Ÿœ+˜7JšœŸœ-˜;Jšœ
Ÿœ'˜4JšœŸœ*˜9Jšœ	Ÿœ/˜;Jšœ
Ÿœ0˜=JšœŸœ.˜9šœ 
œ˜$JšœŸœ6˜?Jš
œ˜JšœŸœ
˜	Jš
œ˜Jš
œ:˜:šŸœŸ˜JšŸœŸœ
˜JšŸœŸœ
˜š
œ˜JšœŸœ
˜JšœŸœ
˜
šŸœ	Ÿœ
ŸœŸ˜'šŸœŸ˜ Jšœ)Ÿœ˜/Jšœ%Ÿœ˜+Jšœ*Ÿœ˜0Jšœ#Ÿœ˜)JšœŸœŸœ˜)JšŸœ˜—JšœŸ
˜JšŸœŸœ
Ÿœ
˜Jš
œ7˜7Jšœ(Ÿœ
Ÿœ
˜8—Jš
œ
˜
—Jš
œ˜š
œ˜JšœŸœ
˜JšœŸœ
Ÿœ
Ÿœ˜%JšœŸœ
˜
Jš
œ>˜>Jš
œ8˜8šŸœŸ˜JšŸœŸœ
Ÿœ
Ÿœ
˜Jšœ%Ÿœ
˜-—JšœŸœŸœŸœ˜6JšŸœŸœ
˜$Jš
œ)˜)JšŸœ˜—Jš
œ3˜3Jš
œQ˜QJš
œL˜LJšŸœŸœ˜——Jšœ œ˜6—J˜Jšœ
Ÿœ˜JšœŸœ˜!Jš	œŸœŸœŸœŸœ˜MJš
œŸœŸœ	Ÿœ
ŸœŸœ
Ÿœ˜EJšœŸœ"˜4Jš
œŸœŸœ	Ÿœ
ŸœŸœ
Ÿœ˜HJšœŸœ˜0J˜š œŸœŸœŸœ˜FšœŸœŸ˜Jš
œ˜JšŸœ˜$——J˜š œŸœ
ŸœŸœ˜Aš
 œŸœŸœŸœ
Ÿœ˜+Jšœ
Ÿœ
Ÿœ,˜6—Jš
œ4˜4JšŸœŸœ
Ÿœ
Ÿœ
˜,Jš
œ2˜2JšœŸœ˜)Jšœ
Ÿœ˜JšœŸœ˜JšœŸœ˜J˜Jš
œ4˜4Jš
œ2˜2Jš
œ1˜1Jš
œ*˜*Jš
œ.˜.Jš
œ(˜(Jš
œ,˜,J˜Jš
œ3˜3Jš
œ1˜1Jš
œ5˜5Jš
œ)˜)Jš
œ-˜-Jš
œ'˜'Jš
œ+˜+J˜Jšœ!Ÿœ(˜KJšœŸœ'˜HJšœ!Ÿœ)˜LJšœŸœ#˜@JšœŸœ%˜DJšœŸœ"˜>JšœŸœ$˜BJ˜Jš
œ3˜3Jš
œ0˜0Jš
œ/˜/Jš
œ(˜(Jš
œ,˜,Jš
œ&˜&Jš
œ*˜*J˜Jš
œ2˜2Jš
œ0˜0Jš
œ3˜3Jš
œ+˜+Jš
œ+˜+Jš
œ'˜'Jš
œ,˜,Jš
œ'˜'Jš
œ'˜'Jš
œ*˜*J˜Jš
œ3˜3Jš
œ1˜1Jš
œ5˜5Jš
œ,˜,Jš
œ-˜-Jš
œ)˜)Jš
œ-˜-Jš
œ(˜(Jš
œ)˜)Jš
œ+˜+J˜Jš
œA˜AJšœŸœ'˜HJšœ!Ÿœ)˜LJš
œ8˜8Jš
œ:˜:Jš
œ5˜5Jš
œ:˜:JšœŸœ#˜@JšœŸœ"˜>JšœŸœ$˜BJšŸœ	˜—J˜š œŸœ
ŸœŸœ˜:š
 œŸœŸœŸœ
Ÿœ˜+Jšœ
Ÿœ
Ÿœ,˜6—Jš
œ4˜4JšŸœŸœ
Ÿœ
Ÿœ˜2Jš
œ+˜+JšœŸœ˜,Jšœ
Ÿœ˜JšœŸœ˜JšœŸœ˜J˜Jš
œ7˜7Jš
œ5˜5Jš
œ9˜9Jš
œ-˜-Jš
œ+˜+Jš
œ/˜/J˜Jšœ!Ÿœ(˜KJšœŸœ'˜HJšœ!Ÿœ)˜LJšœŸœ#˜@JšœŸœ"˜>JšœŸœ$˜BJ˜Jš
œ7˜7Jš
œ4˜4Jš
œ8˜8Jš
œ,˜,Jš
œ&˜&Jš
œ.˜.J˜Jš
œ6˜6Jš
œ4˜4Jš
œ7˜7Jš
œ+˜+Jš
œ+˜+Jš
œ'˜'Jš
œ'˜'Jš
œ'˜'Jš
œ.˜.J˜Jš
œ7˜7Jš
œ5˜5Jš
œ9˜9Jš
œ,˜,Jš
œ-˜-Jš
œ)˜)Jš
œ(˜(Jš
œ)˜)Jš
œ/˜/J˜Jš
œA˜AJšœŸœ'˜HJšœ!Ÿœ)˜LJš
œ8˜8Jš
œ:˜:Jš
œ5˜5Jš
œ:˜:JšœŸœ#˜@JšœŸœ"˜>JšœŸœ$˜BJšŸœ	˜—J™JšœŸœ
Ÿœ˜$J™J˜JšŸœ˜—J™J˜J˜—…—H[ï