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];
[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];
Route.IncludeNet[routingArea, net.name, net.pins];
RETURN[FALSE];
END;

[] _ SymTab.Pairs[tab, EnterOneNet];
};
MakeChannel: PUBLIC PROC[obj1, obj2, bottomOrLeftObj, topOrRightObj: CD.Object, retrieveRect: RefRect, params: RouterParams, isX: BOOL, routeType: RouteType] RETURNS [channel: CD.Object] =  {
tab: SymTab.Ref;
result: Route.RoutingResult;
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, pRight, pTop, pLeft];
routingRect _ [0, 0, pRight.x, pTop.y];
SELECT routeType FROM
channel => result _ Route.ChannelRoute[routingArea, sideCoords, routingRect, params.opt, params.signalSinglePinNets];
switchBox => result _ Route.SwitchBoxRoute[routingArea, sideCoords, routingRect, params.opt, params.signalSinglePinNets];
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"];
channel _ Route.RetrieveRouting[result, result.routingArea.name, retrieveRect, NIL].object;
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.
 
FPWRouteImpl.mesa
Copyright c 1985, 1986 by Xerox Corporation.  All rights reversed.
Last Edited by: Preas, January 27, 1986 3:26:48 pm PST
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™+—J™šΟk	œ
˜
Jšžœ
˜Jš
œ	˜	J˜Jš
œ	˜	Jš
œ˜J˜Jš
œ˜Jšžœ
˜Jš
œ˜Jš
œ˜J˜J˜
J˜—J˜šœ
žœ
žœ˜JšžœžœJžœ"˜yJšžœ
˜Jšžœ
žœ	˜J˜™?šΟn
œžœ0žœ$žœžœžœ
˜Ÿ
Jš
ž˜Jšœžœ
žœ
˜Jšœ5žœ˜?J˜Jš
žœ
žœ
žœ
žœ
žœ˜!Jš
œ*˜*Jšœ
žœ˜š	žœžœžœžœ
ž˜2Jš
œ˜Jšžœžœ
žœžœ
˜3šžœ*˜.Jš
œ*˜*—Jšžœžœ
žœžœ
˜7šžœ.˜2Jš
œ.˜.—Jš
œ_˜_Jšœ
žœžœ˜3Jšœ
Οc˜#Jšžœ
˜—Jšœ
žœ˜$J˜Jšžœžœžœ˜*Jšžœžœ˜$Jšžœ
˜—J˜šŸœžœ
žœ˜Jšœžœ	˜Jšœžœ
žœ˜Jšœžœ
žœ˜Jšœ,žœžœ
˜FJšœ>žœ˜N—J˜šŸœžœ
žœ˜Jšœžœ	˜Jšœžœ
žœ˜Jšœ
žœ
žœ˜Jšœ,žœžœ
˜FJšœ>žœ˜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]šΟbœ&˜-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šœ
žœžœžœ
žœ	žœ˜\Jš
œ,˜,Jšœžœžœ
žœžœ
žœ˜>Jšœžœ˜Jš
œ&˜&Jš
œ˜—J˜J™9šŸœžœ]˜kJ˜š
œ$˜$Jš
ž˜Jšœ	žœžœ˜Jšœžœ˜Kšœžœžœžœ
žœžœ ˜]Jš
œ2˜2Jšžœ
žœ˜Jšžœ
˜—K˜Jš
œ$˜$Kš
œ˜—J™šŸœžœ
žœ-žœ;žœžœžœ
˜Ώ
Jš
œ˜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š
œu˜uJš
œy˜yJšžœ
˜—Jšœ)ž
œM˜wJšœ*ž
œU˜€
JšœOžœ	˜[Jš
œ"˜"Jš
œ˜—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šœžœ8˜?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˜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˜š
Ÿ
œžœ9žœžœžœ˜kJ˜Jšœžœ;˜BJš
œB˜BJ˜J˜—Jšžœ
˜Jš
œ
˜
——…—6nJI