DIRECTORY  CD, CDBasics, CDCells, CDInstances, CDRects, CDSimpleRules, CDSymbolicObjects, GList, PW, PWPins, PWRoute, Rope, Route, RouteUtil, RTBasic, SymTab;

PWRouteImpl: CEDAR PROGRAM
IMPORTS  CD, CDBasics, CDCells, CDInstances, CDRects, CDSimpleRules, CDSymbolicObjects, GList, PW, PWPins, Rope, Route, RouteUtil, RTBasic, SymTab
EXPORTS PWRoute =
BEGIN OPEN PWRoute;

AbutRouteList: PROC [listOb, bottomOrLeftListOb, topOrRightListOb: PWRoute.Objects, params: RouterParams, isX: BOOL, routeType: RouteType]
RETURNS [obj: CD.Object] =
BEGIN
newListObj: PWRoute.Objects _ NIL;
obj1, obj2, topOrRightObj, bottomOrLeftObj, channel: CD.Object;

IF listOb = NIL THEN RETURN[NIL];
obj1 _ listOb.first; listOb _ listOb.rest;
newListObj _ CONS[obj1, NIL];
FOR l: PWRoute.Objects _ listOb, l.rest WHILE l # NIL DO
obj2 _ l.first;
IF topOrRightListOb = NIL THEN topOrRightObj _ NIL 
ELSE {topOrRightObj _ topOrRightListOb.first; 
topOrRightListOb _ topOrRightListOb.rest};
IF bottomOrLeftListOb = NIL THEN bottomOrLeftObj _ NIL 
ELSE {bottomOrLeftObj _ bottomOrLeftListOb.first; 
bottomOrLeftListOb _ bottomOrLeftListOb.rest};
channel _ MakeChannel[obj1, obj2, bottomOrLeftObj, topOrRightObj, NIL, params, isX, routeType];
newListObj _ CONS[obj2, CONS[channel, newListObj]];
obj1 _ obj2;	-- just before looping
ENDLOOP;
newListObj _ Reverse[newListObj];

IF isX THEN obj _ PW.AbutListX[newListObj]
ELSE obj _ PW.AbutListY[newListObj];
END;

AbutChRouteListX: PUBLIC PROC [
listOb: PWRoute.Objects, 
bottomListOb: PWRoute.Objects _ NIL, 
topListOb: PWRoute.Objects _ NIL, 
params: RouterParams _ defaultRouterParams]
RETURNS [obj: CD.Object] =
{obj _ AbutRouteList[listOb, bottomListOb, topListOb, params, TRUE, channel]};

AbutChRouteListY: PUBLIC PROC [
listOb: PWRoute.Objects, 
leftListOb: PWRoute.Objects _ NIL, 
rightListOb: PWRoute.Objects _ NIL, 
params: RouterParams _ defaultRouterParams]
RETURNS [obj: CD.Object] =
{obj _ AbutRouteList[listOb, leftListOb, rightListOb, params, FALSE, channel]};

AbutSbRoute: PUBLIC PROC [
bottomOb, rightOb, topOb, leftOb: CD.Object _ NIL, 
trunkDir: HorV _ horizontal,
params: RouterParams _ defaultRouterParams] RETURNS [obj: CD.Object] = {
IF trunkDir = horizontal THEN 
obj _ MakeChannel[bottomOb, topOb, leftOb, rightOb, NIL, params, FALSE, switchBox]
ELSE
obj _ MakeChannel[leftOb, rightOb, bottomOb, topOb, NIL, params, TRUE, switchBox]};

Net: TYPE = REF NetRec;
NetRec: TYPE = RECORD[
name: Rope.ROPE _ NIL,					-- net name
pins: Route.PinList _ NIL];			-- the list of pins in the net

defaultRouterParams: PUBLIC RouterParams _ NEW[RouterParamsRec _ ["metal", "poly"]];

ParsePins: PROC[obj: CD.Object, tab: SymTab.Ref, side: PWPins.Side, params: RouterParams] = {

EachPin: CDSymbolicObjects.InstEnumerator = {
IF PWPins.GetSide[obj, inst].side=side THEN InsertPin[tab, inst, side, params];
};
IF obj # NIL THEN [] _ PWPins.EnumerateEdgePins[obj, EachPin];
};

FromSideToSide: PROC [side: PWPins.Side] RETURNS [routeSide: Route.Side] = {
routeSide _ SELECT side FROM
left => left,
right => right,
top => top,
bottom => bottom,
ENDCASE => ERROR;
};

OtherSide: PROC [side: Route.Side] RETURNS [opposite: Route.Side] = {
opposite _ SELECT side FROM
left => right,
right => left,
top => bottom,
bottom => top,
ENDCASE => ERROR;
};
InsertPin: PROC [tab: SymTab.Ref, inst: CD.Instance, side: PWPins.Side, params: RouterParams] = {
found: BOOL;
val: REF;
net: Net;

pin: Route.Pin _ Route.CreatePin[inst, OtherSide[FromSideToSide[side]]];
pinName: Rope.ROPE _ CDSymbolicObjects.GetName[inst];
tabIndex: Rope.ROPE _ IF params.makeTabKeyProc=NIL THEN pinName ELSE params.makeTabKeyProc[inst, params.context];
[found, val] _ SymTab.Fetch[tab, tabIndex]; 
net _ IF ~found THEN NEW[NetRec _ [pinName]] ELSE NARROW[val];
net.pins _ CONS[pin, net.pins];
[] _ SymTab.Store[tab, tabIndex, net];
};

ShipNets: PROC [tab: SymTab.Ref, routingArea: Route.RoutingArea, trunkAtom: ATOM, params: RouterParams] = {

EnterOneNet: SymTab.EachPairAction =
BEGIN
netName: Rope.ROPE _ NARROW[key];
net: Net _ NARROW[val];
width: Route.Number _ IF params.wireWidthProc=NIL THEN 0 ELSE params.wireWidthProc[net.name, params.context];
properties: Route.Properties _ RouteUtil.PutNumberProp[NIL, Route.trunkWidthKey, width];
Route.IncludeNet[routingArea, net.name, net.pins, properties];
RETURN[FALSE];
END;

[] _ SymTab.Pairs[tab, EnterOneNet];
};

DoRoute: PUBLIC PROC [obj1, obj2, bottomOrLeftObj, topOrRightObj: CD.Object, params: RouterParams, isX: BOOL, routeType: RouteType]
RETURNS [result: Route.RoutingResult] = {
tab: SymTab.Ref;
sideCoords: Route.PositionVec;	-- the positions of the sides in a "large" coord system
r1, r2, rbl, rtr, routingRect: CD.Rect _ [0, 0, 0, 0];
pBottom, pLeft, pTop, pRight: CD.Position;
trunkAtom: ATOM;

rules: Route.DesignRules _ 
IF isX THEN									-- abutX
Route.CreateDesignRules[params.technologyKey, 
CDSimpleRules.GetLayer[params.technologyKey, params.branchLayer], 
CDSimpleRules.GetLayer[params.technologyKey, params.trunkLayer],
vertical]
ELSE											-- abutY
Route.CreateDesignRules[params.technologyKey, 
CDSimpleRules.GetLayer[params.technologyKey, params.trunkLayer], 
CDSimpleRules.GetLayer[params.technologyKey, params.branchLayer], 
horizontal];

routingArea: Route.RoutingArea _ Route.CreateRoutingArea["Channel", rules];
IF obj1 # NIL THEN r1 _ CD.InterestRect[obj1];
IF obj2 # NIL THEN r2 _ CD.InterestRect[obj2];
IF bottomOrLeftObj # NIL THEN rbl _ CD.InterestRect[bottomOrLeftObj];
IF topOrRightObj # NIL THEN rtr _ CD.InterestRect[topOrRightObj];

IF isX THEN { 	-- AbutX
pBottom _ [0, - rbl.y2 + rbl.y1];
pLeft _ [- r1.x2 + r1.x1, 0];
pTop _ [0, MAX[r1.y2 - r1.y1, r2.y2 - r2.y1]];
pRight _ [MAX[rbl.x2 - rbl.x1, rtr.x2 - rtr.x1], 0];
Route.IncludeRoutingAreaSide[routingArea, left, [r1.x1, r1.y1]];
Route.IncludeRoutingAreaSide[routingArea, right, [r2.x1, r2.y1]];
Route.IncludeRoutingAreaSide[routingArea, bottom, [rbl.x1, rbl.y1]];
Route.IncludeRoutingAreaSide[routingArea, top, [rtr.x1, rtr.y1]];
trunkAtom _ $verticalWidth}

ELSE {	-- AbutY
pBottom _ [0, - r1.y2 + r1.y1];
pLeft _ [- rbl.x2 + rbl.x1, 0];
pTop _ [0, MAX[rbl.y2 - rbl.y1, rtr.y2 - rtr.y1]];
pRight _ [MAX[r1.x2 - r1.x1, r2.x2 - r2.x1], 0];
Route.IncludeRoutingAreaSide[routingArea, bottom, [r1.x1, r1.y1]];
Route.IncludeRoutingAreaSide[routingArea, top, [r2.x1, r2.y1]];
Route.IncludeRoutingAreaSide[routingArea, left, [rbl.x1, rbl.y1]];
Route.IncludeRoutingAreaSide[routingArea, right, [rtr.x1, rtr.y1]];
trunkAtom _ $horizontalWidth};
tab _ SymTab.Create[mod: 17, case: TRUE];	-- the table of all nets
ParsePins[obj1, tab, IF isX THEN right ELSE top, params];
ParsePins[obj2, tab, IF isX THEN left ELSE bottom, params];
ParsePins[topOrRightObj, tab, IF isX THEN bottom ELSE left, params];
ParsePins[bottomOrLeftObj, tab, IF isX THEN top ELSE right, params];
ShipNets[tab, routingArea, trunkAtom, params];

sideCoords _  [pBottom, pTop, pLeft, pRight];
routingRect _ [0, 0, pRight.x, pTop.y];
SELECT routeType FROM
channel => result _ Route.ChannelRoute[routingArea, sideCoords, routingRect, params.opt, params.signalSinglePinNets, params.signalCoincidentPins];
switchBox => result _ Route.SwitchBoxRoute[routingArea, sideCoords, routingRect, params.opt, params.signalSinglePinNets, params.signalCoincidentPins, params.okToDiddleLLPins, params.okToDiddleURPins];
ENDCASE;
IF result.incompleteNets # NIL AND params.signalIncomplete THEN Route.Signal[noResource, Rope.Cat["Incomplete routing of nets: ", RopeFromList[result.incompleteNets]]];
IF result.breakAtExitNets # NIL AND params.signalBreakAtExit THEN Route.Signal[noResource, Rope.Cat["Nets were divided at channel exit: ", RopeFromList[result.breakAtExitNets]]]};

GetRouting: PUBLIC PROC [result: Route.RoutingResult, retrieveRect: RefRect _ NIL, params: RouterParams _ defaultRouterParams] RETURNS [channel: CD.Object] ~ {


channel _ Route.RetrieveRouting[result, result.routingArea.name, retrieveRect, NIL, params.viaTable].object;
Route.Destroy[result.routingArea]};

MakeChannel: PUBLIC PROC [obj1, obj2, bottomOrLeftObj, topOrRightObj: CD.Object, retrieveRect: RefRect, params: RouterParams, isX: BOOL, routeType: RouteType] RETURNS [channel: CD.Object] = {
result: Route.RoutingResult_ DoRoute[obj1, obj2, bottomOrLeftObj, topOrRightObj, params, isX, routeType];
channel _ GetRouting[result, retrieveRect, params].channel;
Route.Destroy[result.routingArea]};

KeepAll: PUBLIC SelectNamesProc = {keepIt _ TRUE};

XferPins: PUBLIC PROC [technologyKey: ATOM, template: CD.Object, objSide: PWPins.Side, minWidth: INT, routingLayerDes: Rope.ROPE, selectNameProc: PWRoute.SelectNamesProc _ KeepAll, xferPinsProc: PWRoute.XferPinsProc] RETURNS [cell: CD.Object _ NIL] = {

FindPins: CDSymbolicObjects.InstEnumerator = {
IF PWPins.GetSide[template, inst].side=objSide THEN {
pinLayer: CD.Layer _ CDSymbolicObjects.GetLayer[inst];
IF pinLayer # routingLayer THEN {
pwBug: CD.Instance _ CDInstances.NewInst[ob: inst.ob, trans: [[0,0], pwBugOrien]];
xferObj: CD.Object;
CDSymbolicObjects.SetLayer[pwBug, pinLayer];
xferObj _ xferPinsProc[technologyKey, pwBug, routingLayer, 0];
needsXfer _ TRUE;
width _ MAX[width, RTBasic.IRSize[xferObj].x]}}};

MapPins: PWRoute.ForEachPinProc = {
obj _ NIL;
IF PWPins.GetSide[template, inst].side = objSide THEN {
pinInst: CD.Instance;
pinSize: CD.Position;
pinOb, wire: CD.Object;
pwBug: CD.Instance _ CDInstances.NewInst[ob: inst.ob, trans: [[0,0], pwBugOrien]];
CDSymbolicObjects.SetLayer[pwBug, CDSymbolicObjects.GetLayer[inst]];
wire _ xferPinsProc[technologyKey, pwBug, routingLayer, width];
pinSize _ CDBasics.OrientedSize[CDBasics.SizeOfRect[pwBug.ob.bbox], pwBug.trans.orient];
pinOb _ CDSymbolicObjects.CreatePin[pinSize];
obj _ CDCells.CreateEmptyCell[];
pinInst _ CDCells.IncludeOb[cell: obj, ob: pinOb, trans: [[width-pinSize.x, 0]]].newInst;
[] _ CDCells.IncludeOb[cell: obj, ob: wire];
CDSymbolicObjects.SetName[pinInst, CDSymbolicObjects.GetName[inst]];
CDSymbolicObjects.SetLayer[pinInst, routingLayer];
RTBasic.RepositionCell[obj];
};
};

width: INT _ MAX[minWidth, 0];
needsXfer: BOOLEAN _ width > 0;
routingLayer: CD.Layer _ CDSimpleRules.GetLayer[technologyKey, routingLayerDes];
pwBugOrien: CD.Orientation _ IF objSide=top OR objSide=bottom THEN rotate90 ELSE original; -- PW problem: inst has wrong orientation!!!
IF template # NIL THEN {
[] _ PWPins.EnumerateEdgePins[template, FindPins];
IF needsXfer THEN
cell _ PWPins.TransferCell[template, objSide, width, MapPins, selectNameProc];
};
};


defaultXferPins: PUBLIC XferPinsProc = {
pinLayer: CD.Layer _ CDSymbolicObjects.GetLayer[inst];
polyLayer: CD.Layer _ CDSimpleRules.GetLayer[technologyKey, "poly"];
metalLayer: CD.Layer _ CDSimpleRules.GetLayer[technologyKey, "metal"];
metal2Layer: CD.Layer _ CDSimpleRules.GetLayer[technologyKey, "metal2"];
m1ToM12: INT _ MAX[CDSimpleRules.MinSpace[NIL, metalLayer, metalLayer], CDSimpleRules.MinSpace[NIL, metal2Layer, metal2Layer]];
sizeX, pinSizeY: INT;
cdLambda: INT _ CD.LayerTechnology[routingLayer].lambda;
pinSize: CD.Position _ CDBasics.OrientedSize[CDBasics.SizeOfRect[inst.ob.bbox], inst.trans.orient];
pinSizeY _ pinSize.y;
cell _ CDCells.CreateEmptyCell[];

SELECT TRUE FROM
pinLayer = routingLayer => {
sizeX _ width;
IF width > 0 THEN {
[] _ CDCells.IncludeOb[cell: cell, ob: CDRects.CreateRect[[sizeX, pinSizeY], pinLayer]]}};

pinLayer = polyLayer => {
pContact: CD.Object _ CDSimpleRules.Contact[NIL, polyLayer, metalLayer];
contactSize: CD.Position _ CDBasics.SizeOfRect[pContact.bbox];
wireP, mPContact: CD.Object;
sizeX _ m1ToM12 + contactSize.x;
wireP _ CDRects.CreateRect[[sizeX, pinSizeY], polyLayer];
[] _ CDCells.IncludeOb[cell: cell, ob: wireP];
mPContact _ RouteUtil.StitchVias[[contactSize.x, pinSizeY], polyLayer, metalLayer, cdLambda, NIL];
[] _ CDCells.IncludeOb[cell: cell, ob: mPContact, trans: [[m1ToM12, (pinSizeY-CDBasics.SizeOfRect[mPContact.bbox].y)/2]]];
IF routingLayer = metal2Layer THEN {
mVia: CD.Object _ CDSimpleRules.Contact[NIL, metalLayer, metal2Layer];
viaSize: CD.Position _ CDBasics.SizeOfRect[mVia.bbox];
wireM2: CD.Object _ CDRects.CreateRect[[m1ToM12, pinSizeY], metal2Layer];
m2M1Via: CD.Object;
[] _ CDCells.IncludeOb[cell: cell, ob: wireM2, trans: [[sizeX, 0]]];
sizeX _ sizeX + m1ToM12;
m2M1Via _ RouteUtil.StitchVias[[viaSize.x, pinSizeY], metalLayer, metal2Layer, cdLambda, NIL];
[] _ CDCells.IncludeOb[cell: cell, ob: m2M1Via, trans: [[sizeX, (pinSizeY-CDBasics.SizeOfRect[m2M1Via.bbox].y)/2]]];
sizeX _ sizeX + viaSize.x};
IF width > sizeX THEN {
wireRL: CD.Object _ CDRects.CreateRect[[width - sizeX, pinSizeY], routingLayer];
[] _ CDCells.IncludeOb[cell: cell, ob: wireRL, trans: [[sizeX, 0]]];
sizeX _ width}};

pinLayer = metalLayer => {
IF routingLayer = metal2Layer THEN {
mVia: CD.Object _ CDSimpleRules.Contact[NIL, metalLayer, metal2Layer];
viaSize: CD.Position _ CDBasics.SizeOfRect[mVia.bbox];
wireM, m2M1Via: CD.Object;
sizeX _ m1ToM12 + viaSize.x;
wireM _ CDRects.CreateRect[[sizeX, pinSizeY], metalLayer];
[] _ CDCells.IncludeOb[cell: cell, ob: wireM];
m2M1Via _ RouteUtil.StitchVias[[viaSize.x, pinSizeY], metalLayer, metal2Layer, cdLambda, NIL];
[] _ CDCells.IncludeOb[cell: cell, ob: m2M1Via, trans:[[m1ToM12, (pinSizeY-CDBasics.SizeOfRect[m2M1Via.bbox].y)/2]]];
IF width > sizeX THEN {
wireM2: CD.Object _ CDRects.CreateRect[[width - sizeX, pinSizeY], metal2Layer];
[] _ CDCells.IncludeOb[cell: cell, ob: wireM2, trans: [[sizeX, 0]]];
sizeX _ width}}
ELSE {
pContact: CD.Object _ CDSimpleRules.Contact[NIL, polyLayer, metalLayer];
contactSize: CD.Position _ CDBasics.SizeOfRect[pContact.bbox];
wireM, mPContact: CD.Object;
sizeX _ m1ToM12 + contactSize.x;
wireM _ CDRects.CreateRect[[sizeX, pinSizeY], metalLayer];
[] _ CDCells.IncludeOb[cell: cell, ob: wireM];
mPContact _ RouteUtil.StitchVias[[contactSize.x, pinSizeY], polyLayer, metalLayer, cdLambda, NIL];
[] _ CDCells.IncludeOb[cell: cell, ob: mPContact, trans: [[CDBasics.SizeOfRect[wireM.bbox].x, (pinSizeY-CDBasics.SizeOfRect[mPContact.bbox].y)/2]]];
IF width > sizeX THEN {
wireP: CD.Object _ CDRects.CreateRect[[width - sizeX, pinSizeY], polyLayer];
[] _ CDCells.IncludeOb[cell: cell, ob: wireP, trans: [[sizeX, 0]]];
sizeX _ width}}};

pinLayer = metal2Layer => {
mVia: CD.Object _ CDSimpleRules.Contact[NIL, metalLayer, metal2Layer];
viaSize: CD.Position _ CDBasics.SizeOfRect[mVia.bbox];
wireM2, m2M1Via: CD.Object;
sizeX _ m1ToM12 + viaSize.x;
wireM2 _ CDRects.CreateRect[[sizeX, pinSizeY], metal2Layer];
[] _ CDCells.IncludeOb[cell: cell, ob: wireM2];
m2M1Via _ RouteUtil.StitchVias[[viaSize.x, pinSizeY], metalLayer, metal2Layer, cdLambda, NIL];
[] _ CDCells.IncludeOb[cell: cell, ob: m2M1Via, trans: [[m1ToM12, (pinSizeY-CDBasics.SizeOfRect[m2M1Via.bbox].y)/2]]];
IF routingLayer = polyLayer THEN {
pContact: CD.Object _ CDSimpleRules.Contact[NIL, metalLayer, polyLayer];
contactSize: CD.Position _ CDBasics.SizeOfRect[pContact.bbox];
wireM: CD.Object _ CDRects.CreateRect[[m1ToM12 + contactSize.x, pinSizeY], metalLayer];
mPContact: CD.Object _ RouteUtil.StitchVias[[contactSize.x, pinSizeY], polyLayer, metalLayer, cdLambda, NIL];
[] _ CDCells.IncludeOb[cell: cell, ob: wireM, trans: [[sizeX, 0]]];
sizeX _ sizeX + m1ToM12;
[] _ CDCells.IncludeOb[cell: cell, ob: mPContact, trans: [[sizeX, (pinSizeY-CDBasics.SizeOfRect[mPContact.bbox].y)/2]]];
sizeX _ sizeX + contactSize.x};
IF width > sizeX THEN {
wireRL: CD.Object _ CDRects.CreateRect[[width - sizeX, pinSizeY], routingLayer];
[] _ CDCells.IncludeOb[cell: cell, ob: wireRL, trans: [[sizeX, 0]]];
sizeX _ width};
};
ENDCASE;
CDCells.SetInterestRect[design: NIL, cell: cell, r: [0, 0, sizeX, pinSizeY]]};

Reverse: PROC [objects: PWRoute.Objects] RETURNS [result: PWRoute.Objects _ NIL] = {
result _ NARROW [GList.Reverse[objects]]};

RopeFromList: PROC [list: LIST OF Rope.ROPE] RETURNS [rope: Rope.ROPE] ~ {
-- make a rope from a list of ropes
UNTIL list = NIL DO rope _ Rope.Cat[list.first, ", ", rope]; list _ list.rest ENDLOOP};

END.
:PWRouteImpl.mesa
Copyright Σ 1985, 1986, 1987 by Xerox Corporation.  All rights reversed.
Last Edited by: Preas, April 3, 1987 4:29:46 pm PST

-- AbutRoute: uses a channel router to connect adjacent objects
-- Given two cells that we plan to abut, this module parses the corresponding edges, extract the pins, build nets according to the names on the pins, then calls the router to produce a cell containing the channel routing.
-- Gets all the pins on the edge; pack them into nets and put in the SymTab.Ref
[inst: CD.Instance] RETURNS [quit: BOOL _ FALSE]

-- Group pins in net and insert in table
-- Read the table and ship the nets to the channel router
-- Make the design rules for proper spacing in this techno
-- Initialize the channel: no fancy option for now
-- In prevision of the use of the IRect coord system, origins are [0, 0]


-- Parse the objects, get the pins, make the nets, put in table

-- Read the table and ship the nets to the channel router
-- Now route!

[inst: CD.Instance] RETURNS [quit: BOOL _ FALSE]
-- when PW is fixed clean this up
[inst: Instance] RETURNS [obj: Object]
-- when PW is fixed clean this up
-- when PW is fixed clean this up
XferPinsProc: TYPE = PROC [technologyKey: ATOM, inst: CD.Instance, routingLayer: CD.Layer, width: INT] RETURNS [cell: CD.Object] --
-- Reverse a list of objects
ΚG˜
code–

"Cedar" styleš
œ™Kš
œH™HKš
œ3™3—™KšΟk	œœTœ;˜ž
—K˜šΟnœœ
˜KšœœTœ1˜’
Kšœ
˜Kšœ
œ	˜K˜Kš
Οc?™?šž
œœ\œ˜Š
Kšœœ
˜Kš
˜Kšœœ
˜"Kšœ5œ˜?K˜Kš
œ
œ
œ
œ
œ˜!Kš
œ*˜*Kšœ
œœ˜šœ%œœ
˜8Kš
œ˜Kšœœ
œœ
˜3šœ*˜.Kš
œ*˜*—Kšœœ
œœ
˜7šœ.˜2Kš
œ.˜.—KšœBœ˜_Kšœ
œœ˜3Kšœ
Ÿ˜#Kšœ
˜—Kš
œ!˜!K˜Kšœœœ˜*Kšœœ˜$Kšœ
˜K˜—šžœœ
œ˜Kš
œ˜Kšœ œ˜%Kšœœ˜"Kš
œ+˜+Kšœœ
˜Kšœ>œ˜N—K˜šžœœ
œ˜Kš
œ˜Kšœœ˜#Kšœœ˜$Kš
œ+˜+Kšœœ
˜Kšœ>œ˜O—K˜šžœœ
œ˜Kšœ"œ
œ˜3K˜Kšœ,œœ˜Hšœœ
˜Kšœ4œ
œ˜R—š
˜Kšœ4œ
œ˜S———K˜Kš
Ÿέ
™έ
Kšœœœ˜šœœœ
˜KšœœœŸ˜&KšœœŸ˜<—K˜Kšœœœ&˜TK˜Kš
ŸO™OKšž	œœœF˜]˜•StartOfExpansion4 -- [inst: CD.Instance] RETURNS [quit: BOOL _ FALSE]šΠbnœ&˜-Kš	œœœœœ
™0Kšœ%œ$˜OKš
œ˜—Kšœœ
œ-˜>Kš
œ˜—K˜–[]šžœœœ˜Lšœœ˜K˜
Kš
œ˜Kš
œ˜Kš
œ˜Kšœœ
˜—K˜—K˜šž	œœœ˜Ešœœ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kšœœ
˜—K˜—K™Kš
Ÿ(™(šž	œœœ7˜aKšœœ
˜Kšœœ
˜	K˜	K˜Kš
œH˜HKšœœ#˜5Kšœœœœ
œ	œ-˜qKš
œ,˜,Kšœœœ
œœ
œ˜>Kšœœ˜Kš
œ&˜&Kš
œ˜—K˜Kš
Ÿ9™9šžœœ>œ˜kK˜šžœ˜$Kš
˜Kšœœœ˜!Kšœœ˜Kš	œœœ
œœ0˜mKšœ7œ˜XKš
œ>˜>Kšœ
œ˜Kšœ
˜—K˜Kš
œ$˜$Kš
œ˜K˜—š
žœœ
œ.œ$œ˜ƒ
Kšœ"˜)Kš
œ˜KšœŸ7˜VKšœœ˜6Kšœœ
˜*Kšœœ
˜K˜Kš
Ÿ:™:š
œ˜šœœ	Ÿ˜š
œ.˜.Kš
œB˜BKš
œ@˜@Kš
œ	˜	——šœŸ˜š
œ.˜.Kš
œA˜AKš
œB˜BKš
œ
˜
———Kš
Ÿ2™2Kš
œK˜KKš
ŸH™HKšœœ
œœ˜.Kšœœ
œœ˜.Kšœœ
œœ˜EKšœœ
œœ˜AK˜šœœŸ˜Kš
œ!˜!Kš
œ˜Kšœœ ˜.Kšœ
œ'˜4Kš
œ@˜@Kš
œA˜AKš
œD˜DKš
œA˜AKš
œ˜K˜—šœŸ˜Kš
œ˜Kš
œ˜Kšœœ$˜2Kšœ
œ#˜0Kš
œB˜BKš
œ?˜?Kš
œB˜BKš
œC˜CKš
œ˜—K™Kšœ#œŸ˜BK™Kš
Ÿ?™?Kšœœœœ˜9Kšœœœœ˜;Kšœœœœ˜DKšœ œœœ˜DK™Kš
Ÿ9™9Kš
œ.˜.K˜Kš
Ÿ
™
Kš
œ-˜-Kš
œ'˜'šœ˜Kš
œ’
˜’
Kš
œΘ
˜Θ
Kšœ
˜—Kšœœ
œœi˜¨
Kšœœ
œœr˜³
K˜—šž
œœ
œ7œ.œœ˜Ÿ
K˜K˜KšœOœ˜lKš
œ#˜#K˜—šžœœ
œ.œ;œœœ˜Ώ
Kš
œi˜iKš
œ;˜;Kš
œ#˜#K˜—K™Kšžœœœ˜2K˜šžœœ
œœœ)œœYœœ
œ˜ό
K–4 -- [inst: CD.Instance] RETURNS [quit: BOOL _ FALSE]˜š œ&˜.Kš	œœœœœ
™0šœ-œ˜5Kšœ
œ*˜6šœœ˜!Kš
Ÿ!™!KšœœI˜RKšœ	œ˜Kš
œ,˜,Kš
œ>˜>Kšœœ
˜Kšœœ&˜1———K˜šžœ˜#Kšœœ™&Kšœœ
˜
šœ/œ˜7Kšœ	œ
˜Kšœ	œ
˜Kšœ
œ˜Kš
Ÿ!™!KšœœI˜RKš
œD˜DKš
œ?˜?Kš
œX˜XKš
œ-˜-Kš
œ ˜ Kš
œY˜YKš
œ,˜,Kš
œD˜DKš
œ2˜2Kš
œ˜K˜—Kš
œ˜K˜—Kšœœœ˜Kšœœ
˜Kšœœ@˜PKš
Ÿ!™!Kšœœœ
œœ
œŸ,˜‡
šœœ
œ˜Kš
œ2˜2šœ˜Kš
œN˜N—K˜—K˜—K˜K˜šœœ˜(Kšœœœœœœœœœ	Ÿ™ƒ
Kšœ
œ*˜6Kšœœ7˜DKšœœ8˜FKšœ
œ9˜HKšœ	œœm˜Kšœœ
˜Kšœ
œœ&˜8Kšœ	œX˜cKš
œ˜Kš
œ!˜!K˜šœ
œ
˜š
œ˜Kš
œ˜šœœ˜Kš
œZ˜ZK˜——š
œ˜Kšœ
œ<˜HKšœ
œ/˜>Kšœœ˜Kš
œ ˜ Kš
œ9˜9Kš
œ.˜.Kšœ]œ˜bKš
œz˜zšœœ˜$Kšœœ>˜FKšœ	œ+˜6Kšœœ?˜IKšœ	œ˜Kš
œD˜DKš
œ˜KšœYœ˜^Kš
œt˜tKš
œ˜—šœœ˜KšœœF˜PKš
œD˜DKš
œ˜——K˜š
œ˜šœœ˜$Kšœœ>˜FKšœ	œ+˜6Kšœœ˜Kš
œ˜Kš
œ:˜:Kš
œ.˜.KšœYœ˜^Kš
œu˜ušœœ˜KšœœE˜OKš
œD˜DKš
œ˜——šœ˜Kšœ
œ<˜HKšœ
œ/˜>Kšœœ˜Kš
œ ˜ Kš
œ:˜:Kš
œ.˜.Kšœ]œ˜bKš
œ”
˜”
šœœ˜KšœœC˜LKš
œC˜CKš
œ˜———K˜š
œ˜Kšœœ>˜FKšœ	œ+˜6Kšœœ˜Kš
œ˜Kš
œ<˜<Kš
œ/˜/KšœYœ˜^Kš
œv˜všœœ˜"Kšœ
œ<˜HKšœ
œ/˜>KšœœN˜WKšœœ[œ˜mKš
œC˜CKš
œ˜Kš
œx˜xKš
œ˜—šœœ˜KšœœF˜PKš
œD˜DKš
œ˜—K˜—Kšœ
˜—Kšœ œ+˜N—K˜šžœœœœ˜TKš
Ÿ™Kšœ	œ˜*K˜—šžœœœ˜JK˜#Kšœœ
œ;œ˜WK˜—Kšœ
˜—…—>(R©