DIRECTORY 
CCDUtils, CD, CDOrient, Core, CoreFrame, CoreGlue, CoreName, CoreLibrary, Dragon, IFUCoreCtl, IFUCoreDrive, IFUCorePads, IFUSrc, IO, PW;

IFUSrcComplete: CEDAR PROGRAM	
IMPORTS CCDUtils, CDOrient, CoreFrame, CoreGlue, CoreName, CoreLibrary, IFUCoreCtl, IFUCoreDrive, IFUCorePads, IFUSrc, IO, PW
EXPORTS IFUSrc =
BEGIN

ROPE:			TYPE = Core.ROPE;
PadsType:	TYPE = IFUCorePads.PadsType;
PadRec:		TYPE = IFUCorePads.PadRec;
Side:			TYPE = CoreFrame.Side;
CellType:		TYPE = Core.CellType;
Ph:			TYPE = CoreName.Ph;
DrGate:		TYPE = IFUCoreDrive.DrGate;
GND:			ROPE _ CoreName.RopeNm["GND"];
VDD:			ROPE _ CoreName.RopeNm["VDD"];
NRjt:			ROPE _ CoreName.RopeNm["NotDPRejectBA"];

Signal: SIGNAL = CODE;

MakePads: PROC[name: ROPE, side: Side, pads: LIST OF PadRec]
RETURNS[cellType: CellType] = {
PadCell: PROC[pad: PadRec] =
{pad.side _ side; cnt _ cnt-1; new.seq[cnt] _ IFUCorePads.CellProc[data: pad]};
Sig: PROC RETURNS[pad: PadRec] = {pad _ list.first; list _ list.rest};
ltOrRt:	BOOL _ side=left OR side=right;
list:		LIST OF PadRec;
new:		CoreFrame.Frame;
cnt:		INT _ 0;
list _ pads; pads _ NIL;
FOR list _ list, list.rest WHILE list # NIL DO
cnt _ cnt+1; pads _ CONS[list.first, pads] ENDLOOP; -- count and reverse list
IF cnt#32 THEN ERROR;
IF ltOrRt
THEN {
cnt _ 32+15;
cellType	_ CoreFrame.NewFrameCell[ name: name, rec: [first: bottom],	size: cnt ]}
ELSE {
cnt _ 32+15+2;	-- corners on top and bottom
cellType	_ CoreFrame.NewFrameCell[ name: name, rec: [first: left],		size: cnt ]};
new		_ CoreFrame.FCT[cellType];
list _ pads;
IF NOT ltOrRt THEN PadCell[[type: corHi ]];
									PadCell[ Sig[] ];		PadCell[ Sig[] ];
PadCell[[type: gnd			]];	PadCell[ Sig[] ];		PadCell[ Sig[] ];
PadCell[[type: padgnd		]];	PadCell[ Sig[] ];		PadCell[ Sig[] ];
PadCell[[type: padvdd		]];	PadCell[ Sig[] ];		PadCell[ Sig[] ];
PadCell[[type: vdd			]];	PadCell[ Sig[] ];		PadCell[ Sig[] ];
PadCell[[type: vdd			]];	PadCell[ Sig[] ];		PadCell[ Sig[] ];
PadCell[[type: padvdd		]];	PadCell[ Sig[] ];		PadCell[ Sig[] ];
PadCell[[type: padgnd		]];	PadCell[ Sig[] ];		PadCell[ Sig[] ];
PadCell[[type: gnd			]];	PadCell[ Sig[] ];		PadCell[ Sig[] ];
PadCell[[type: padgnd		]];	PadCell[ Sig[] ];		PadCell[ Sig[] ];
PadCell[[type: padvdd		]];	PadCell[ Sig[] ];		PadCell[ Sig[] ];
PadCell[[type: vdd			]];	PadCell[ Sig[] ];		PadCell[ Sig[] ];
PadCell[[type: vdd			]];	PadCell[ Sig[] ];		PadCell[ Sig[] ];
PadCell[[type: padvdd		]];	PadCell[ Sig[] ];		PadCell[ Sig[] ];
PadCell[[type: padgnd		]];	PadCell[ Sig[] ];		PadCell[ Sig[] ];
PadCell[[type: gnd			]];	PadCell[ Sig[] ];		PadCell[ Sig[] ];
IF NOT ltOrRt THEN PadCell[[type: corLo ]];
IF list#NIL OR cnt#0 THEN ERROR };

PadLt: PUBLIC PROC RETURNS[cellType: CellType] = {
pads: LIST OF PadRec _ NIL;
name:	ROPE _ CoreName.RopeNm["IFUPadLt"];
IF (cellType _ CoreFrame.ReadFrameCache[name])#NIL THEN RETURN;
IF Dragon.PBusCommands[Fetch].ORD#16 THEN Signal[];

pads _ CONS[ [type: empty],												pads];
pads _ CONS[ [type: empty],												pads];
pads _ CONS[ [type: empty],												pads];
pads _ CONS[ [type: empty],												pads];
pads _ CONS[ [type: empty],												pads];
pads _ CONS[ [type: empty],												pads];
pads _ CONS[ [type: empty],												pads];
pads _ CONS[ [type: empty],												pads];

pads _ CONS[ [type: empty],												pads];
pads _ CONS[ [type: empty],												pads];
pads _ CONS[ [type: empty],												pads];
pads _ CONS[ [type: empty],												pads];
pads _ CONS[ [type: empty],												pads];
pads _ CONS[ [type: empty],												pads];
pads _ CONS[ [type: empty],												pads];
pads _ CONS[ [type: empty],												pads];

pads _ CONS[ [type: in,	data1: "IPRejectB"],							pads];
pads _ CONS[ [type: in,	data1: "IPFaultingB"],						pads];
pads _ CONS[ [type: out,	data2: "NewFetchBAA"],					pads];
pads _ CONS[ [type: in,	data1: "ResetAB"],							pads];
pads _ CONS[ [type: in,	data1: "RescheduleAB"],					pads];
pads _ CONS[ [type: conn,	data1: "VBB"],								pads];
pads _ CONS[ [type: in,	data1: IFUSrc.dShIn],						pads];
pads _ CONS[ [type: out,	data2: IFUSrc.dShOut],						pads];

pads _ CONS[ [type: conn,	data1: "PhA"],								pads];
pads _ CONS[ [type: conn,	data1: "PhB"],								pads];
pads _ CONS[ [type: conn,	data1: "NotPhA"],							pads];
pads _ CONS[ [type: conn,	data1: "NotPhB"],							pads];
pads _ CONS[ [type: conn,	data1: "DShA"],								pads];
pads _ CONS[ [type: conn,	data1: "DShB"],								pads];
pads _ CONS[ [type: conn,	data1: "DShRd"],								pads];
pads _ CONS[ [type: conn,	data1: "DShWt"],								pads];

cellType _ MakePads[name, left, pads];
CoreFrame.WriteFrameCache[cellType]};

PadRt: PUBLIC PROC RETURNS[cellType: CellType] = {
pads:	LIST OF PadRec _ NIL;
name:	ROPE _ CoreName.RopeNm["IFUPadRt"];
IF (cellType _ CoreFrame.ReadFrameCache[name])#NIL THEN RETURN;

pads _ CONS[ [type: conn,	data1: "FireControlV"],						pads];
pads _ CONS[ [type: conn,	data1: "NotPreChg"],						pads];
pads _ CONS[ [type: empty],												pads];
pads _ CONS[ [type: in,	data1: "DPRejectB"],							pads];
pads _ CONS[ [type: in,	data1: "DPFaultB.3"],						pads];
pads _ CONS[ [type: in,	data1: "DPFaultB.2"],						pads];
pads _ CONS[ [type: in,	data1: "DPFaultB.1"],						pads];
pads _ CONS[ [type: in,	data1: "DPFaultB.0"],						pads];

pads _ CONS[ [type: out,	data2: "DPCmnd3ABB.7"], pads];
pads _ CONS[ [type: out,	data2: "DPCmnd3ABB.6"], pads];
pads _ CONS[ [type: out,	data2: "DPCmnd3ABB.5"], pads];
pads _ CONS[ [type: out,	data2: "DPCmnd3ABB.4"], pads];
pads _ CONS[ [type: out,	data2: "DPCmnd3ABB.3"], pads];
pads _ CONS[ [type: out,	data2: "DPCmnd3ABB.2"], pads];
pads _ CONS[ [type: out,	data2: "DPCmnd3ABB.1"], pads];
pads _ CONS[ [type: out,	data2: "DPCmnd3ABB.0"], pads];

pads _ CONS[ [type: empty],												pads];
pads _ CONS[ [type: empty],												pads];

pads _ CONS[ [type: out,	data2: "EUAluOp2ABB.0"],					pads];
pads _ CONS[ [type: out,	data2: "EUAluOp2ABB.1"],					pads];
pads _ CONS[ [type: out,	data2: "EUAluOp2ABB.2"],					pads];
pads _ CONS[ [type: out,	data2: "EUAluOp2ABB.3"],					pads];

pads _ CONS[ [type: out,	data2: "EUCondSel2ABB.0"],					pads];
pads _ CONS[ [type: out,	data2: "EUCondSel2ABB.1"],					pads];
pads _ CONS[ [type: out,	data2: "EUCondSel2ABB.2"],					pads];
pads _ CONS[ [type: out,	data2: "EUCondSel2ABB.3"],					pads];  

pads _ CONS[ [type: empty],												pads];
pads _ CONS[ [type: empty],												pads];
pads _ CONS[ [type: empty],												pads];
pads _ CONS[ [type: out,	data2: "EUCondition2B"],					pads];
pads _ CONS[ [type: out,	data2: "EURes3BisPBus3ABB"],				pads];
pads _ CONS[ [type: out,	data2: "EUWriteToPBus3ABB"],				pads];

cellType _ MakePads[name, right, pads];
CoreFrame.WriteFrameCache[cellType]};


PadTop: PUBLIC PROC RETURNS[cellType: CellType] = {
pads: LIST OF PadRec _ NIL;
name:	ROPE _ CoreName.RopeNm["IFUPadTop"];
IF (cellType _ CoreFrame.ReadFrameCache[name])#NIL THEN RETURN;
FOR i: INT DECREASING IN [0..32) DO
in:		ROPE _ IO.PutFR["IPData.%02b", IO.int[i] ];
out:	ROPE _ IO.PutFR["IPAddr.%02b", IO.int[i] ];
pads _ CONS[ [type: triOut, data1: out, data2: in, enWtA: VDD, enWtB: GND], pads];
ENDLOOP;
cellType _ MakePads[name, top, pads];
CoreFrame.WriteFrameCache[cellType]};

PadBot: PUBLIC PROC RETURNS[cellType: CellType] = {
enWtA:	ROPE _ "NotKPadsIn3BA";
enRd:		ROPE _ "KPadsIn4Ac";
disRd:		ROPE _ "NotKPadsIn4Ac";
pads: LIST OF PadRec _ NIL;
name:	ROPE _ CoreName.RopeNm["IFUPadBot"];
IF (cellType _ CoreFrame.ReadFrameCache[name])#NIL THEN RETURN;
FOR i: INT DECREASING IN [0..32) DO
in:			ROPE _ IO.PutFR["XBus.%02b", IO.int[i] ];
out:		ROPE _ IO.PutFR["XBus.%02b", IO.int[i] ];
pads _ CONS[[type: triIO, data1: in, data2: out, enWtA: enWtA, enWtB: VDD], pads];
ENDLOOP;
cellType _ MakePads[name, bottom, pads];
CoreFrame.WriteFrameCache[cellType]};

PadExt: PROC[side1, side2: Side] RETURNS[cellType: CellType] = {
cellType _ CoreFrame.NewFrameCells[name:CoreName.ID["PadExt"],
rec:[	-- starts in top-left
first:		left,
orient:	CDOrient.ComposeOrient[
SELECT side1 FROM
top		=> CDOrient.original,
bottom	=> CDOrient.mirrorY,
left		=> CDOrient.rotate270X,
right		=> CDOrient.rotate270, ENDCASE => ERROR,
SELECT side2 FROM
top		=> CDOrient.original,
bottom	=> CDOrient.mirrorY,
left		=> CDOrient.original,
right		=> CDOrient.mirrorX, ENDCASE => ERROR] ],
cells: LIST[
IFUCorePads.CellProc[data: [type: ext, side: top]],
CoreGlue.CellProc[r: ext, l: conn] ] ] };

Interlock: PUBLIC PROC [sIn: ROPE, altOut: ROPE _ NIL]
RETURNS [cellType: CellType, sOut: ROPE] = {
name:	ROPE _ CoreName.RopeNm["IFUPLAInterlock"];
IF altOut#NIL THEN Signal[];
IF (cellType _ CoreFrame.ReadFrameCache[name])=NIL THEN {
dr: IFUCoreDrive.Drive;
desc:	IFUCoreCtl.PLADescription _ NEW[IFUCoreCtl.PLADescriptionRec _
[name: "IFUPLAInterlock", plaPhs: [BA, B, BAA, B, BA] ] ];
desc.plaType				_ hot ;
desc.inSh					_ sIn;
IFUCoreCtl.MakePLA1[desc];
dr _ IFUCoreDrive.FindDrive[desc.inDrs,	"CIsField2BA"];		dr.in.ph	_ AB;
dr _ IFUCoreDrive.FindDrive[desc.inDrs,	"CIsField3BA"];		dr.in.ph	_ AB;
dr _ IFUCoreDrive.FindDrive[desc.inDrs,	"A1IsC2BA"];		dr.in.ph	_ B;
dr _ IFUCoreDrive.FindDrive[desc.inDrs,	"A1IsC3BA"];		dr.in.ph	_ B;
dr _ IFUCoreDrive.FindDrive[desc.inDrs,	"B1IsC2BA"];			dr.in.ph	_ B;
dr _ IFUCoreDrive.FindDrive[desc.inDrs,	"B1IsC3BA"];			dr.in.ph	_ B;
IFUCoreCtl.MakePLA2[desc];
sOut			_ desc.outSh;
cellType		_ IFUCoreCtl.CellProc[complete, desc];
[ ] _ CoreName.CellNm[cellType, name];
IFUCoreDrive.SetDShiftIO[cellType, sIn, sOut];
CoreFrame.WriteFrameCache[cellType]};
[sIn, sOut] _ IFUCoreDrive.GetDShiftIO[cellType];
cellType _ CoreFrame.NewFrameCells[ name: "InterlockFillX", rec: [first: left], cells: LIST[
CoreGlue.CellProc[l: ext, r: conn],
cellType ]]};

MainPipeControl: PUBLIC PROC [sIn: ROPE, altOut: ROPE _ NIL]
RETURNS [cellType: CellType, sOut: ROPE] = {
name:	ROPE _ CoreName.RopeNm["IFUPLAMainPipeControl"];
IF altOut#NIL THEN Signal[];
IF (cellType _ CoreFrame.ReadFrameCache[name])=NIL THEN {
dr: IFUCoreDrive.Drive;
desc:	IFUCoreCtl.PLADescription _ NEW[IFUCoreCtl.PLADescriptionRec _
[name: "IFUPLAMainPipeControl", plaPhs: [BA, B, BAA, B, BA] ] ];
desc.plaType				_ hot ;
desc.nofTermCols		_ 3;
desc.fullWidthTerms	_ FALSE;
IFUCoreCtl.MakePLA1[desc];
dr _ IFUCoreDrive.FindDrive[desc.inDrs, "DPFaultedBA"];	dr.name _ "DPFault"; dr.idx _ 0;
dr _ IFUCoreDrive.FindDrive[desc.inDrs, "Push2BA"];							dr.in.ph _ AB;
dr _ IFUCoreDrive.FindDrive[desc.inDrs, "MicroExcptJmpBubbleBA"];		dr.in.ph _ AB;
dr _ IFUCoreDrive.FindDrive[desc.inDrs, "Stage2BAbortBA"];					dr.in.ph _ AB;
IFUCoreDrive.AdjustDriveOutPh[desc.outDrs, "
Stage2ANormalBA		Stage2ABubbleBA
Stage3ANormalBA		Stage3AAbortBA
LoadStage1Ac
LoadStage2Ac
LoadStage3Ac
X2ASrcLit2Ac			NotX2ASrcLit2Ac
Stage1BHoldingAB		NotStage1BHoldingAB
Stage2BNormalAB 		Stage2BAbortAB
Stage3BCPipeNormalAB	Stage3BCPipeAbortAB
MicroExcptJmpNoneAB
MicroExcptJmpMicroJumpAB
MicroExcptJmpBubbleAB
MicroExcptJmpResettingAB
MicroExcptJmpTrapAB
MicroExcptJmpCJumpAB
ExceptTypeSpecialCodeAB ExceptTypeCondCodeAB ExceptTypeDpFaultAB
ExceptCodeAB.0	ExceptCodeAB.1	ExceptCodeAB.2	ExceptCodeAB.3 " ];
dr _ IFUCoreDrive.FindDrive[desc.outDrs, "BcLoadStage1BA"];
dr.name		_ "LoadStage";
dr.dualOut	_ FALSE;
dr.gate		_ negBc;
dr.in	_ [pos,	A];
dr.ref	_ [neg,	A];
dr.out	_ [pos,	Bc];
IFUCoreCtl.MakePLA2[desc];
sOut			_ desc.outSh;
cellType		_ IFUCoreCtl.CellProc[complete, desc];
[ ] _ CoreName.CellNm[cellType, name];
IFUCoreDrive.SetDShiftIO[cellType, sIn, sOut];
CoreFrame.WriteFrameCache[cellType]};
[sIn, sOut] _ IFUCoreDrive.GetDShiftIO[cellType];
cellType _ CoreFrame.NewFrameCells[name: "MainPipeControlFillX", rec:[first:left], cells:LIST[
CoreGlue.CellProc[l: ext, r: conn],
cellType ]]};

LtDrPadIO: PUBLIC PROC[sIn: ROPE, altOut: ROPE _ NIL]
RETURNS [cellType: CellType, sOut: ROPE] = {
name:	ROPE _ CoreName.RopeNm["IFULtDrPadIOCore"];
IF altOut#NIL THEN Signal[];
IF (cellType _ CoreFrame.ReadFrameCache[name])=NIL THEN {
Drive: PROC[dir: IFUCoreDrive.Dir, in, out: ROPE, inverted, dual: BOOL _ FALSE] = {
drives _ CONS[IFUCoreDrive.SpecificDrive[dir, in, out, inverted, dual], drives]};
drives:		IFUCoreDrive.Drives _ NIL;
toInside:		IFUCoreDrive.Dir = out;
toOutside:	IFUCoreDrive.Dir = in;
Drive[toInside,	"IPRejectB",			"IPRejectBA"];
Drive[toInside,	"IPFaultingB",		"IPFaultingBA"];
Drive[toOutside,	"NewFetchBA",		"NewFetchBAA"];
Drive[toInside,	"ResetAB",			"ResetBA",				FALSE, TRUE];
Drive[toInside,	"RescheduleAB",	"RescheduleBA"];
Drive[toInside,	NIL,					"DebugOpStatus"];
Drive[toInside,	NIL,					"DebugABGD"];
Drive[toInside,	NIL,					"DebugPC"];
Drive[toInside,	NIL,					"DebugLSC"];
Drive[toInside,	NIL,					"DebugABStLim"];

Drive[toOutside,	"KPadsIn3BA",		"KPadsIn3BAA"];
Drive[toInside,	"KPadsIn3BAA",		"NotKPadsIn3BA",	TRUE];
Drive[toInside,	"KPadsIn3BAA",		"KPadsIn4Ac",	FALSE, TRUE];
Drive[toInside,	"KPadsIn3BAA",		"KPadsIn4Ac",	FALSE, TRUE];
Drive[toInside,	"KPadsIn3BAA",		"KPadsIn4Ac",	FALSE, TRUE];
Drive[toInside,	"KPadsIn3BAA",		"KPadsIn4Ac",	FALSE, TRUE];
[drives, sOut] _ IFUCoreDrive.CapDrives[drives, sIn];
cellType	_ IFUCoreDrive.DrivesToFrame[name, drives];
IFUCoreDrive.SetDShiftIO[cellType, sIn, sOut];
CoreFrame.WriteFrameCache[cellType]};
[sIn, sOut] _ IFUCoreDrive.GetDShiftIO[cellType];
cellType _ CoreFrame.NewFrameCells[ name: "LtDrPadIO", rec: [first: left],
cells: LIST[ CoreGlue.CellProc[l: ext, r: conn], cellType ]]};


IFULogoCell: CellType _ NIL;
IFULogo: PROC RETURNS [cellType: CellType] = {
IF IFULogoCell=NIL THEN {
design:			CD.Design	_ PW.OpenDesign["IFULogo"];
object:			CD.Object		_ PW.Get[design, "HorizontalLogo"];
IFULogoCell	_ CoreLibrary.ObjCell[object, "IFULogo"]};
cellType _ CoreFrame.NewFrameCells[ name: "IFULogo", rec: [first: top], cells: LIST[
CoreGlue.CellProc[],
CoreFrame.NewFrameCells[ name: NIL, rec: [first: left], cells: LIST[
CoreGlue.CellProc[l: ext, r: conn],
CoreFrame.NewFrameCell[size: 0, name: "IFULogoMain", rec: [first: left, cell: IFULogoCell] ],
CoreGlue.CellProc[l: conn, r: ext] ]],
CoreGlue.CellProc[] ]]  };

pwrLeft: CellType _ CoreLibrary.ObjCell[ CoreGlue.SideObject[ left, LIST[
[name: GND,	max: 32*CCDUtils.lambda],
[name: VDD,	max: 32*CCDUtils.lambda] ], CCDUtils.cmosMet], CoreName.ID["ChanSide"]];
pwrRight: CellType _ CoreLibrary.ObjCell[ CoreGlue.SideObject[ right, LIST[
[name: GND,	max: 32*CCDUtils.lambda],
[name: VDD,	max: 32*CCDUtils.lambda] ], CCDUtils.cmosMet], CoreName.ID["ChanSide"]];

LeftColumn: PUBLIC PROC RETURNS [cellType: CellType] = {
name:	ROPE _ CoreName.RopeNm["IFULeftColumnCore"];
IF (cellType _ CoreFrame.ReadFrameCache[name])=NIL THEN {
cellType _ CoreFrame.NewFrameCells[ name: name, rec: [first: top], cells: LIST[
IFUSrc.LeftColumnTop[],
IFUSrc.LeftColumnBot[] ] ];
CoreFrame.WriteFrameCache[cellType]};
cellType _ CoreFrame.NewFrameCells[ name: "IFULeftColumn", rec: [first: top],
cells: LIST[ CoreGlue.CellProc[], cellType, CoreGlue.CellProc[] ]]};

LeftColumnTop: PUBLIC PROC RETURNS [cellType: CellType] = {
name:	ROPE _ CoreName.RopeNm["IFULeftColumnTop"];
IF (cellType _ CoreFrame.ReadFrameCache[name])=NIL THEN {
sft:		ROPE _ NIL;
fetchIndex, fetchControl, ltDrPadIO: CellType;
chanTopLeft, chanTopRight: CellType;
[ltDrPadIO,			sft]	_ LtDrPadIO					[NIL];
[fetchControl,		sft]	_ IFUSrc.FetchControler	[sft, IFUSrc.dShLeftOut];
fetchIndex					_ IFUSrc.FetchIndexing	[];
chanTopLeft _ CoreGlue.ChanSideCell[side: left, layer: CCDUtils.cmosMet, list: LIST[
"GND/50", "VDD/50" ]];
chanTopRight _ CoreGlue.ChanSideCell[side: right, layer: CCDUtils.cmosMet, list: LIST[
"GND/50", "VDD/50", IFUSrc.dShLeftOut ]];
cellType _ CoreFrame.NewFrameCells[ name: name, rec: [first: top], cells: LIST[
fetchIndex,
CoreGlue.CellProc[l: chan, b: conn, r: chan, lCell: chanTopLeft, rCell: chanTopRight],
fetchControl,
ltDrPadIO ] ];
CoreFrame.WriteFrameCache[cellType]};
cellType _ CoreFrame.NewFrameCells[ name: "IFULeftColumnTopX", rec: [first: left],
cells: LIST[ CoreGlue.CellProc[l: ext, r: conn], cellType ]]};

LeftColumnBot: PUBLIC PROC RETURNS [cellType: CellType] = {
name:	ROPE _ CoreName.RopeNm["IFULeftColumnBot"];
IF (cellType _ CoreFrame.ReadFrameCache[name])=NIL THEN {
sftIn:		ROPE _ IFUSrc.dShIn;
sft:		ROPE _ sftIn;
sftRtn:	ROPE _ IFUSrc.dShOut;
stackControl, mainPipeControl, interlock, stackIndex, chanBotLeft, chanBotRight: CellType;
stackIndex					_ IFUSrc.StackIndexing	[];
[interlock,			sft]	_ IFUSrc.Interlock			[sft];
[mainPipeControl,	sft]	_ IFUSrc.MainPipeControl	[sft];
[stackControl,		sft]	_ IFUSrc.StackControler		[sft];
chanBotLeft _ CoreGlue.ChanSideCell[side: left, layer: CCDUtils.cmosMet, list: LIST[
"GND/50", "VDD/50", "DShRd", "DShWt", "DShA", "DShB",
"PhA", "PhB", "NotPhA", "NotPhB", "VBB",	sftRtn,	sftIn ]];
chanBotRight _ CoreGlue.ChanSideCell[side: right, layer: CCDUtils.cmosMet, list: LIST[
"GND/50", "VDD/50","DShRd", "DShWt", "DShA", "DShB",
"PhA", "PhB", "NotPhA", "NotPhB", "VBB",	sftRtn]];
cellType _ CoreFrame.NewFrameCells[ name: name, rec: [first: top], cells: LIST[
stackControl,
mainPipeControl,
interlock,
CoreGlue.CellProc[l: chan, t: conn, r: chan, lCell: chanBotLeft, rCell: chanBotRight],
stackIndex ] ];
CoreFrame.WriteFrameCache[cellType]};
cellType _ CoreFrame.NewFrameCells[ name: "IFULeftColumnBotX", rec: [first: left],
cells: LIST[ CoreGlue.CellProc[l: ext, r: conn], cellType ]]};


DataColumn: PUBLIC PROC RETURNS [cellType: CellType] = {
name:	ROPE _ CoreName.RopeNm["IFUDataColumnCore"];
IF (cellType _ CoreFrame.ReadFrameCache[name])=NIL THEN {
cellType _ CoreFrame.NewFrameCells[ name: name, rec: [first: left], cells: LIST[
CoreGlue.CellProc[	l: ext,		r: conn,	xlate: TRUE],
CoreFrame.NewFrameCells[ name: "IFUDataColumnMain", rec: [first: top], cells: LIST[
IFUSrc.DataColumnTop[],
IFUSrc.DataColumnBot[] ] ],
CoreGlue.CellProc[	l: conn,	r: ext,		xlate: TRUE] ] ];
CoreFrame.WriteFrameCache[cellType]};
cellType _ CoreFrame.NewFrameCells[ name: "DataColumn", rec: [first: top], cells: LIST[
CoreGlue.CellProc[t:ext, b:conn, xlate: TRUE],
cellType,
CoreGlue.CellProc[t:conn, b:ext, xlate: TRUE] ] ]};

DataColumnTop: PUBLIC PROC RETURNS [cellType: CellType] = {
name:	ROPE _ CoreName.RopeNm["IFUDataColumnTop"];
IF (cellType _ CoreFrame.ReadFrameCache[name])=NIL THEN {
cellType _ CoreFrame.NewFrameCells[ name: name, rec: [first: top], cells: LIST[
IFUSrc.Fetch[],
IFUSrc.FetchBuf[],
IFUSrc.XaForm[],
IFUSrc.PCFormTop[],
IFUSrc.PCFormBot[] ] ];
CoreFrame.WriteFrameCache[cellType]}};

DataColumnBot: PUBLIC PROC RETURNS [cellType: CellType] = {
name:	ROPE _ CoreName.RopeNm["IFUDataColumnBot"];
IF (cellType _ CoreFrame.ReadFrameCache[name])=NIL THEN {
cellType _ CoreFrame.NewFrameCells[ name: name, rec: [first: top], cells: LIST[
IFUSrc.StackBuf[],
IFUSrc.LSForm[],
IFUSrc.ABForm[],
IFUSrc.ControlPipe[] ] ];
CoreFrame.WriteFrameCache[cellType]}};

RtDrPadIO: PUBLIC PROC[sIn, altOut: ROPE _ NIL]
RETURNS [cellType: CellType, sOut: ROPE] = {
name:	ROPE _ CoreName.RopeNm["IFURtDrPadIOCore"];
IF altOut#NIL THEN Signal[];
IF (cellType _ CoreFrame.ReadFrameCache[name])=NIL THEN {
Drive: PROC[dir: IFUCoreDrive.Dir, in, out: ROPE, inverted, dual: BOOL _ FALSE] = {
drives _ CONS[IFUCoreDrive.SpecificDrive[dir, in, out, inverted, dual], drives]};
drives:		IFUCoreDrive.Drives _ NIL;
toInside:		IFUCoreDrive.Dir = out;
toOutside:	IFUCoreDrive.Dir = in;
Drive[toInside,	"DPRejectB",				"DPRejectBA"];
Drive[toInside,	"DPFaultB.3",			"DPFaultBA.3"];
Drive[toInside,	"DPFaultB.2",			"DPFaultBA.2"];
Drive[toInside,	"DPFaultB.1",			"DPFaultBA.1"];
Drive[toInside,	"DPFaultB.0",			"DPFaultBA.0"];
Drive[toOutside,	"DPFaultBA.3",			"DPFaultBAA.3"];
Drive[toOutside,	"DPFaultBA.2",			"DPFaultBAA.2"];
Drive[toOutside,	"DPFaultBA.1",			"DPFaultBAA.1"];
Drive[toInside,	"DPFaultBAA.3",		"DPFaultAB.3"];
Drive[toInside,	"DPFaultBAA.2",		"DPFaultAB.2"];
Drive[toInside,	"DPFaultBAA.1",		"DPFaultAB.1"];
Drive[toOutside,	"DPCmnd3AB.7",		"DPCmnd3ABB.7"];
Drive[toOutside,	"DPCmnd3AB.6",		"DPCmnd3ABB.6"];
Drive[toOutside,	"DPCmnd3AB.5",		"DPCmnd3ABB.5"];
Drive[toOutside,	"DPCmnd3AB.4",		"DPCmnd3ABB.4"];
Drive[toOutside,	"DPCmnd3AB.3",		"DPCmnd3ABB.3"];
Drive[toOutside,	"DPCmnd3AB.2",		"DPCmnd3ABB.2"];
Drive[toOutside,	"DPCmnd3AB.1",		"DPCmnd3ABB.1"];
Drive[toOutside,	"DPCmnd3AB.0",		"DPCmnd3ABB.0"];
Drive[toOutside,	"EUAluOp2AB.3",		"EUAluOp2ABB.3"];
Drive[toOutside,	"EUAluOp2AB.2",		"EUAluOp2ABB.2"];
Drive[toOutside,	"EUAluOp2AB.1",		"EUAluOp2ABB.1"];
Drive[toOutside,	"EUAluOp2AB.0",		"EUAluOp2ABB.0"];
Drive[toOutside,	"EUCondSel2AB.3",		"EUCondSel2ABB.3"];
Drive[toOutside,	"EUCondSel2AB.2",		"EUCondSel2ABB.2"];
Drive[toOutside,	"EUCondSel2AB.1",		"EUCondSel2ABB.1"];
Drive[toOutside,	"EUCondSel2AB.0",		"EUCondSel2ABB.0"];
Drive[toInside,	"EUCondition2B",		"EUCondition2BA"];
Drive[toOutside,	"EUWriteToPBus3AB",	"EUWriteToPBus3ABB"];
Drive[toOutside,	"EURes3BisPBus3AB",	"EURes3BisPBus3ABB"];
Drive[toOutside,	"X2ASrcStatus1BA",		"X2ASrcStatus2Ac",	FALSE, TRUE];
[drives, sOut] _ IFUCoreDrive.CapDrives[drives, sIn];
cellType	_ IFUCoreDrive.DrivesToFrame[name, drives];
IFUCoreDrive.SetDShiftIO[cellType, sIn, sOut];
CoreFrame.WriteFrameCache[cellType]};
[sIn, sOut] _ IFUCoreDrive.GetDShiftIO[cellType];
cellType _ CoreFrame.NewFrameCells[ name: "RtDrPadIO", rec: [first: left],
cells: LIST[ CoreGlue.CellProc[l: ext, r: conn], cellType ]]};

RightColumn: PUBLIC PROC RETURNS[cellType: CellType] = {
name:	ROPE _ CoreName.RopeNm["IFURightColumnCore"];
IF (cellType _ CoreFrame.ReadFrameCache[name])=NIL THEN {
sftIn:		ROPE	_ IFUSrc.dShLeftOut;
sftOut:	ROPE	_ IFUSrc.dShRightOut;
sft:		ROPE	_ sftIn;
logo, instrDecode, rtDrPadIO, statusControl: CellType;
idTopLeft, idTopRight, idBotLeft, idBotRight: CellType;
statusTopLeft, statusTopRight: CellType;
statusControl				_ IFUSrc.StatusControl[];
[rtDrPadIO,		sft]	_ RtDrPadIO[sft];
[instrDecode,		sft]	_ IFUSrc.InstrDecode[sft, sftOut];
logo						_ IFULogo[];
CoreFrame.FCT[rtDrPadIO].orient		_ CDOrient.mirrorX;
CoreFrame.FCT[instrDecode].orient	_ CDOrient.mirrorX;
idTopLeft _ CoreGlue.ChanSideCell[side: left, layer: CCDUtils.cmosMet, list: LIST[
"GND/50", "VDD/50", sftOut ]];
idTopRight _ CoreGlue.ChanSideCell[side: right, layer: CCDUtils.cmosMet, list: LIST[
"GND/50", "VDD/50" ]];
idBotLeft _ CoreGlue.ChanSideCell[side: left, layer: CCDUtils.cmosMet, list: LIST[
"GND/50", "VDD/50", "DShRd", "DShWt", "DShA", "DShB",
"PhA", "PhB", "NotPhA", "NotPhB", "FireControlV", "NotPreChg",		sftIn ]];
idBotRight _ CoreGlue.ChanSideCell[side: right, layer: CCDUtils.cmosMet, list: LIST[
"GND/50", "VDD/50", "FireControlV", "NotPreChg"]];
statusTopLeft _ CoreGlue.ChanSideCell[side: left, layer: CCDUtils.cmosMet, list: LIST[
"GND/50", "VDD/50", "PhA", "PhB", "VBB", "DebugOpStatus", "X1ADstStatusBA", "NotX1ADstStatusBA", "LoadStage1Ac", "LoadStage1Bc"]];
statusTopRight _ CoreGlue.ChanSideCell[side: right, layer: CCDUtils.cmosMet, list: LIST[
"GND/50", "VDD/50","X2ASrcStatus2Ac", "NotX2ASrcStatus2Ac"]];
cellType _ CoreFrame.NewFrameCells[ name: name, rec: [first: top], cells: LIST [
logo,
CoreGlue.CellProc[l: chan, b: conn, r: chan, lCell: idTopLeft, rCell: idTopRight],
instrDecode,
rtDrPadIO,
CoreGlue.CellProc[l: chan, t: conn, r: chan, lCell: idBotLeft, rCell: idBotRight],
CoreGlue.CellProc[l: chan, b: conn, r: chan, lCell: statusTopLeft, rCell: statusTopRight],
statusControl ] ];
CoreFrame.WriteFrameCache[cellType] };
cellType _ CoreFrame.NewFrameCells[ name: "IFURightColumn", rec: [first: top], cells: LIST [
CoreGlue.CellProc[ ], cellType, CoreGlue.CellProc[ ] ] ] };

Heart: PUBLIC PROC RETURNS[cellType: CellType] = {
name:	ROPE _ CoreName.RopeNm["IFUHeart"];
IF (cellType _ CoreFrame.ReadFrameCache[name]) =NIL THEN {
right: CellType _ CoreGlue.ChanSideCell[ side: bottom, layer: CCDUtils.cmosMet2,
list: LIST[
"XBus.20","XBus.21","XBus.22","XBus.23","XBus.24","XBus.25","XBus.26","XBus.27",
"XBus.30","XBus.31","XBus.32","XBus.33","XBus.34","XBus.35","XBus.36","XBus.37" ] ];
cellType _ CoreFrame.NewFrameCells[ name: name, rec: [first: left], cells: LIST [
HeartLt[],
CoreGlue.CellProc[name: "RtColumnRoute",	l: conn,	r: conn, b: chan, bCell: right],
RightColumn[] ] ];
CoreFrame.WriteFrameCache[cellType] }};

HeartLt: PUBLIC PROC RETURNS[cellType: CellType] = {
name:	ROPE _ CoreName.RopeNm["IFUHeartLt"];
IF (cellType _ CoreFrame.ReadFrameCache[name])=NIL THEN {
left: CellType _ CoreGlue.ChanSideCell[ side: bottom, layer: CCDUtils.cmosMet2,
list: LIST["NotKPadsIn3BA", "NotKPadsIn4Ac", "KPadsIn4Ac" ] ];
cellType _ CoreFrame.NewFrameCells[ name: name, rec: [first: left], cells: LIST [
LeftColumn[],
CoreGlue.CellProc[name: "LtColumnRoute",	l: conn,	r: conn, b: chan, bCell: left],
DataColumn[] ] ];
CoreFrame.WriteFrameCache[cellType] }};

PadHeart: PUBLIC PROC RETURNS[cellType: CellType] = {
cellType _ CoreFrame.NewFrameCells[ name: "IFUSrcPadHeart", rec: [first: left], cells: LIST [
PadLt[],
CoreFrame.NewFrameCells[ name: "IFUSrcPadHeartMid", rec: [first: left], cells: LIST [
CoreGlue.CellProc[name: "LtPadRoute",	l: pwr, b: diff, r: conn],
Heart[],
CoreGlue.CellProc[name: "RtPadRoute",	l: conn, b: diff, r: pwr] ] ],
PadRt[] ] ]};

Complete: PUBLIC PROC RETURNS[cellType: CellType] = {
name:	ROPE _ CoreName.RopeNm["IFUComplete"];
IF (cellType _ CoreFrame.ReadFrameCache[name])=NIL THEN {
cellType _ CoreFrame.NewFrameCells[ name: name, rec: [first: top], cells: LIST [
PadTop[],
CoreFrame.NewFrameCells[ name: "TopPadGlue", rec: [first: left], cells: LIST [
PadExt[left, top],
CoreGlue.CellProc[name: "TopPadRoute",	t: pwr, b: conn],
PadExt[right, top] ] ],
PadHeart[],
CoreFrame.NewFrameCells[ name: "BotPadGlue", rec: [first: left], cells: LIST [
PadExt[left, bottom],
CoreGlue.CellProc[name: "BotPadRoute",	t: conn, b: pwr],
PadExt[right, bottom] ] ],
PadBot[] ] ];
CoreFrame.WriteFrameCache[cellType]}};

END. 


vIFUSrcComplete.mesa 
Copyright c 1986 by Xerox Corporation.  All rights reserved.
Last Edited by Curry, July 23, 1986 7:06:54 pm PDT

From Top or Right
pads _ CONS[ [type: triOut, data2: "DPCmnd3A.7", enWtA: NRjt, enWtB: GND], pads];
pads _ CONS[ [type: triOut, data2: "DPCmnd3A.6", enWtA: NRjt, enWtB: GND], pads];
pads _ CONS[ [type: triOut, data2: "DPCmnd3A.5", enWtA: NRjt, enWtB: GND], pads];
pads _ CONS[ [type: triOut, data2: "DPCmnd3A.4", enWtA: NRjt, enWtB: GND], pads];
pads _ CONS[ [type: triOut, data2: "DPCmnd3A.3", enWtA: NRjt, enWtB: GND], pads];
pads _ CONS[ [type: triOut, data2: "DPCmnd3A.2", enWtA: NRjt, enWtB: GND], pads];
pads _ CONS[ [type: triOut, data2: "DPCmnd3A.1", enWtA: NRjt, enWtB: GND], pads];
pads _ CONS[ [type: triOut, data2: "DPCmnd3A.0", enWtA: NRjt, enWtB: GND], pads];
desc.nofTermCols		_ 3;
desc.fullWidthTerms	_ FALSE;
IFULogoObj: CD.Object _ NIL;
GetIFULogo: PWCore.LayoutProc = {
IF IFULogoObj=NIL THEN {
design:		CD.Design	_ PW.OpenDesign["IFULogo"];
IFULogoObj	_ PW.Get[design, "IFULogo"];
IFULogoObj	_ PW.Rot90[IFULogoObj]};
RETURN[IFULogoObj]};
IFULogo: PROC RETURNS [cellType: CellType] = {
cellType	_ CCDUtils.NewBlankCellType[];
PWCore.SetLayout[cellType, $IFULogo];
cellType _ CoreFrame.NewFrameCell
[name: "IFULogo", rec: [first: top, cell: cellType], size: 0]};
object				_ PW.Rot90[object];
capTop
capBot
LeftColumn: PUBLIC PROC RETURNS [cellType: CellType] = {
name:	ROPE _ CoreName.RopeNm["IFULeftColumnCore"];
IF (cellType _ CoreFrame.ReadFrameCache[name])=NIL THEN {
sftIn:		ROPE _ IFUSrc.dShIn;
sft:		ROPE _ sftIn;
sftRtn:	ROPE _ IFUSrc.dShOut
fetchIndex, stackIndex: CellType;
fetchControl, ltDrPadIO, stackControl, mainPipeControl, interlock: CellType;
chanTopLeft, chanTopRight, chanBotLeft, chanBotRight: CellType;
stackIndex					_ IFUSrc.StackIndexing	[];
capBot
[interlock,			sft]	_ IFUSrc.Interlock			[sft];
[mainPipeControl,	sft]	_ IFUSrc.MainPipeControl	[sft];
[stackControl,		sft]	_ IFUSrc.StackControler		[sft];
[ltDrPadIO,			sft]	_ LtDrPadIO					[sft];
[fetchControl,		sft]	_ IFUSrc.FetchControler	[sft, IFUSrc.dShLeftOut];
capTop
fetchIndex					_ IFUSrc.FetchIndexing	[];
chanTopLeft _ CoreGlue.ChanSideCell[side: left, layer: CCDUtils.cmosMet, list: LIST[
"GND/50", "VDD/50" ]];
chanTopRight _ CoreGlue.ChanSideCell[side: right, layer: CCDUtils.cmosMet, list: LIST[
"GND/50", "VDD/50", IFUSrc.dShLeftOut ]];
chanBotLeft _ CoreGlue.ChanSideCell[side: left, layer: CCDUtils.cmosMet, list: LIST[
"GND/50", "VDD/50", "DShRd", "DShWt", "DShA", "DShB",
"PhA", "PhB", "NotPhA", "NotPhB", "VBB",	sftRtn,	sftIn ]];
chanBotRight _ CoreGlue.ChanSideCell[side: right, layer: CCDUtils.cmosMet, list: LIST[
"GND/50", "VDD/50","DShRd", "DShWt", "DShA", "DShB",
"PhA", "PhB", "NotPhA", "NotPhB", "VBB",	sftRtn]];
cellType _ CoreFrame.NewFrameCells[ name: name, rec: [first: top], cells: LIST[
fetchIndex,
CoreGlue.CellProc[l: chan, b: conn, r: chan, lCell: chanTopLeft, rCell: chanTopRight],
fetchControl,
ltDrPadIO,
stackControl,
mainPipeControl,
interlock,
CoreGlue.CellProc[l: chan, t: conn, r: chan, lCell: chanBotLeft, rCell: chanBotRight],
stackIndex ] ];
CoreFrame.WriteFrameCache[cellType]};
cellType _ CoreFrame.NewFrameCells[ name: "IFULeftColumn", rec: [first: top],
cells: LIST[ CoreGlue.CellProc[], cellType, CoreGlue.CellProc[] ]]};

capBot
capTop
Heart: PUBLIC PROC RETURNS[cellType: CellType] = {
name:	ROPE _ CoreName.RopeNm["IFUHeart"];
IF (cellType _ CoreFrame.ReadFrameCache[name])=NIL THEN {
left: CellType _ CoreGlue.ChanSideCell[ side: bottom, layer: CCDUtils.cmosMet2,
list: LIST["NotKPadsIn3BA", "NotKPadsIn4Ac", "KPadsIn4Ac" ] ];
right: CellType _ CoreGlue.ChanSideCell[ side: bottom, layer: CCDUtils.cmosMet2,
list: LIST[
"XBus.20","XBus.21","XBus.22","XBus.23","XBus.24","XBus.25","XBus.26","XBus.27",
"XBus.30","XBus.31","XBus.32","XBus.33","XBus.34","XBus.35","XBus.36","XBus.37" ] ];
cellType _ CoreFrame.NewFrameCells[ name: name, rec: [first: left], cells: LIST [
LeftColumn[],
CoreGlue.CellProc[name: "LtColumnRoute",	l: conn,	r: conn, b: chan, bCell: left],
DataColumn[],
CoreGlue.CellProc[name: "RtColumnRoute",	l: conn,	r: conn, b: chan, bCell: right],
RightColumn[] ] ];
CoreFrame.WriteFrameCache[cellType] }};

�ʤ˜š
œ™Jš
œ<™<Jš
œ2™2—J™šÏk	œ
˜
Jš�œu�œ˜ˆ
—J˜šÏnœ�œ
�œ
˜Jš�œp�œ˜}Jš�œ	˜Jš
�˜J˜Jš�œ�œ�œ
˜Jšœ
�œ˜&Jšœ	�œ˜#Jšœ�œ˜Jšœ�œ˜ Jšœ�œ˜Jšœ	�œ˜$Jš�œ�œ˜%Jš�œ�œ˜%Jšžœ�œ$˜0J˜J˜J˜š
žœ�œ�œ�œ
�œ˜<Jš�œ˜šžœ�œ˜Jš
œO˜O—Jšžœ�œ
�œ5˜FJšœ�œ
�œ˜'Jšœ�œ
�œ˜Jš
œ˜Jšœ�œ˜Jšœ�œ
˜š�œ�œ�œ
�˜.Jšœ�œ�œÏc˜M—Jš�œ�œ
�œ
˜š�œ˜	š
�˜Jš
œ˜Jš
œQ˜Q—š
�˜JšœŸ˜+Jš
œQ˜Q——Jšœ�œ˜Jš
œ˜š
Ïb™Jš�œ
�œ�œ˜+Jš
œ-˜-Jš
œ=˜=Jš
œ?˜?Jš
œ?˜?Jš
œ=˜=Jš
œ=˜=Jš
œ?˜?Jš
œ?˜?Jš
œ=˜=Jš
œ?˜?Jš
œ?˜?Jš
œ=˜=Jš
œ=˜=Jš
œ?˜?Jš
œ?˜?Jš
œ=˜=Jš�œ
�œ�œ˜+—Jš
�œ�œ
�œ�œ
�œ˜"J˜—šžœ�œ
�œ
�œ˜2Jšœ�œ
�œ
�œ
˜Jšœ�œ˜)Jš�œ-�œ
�œ
�œ
˜?Jš�œ�œ�œ
˜3J˜Jšœ�œ"˜-Jšœ�œ"˜-Jšœ�œ"˜-Jšœ�œ"˜-Jšœ�œ"˜-Jšœ�œ"˜-Jšœ�œ"˜-Jšœ�œ"˜-J˜Jšœ�œ"˜-Jšœ�œ"˜-Jšœ�œ"˜-Jšœ�œ"˜-Jšœ�œ"˜-Jšœ�œ"˜-Jšœ�œ"˜-Jšœ�œ"˜-J˜Jšœ�œ.˜9Jšœ�œ/˜:Jšœ�œ/˜:Jšœ�œ,˜7Jšœ�œ/˜:Jšœ�œ+˜6Jšœ�œ.˜9Jšœ�œ0˜;J˜Jšœ�œ+˜6Jšœ�œ+˜6Jšœ�œ-˜8Jšœ�œ-˜8Jšœ�œ,˜7Jšœ�œ,˜7Jšœ�œ-˜8Jšœ�œ-˜8J˜Jš
œ&˜&Jš
œ%˜%—J˜šžœ�œ
�œ
�œ˜2Jšœ�œ
�œ
�œ
˜Jšœ�œ˜)Jš�œ-�œ
�œ
�œ
˜?J˜Jšœ�œ2˜=Jšœ�œ/˜:Jšœ�œ"˜-Jšœ�œ.˜9Jšœ�œ.˜9Jšœ�œ.˜9Jšœ�œ.˜9Jšœ�œ.˜9J˜Jšœ�œ:�œ	™QJšœ�œ:�œ	™QJšœ�œ:�œ	™QJšœ�œ:�œ	™QJšœ�œ:�œ	™QJšœ�œ:�œ	™QJšœ�œ:�œ	™QJšœ�œ:�œ	™QJšœ�œ,˜7Jšœ�œ,˜7Jšœ�œ,˜7Jšœ�œ,˜7Jšœ�œ,˜7Jšœ�œ,˜7Jšœ�œ,˜7Jšœ�œ,˜7J˜Jšœ�œ"˜-Jšœ�œ"˜-J˜Jšœ�œ1˜<Jšœ�œ1˜<Jšœ�œ1˜<Jšœ�œ1˜<J˜Jšœ�œ3˜>Jšœ�œ3˜>Jšœ�œ3˜>Jšœ�œ5˜@J˜Jšœ�œ"˜-Jšœ�œ"˜-Jšœ�œ"˜-Jšœ�œ1˜<Jšœ�œ4˜?Jšœ�œ4˜?J˜Jš
œ'˜'Jš
œ%˜%—˜J˜—šžœ�œ
�œ
�œ˜3Jšœ�œ
�œ
�œ
˜Jšœ�œ ˜*Jš�œ-�œ
�œ
�œ
˜?š	�œ�œ
�
œ
�œ	�˜#Jšœ�œ�œ�œ
˜0Jšœ�œ�œ�œ
˜0Jšœ�œ/�œ	�œ	˜RJš�œ
˜—Jš
œ%˜%Jš
œ%˜%J˜—šžœ�œ
�œ
�œ˜3Jšœ�œ˜Jšœ�œ˜Jšœ�œ˜Jšœ�œ
�œ
�œ
˜Jšœ�œ ˜*Jš�œ-�œ
�œ
�œ
˜?š	�œ�œ
�
œ
�œ	�˜#Jšœ�œ�œ�œ
˜/Jšœ�œ�œ�œ
˜/Jšœ�œ;�œ	˜RJš�œ
˜—Jš
œ(˜(Jš
œ%˜%J˜—šžœ�œ�œ˜@šœ1�œ˜>šœŸ˜Jš
œ
˜
š
œ˜š�œ�˜Jš
œ˜Jš
œ˜Jš
œ˜Jšœ�œ�œ
˜/—š�œ�˜Jš
œ˜Jš
œ˜Jš
œ˜Jšœ�œ�œ˜0———šœ�œ
˜Jš
œ3˜3Jš
œ)˜)———J˜šž	œ�œ
�œ�œ
�œ�œ
˜6Jš�œ�œ˜,Jšœ�œ&˜0Jš�œ�œ
�œ
˜š�œ-�œ
�œ˜9Jš
œ˜šœ"�œ˜DJšœ#�œ�œ�œ˜:—Jš
œ˜Jš
œ™Jšœ�œ
™Jš
œ˜Jš
œ˜Jš
œG˜GJš
œG˜GJš
œC˜CJš
œC˜CJš
œD˜DJš
œD˜DJš
œ˜Jš
œ˜Jš
œ0˜0Jš
œ&˜&Jš
œ.˜.Jš
œ%˜%—Jš
œ1˜1šœW�œ
˜\Jš
œ#˜#Jš
œ
˜
——J˜šžœ�œ
�œ�œ
�œ�œ
˜<Jš�œ�œ˜,Jšœ�œ,˜6Jš�œ�œ
�œ
˜š�œ-�œ
�œ˜9Jš
œ˜šœ"�œ˜DJšœ)�œ�œ�œ˜@—Jš
œ˜Jš
œ˜Jšœ�œ
˜Jš
œ˜Jšœ2�œ$˜XJš
œH˜HJš
œQ˜QJš
œM˜Mš
œ,˜,Jš
œ ˜ Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ%˜%Jš
œ ˜ Jš
œ(˜(Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ@˜@Jš
œ@˜@—š
œ;˜;Jš
œ˜Jšœ
�œ
˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜—Jš
œ˜Jš
œ˜Jš
œ0˜0Jš
œ&˜&Jš
œ.˜.Jš
œ%˜%—Jš
œ1˜1šœY�œ
˜^Jš
œ#˜#Jš
œ
˜
——J˜šž	œ�œ
�œ�œ
�œ�œ
˜5Jš�œ%˜,Jšœ�œ'˜1Jš�œ�œ
�œ
˜š�œ-�œ
�œ˜9š
žœ�œ!�œ�œ�œ˜SJšœ	�œD˜Q—Jšœ�œ
˜#Jš
œ"˜"Jš
œ!˜!Jš
œ-˜-Jš
œ0˜0Jš
œ/˜/Jšœ+�œ�œ˜8Jš
œ0˜0Jš
œ*˜*Jš
œ&˜&Jš
œ$˜$Jš
œ%˜%Jš
œ)˜)J˜Jš
œ/˜/Jšœ1�œ˜7Jšœ.�œ˜;Jšœ.�œ˜;Jšœ.�œ˜;Jšœ.�œ˜;Jš
œ5˜5Jš
œ4˜4Jš
œ.˜.Jš
œ%˜%—Jš
œ1˜1š
œJ˜JJšœ�œ3˜>——J˜Jšž
œ�œ
�œ
™šž
œ™!š�œ�œ
�œ™Jšœ	�œ
�œ™.Jšœ
�œ™'Jšœ
�œ™#—Jš�œ™—šžœ�œ
�œ™.Jš
œ'™'Jš
œ%™%š
œ!™!Jš
œ?™?——J˜Jšžœ
�œ
˜šžœ�œ
�œ˜.š�œ
�œ
�œ˜Jšœ
�œ
�œ˜/Jšœ
�œ�œ˜8Jšœ�œ™Jš
œ6˜6—šœO�œ
˜TJš
œ˜šœ�œ�œ
˜DJš
œ#˜#Jš
œ]˜]Jš
œ&˜&—Jš
œ˜—J˜—šœD�œ
˜IJšœ�œ˜%Jšœ�œ:�œ˜T—šœF�œ
˜KJšœ�œ˜%Jšœ�œ:�œ˜T—J˜šž
œ�œ
�œ
�œ˜8Jšœ�œ(˜2š�œ-�œ
�˜9šœJ�œ
˜OJšœž
œ˜Jšœž
œ˜—Jš
œ%˜%—š
œM˜MJšœ�œ9˜D—J˜—šž
œ�œ
�œ
�œ˜;Jšœ�œ'˜1š�œ-�œ
�˜9Jšœ�œ˜Jš
œ.˜.Jš
œ$˜$Jš
œ)˜)Jš
œF˜FJš
 ™Jš
œ)˜)šœO�œ
˜TJš
œ˜—šœQ�œ
˜VJš
œ)˜)—šœJ�œ
˜OJš
œ˜Jš
œV˜VJš
œ
˜
Jš
œ˜—Jš
œ%˜%—š
œR˜RJšœ�œ3˜>—J˜—šž
œ�œ
�œ
�œ˜;Jšœ�œ'˜1š�œ-�œ
�˜9Jš œ�œ˜Jšœ�œ	˜Jš œ�œ˜Jš
œZ˜ZJš
œ)˜)Jš
 ™Jš
œ.˜.Jš
œ6˜6Jš
œ4˜4šœO�œ
˜TJš
œ5˜5Jš
œ:˜:—šœQ�œ
˜VJš
œ4˜4Jš
œ2˜2—šœJ�œ
˜OJš
œ
˜
Jš
œ˜Jš
œ
˜
Jš
œV˜VJš
œ˜—Jš
œ%˜%—š
œR˜RJšœ�œ3˜>—J˜—šž
œ�œ
�œ
�œ™8Jšœ�œ(™2š�œ-�œ
�™9Jš œ�œ™Jšœ�œ	™Jš œ�œ™Jš
œ!™!Jš
œL™LJš
œ?™?Jš
œ)™)Jš
 ™Jš
œ.™.Jš
œ6™6Jš
œ4™4Jš
œ)™)Jš
œF™FJš
 ™Jš
œ)™)šœO�œ
™TJš
œ™—šœQ�œ
™VJš
œ)™)—šœO�œ
™TJš
œ5™5Jš
œ:™:—šœQ�œ
™VJš
œ4™4Jš
œ2™2—šœJ�œ
™OJš
œ™Jš
œV™VJš
œ
™
Jš
œ
™
Jš
œ
™
Jš
œ™Jš
œ
™
Jš
œV™VJš
œ™—Jš
œ%™%—š
œM™MJšœ�œ9™D—J™—J˜šž
œ�œ
�œ
�œ˜8Jšœ�œ(˜2š�œ-�œ
�˜9šœK�œ
˜PJšœ,�œ˜2šœN�œ
˜SJšœž
œ˜Jšœž
œ˜—Jšœ,�œ˜6—Jš
œ%˜%—šœR�œ
˜WJšœ(�œ˜.Jš
œ	˜	Jšœ(�œ˜3——J˜šž
œ�œ
�œ
�œ˜;Jšœ�œ'˜1š�œ-�œ
�˜9šœJ�œ
˜OJ˜J˜Jš
œ˜J˜Jš
œ˜Jš
œ&˜&———J˜šž
œ�œ
�œ
�œ˜;Jšœ�œ'˜1š�œ-�œ
�˜9šœJ�œ
˜OJš
œ˜J˜J˜Jš
œ˜Jš
œ&˜&———J˜šž	œ�œ�
œ
˜/Jš�œ%˜,Jšœ�œ'˜1Jš�œ�œ
�œ
˜š�œ-�œ
�œ˜9š
žœ�œ!�œ�œ�œ˜SJšœ	�œD˜Q—Jšœ�œ
˜#Jš
œ"˜"Jš
œ!˜!Jš
œ.˜.Jš
œ/˜/Jš
œ/˜/Jš
œ/˜/Jš
œ/˜/Jš
œ2˜2Jš
œ2˜2Jš
œ2˜2Jš
œ0˜0Jš
œ0˜0Jš
œ0˜0Jš
œ1˜1Jš
œ1˜1Jš
œ1˜1Jš
œ1˜1Jš
œ1˜1Jš
œ1˜1Jš
œ1˜1Jš
œ1˜1Jš
œ3˜3Jš
œ3˜3Jš
œ3˜3Jš
œ3˜3Jš
œ7˜7Jš
œ7˜7Jš
œ7˜7Jš
œ7˜7Jš
œ4˜4Jš
œ:˜:Jš
œ:˜:Jšœ8�œ�œ˜EJš
œ5˜5Jš
œ4˜4Jš
œ.˜.Jš
œ%˜%—Jš
œ1˜1š
œJ˜JJšœ�œ3˜>——J˜šžœ�œ
�œ
�œ˜8Jšœ�œ)˜3š�œ-�œ
�œ˜9Jš œ�œ˜!Jš œ�œ˜"Jšœ�œ œ
˜Jš
œ6˜6Jš
œ7˜7Jš
œ(˜(Jš
œ*˜*Jš
œ™Jš
œ#˜#Jšœ. œ˜6Jš
œ™Jš
œ˜Jšœ
�œ'˜4Jšœ
�œ(˜5šœM�œ
˜RJšœ œ˜—šœO�œ
˜TJš
œ˜—šœM�œ
˜RJš
œ5˜5Jš
œI˜I—šœO�œ
˜TJš
œ2˜2—šœQ�œ
˜VJš
œ‚
˜‚
—šœS�œ
˜XJš
œ=˜=—šœJ�œ˜PJš
œ˜Jš
œR˜RJš
œ˜Jš
œ
˜
Jš
œR˜RJš
œZ˜ZJš
œ˜—Jš
œ&˜&—šœV�œ˜\Jš
œ;˜;——J˜šžœ�œ
�œ
�œ˜2Jšœ�œ˜)š�œ.�œ
�œ˜:š
œP˜Pšœ�œ
˜Jš
œP˜PJš
œT˜T——šœK�œ˜Qšžœ˜
Jš
œR˜R—Jš
œ˜—Jš
œ'˜'—J˜—šžœ�œ
�œ
�œ˜4Jšœ�œ!˜+š�œ-�œ
�œ˜9š
œO˜OJšœ�œ4˜>—šœK�œ˜Q˜
Jš
œQ˜Q—Jš
œ˜—Jš
œ'˜'—J˜—šžœ�œ
�œ
�œ™2Jšœ�œ™)š�œ-�œ
�œ™9š
œO™OJšœ�œ4™>—š
œP™Pšœ�œ
™Jš
œP™PJš
œT™T——šœK�œ™Q™
Jš
œQ™Q—™
Jš
œR™R—Jš
œ™—Jš
œ'™'—J™—šžœ�œ
�œ
�œ˜5šœW�œ˜]J˜šœO�œ˜UJš
œ@˜@Jš
œ˜Jš
œD˜D—Jš
œ
˜
——J˜šžœ�œ
�œ
�œ˜5Jšœ�œ"˜,Jš�œ-�œ
�œ˜9šœJ�œ˜Pš
œ	˜	šœH�œ˜NJš
œ˜Jš
œ8˜8Jš
œ˜——š
œ˜šœH�œ˜NJš
œ˜Jš
œ8˜8Jš
œ˜——Jš
œ
˜
—Jš
œ&˜&—J˜Jš�œ˜J˜—J˜—…—ddŽ~