DIRECTORY
CCDUtils, CD, CDCells, CDCreateLabels, CDDirectory, CDOps, CDOrient, CDRects, CDSimpleOps, CDSimpleRules, CDSymbolicObjects, CDViewer, CMosB, CMosBObjects, Convert, Core, CoreBlock, CoreFrame, CoreGeometry, CoreInstCell, CoreLibrary, CoreName, CoreOps, FS, HashTable, Imager, ImagerFont, IO, PW, PWC, Real, Rope, VFonts;

CCDUtilsImpl: CEDAR PROGRAM
IMPORTS CCDUtils, CD, CDCells, CDCreateLabels, CDDirectory, CDOps, CDRects, CDSimpleOps, CDSimpleRules, CDSymbolicObjects, CDViewer, CMosB, CMosBObjects, Convert, CoreBlock, CoreFrame, CoreGeometry, CoreInstCell, CoreLibrary, CoreName, CoreOps, FS, HashTable, ImagerFont, IO, PW, PWC, Real, Rope, VFonts
EXPORTS CCDUtils =
BEGIN

Signal:				SIGNAL	= CODE;
ROPE:					TYPE		= Core.ROPE;
GND:					ROPE		= CoreName.RopeNm["GND"];
VDD:					ROPE		= CoreName.RopeNm["VDD"];
plus:					ROPE		= CoreName.RopeNm["+"];
minus:				ROPE		= CoreName.RopeNm["-"];
NWMML:				TYPE		= PWC.NWMML;
CellType:				TYPE		= Core.CellType;
Side:					TYPE		= CoreFrame.Side;

cache:		HashTable.Table _
HashTable.Create[equal: HashTable.RopeEqual, hash: HashTable.HashRope];
Store:		PROC[name: ROPE, obj: CD.Object] = {[]_HashTable.Store[cache, name, obj]};
Fetch:	PROC[name: ROPE] RETURNS[obj: CD.Object] =
{RETURN[NARROW[HashTable.Fetch[cache, name].value, CD.Object]]};

SizeBlankName: PROC[size: CD.Position] RETURNS[name: ROPE] ~
{RETURN[ IO.PutFR["Blank-%g-%g", IO.int[size.x], IO.int[size.y]]]};

BlankObj: PUBLIC PROC[size: CD.Position] RETURNS[cell: CD.Object] ~ {
minLineW:		INT = 2 ;
name:				ROPE _ SizeBlankName[size];
IF size.x=0 OR size.y=0 THEN RETURN[NIL];
cell	_ Fetch[name];
IF cell#NIL THEN RETURN[cell];
cell	_ CDCells.CreateEmptyCell[];
IF size.x IN (0..4*minLineW) OR size.y IN (0..4*minLineW)
THEN [ ] _ PW.IncludeInCell[cell, CDRects.CreateRect[size, CD.commentLayer],	[0, 0] ]
ELSE {
lwidth:	INT		_ MAX[minLineW, MIN[size.x/100, size.y/100]];
hor:		CD.Object	_ CDRects.CreateRect[[size.x, lwidth], CD.commentLayer];
ver:		CD.Object	_ CDRects.CreateRect[[lwidth, size.y], CD.commentLayer];
[ ] _ PW.IncludeInCell[cell, hor,	[0,					0] ];
[ ] _ PW.IncludeInCell[cell, hor,	[0,		size.y-lwidth] ];
[ ] _ PW.IncludeInCell[cell, ver,	[0,					0] ];
[ ] _ PW.IncludeInCell[cell, ver,	[size.x-lwidth,	0] ]};
PW.RepositionCell[cell];
Store[name, cell]};
BlankCell: PUBLIC PROC[size: CD.Position] RETURNS[cell: CellType] ~ {
obj:	CD.Object _ BlankObj[size];
name:	ROPE _ SizeBlankName[size];
cell _ CoreLibrary.ObjCell[obj, name, NIL, 0];
cell _ CoreFrame.NewFrameCell[0, name, [cell: cell]]};

ObjName: PUBLIC PROC[obj: CD.Object] RETURNS[name: ROPE] = {
IF obj=NIL				THEN RETURN[NIL];
IF obj.specificRef=NIL	THEN RETURN[NIL];
IF NOT ISTYPE[obj.specificRef, CD.CellPtr] THEN RETURN[NIL];
RETURN[NARROW[obj.specificRef, CD.CellPtr].name]};

ObjSize: PUBLIC PROC[obj: CD.Object] RETURNS[size: CD.Position] =
{RETURN[CD.InterestSize[obj]]};
Layout: PUBLIC PROC[ct: Core.CellType] RETURNS[obj: CD.Object] = {
IF ct=NIL THEN RETURN[NIL];
SELECT ct.class FROM
CoreInstCell.specificGenericCellClass	=> RETURN[Layout[ NARROW[ct.data]]];
CoreFrame.frameCellClass				=> RETURN[Layout[ CoreFrame.FCT[ct].cell ]];
ENDCASE									=> RETURN[PWC.Layout[ ct]]};
font1: Imager.Font _ VFonts.EstablishFont
[family:"Helvetica", size: 7, bold: TRUE, italic: FALSE, defaultOnFailure: FALSE];
font2: Imager.Font _ VFonts.EstablishFont
[family:"Helvetica", size: 14, bold: TRUE, italic: FALSE, defaultOnFailure: FALSE];

OrnateFrame: PUBLIC PROC [cell: CellType, design: CD.Design_NIL]
RETURNS[picture: CD.Object] = {
recCell:		CellType _ cell;
rSize:			CD.Position;
loc:			CD.Position;
sidesObj:		ARRAY Side OF CD.Object;
refObj:		CD.Object;
IF cell.class = CoreFrame.frameCellClass
THEN	recCell _ CoreFrame.FCT[cell].cell
ELSE	recCell _ cell;
refObj		_ CCDUtils.Layout[recCell];
picture		_ CDCells.CreateEmptyCell[];
rSize			_ CD.InterestSize[refObj];
[ ]				_ PW.IncludeInCell[picture, refObj, [0, 0]];
FOR side: Side IN Side DO
nwmmls:	LIST OF NWMML _ SidePinList[recCell, side];
bias:		INT	= lambda;
orient:	CD.Orientation;
size:		CD.Position _ [0, 0];
IF nwmmls=NIL THEN LOOP;
sidesObj[side] _ CDCells.CreateEmptyCell[];
FOR nwmmls _ nwmmls, nwmmls.rest WHILE nwmmls#NIL DO
textOb: CD.Object _ ScaledText
[nwmmls.first.name, [400*lambda,10*lambda],CD.commentLayer, design];
org:		CD.Position _ CD.ClientOrigin[textOb];
pos:		CD.Position ;
size.x		_ MAX[size.x, ((textOb.size.x+2*bias+lambda-1)/lambda)*lambda];
pos.x		_ bias;
pos.y		_ SELECT side FROM
left, right	=> 			nwmmls.first.min - org.y,
bottom, top	=> rSize.x -	nwmmls.first.max - org.y,
ENDCASE		=> ERROR;
[ ] _ PW.IncludeInCell[sidesObj[side], textOb, pos];
ENDLOOP;
SELECT side FROM
left, right	=>	{size.y	_ rSize.y};
top, bottom	=>	{size.y	_ rSize.x};
ENDCASE	=> ERROR;
SELECT side FROM
left		=>	{loc _ [-size.x,		0		];	orient _ CDOrient.original};
right		=>	{loc _ [ rSize.x,		0		];	orient _ CDOrient.original};
top		=>	{loc _ [	0,		 rSize.y	];	orient _ CDOrient.rotate90};
bottom	=>	{loc _ [	0,		-size.x	];	orient _ CDOrient.rotate90};
ENDCASE	=> ERROR;
CDCells.SetInterestRect[sidesObj[side], [0, 0, size.x, size.y]];
[ ] _ CDCells.RepositionCell[sidesObj[side], NIL];
[ ] _ PW.IncludeInCell[picture, sidesObj[side], loc, orient];
ENDLOOP;
[ ] _ CDCells.RepositionCell[picture, NIL]};

AddRet: PUBLIC PROC [cell: CD.Object, size: CD.Position, loc: CD.Position, level: CD.Layer] = {
IF  size.x<0 OR size.y<0
THEN {
PW.WriteF["Strange rectangle size [%g, %g]\n", IO.int[size.x], IO.int[size.y] ];
Signal[]};
IF size.x=0 OR size.y=0 THEN RETURN;
[] _ PW.IncludeInCell[cell, CDRects.CreateRect[size, level], loc]};

SidePinList: PUBLIC PROC [cellType: CellType, side: Side]
RETURNS [list: LIST OF NWMML _ NIL] = {
refCell:	CellType;
thisSide:	Side _ side;
EachWirePin: CoreGeometry.EachWirePinProc = {
SubstituteWireName: CoreOps.EachWirePairProc ~ {
IF actualWire#wire THEN RETURN;
wire_publicWire; name_CoreName.WireNm[wire].n; RETURN[FALSE, TRUE]};
name:		ROPE _ CoreName.WireNm[wire].n;
IF side#thisSide THEN RETURN;
IF NOT CoreBlock.OnSide[CoreFrame.SideSides[side], CoreBlock.GetWireSide[wire]]
THEN RETURN;
IF layer#cmosMet AND layer#cmosMet2 THEN
SELECT name FROM GND, VDD, plus, minus => RETURN ENDCASE;
IF cellType.class=CoreInstCell.specificGenericCellClass THEN 
[ ] _ CoreOps.VisitBinding[refCell.public, cellType.public, SubstituteWireName];
IF name=NIL THEN RETURN;
list _ PWC.AddMergeNWMMLs[[name, wire, min, max, layer], list]};
IF cellType.class=CoreInstCell.specificGenericCellClass
THEN {refCell _ NARROW[cellType.data]} ELSE refCell _ cellType;
[] _ PWC.InterestRect[refCell];
[] _ CoreGeometry.EnumerateWireSides
[PWC.extractMode.decoration, refCell, EachWirePin];
PWC.PosSortNWMMLs[list]};

ListNWMMLs: PUBLIC PROC[lst: LIST OF NWMML, log: IO.STREAM] = {
list:		LIST OF NWMML;
list _ lst; lst _ NIL;
FOR list _ list, list.rest WHILE list#NIL DO
lst _ CONS[list.first, lst] ENDLOOP;
list _ lst;
FOR list _ list, list.rest WHILE list#NIL DO ListNWMML[list.first, log] ENDLOOP;
log.PutChar[IO.CR] };

ListNWMML: PUBLIC PROC[nwmml: NWMML, log: IO.STREAM] = {
layerCard: CARDINAL _ LOOPHOLE[nwmml.layer];
log.PutF["\n%g\tpos: %5g\tsize: %5g\tlayer: %g",
IO.rope[nwmml.name],
IO.int[nwmml.min],
IO.int[nwmml.max-nwmml.min],
IO.rope[ SELECT nwmml.layer FROM
cmosMet2	=> "metal2",
cmosMet	=> "metal",
cmosPoly	=> "poly",
ENDCASE	=> Convert.RopeFromCard[layerCard] ] ]};
ListUniqueSignals: PUBLIC PROC[first: Side, cell0, cell1: CellType, log: REF _ NIL] = {
Incrment: PROC[table: HashTable.Table, id: REF] = {
val: REF INT _ NARROW[HashTable.Fetch[table, id].value];
IF val=NIL THEN {val _ NEW[INT _ 0]; [] _ HashTable.Store[table, id, val]};
val^ _ val^ + 1};
nwmmls0:	LIST OF NWMML _ SidePinList[cell0, CoreFrame.OppSide[first]];
nwmmls1:	LIST OF NWMML _ SidePinList[cell1, first];
side0Nm:		ROPE _ CoreFrame.SideRope[CoreFrame.OppSide[first]];
side1Nm:		ROPE _ CoreFrame.SideRope[first];
out:			IO.STREAM;
count:			INT _ 0;
mark:			REF _ NEW[INT _ 0];
table0:		HashTable.Table _ HashTable.Create[ ];
table1:		HashTable.Table _ HashTable.Create[ ];
IF log=NIL
THEN	out _ FS.StreamOpen["UniqueSignals.txt", $create]
ELSE	WITH log SELECT FROM
rope:	ROPE			=>	{out _ FS.StreamOpen[rope, $create]};
text:	REF TEXT	=>	{out _ FS.StreamOpen[Rope.FromRefText[text], $create]};
stm:	IO.STREAM	=>	{out _ stm};
ENDCASE				=>	{Signal[]};
FOR temp: LIST OF NWMML _ nwmmls0, temp.rest WHILE temp#NIL DO
Incrment[table0, temp.first.name] ENDLOOP;
FOR temp: LIST OF NWMML _ nwmmls1, temp.rest WHILE temp#NIL DO
Incrment[table1, temp.first.name] ENDLOOP;
out.PutF["\nUnique signal log		%g\n%10g side of %g\n%10g side of %g\n",
IO.time[],
IO.rope[side0Nm],	IO.rope[CoreName.CellNm[cell0].n],
IO.rope[side1Nm],	IO.rope[CoreName.CellNm[cell1].n] ];
FOR temp: LIST OF NWMML _ nwmmls0, temp.rest WHILE temp#NIL DO
val: REF INT _ NARROW[HashTable.Fetch[table0, temp.first.name].value];
IF val^<2 AND NOT HashTable.Fetch[table1, temp.first.name].found THEN
out.PutF["\n%g\tpos: %5g", IO.rope[temp.first.name], IO.int[temp.first.min]] ENDLOOP;
out.PutRope["\n******"];
FOR temp: LIST OF NWMML _ nwmmls1, temp.rest WHILE temp#NIL DO
val: REF INT _ NARROW[HashTable.Fetch[table1, temp.first.name].value];
IF val^<2 AND NOT HashTable.Fetch[table0, temp.first.name].found THEN
out.PutF["\n%g\tpos: %5g", IO.rope[temp.first.name], IO.int[temp.first.min]] ENDLOOP;
out.PutRope["\n"]; out.Close[]};

PutPin: PUBLIC PROC[cell: CD.Object, size, loc: CD.Position, level: CD.Layer, name: ROPE]  = {
pinApl: CD.Instance
_ PW.IncludeInCell[cell, CDSymbolicObjects.CreatePin[size], loc];
CDSymbolicObjects.SetName[pinApl, name];
CDSymbolicObjects.SetLayer[pinApl, level]};


cmos: 				PUBLIC CD.Technology	= CMosB.cmosB;

cmosNDif:		PUBLIC CD.Layer _ CMosB.ndif;
cmosPDif:			PUBLIC CD.Layer	_ CMosB.pdif;
cmosWPDif:		PUBLIC CD.Layer	_ CMosB.wpdif;
cmosWNDif:		PUBLIC CD.Layer	_ CMosB.wndif;
cmosPoly:			PUBLIC CD.Layer	_ CMosB.pol;
cmosMet:			PUBLIC CD.Layer	_ CMosB.met;
cmosMet2:		PUBLIC CD.Layer	_ CMosB.met2;
cmosPWCont:		PUBLIC CD.Layer	_ CMosB.pwellCont;
cmosNWCont:	PUBLIC CD.Layer	_ CMosB.nwellCont;
cmosNWell:		PUBLIC CD.Layer	_ CMosB.nwell;

lambda:			PUBLIC INT	_	CMosB.lambda;

pwrW:			PUBLIC INT	_	5*lambda;
metW:				PUBLIC INT	_	3*lambda;
met2W:			PUBLIC INT	_	4*lambda;
polW:				PUBLIC INT	_	2*lambda;
difW:				PUBLIC INT	_	2*lambda;

topTail:			PUBLIC INT	_	2*lambda;
leftTail:			PUBLIC INT	_	6*lambda;	-- to center of 0th channel
rightTail:			PUBLIC INT	_	2*lambda;	-- metPitch-leftTail
botTail:			PUBLIC INT	_	1*lambda;

cnctSize: 			PUBLIC INT	_  4*lambda;
metPitch: 		PUBLIC INT	_  8*lambda;
met2Pitch: 		PUBLIC INT	_  8*lambda;
polMuxPitch: 	PUBLIC INT	_  8*lambda;
polPitch: 			PUBLIC INT	_  6*lambda;	-- without adjacent contacts

Contact: PUBLIC PROC[layer: CD.Layer] RETURNS[cntc: CD.Object] = {
RETURN[SELECT layer FROM
cmosMet2, cmosPoly, cmosNDif, cmosPDif, cmosWPDif, cmosWNDif	=>
CDSimpleRules.Contact[cmosMet, layer],
cmosPWCont, cmosNWCont	=>
CMosBObjects.CreateDifCon[layer],
ENDCASE	=> ERROR]};

TransistorObject: PUBLIC PROC[size: CD.Position, difLayer: CD.Layer]
RETURNS[trans: CD.Object]=
{trans _ CMosBObjects.CreateTransistor[size: size, difLayer: difLayer]};

textCache: CD.Design _ CDOps.CreateDesign[CD.FetchTechnology[$cmosB]];

ScaledText: PUBLIC PROC[text: ROPE, box: CD.Position, layer: CD.Layer, design: CD.Design_NIL]
RETURNS[cell: CD.Object _ NIL] = {
MakeName: PROC[fontIndex: INT] RETURNS[name: ROPE] = {
name _ IO.PutFR["Label%g-%g[%g]", IO.int[fontIndex], IO.int[scaleFactor], IO.rope[text]]};
Scale: PROC[font: Imager.Font] RETURNS[scale:		INT] = {
extents:	ImagerFont.Extents _ ImagerFont.RopeBoundingBox[font, text];
strSize:	CD.Position;
IF box.x<4 OR box.y<4 THEN RETURN[0];
strSize.x	_ Real.RoundI[extents.rightExtent+extents.leftExtent];
strSize.y	_ Real.RoundI[extents.ascent+extents.descent];
scale		_ MIN[box.x/strSize.x, box.y/strSize.y]};
scaleFactor: INT;
IF design=NIL THEN design _ textCache;
IF text.Length[]=0 THEN text _ "<no name>";
scaleFactor _ Scale[font2];
IF scaleFactor>0 THEN {
cell _ CDDirectory.Fetch[design, MakeName[2]].object;
IF cell=NIL THEN {
cell _ CDCreateLabels.CreateTextCell[design, text, font2, scaleFactor, layer];
[] _ CDDirectory.Include[design, cell, MakeName[2]];
RETURN[cell]} };
scaleFactor _ Scale[font1];
IF scaleFactor>0 THEN {
cell _ CDDirectory.Fetch[design, MakeName[1]].object;
IF cell=NIL THEN {
cell _ CDCreateLabels.CreateTextCell[design, text, font1, scaleFactor, layer];
[] _ CDDirectory.Include[design, cell, MakeName[2]];
RETURN[cell]} };
RETURN[NIL] };

ShowModule:	PUBLIC PROC[name: ROPE, design: CD.Design _ NIL] = {
frameCT: CellType;
new: BOOL _ design=NIL;
decoratedObj: CD.Object;
IF new THEN {
design _ CDOps.CreateDesign[CD.FetchTechnology[$cmosB]];
CDSimpleOps.RenameDesign[design, name]};
frameCT _ CoreFrame.ReadFrameCache[name];
IF frameCT=NIL THEN Signal[];
IF frameCT=NIL THEN RETURN;
decoratedObj	_ OrnateFrame[frameCT, design];
[] _ CDDirectory.Include[design, decoratedObj, Rope.Cat["Ornate", name]];
IF new THEN CDOps.IncludeObjectI[design, decoratedObj,	[0, 0]];
[ ] _ CDViewer.CreateViewer[design]};
DrawX: PUBLIC PROC[obj0, obj1, obj2, obj3, obj4: CD.Object _ NIL] =
{Draw[TRUE, obj0, obj1, obj2, obj3, obj4]};
DrawY: PUBLIC PROC[obj0, obj1, obj2, obj3, obj4: CD.Object _ NIL] =
{Draw[FALSE, obj0, obj1, obj2, obj3, obj4]};
Draw: PROC[inX: BOOL, obj0, obj1, obj2, obj3, obj4: CD.Object _ NIL] = {
design:	CD.Design _ CDOps.CreateDesign[CD.FetchTechnology[$cmosB]];
pos:		CD.Position _ [0, 0];
Add: PROC[obj: CD.Object, name: ROPE] = {
[] _ CDDirectory.Include[design, obj, name];
CDOps.IncludeObjectI[design, obj,	pos];
IF inX
THEN	pos.x	_ pos.x	+ ObjSize[obj].x
ELSE	pos.y	_ pos.y	+ ObjSize[obj].y};
IF obj0#NIL THEN {Add[obj0, "0"]};
IF obj1#NIL THEN {Add[obj1, "1"]};
IF obj2#NIL THEN {Add[obj2, "2"]};
IF obj3#NIL THEN {Add[obj3, "3"]};
IF obj4#NIL THEN {Add[obj4, "4"]};
[ ] _ CDViewer.CreateViewer[design] };


log: IO.STREAM _ CoreFrame.GetLog[];

IF metW	#	CDSimpleRules.MinWidth[cmosMet]	THEN ERROR;
IF met2W	#	CDSimpleRules.MinWidth[cmosMet2]	THEN ERROR;
IF polW	#	CDSimpleRules.MinWidth[cmosPoly]	THEN ERROR;
IF difW	#	CDSimpleRules.MinWidth[cmosNDif]	THEN ERROR;

END.





CCDUtilsImpl.mesa
Copyright c 1985 by Xerox Corporation.  All rights reserved.
Last Edited by Curry, October 8, 1986 7:28:04 am PDT



textOb	_ CDTexts.CreateText[pins[i].name, font, layer];
IF (size.x MOD 2)=1 OR (size.y MOD 2)=1 OR size.x<0 OR size.y<0
Alt vertsion of PWC.sidePinList
Only metal2 left/right or metal1 top/bottom power is included

RenamePins: PUBLIC PROC[
object:			CD.Object,
pinNameProc:	CCDUtils.PinNameProc]
RETURNS[newObject: CD.Object] = {
KeepPinOnEdge: CDSymbolicObjects.InstEnumerator ~ {
newRope: ROPE;
newInst: CD.Instance;
side: Side;
side _ PWPins.GetSide[object, inst];
IF side=none THEN RETURN;
newRope _ pinNameProc[inst, side];
IF Rope.IsEmpty[newRope] THEN RETURN;
newInst _ NEW[CD.InstanceRep _ [
ob:			CDSymbolicObjects.CreatePin[inst.ob.size], 
location:		inst.location,
orientation:	inst.orientation ]];
CDProperties.CopyProps[inst.properties, newInst];
CDSymbolicObjects.SetName[newInst, newRope];
newCellPtr.contents _ CONS[newInst, newCellPtr.contents] };
newCellPtr:	CD.CellPtr;
inst:			CD.Instance _ NEW[CD.InstanceRep _ [ob: object]];
CDProperties.PutInstanceProp[inst, $StopEnumerateDeepPins, $StopEnumerateDeepPins];
newObject	_ CDCells.CreateEmptyCell[];
newCellPtr	_ NARROW[newObject.specificRef];
[] _ PWPins.EnumerateDeepPins[object, KeepPinOnEdge];
newCellPtr.contents _ CONS[inst, newCellPtr.contents];
CDCells.SetInterestRect[newObject, CD.InterestRect[object]];
RETURN[newObject] };
mainObj _ CCDUtils.Layout[frameCT];
[] _ CDDirectory.Include[design, mainObj, name];
CDCleanUp.CleanUp[ design, NIL];


InsertModule: PUBLIC PROC
[cell: CellType, name: ROPE _ NIL, design: CD.Design] = {
new: BOOL _ design=NIL;
mainObj, decoratedObj: CD.Object;
name _ CoreName.CellNm[cell, name].n;
IF new THEN {
design _ CDOps.CreateDesign[CD.FetchTechnology[$cmosB]];
CDSimpleOps.RenameDesign[design, name]};
CoreFrame.Expand[hard, cell];
CoreFrame.NameFrame[cell, name];
[ ] _ CoreGlue.RouteHard[cell];
mainObj _ CoreFrame.Layout[cell];
[] _ CDDirectory.Include[design, mainObj, name];
decoratedObj	_ OrnateFrame[cell, design];
[] _ CDDirectory.Include[design, decoratedObj, Rope.Cat["Ornate", name]];
IF new THEN CDOps.IncludeObjectI[design, decoratedObj,	[0, 0]];
CDCleanUp.CleanUp[ design, NIL];
[ ] _ CDViewer.CreateViewer[design];
[ ] _ CDIO.WriteDesign[design, design.name] };
InsertModule: PUBLIC PROC[cell:CellType, name: ROPE _ NIL, design: CD.Design _NIL]={
name _ CoreName.CellNm[cell, name].n;
CoreFrame.Expand[hard, cell];
CoreFrame.NameFrame[cell, name];
[ ] _ CoreGlue.RouteHard[cell];
CoreFrame.WriteFrameCheckPoint[cell]};
�ʪ˜š
œ™Jš
œ<™<J™4J™—š
Ïk	˜	Jšœ
�œ”�œ�œ˜À—J˜šÏnœ�œ
�˜Jš�œ�œü
�œ�œ˜¯Jš�œ˜Jš
�˜J˜Jšžœ�œ�œ
˜Jš�œ�œ	�œ
˜Jš�œ�œ˜(Jš�œ�œ˜(Jšœ
�œ˜'Jšœ
�œ˜'Jš�œ�œ�œ
˜Jšœ
�œ˜#Jšœ
�œ˜!J˜š
œ˜Jš
œG˜G—Jšžœ�œ�œ�œ2˜Rš
žœ�œ�œ�œ�œ
˜1Jšœ
�œ
�œ%�œ˜@—J˜š
ž
œ�œ�œ�œ�œ˜<Jš	œ
�œ�œ�œ�œ˜C—J˜šžœ�œ
�œ�œ�œ�œ˜EJšœ�œ˜Jšœ	�œž
œ˜$Jš
�œ
�œ
�œ
�œ
�œ˜)Jš
œ˜Jš�œ�œ
�œ
�œ˜Jš
œ!˜!š�œ�œ�œ�œ˜9Jš�œ�œH˜Uš�œ˜Jšœ�œ�œ�œ˜:Jšœ�œ@˜HJšœ�œ@˜HJšœ�œ'˜/Jšœ�œ0˜8Jšœ�œ'˜/Jšœ�œ0˜8——Jšœžœ˜Jš
œ˜J™—š
ž	œ�œ
�œ�œ�œ˜EJšœ�œ˜ Jšœ�œ˜!Jšœ&�œ˜.Jš
œ6˜6—J˜šžœ�œ
�œ�œ	�œ�œ˜<Jš
�œ�œ�œ
�œ
�œ˜Jš
�œ�œ
�œ
�œ
�œ˜(Jš�œ
�œ
�œ�œ
�œ
�œ
�œ˜<Jš�œ
�œ�œ˜2—J˜šžœ�œ
�œ�œ	�œ�œ˜AJšœ
�œ
�œ˜—š
žœ�œ
�œ�œ�œ˜BJš
�œ�œ
�œ
�œ
�œ˜š�œ
�˜Jšœ)�œ
žœ
�œ˜JJšœ�œ
Ïbœ�œ
˜HJš�œ�œ
ž
œ
�
œ˜,——J™š
œ)˜)Jšœ$�œ
�œ�œ˜R—š
œ)˜)Jšœ%�œ
�œ�œ˜S—J˜šžœ�œ(˜@Jš�œ
�œ˜Jš
œ˜Jšœ	�œ
˜Jšœ�œ
˜Jšœ�œ�œ
�œ˜#Jšœ	�œ˜š�œ&˜(Jš�œ�œ˜'Jš�œ˜—Jš
œ#˜#Jš
œ%˜%Jšœ
�œ˜"Jšœ	�œ(˜3š�œ�œ�˜Jšœ�œ
�œ
�œ˜3Jšœ�œ
˜Jšœ�œ
˜Jšœ�œ˜Jš�œ�œ
�œ
�œ
˜Jš
œ+˜+š�œ�œ�œ
�˜4š
œ˜Jšœ+�œ˜D—Jš
œ7™7Jšœ�œÐbnœ	˜,Jšœ�œ˜Jšœ
�œ:˜GJš
œ˜šœ	�œ�˜Jš
œ+˜+Jš
œ2˜2Jš�œ�œ
˜—Jšœ�œ,˜4Jš
�˜—š�œ�˜Jš
œ"˜"Jš
œ"˜"Jš�œ�œ
˜—š�œ�˜Jš
œ=˜=Jš
œ?˜?Jš
œ=˜=Jš
œ>˜>Jš�œ�œ
˜—Jš
œ@˜@Jš
œ2˜2Jšœ�œ5˜=Jš�œ
˜—Jš
œ,˜,—J˜šžœ�œ
�œ�œ�œ�œ�œ˜_Jš�œ	�œ�œ	�œ�œ
�œ	™?š�œ�œ	˜š�œ˜Jš�œ-�œ�œ˜PJš
œ
˜
——Jš�œ
�œ
�œ
�œ
˜$Jšœ�œ<˜C—J˜J™J™=šžœ�œ
�œ!˜9Jš
�œ�œ
�œ
�œ�œ˜'Jš
œ˜Jš
œ˜šžœ"˜-šžœ˜0Jš�œ�œ
�œ
˜Jšœ/�œ
�œ�œ˜D—Jšœ�œ˜&Jš�œ�œ
�œ
˜š�œ
�œI˜OJš�œ
�œ
˜—š�œ�œ�˜(Jš
�œ�œ�œ�œ
�œ
˜9—š�œ5�œ
˜=Jš
œP˜P—Jš�œ�œ
�œ
�œ
˜Jš
œ@˜@—š�œ5˜7Jš�œ�œ�œ˜?—Jšœ�œ˜šœž˜$Jš
œ3˜3—Jšžœ˜—J˜šž
œ�œ
�œ�œ
�œ
�œ�œ
�œ˜?Jšœ�œ
�œ
�œ
˜Jšœ�œ
˜š�œ�œ�œ
�˜,Jšœ�œ�œ
˜$—Jš
œ˜Jš
�œ�œ�œ
�œ�œ
˜PJšœ�œ
�œ˜—J˜šž	œ�œ
�œ
�œ�œ
�œ˜8Jšœ�œ�œ˜,š
œ0˜0Jš�œ˜Jš�œ˜Jš�œ˜š�œ�œ
�˜ Jš
œ˜Jš
œ˜Jš
œ˜Jš�œ)˜0———J™šžœ�œ+�œ�œ˜Wšžœ�œ�œ˜3Jšœ�œ
�œ�œ#˜8Jš
�œ�œ
�œ�œ
�œ-˜KJš
œ˜—Jšœ	�œ
�œ
�œ0˜FJšœ	�œ
�œ
�œ˜3Jšœ
�œ0˜>Jšœ
�œ˜+Jšœ�œ
�œ
˜Jšœ	�œ˜Jšœ�œ�œ
�œ˜Jš
œ/˜/Jš
œ/˜/š�œ�˜
Jš�œ�œ)˜6š�œ
�œ�œ
�˜Jšœ�œ
�œ˜5Jšœ�œ
�œ�œ.˜IJšœ�œ
�œ˜Jš�œ˜——š
�œ�œ
�œ
�œ�œ�œ
�˜>Jšœ"�œ
˜*—š
�œ�œ
�œ
�œ�œ�œ
�˜>Jšœ"�œ
˜*—š
œG˜GJš�œ�
˜
Jš�œ�œ ˜4Jš�œ�œ!�
˜6—š
�œ�œ
�œ
�œ�œ�œ
�˜>Jšœ�œ
�œ�œ1˜Fš�œ�œ
�œ0�˜EJšœ�œ�œ�œ
˜U——Jš
œ˜š
�œ�œ
�œ
�œ�œ�œ
�˜>Jšœ�œ
�œ�œ1˜Fš�œ�œ
�œ0�˜EJšœ�œ�œ�˜U——Jšœ�
œ˜ J˜—šžœ�œ
�œ�œ�œ�œ�œ˜^šœ�œ	˜Jšœ�œ=˜A—Jš
œ(˜(Jš
œ+˜+—J˜šž
œ�œ
�œ
™Jšœ
�œ™š
œ"™"Jš�œ�œ™!—•StartOfExpansion= -- [app: CD.ApplicationPtr] RETURNS [quit: BOOL _ FALSE] -- šž
œ&™3Jšœ	�œ
™Jšœ	�œ
™Jš
œ™Jš
œ$™$Jš�œ�œ
�œ
™Jš
œ"™"Jš�œ�œ
�œ
™%šœ
�œ
�œ™ Jš
œ1™1Jš
œ™Jš
œ!™!—Jš
œ1™1Jš
œ,™,Jšœ�œ!™;—Jšœ�œ	™Jšœ�œ�œ
�œ™9Jš
œS™SJš
œ&™&Jšœ
�œ™+Jš
œ5™5Jšœ�œ™6Jšœ#�œ™<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šœ�œ
�œ
Ïc˜>Jšœ
�œ
�œ
¡˜8Jšœ�œ
�œ˜!J˜Jšœ
�œ
�œ
˜$Jšœ�œ
�œ
˜#Jšœ
�œ
�œ
˜$Jšœ�œ
�œ
˜%Jšœ
�œ
�œ¡˜AJ˜šžœ�œ
�œ�œ�œ�œ˜Bš�œ
�œ�˜š
œ?˜?Jš
œ&˜&—š
œ˜Jš
œ!˜!—Jš�œ�œ˜J˜——š
žœ�œ
�œ�œ�œ˜Dš�œ�œ	˜Jš
œH˜H——J˜Jšœ�œ9˜FJ˜šž
œ�œ
�œ�œ�œ�œ˜]Jš�œ�œ˜"š
žœ�œ�œ�œ�œ˜6Jš	œ�œ�œ�œ�œ˜Z—šžœ�œ�œ	�œ˜7Jš
œE˜EJšœ	�œ
˜Jš�œ	�œ	�œ
�œ˜%Jš
œ@˜@Jš
œ8˜8Jšœ	�œ$˜0—Jšœ
�œ
˜Jš�œ�œ
�œ˜&Jš
œ+˜+Jš
œ˜š�œ�œ˜Jš
œ5˜5š�œ�œ
�˜Jš
œN˜NJšœžœ˜4Jš�œ
˜——Jš
œ˜š�œ�œ˜Jš
œ5˜5š�œ�œ
�˜Jš
œN˜NJšœžœ˜4Jš�œ
˜——Jš�œ
�œ˜J˜—šž
œ�œ
�œ�œ
�œ
�œ˜@Jš
œ˜Jšœ�œ
�œ
˜Jšœ�œ˜š�œ�œ˜
Jšœ�œ˜8Jš
œ(˜(—Jš
œ)˜)Jš�œ	�œ
�œ
˜Jš�œ	�œ
�œ
�œ
˜Jš
œ#™#Jš
œ0™0Jš
œ,˜,Jš
œI˜IJš�œ�œ4˜?Jšœ�œ™ Jš
œ%˜%—J™š
žœ�œ
�œ�œ
�œ˜CJšœ�œ!˜+—š
žœ�œ
�œ�œ
�œ˜CJšœ�œ!˜,—š
žœ�œ�œ �œ
�œ˜HJšœ�œ�œ˜CJšœ�œ˜šžœ�œ�œ�œ˜)Jš
œ,˜,Jš
œ'˜'š�œ˜Jš�œ˜#Jš�œ!˜%——Jš�œ�œ
�œ˜"Jš�œ�œ
�œ˜"Jš�œ�œ
�œ˜"Jš�œ�œ
�œ˜"Jš�œ�œ
�œ˜"Jš
œ&˜&—J™šžœ�œ
�™Jšœ�œ�œ
�œ™9Jšœ�œ
�œ
™Jšœ�œ™!Jš
œ%™%š�œ�œ™
Jšœ�œ™8Jš
œ(™(—Jš
œ™Jš
œ ™ Jš
œ™Jš
œ!™!Jš
œ0™0Jš
œ)™)Jš
œI™IJš�œ�œ4™?Jšœ�œ™ Jš
œ$™$Jšœ�œ$™.—J˜šžœ�œ
�œ�œ�œ
�œ	�œ™TJš
œ%™%Jš
œ™Jš
œ ™ Jš
œ™Jš
œ&™&—J˜Jšœ�œ
�œ˜$J˜Jš�œ(�œ
�œ
˜5Jš�œ*�œ
�œ
˜7Jš�œ)�œ
�œ
˜6Jš�œ)�œ
�œ
˜6J˜Jš�œ
˜—J˜J˜J˜J˜—…—7rV: