DIRECTORY 
CD,
CDBasics,
CDCells,
CDOrient,
CDSymbolicObjects,
CDRects,
CDSimpleRules,
PW,
PWPins,
PWRoute,
Route, 
RouteUtil,
SymTab;

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

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

IF listOb = NIL THEN RETURN[NIL];
obj1 _ listOb.first; listOb _ listOb.rest;
newListObj _ CONS[obj1, NIL];
FOR l: PW.ListOb _ 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 _ PW.Reverse[newListObj];

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

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

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

AbutSbRoute: PUBLIC PROC [
bottomOb, rightOb, topOb, leftOb: PW.Object _ NIL, 
trunkDir: HorV _ horizontal,
params: RouterParams _ defaultRouterParams] RETURNS [obj: PW.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 _ 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 _ CDSymbolicObjects.GetName[inst];
tabIndex: 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 _ NARROW[key];
net: Net _ NARROW[val];
width: Route.Number _ IF params.wireWidthProc=NIL THEN 0 ELSE params.wireWidthProc[net.name, params.context];
properties: Route.PropList _ 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, "Incomplete routing of nets"];
IF result.breakAtExitNets # NIL AND params.signalBreakAtExit THEN Route.Signal[noResource, "Nets were divided at channel exit"];
};

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

channel _ Route.RetrieveRouting[result, result.routingArea.name, retrieveRect, NIL].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].channel;
Route.Destroy[result.routingArea];
};

XferPins: PUBLIC PROC [technologyKey: ATOM, template: PW.Object, objSide: PWPins.Side, minWidth: INT, routingLayerDes: ROPE, selectNameProc: PW.SelectNamesProc _ PW.KeepAll, xferPinsProc: PWRoute.XferPinsProc] RETURNS [cell: PW.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 _ CDCells.IncludeOb[NIL, NIL, inst.ob, [0,0], pwBugOrien].newInst;
xferObj: PW.Object;
CDSymbolicObjects.SetLayer[pwBug, pinLayer];
xferObj _ xferPinsProc[technologyKey, pwBug, routingLayer, 0];
needsXfer _ TRUE;
width _ MAX[width, IRSize[xferObj].x]};
};
};

MapPins: PW.ForEachPinProc = {
obj _ NIL;
IF PWPins.GetSide[template, inst].side = objSide THEN {
pinInst: CD.Instance;
pinSize: CD.Position;
pinOb, wire: CD.Object;
pwBug: CD.Instance _ CDCells.IncludeOb[NIL, NIL, inst.ob, [0,0], pwBugOrien].newInst;
CDSymbolicObjects.SetLayer[pwBug, CDSymbolicObjects.GetLayer[inst]];
wire _ xferPinsProc[technologyKey, pwBug, routingLayer, width];
pinSize _ CDOrient.OrientedSize[pwBug.ob.size, pwBug.orientation];
pinOb _ CDSymbolicObjects.CreatePin[pinSize];
obj _ PW.CreateEmptyCell[];
pinInst _ PW.IncludeInCell[obj, pinOb, [width-pinSize.x, 0]];
[] _ PW.IncludeInCell[obj, wire];
CDSymbolicObjects.SetName[pinInst, CDSymbolicObjects.GetName[inst]];
CDSymbolicObjects.SetLayer[pinInst, routingLayer];
PW.RepositionCell[obj];
};
};

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

IRSize: PROC [obj: PW.Object] RETURNS [size: CD.Position] =
{size _ CDBasics.SizeOfRect[CD.InterestRect[obj]]};

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.MinDist[metalLayer, metalLayer], CDSimpleRules.MinDist[metal2Layer, metal2Layer]];
sizeX, pinSizeY: INT;
cdLambda: INT _ CD.LayerTechnology[routingLayer].lambda;
pinSize: CD.Position _ CDOrient.OrientedSize[inst.ob.size, inst.orientation];
pinSizeY _ pinSize.y;
cell _ PW.CreateEmptyCell[];

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

pinLayer = polyLayer => {
pContact: PW.Object _ CDSimpleRules.Contact[polyLayer, metalLayer];
wireP, mPContact: PW.Object;
sizeX _ m1ToM12 + pContact.size.x;
wireP _ CDRects.CreateRect[[sizeX, pinSizeY], polyLayer];
[] _ PW.IncludeInCell[cell, wireP];
mPContact _ StitchVias[[pContact.size.x, pinSizeY], polyLayer, metalLayer, cdLambda];
[] _ PW.IncludeInCell[cell, mPContact, [m1ToM12, (pinSizeY-mPContact.size.y)/2]];
IF routingLayer = metal2Layer THEN {
mVia: PW.Object _ CDSimpleRules.Contact[metalLayer, metal2Layer];
wireM2: PW.Object _ CDRects.CreateRect[[m1ToM12, pinSizeY], metal2Layer];
m2M1Via: PW.Object;
[] _ PW.IncludeInCell[cell, wireM2, [sizeX, 0]];
sizeX _ sizeX + m1ToM12;
m2M1Via _ StitchVias[[mVia.size.x, pinSizeY], metalLayer, metal2Layer, cdLambda];
[] _ PW.IncludeInCell[cell, m2M1Via, [sizeX, (pinSizeY-m2M1Via.size.y)/2]];
sizeX _ sizeX + mVia.size.x};
IF width > sizeX THEN {
wireRL: PW.Object _ CDRects.CreateRect[[width - sizeX, pinSizeY], routingLayer];
[] _ PW.IncludeInCell[cell, wireRL, [sizeX, 0]];
sizeX _ width}};

pinLayer = metalLayer => {
IF routingLayer = metal2Layer THEN {
mVia: PW.Object _ CDSimpleRules.Contact[metalLayer, metal2Layer];
wireM, m2M1Via: PW.Object;
sizeX _ m1ToM12 + mVia.size.x;
wireM _ CDRects.CreateRect[[sizeX, pinSizeY], metalLayer];
[] _ PW.IncludeInCell[cell, wireM];
m2M1Via _ StitchVias[[mVia.size.x, pinSizeY], metalLayer, metal2Layer, cdLambda];
[] _ PW.IncludeInCell[cell, m2M1Via, [m1ToM12, (pinSizeY-m2M1Via.size.y)/2]];
IF width > sizeX THEN {
wireM2: PW.Object _ CDRects.CreateRect[[width - sizeX, pinSizeY], metal2Layer];
[] _ PW.IncludeInCell[cell, wireM2, [sizeX, 0]];
sizeX _ width}}
ELSE {
pContact: PW.Object _ CDSimpleRules.Contact[polyLayer, metalLayer];
wireM, mPContact: PW.Object;
sizeX _ m1ToM12 + pContact.size.x;
wireM _ CDRects.CreateRect[[sizeX, pinSizeY], metalLayer];
[] _ PW.IncludeInCell[cell, wireM];
mPContact _ StitchVias[[pContact.size.x, pinSizeY], polyLayer, metalLayer, cdLambda];
[] _ PW.IncludeInCell[cell, mPContact, [wireM.size.x, (pinSizeY-mPContact.size.y)/2]];
IF width > sizeX THEN {
wireP: PW.Object _ CDRects.CreateRect[[width - sizeX, pinSizeY], polyLayer];
[] _ PW.IncludeInCell[cell, wireP, [sizeX, 0]];
sizeX _ width}}};

pinLayer = metal2Layer => {
mVia: PW.Object _ CDSimpleRules.Contact[metalLayer, metal2Layer];
wireM2, m2M1Via: PW.Object;
sizeX _ m1ToM12 + mVia.size.x;
wireM2 _ CDRects.CreateRect[[sizeX, pinSizeY], metal2Layer];
[] _ PW.IncludeInCell[cell, wireM2];
m2M1Via _ StitchVias[[mVia.size.x, pinSizeY], metalLayer, metal2Layer, cdLambda];
[] _ PW.IncludeInCell[cell, m2M1Via, [m1ToM12, (pinSizeY-m2M1Via.size.y)/2]];
IF routingLayer = polyLayer THEN {
pContact: PW.Object _ CDSimpleRules.Contact[metalLayer, polyLayer];
wireM: PW.Object _ CDRects.CreateRect[[m1ToM12 + pContact.size.x, pinSizeY], metalLayer];
mPContact: PW.Object _ StitchVias[[pContact.size.x, pinSizeY], polyLayer, metalLayer, cdLambda];
[] _ PW.IncludeInCell[cell, wireM, [sizeX, 0]];
sizeX _ sizeX + m1ToM12;
[] _ PW.IncludeInCell[cell, mPContact, [sizeX, (pinSizeY-mPContact.size.y)/2]];
sizeX _ sizeX + pContact.size.x};
IF width > sizeX THEN {
wireRL: PW.Object _ CDRects.CreateRect[[width - sizeX, pinSizeY], routingLayer];
[] _ PW.IncludeInCell[cell, wireRL, [sizeX, 0]];
sizeX _ width};
};
ENDCASE;
CDCells.SetInterestRect[cell, [0, 0, sizeX, pinSizeY]];
[] _ CDCells.RepositionCell[cell, NIL]};

StitchVias: PROC [size: CD.Position, layer1, layer2: CD.Layer, cdLambda: INT] RETURNS [cell: PW.Object] = {

via: PW.Object _ RouteUtil.GetVia[size, layer1, layer2, cdLambda];
cell _ RouteUtil.StitchVias[via, size, layer1, layer2, cdLambda]};


END.
 
pPWRouteImpl.mesa
Copyright c 1985, 1986 by Xerox Corporation.  All rights reversed.
Last Edited by: Preas, January 27, 1986 3:26:48 pm PST
Frank Bowers May 20, 1986 10:49:50 am PDT
Bryan Preas February 6, 1986 2:43:49 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: PW.Object] --
Κ…˜–

"Cedar" styleš
œ™Jšœ
Οm
œ7™BJ™6Icode™)K™+—J™šΟk	œ
˜
Jšžœ
˜Jš
œ	˜	J˜Jš
œ	˜	Jš
œ˜J˜Jš
œ˜Jšžœ
˜Jš
œ˜Jš
œ˜J˜J˜
J˜—J˜šΟnœžœ
žœ˜JšžœžœJžœ"˜yJšžœ
˜Jšžœ
žœ	˜J˜™?šŸ
œžœ0žœ$žœ˜„
Jšžœžœ
˜Jš
ž˜Jšœžœ
žœ
˜Jšœ5žœ˜?J˜Jš
žœ
žœ
žœ
žœ
žœ˜!Jš
œ*˜*Jšœ
žœžœ˜š	žœžœžœžœ
ž˜2Jš
œ˜Jšžœžœ
žœžœ
˜3šžœ*˜.Jš
œ*˜*—Jšžœžœ
žœžœ
˜7šžœ.˜2Jš
œ.˜.—JšœBžœ˜_Jšœ
žœžœ˜3Jšœ
Οc˜#Jšžœ
˜—Jšœ
žœ˜$J˜Jšžœžœžœ˜*Jšžœžœ˜$Jšžœ
˜—J˜šŸœžœ
žœ˜Jšœžœ	˜Jšœžœ
žœ˜Jšœžœ
žœ˜Jš
œ+˜+Jšžœžœ
˜Jšœ>žœ˜N—J˜šŸœžœ
žœ˜Jšœžœ	˜Jšœžœ
žœ˜Jšœ
žœ
žœ˜Jš
œ+˜+Jšžœžœ
˜Jšœ>žœ˜O—J˜šŸœžœ
žœ˜Jšœ"žœ
žœ˜3J˜Jšœ,žœžœ˜Hšžœžœ
˜Jšœ4žœ
žœ˜R—š
ž˜Jšœ4žœ
žœ˜S———J˜J™έ
Jšœžœžœ˜šœžœžœ
˜Jšœžœžœ ˜!Jšœžœ ˜<—J˜Jšœžœžœ&˜TJ˜Jš
œO™OJšŸ	œžœžœF˜]˜•StartOfExpansion4 -- [inst: CD.Instance] RETURNS [quit: BOOL _ FALSE]šΠbnœ&˜-Jš
Πck0™0Jšžœ%žœ$˜OJš
œ˜—Jšžœžœ
žœ-˜>Jš
œ˜—J˜–[]šŸœžœžœ˜Lšœžœž˜K˜
Kš
œ˜Kš
œ˜Kš
œ˜Kšžœžœ
˜—K˜—K˜šŸ	œžœžœ˜Ešœžœž˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kšžœžœ
˜—K˜—J™J™(šŸ	œžœžœ7˜aKšœžœ
˜Kšœžœ
˜	K˜	K˜Kš
œH˜HKšœ	žœ#˜0Kšœ
žœžœžœ
žœ	žœ-˜lJš
œ,˜,Jšœžœžœ
žœžœ
žœ˜>Jšœžœ˜Jš
œ&˜&Jš
œ˜—J˜J™9šŸœžœ>žœ˜kJ˜šŸœ˜$Jš
ž˜Jšœ	žœžœ˜Jšœžœ˜Kš	œžœžœ
žœžœ0˜mJšœ5žœ˜VJš
œ>˜>Jšžœ
žœ˜Jšžœ
˜—K˜Jš
œ$˜$Kš
œ˜K˜—š
Ÿœžœ
žœ.žœ$žœ˜ƒ
Kšžœ"˜)Jš
œ˜Jšœ 7˜VJšœžœ˜6Jšœžœ
˜*Jšœžœ
˜J˜Jš
œ:™:š
œ˜šžœžœ	 ˜š
œ.˜.Jš
œB˜BJš
œ@˜@Jš
œ	˜	——šžœ ˜š
œ.˜.Jš
œA˜AJš
œB˜BJš
œ
˜
———J™2Jš
œK˜KJ™HJšžœžœ
žœžœ˜.Jšžœžœ
žœžœ˜.Jšžœžœ
žœžœ˜EJšžœžœ
žœžœ˜AJ˜šžœžœ ˜Jš
œ!˜!Jš
œ˜Jšœžœ ˜.Jšœ
žœ'˜4Jš
œ@˜@Jš
œA˜AJš
œD˜DJš
œA˜AJš
œ˜J˜—šžœ ˜Jš
œ˜Jš
œ˜Jšœžœ$˜2Jšœ
žœ#˜0Jš
œB˜BJš
œ?˜?Jš
œB˜BJš
œC˜CJš
œ˜—J™Jšœ#žœ ˜BJ™J™?Jšœžœžœžœ˜9Jšœžœžœžœ˜;Jšœžœžœžœ˜DJšœ žœžœžœ˜DJ™J™9Jš
œ.˜.J˜J™
Jš
œ-˜-Jš
œ'˜'šžœž˜Jš
œ’
˜’
Jš
œΘ
˜Θ
Jšžœ
˜—Jšžœžœ
žœžœ8˜wJšžœžœ
žœžœ?˜€
K˜K˜—šŸ
œžœ
žœ7žœžœžœ˜sJ˜JšœOžœ	˜[Jš
œ"˜"K˜K˜—šŸœžœ
žœ.žœ;žœžœžœ˜Ώ
Jš
œi˜iJš
œ3˜3Jš
œ"˜"J˜K˜—J™šŸœžœ
žœžœžœ)žœžœžœžœ.žœžœ
žœ˜υ
J–4 -- [inst: CD.Instance] RETURNS [quit: BOOL _ FALSE]˜š‘œ&˜.Jš
’0™0šžœ-žœ˜5Jšœ
žœ*˜6šžœžœ˜!Jš
 !™!Jšœžœžœžœ&˜UJšœ	žœ˜Jš
œ,˜,Jš
œ>˜>Jšœžœ
˜Jšœžœ˜'—J˜—Jš
œ˜—J˜šŸœžœ˜Jš’
œžœ
’
™&Jšœžœ
˜
šžœ/žœ˜7Jšœ	žœ
˜Jšœ	žœ
˜Jšœ
žœ˜Jš
 !™!Jšœžœžœžœ&˜UJš
œD˜DJš
œ?˜?Jš
œB˜BJš
œ-˜-Jšœžœ˜Jšœ
žœ1˜=Jšœžœ˜!Jš
œD˜DJš
œ2˜2Jšžœ˜J˜—Jš
œ˜J˜—Jšœžœžœ˜Jšœžœ
˜Jšœžœ@˜PJš
 !™!Jš
œ#žœ
žœžœžœ ,˜Ÿ
šžœžœ
žœ˜Jš
œ2˜2šžœž˜JšœžœA˜J—J˜—J˜—J˜š
Ÿœžœžœ	žœžœ˜;Jšœžœ˜3—J˜šœžœ˜(Jšœ*žœU™ƒ
Jšœ
žœ*˜6Jšœžœ7˜DJšœžœ8˜FJšœ
žœ9˜HJšœ	žœžœa˜sJšœžœ
˜Jšœ
žœžœ&˜8Jšœ	žœB˜MJš
œ˜Jšœžœ˜J˜šžœ
žœ
ž˜š
œ˜Jš
œ˜šžœžœ˜JšœžœH˜OJ˜——š
œ˜Jšœ
žœ7˜CJšœžœ˜Jš
œ"˜"Jš
œ9˜9Jšœžœ˜#Jš
œU˜UJšœžœJ˜Qšžœžœ˜$Jšœžœ9˜AJšœžœ?˜IJšœ	žœ˜Jšœžœ)˜0Jš
œ˜Jš
œQ˜QJšœžœD˜KJš
œ˜—šžœžœ˜JšœžœF˜PJšœžœ)˜0Jš
œ˜——J˜š
œ˜šžœžœ˜$Jšœžœ9˜AJšœžœ˜Jš
œ˜Jš
œ:˜:Jšœžœ˜#Jš
œQ˜QJšœžœF˜Mšžœžœ˜JšœžœE˜OJšœžœ)˜0Jš
œ˜——šžœ˜Jšœ
žœ7˜CJšœžœ˜Jš
œ"˜"Jš
œ:˜:Jšœžœ˜#Jš
œU˜UJšœžœO˜Všžœžœ˜JšœžœC˜LJšœžœ(˜/Jš
œ˜———J˜š
œ˜Jšœžœ9˜AJšœžœ˜Jš
œ˜Jš
œ<˜<Jšœžœ˜$Jš
œQ˜QJšœžœF˜Mšžœžœ˜"Jšœ
žœ7˜CJšœžœP˜YJšœžœS˜`Jšœžœ(˜/Jš
œ˜JšœžœH˜OJš
œ!˜!—šžœžœ˜JšœžœF˜PJšœžœ)˜0Jš
œ˜—J˜—Jšžœ
˜—Jš
œ7˜7Jšœ"žœ˜(—J˜šŸ
œžœžœžœžœžœžœ˜kJ˜Jšœžœ;˜BJš
œB˜BJ˜J˜—Jšžœ
˜Jš
œ
˜
——…—9.N#