DIRECTORY
CDBasics,
CoreRouteFlat,
CoreRouteFlatProcs,
Imager USING [Context, PathProc, SetGray, SetXY, ShowRope, MaskBox, MaskStroke],
IO,
IP,
IPConstants,
IPBasicOps,
IPToolBox,
IPChipRose,
IPCTG,
IPNetTab,
Rope,
Set USING [Handle, New, Put, Enumerate],
SymTab;

IPNetTabImpl: CEDAR PROGRAM 
IMPORTS CDBasics, CoreRouteFlatProcs, IO, Imager, IP, IPChipRose, IPBasicOps, IPToolBox, IPCTG, IPNetTab, Rope, Set, SymTab
EXPORTS IPNetTab = BEGIN OPEN TB: IPToolBox, CR: IPChipRose, BO: IPBasicOps, IPNetTab;


SimpleChNetFactorEstimator: PUBLIC ChNetFactorEstimator ={horFactor _ (netBRect.x2 - netBRect.x1); verFactor _ (netBRect.y2 - netBRect.y1)}; --SimpleChNetFactorEstimator

Create: PUBLIC PROC[chipRose: CR.Ref] RETURNS [Ref] = {
eachNet: CR.EachNetAction ={
[] _ nets.Store[net, NEW[NetRep _ [name: net]]];
}; --eachNet

nets: SymTab.Ref _ SymTab.Create[];
chipRose.Nets[eachNet];
RETURN [NEW[Rep _ [nets]]];
}; --Create

CreateFromStructure: PUBLIC PROC[structure: CoreRouteFlat.Structure] RETURNS [Ref] = {

EachNet: CoreRouteFlatProcs.EachNetAction ={
-- PROC [net: CoreRouteFlat.Net] RETURNS [quit: BOOLEAN _ FALSE];
[] _ SymTab.Store[nets, net.name, NEW[NetRep _ [name: net.name]]];
}; --eachNet

nets: SymTab.Ref _ SymTab.Create[];
[] _ CoreRouteFlatProcs.EnumerateNets[structure, EachNet];
RETURN [NEW[Rep _ [nets]]];
}; --Create

FetchNet: PUBLIC PROC[netTab: Ref, name: Rope.ROPE, raiseError: BOOL] RETURNS [Net] ={
found: BOOL;
val: REF;
[found, val] _ netTab.nets.Fetch[name];
IF found THEN RETURN [NARROW[val]];
IF raiseError 
THEN ERROR IP.Error[missingRegistration, Rope.Cat[name, " is not a net name"]]
ELSE RETURN [NIL];
}; --FetchNet

Size: PUBLIC PROC[netTab: Ref] RETURNS [INT] ={
RETURN [SymTab.GetSize[netTab.nets]]}; --Size

Nets: PUBLIC PROC[netTab: Ref, action: EachNetAction] ={
p: SymTab.EachPairAction = {RETURN[action[NARROW[val]]]};--p
[] _ netTab.nets.Pairs[p];
}; --Nets

TotalNetLength: PUBLIC PROC[netTab: Ref, netFactorProc: ChNetFactorEstimator] RETURNS [totalLength: INT _ 0] ={
eachNetProc: EachNetAction ={
totalLength _ totalLength + NetLength[net, netFactorProc]}; --eachNetProc
Nets[netTab, eachNetProc];
}; --TotalNetLength

CountNets: PUBLIC PROC[netTab: Ref] RETURNS [active, nonActive: INT _ 0] ={
eachNetProc: EachNetAction ={
IF NetActive[net] 
THEN active _ active.SUCC
ELSE nonActive _ nonActive.SUCC;
}; --eachNetProc
Nets[netTab, eachNetProc];
}; --CountNets

CountAllPins: PUBLIC PROC[netTab: Ref, activeNetsOnly: BOOL _ TRUE] RETURNS [active, nonActive: INT _ 0] ={
eachNetProc: EachNetAction ={
IF activeNetsOnly AND ~ NetActive[net] 
THEN NULL
ELSE {
aIncr, nIncr: INT;
[aIncr, nIncr] _ CountPins[net];
active _ active + aIncr;
nonActive _ nonActive + nIncr;};}; --eachNetProc
Nets[netTab, eachNetProc];
}; --CountAllPins

CheckSelf: PUBLIC PROC[netTab: Ref] ={NULL}; --CheckSelf

DescribeSelf: PUBLIC PROC[netTab: Ref, stream: IO.STREAM, debug: BOOL] ={
pNet: EachNetAction ={

stream.PutF["%g: \t{", IO.rope[net.name]];

IF debug THEN {
stream.PutF["pinNets: {"];
FOR l: PinNets _ net.pinNets, l.rest UNTIL l = NIL DO
stream.PutF[" %g@%g", IO.rope[l.first.name], IO.rope[l.first.owner.name]]
ENDLOOP;
stream.PutF["}"];
}; --endIF

stream.PutF["}\n"];
};--pNet

stream.PutF["\nBeginNetTab\n"];
stream.PutF["\n%g \t--Number of Nets\n", IO.int[netTab.nets.GetSize[]]];
Nets[netTab, pNet];
stream.PutF["EndNetTab\n"];
}; --DescribeSelf

ReconstructSelf: PUBLIC PROC[stream: IO.STREAM] RETURNS [Ref] ={
nets: SymTab.Ref _ SymTab.Create[];
THROUGH [0..stream.GetInt) DO
name: Rope.ROPE;
net: REF IP.NetRep;
[name, net] _ GetNet[stream];
[] _ nets.Store[name, net];
ENDLOOP;
IF stream.GetAtom[] # $EndNetTab THEN ERROR;
RETURN [NEW[Rep _ [nets]]];
}; --ReconstructSelf

NetLength: PUBLIC PROC[net: Net, netFactorProc: ChNetFactorEstimator] RETURNS [INT] ={
netBRect: Rect _ GetNetBRect[net];
IF NetActive[net] AND netFactorProc # NIL THEN { 
activePins, nonActivePins: INT;
horFactor, verFactor: REAL;
horChSum, verChSum: INT _ 0;
chSet: Set.Handle _ Set.New[];
eachChAction: PROC[e: REF ANY] RETURNS [stop: BOOL _ FALSE] ={
ch: IPCTG.Channel _ NARROW[e];
chInt: INT _ ChAndRectOverlap[ch, netBRect];
chLength: INT _ IPCTG.Length[ch];
chStatIncr: REAL _ IF ch.type = hor 
THEN (horFactor * chInt * chInt) /(horChSum * chLength)
ELSE (verFactor * chInt * chInt) /(verChSum * chLength);
ch.statistics.netFactor _ ch.statistics.netFactor + chStatIncr;
}; --eachChAction
[activePins, nonActivePins] _ CountPins[net];
[horFactor, verFactor] _ netFactorProc[netBRect, activePins, nonActivePins];

FOR l: PinNets _ net.pinNets, l.rest UNTIL l = NIL DO
comp: REF IP.ComponentRep _ l.first.owner; -- get the component
coChAction: PROC[ch: IPCTG.Channel] RETURNS [quit: BOOL _ FALSE] ={
overLap: INT _ ChAndRectOverlap[ch, netBRect];
IF overLap > 0 THEN {
SELECT ch.type FROM
hor => horChSum _ horChSum + overLap;
ver => verChSum _ verChSum + overLap;
ENDCASE => ERROR;
[] _ Set.Put[chSet, ch]}; 
}; --eachCoChAction
IPToolBox.CoChannels[comp, coChAction];
ENDLOOP;

[] _ Set.Enumerate[chSet, eachChAction];
}; --endIF

RETURN [(netBRect.x2- netBRect.x1) + (netBRect.y2 - netBRect.y1)]; --This is the semi-perimeter of the net's bounding box
}; --NetLength

CountPins: PUBLIC PROC[net: Net] RETURNS [active, nonActive: INT _ 0] ={
FOR l: PinNets _ net.pinNets, l.rest UNTIL l = NIL DO
FOR phyPins: PhysicalPins _ l.first.physicalPins, phyPins.rest UNTIL phyPins = NIL DO
IF phyPins.first.active 
THEN active _ active.SUCC 
ELSE nonActive _ nonActive.SUCC;
ENDLOOP;
ENDLOOP;
}; --CountPins

PaintNet: PUBLIC PROC [net: Net, context: Imager.Context, xOffset, yOffset, scaleFactor: REAL, stipple: CARDINAL, showNetName: BOOL] ={
xMin, yMin, xMax, yMax: REAL;
[[xMin, yMin, xMax, yMax]] _ GetNetBRect[net];
xMin _ xOffset + (xMin * scaleFactor);
yMin _ yOffset + (yMin * scaleFactor);
xMax _ xOffset + (xMax * scaleFactor);
yMax _ yOffset + (yMax * scaleFactor);

IF stipple = IPConstants.White 
THEN {
path: Imager.PathProc ~ {
  moveTo[[xMin, yMin]];
  lineTo[[xMax, yMin]];
  lineTo[[xMax, yMax]];
  lineTo[[xMin, yMax]];
  lineTo[[xMin, yMin]];};
Imager.MaskStroke[context, path];}
ELSE {
Imager.SetGray[context, stipple]; 
Imager.MaskBox[context, [xMin, yMin, xMax, yMax]];};
IF showNetName 
THEN {
Imager.SetXY[context, [(xMin + xMax)/2.0, (yMin + yMax)/2.0]]; --place at center
Imager.ShowRope[context, net.name]};

};--PaintNet


GetNet: PROC[stream: IO.STREAM] RETURNS [Rope.ROPE, REF IP.NetRep] ={
name: Rope.ROPE _ TB.GetIdRope[stream];  -- First get the name
net: REF IP.NetRep _ NEW[IP.NetRep _ [name]]; 
TB.EnterBlock[stream];
UNTIL TB.ExitBlock[stream]  DO
token: ATOM _ TB.GetIdAtom[stream];
SELECT token FROM
$pinNets => TB.RemoveBlock[stream]; --list of pinNet names, not used
ENDCASE => ERROR;
ENDLOOP;
RETURN[name, net];
}; --GetNet



ChAndRectOverlap: PROC[ch: IPCTG.Channel, rect: Rect] RETURNS [INT]= {
chCoord: INT _ IPCTG.GetCoord[ch];
chNegBnd, chPosBnd, rectNegBnd, rectPosBnd: INT;
[chNegBnd, chPosBnd] _ IPCTG.Bounds[ch];
SELECT ch.type FROM
hor => IF chCoord < rect.y1 OR rect.y2 < chCoord 
THEN RETURN [0]
ELSE {rectNegBnd _ rect.x1; rectPosBnd _ rect.x2};
ver => IF chCoord < rect.x1 OR rect.x2 < chCoord 
THEN RETURN [0]
ELSE {rectNegBnd _ rect.y1; rectPosBnd _ rect.y2};
ENDCASE => ERROR;
IF chNegBnd > rectPosBnd OR chPosBnd < rectNegBnd 
THEN RETURN [0]
ELSE RETURN [1 + MIN[rectPosBnd, chPosBnd] - MAX[chNegBnd, rectNegBnd]]
}; --ChAndRectOverlap

GetNetBRect: PROC [net: Net] RETURNS [bRect: Rect _ [0, 0, 0, 0]] = {
pinNets: PinNets _ net.pinNets;
IF pinNets = NIL THEN RETURN; --No pinNets
IF pinNets.rest = NIL THEN { -- ONE pinNet but need at least two
FOR l: PhysicalPins  _ pinNets.first.physicalPins, l.rest UNTIL l = NIL DO
l.first.active _ FALSE
ENDLOOP;
RETURN};
BEGIN
ctrMass: IP.IntVector _ FindPhyPinsCM[pinNets];
bRect _ FindInitialNetBRect[pinNets, ctrMass];
FOR l: PinNets _ pinNets, l.rest UNTIL l = NIL DO
bRect _ NuBRectNActivatePin[l.first, bRect];
ENDLOOP;
END;
}; --GetNetBRect


FindPhyPinsCM: PROC[pinNets: PinNets] RETURNS [IP.IntVector] ={
totalMass: IP.IntVector _ [0, 0];
totalPhyPins: NAT _ 0;
WHILE pinNets # NIL DO
incrMass: IP.IntVector _ [0, 0];
incrPhyPins: NAT _ 0;
phyPinsOrigin: IP.IntVector _ IPToolBox.GetCoOrigin[pinNets.first.owner];
FOR l: PhysicalPins _ pinNets.first.physicalPins, l.rest UNTIL l = NIL DO
incrPhyPins _ incrPhyPins.SUCC;
incrMass _ CDBasics.AddPoints[incrMass, l.first.coord];
ENDLOOP;
totalMass _ CDBasics.AddPoints[totalMass, incrMass];
totalMass _ CDBasics.AddPoints[totalMass, BO.IntVectorScale[phyPinsOrigin, incrPhyPins]];
totalPhyPins _ totalPhyPins + incrPhyPins;

pinNets _ pinNets.rest
ENDLOOP;
RETURN [BO.IntVectorDivide[totalMass, totalPhyPins]];
}; --FindPhyPinsCM

FindInitialNetBRect: PROC[pinNets: PinNets, target: IP.IntVector] RETURNS [Rect] ={
bestPosition: IP.IntVector _ [0, 0];
bestDist: INT _ LAST[INT];
WHILE pinNets # NIL DO
coOrigin: IP.IntVector _  IPToolBox.GetCoOrigin[pinNets.first.owner];
nTarget: IP.IntVector _ CDBasics.SubPoints[target, coOrigin]; 
FOR l: PhysicalPins _ pinNets.first.physicalPins, l.rest UNTIL l = NIL DO
newDist: INT _ BO.IntVectorMDistance[nTarget, l.first.coord];
IF newDist < bestDist 
THEN {bestDist _ newDist; bestPosition _ CDBasics.AddPoints[l.first.coord, coOrigin]};
ENDLOOP;
pinNets _ pinNets.rest
ENDLOOP;
RETURN [Rect[bestPosition.x, bestPosition.y, bestPosition.x, bestPosition.y]]
}; --FindInitialNetBRect

NuBRectNActivatePin: PROC[pinNet: REF IP.PinNetRep, bRect: Rect] RETURNS [Rect] ={
bestP: REF IP.PhysicalPinRep _ NIL;
bestCoord: IP.IntVector;
bestDistFromRect: INT _ LAST[INT];
coOrigin: IP.IntVector _ IPToolBox.GetCoOrigin[pinNet.owner];
FOR l: PhysicalPins _ pinNet.physicalPins, l.rest UNTIL l = NIL DO
newCoord: IP.IntVector _ CDBasics.AddPoints[l.first.coord, coOrigin];
newDistFromRect: INT _ BO.RectMDistanceToPt[bRect, newCoord];
l.first.active _ FALSE;
IF newDistFromRect <= 0 THEN {
bestP _ l.first;
bestP.active _ TRUE;
FOR ll: PhysicalPins _ l.rest, ll.rest UNTIL ll = NIL DO ll.first.active _ FALSE; ENDLOOP;
RETURN [bRect];
};
IF newDistFromRect < bestDistFromRect THEN {
bestP _ l.first;
bestDistFromRect _ newDistFromRect;
bestCoord _ newCoord;
};
ENDLOOP;
IF bestP # NIL THEN {
bestP.active _ TRUE;
bRect _ BO.RectExtendToPt[bRect, bestCoord];
};
RETURN [bRect];
}; --NuBRectNActivatePin

END.
0--File: IPNetTabImpl.mesa
Last Edited by: CSChow, February 2, 1985 2:15:11 am PST
Preas, August 26, 1986 6:57:48 pm PDT
changed definition of ChAndRectOverlap November 30, 1987 2:42:26 pm PST


--(1) Print net name
--(2) Print pinNet: NOT used, for debugging
--Print out <pinName>@<componentName> 
-- netFactorProc # NIL => assign channel.statistics.netFactor (for all relevant channel)

--(a) Calculate horFactor and verFactor for net
--(b) Find relevant channel and calculate horChSum and verChSum
--(c)  Assign ch.statistics.netFactor for each channel in chSet
--###Private Types & Procedures####--
--I used format to impl GetNet  to make it more general/extensible
--  Related to computing channel's netFactor 

--Related to computing bounding of net and deciding pin active/nonActive

--Have two pinNets can do something
--The algorithm is:
-- (1) Find center of mass (ctrMass) of all physical pins
--(2)  Use ctrMass to find the closest physical pin's coord and use that as 
--       the starting Net Bounding Rect.(set to xMin, yMin, xMax yMax)
--(3) With the starting Bounding Rect chose a physicalPin representative 
--   from each pinNet (and set that active.) This physical Pin is chosen 
-- so that it will increase the Bounding Rect minimally (increase is 0 if it lies 
--  inside Rect.)   
The pin is inside the rectangle, so if it is the first, then it is the best
Set the "best" pin to active
Set all of the other pins to be NOT active
This pin is outside the rectangle, and better than any we have seen before
A non-empty pin list
Set the "best" pin to active
Κp˜J™™7Icode™%KšœΟnœ!™G—J™J™š
Οk	˜	K˜	K˜K˜KšœžœC˜PKšžœ
˜Kšžœ
˜Kš
œ˜K˜Kš
œ
˜
Kš
œ˜Kšžœ
˜Kš
œ	˜	K˜Kšœžœ˜(Kš
œ˜—K˜šœžœ
žœ
˜Kšžœžœ
žœ%žœ˜{Kšžœžœ
žœ
žœ
žœžœ˜VK˜K˜KšœžœkΟc˜©
K˜š
œžœ
žœžœžœ
˜7šœ	žœ˜Kšœžœ˜0KšœŸ	˜—K˜Kš
œ#˜#Kš
œ˜Kšžœžœ˜KšœŸ˜—K˜šœžœ
žœ%žœ
˜VK˜šœ%˜,Kš	œžœžœžœžœ˜AKšœ"žœ˜BKšœŸ	˜—K˜Kš
œ#˜#Kš
œ:˜:Kšžœžœ˜KšœŸ˜K˜—šœžœ
žœžœžœžœ	˜VKšœžœ
˜Kšœžœ
˜	Kš
œ'˜'Kšžœžœ
žœžœ˜#šžœ
ž
˜Kšž
œ
žœA˜NKšžœ
žœžœ˜—KšœŸ
˜
—K˜š
œžœ
žœžœžœ˜/Kšžœ!Ÿ˜-—K˜šœžœ
žœ'˜8Kšœžœžœ	Ÿ˜<K–

"Cedar" styleš
œ˜KšœŸ˜	—K˜š
œžœ
žœ3žœžœ˜oš
œ˜Kšœ<Ÿ
˜I—Kš
œ˜KšœŸ˜—K˜š
	œžœ
žœžœžœ˜Kš
œ˜šžœž
˜Kšžœž˜Kšžœžœ
˜ —KšœŸ
˜—Kš
œ˜KšœŸ˜—K˜šœžœ
žœžœžœžœžœ˜kš
œ˜šžœžœ˜'Kšžœ
ž˜	šžœ˜Kšœžœ
˜Kš
œ ˜ Kš
œ˜Kšœ#Ÿ
˜0———Kš
œ˜KšœŸ˜—K˜Kš		œžœ
žœžœŸ˜8K˜šœžœ
žœžœ
žœ	žœ˜Iš
œ˜K˜K™Kšœžœ˜*K˜K™+šžœžœ˜Kš
œ˜šžœ"žœžœ
ž˜5K™&Kšœžœžœ˜IKšžœ
˜—K˜KšœŸ˜
—K˜K˜KšœŸ˜—K˜Kš
œ˜K–

"Cedar" stylešœ)žœ˜HKš
œ˜Kš
œ˜KšœŸ˜—K˜šœžœ
žœ	žœ
žœžœ	˜@Kš
œ#˜#šžœž˜Kšœžœ
˜Kšœžœ
žœ˜Kš
œ˜Kš
œ˜Kšžœ
˜—K–

"Cedar" stylešžœžœ
žœ
˜,Kšžœžœ˜KšœŸ˜—K˜š
	œžœ
žœ0žœžœ˜VKš
œ"˜"šžœžœžœ
žœ˜1Kš
ŸX™XKšœžœ
˜Kšœžœ
˜Kšœžœ˜Kš
œ˜š
œžœžœ
žœžœžœžœ˜>Kšœžœžœ˜Kšœžœ"˜,Kšœ
žœžœ˜!šœžœžœ˜$Kšžœ3˜7Kšžœ4˜8—Kš
œ?˜?KšœŸ˜—K™Kš
œ/™/Kš
œ-˜-Kš
œL˜LK˜Kš
œ?™?šžœ"žœžœ
ž˜5Kšœžœ
žœŸ˜?šœžœžœ
žœžœžœ˜CKšœ	žœ"˜.šžœ
žœ˜šžœ	ž˜Kš
œ%˜%Kš
œ%˜%Kšžœžœ
˜—Kš
œ˜—KšœŸ˜—Kš
œ'˜'Kš
ž˜—K˜Kš
Ÿ?™?Kš
œ(˜(KšœŸ˜
—K˜Kšžœ=Ÿ6˜yKšœŸ˜—K˜š
	œžœ
žœžœžœ˜Hšžœ"žœžœ
ž˜5šžœ<žœžœ
ž˜Ušžœ˜Kšžœžœ
˜Kšžœžœ
˜ —Kšžœ
˜—Kšžœ
˜—KšœŸ˜—K˜šœžœ
žœDžœžœžœ˜‡
Kšœžœ
˜Kš
œ.˜.Kš
œ&˜&Kš
œ&˜&Kš
œ&˜&Kš
œ&˜&K˜šžœ˜šžœ
˜K˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ"˜"—šžœ˜Kš
œ"˜"Kš
œ4˜4——šžœ
˜šžœ˜Kšœ?Ÿ˜PKš
œ$˜$——K˜KšœŸ
˜—K˜K™%K˜šœžœ	žœ
žœžœžœžœ
žœ˜EKšœžœžœŸ˜>Kš	œžœ
žœ
žœ
žœ˜.Kšžœ˜šžœ
žœž˜Kšœžœžœ˜#šžœž˜Kšœœ#™BKšœžœŸ ˜DKšžœžœ
˜—Kšžœ
˜—Kšžœ˜KšœŸ˜—K˜K˜K™-K˜š
œžœžœžœžœ˜FKšœ	žœžœ˜"Kšœ,žœ
˜0Kšœžœ˜(šžœ	ž˜šœžœžœ˜1Kšžœ
žœ˜Kšžœ.˜2—šœžœžœ˜1Kšžœ
žœ˜Kšžœ.˜2—Kšžœžœ
˜—šžœžœ˜2Kšžœ
žœ˜Kšžœ
žœžœžœ˜G—KšœŸ˜—K˜K™K™Hšœžœžœ!˜EKš
œ˜Kšžœžœ
žœ
žŸ˜*šžœžœ
žœŸ#˜@šžœ7žœžœ
ž˜JKšœž˜Kšžœ
˜—Kšžœ˜—K™K™#K™K™9K™LK™FK™IK™IK™RK™š
ž˜Kšœ	žœ$˜/Kš
œ.˜.šžœžœžœ
ž˜1Kš
œ,˜,Kšžœ
˜—Kšžœ
˜—KšœŸ
˜—K˜K˜š
œžœžœžœ˜?Kšœžœ˜!Kšœžœ˜šžœžœ
ž˜Kšœ
žœ˜ Kšœ
žœ˜Kšœžœ8˜Išžœ6žœžœ
ž˜IKšœžœ
˜Kš
œ7˜7Kšžœ
˜—Kš
œ4˜4Kšœ*žœ-˜YKš
œ*˜*K˜Kš
œ˜Kšžœ
˜—Kšžœžœ+˜5KšœŸ˜—K˜šœžœžœžœ
˜SKšœžœ˜$Kšœ
žœžœ
žœ˜šžœžœ
ž˜Kšœ
žœ9˜EKšœ	žœ3˜>šžœ6žœžœ
ž˜IKšœ	žœžœ,˜=šžœ˜KšžœR˜V—Kšžœ
˜—Kš
œ˜Kšžœ
˜—KšžœG˜MKšœŸ˜—K•StartOfExpansion[]˜š
œžœ	žœ
žœžœ
˜RKšœžœ
žœžœ
˜#K˜Kšœžœžœ
žœ˜"Kšœ
žœ1˜=šžœ/žœžœ
ž˜BKšœ
žœ9˜EKšœžœžœ$˜=Kšœžœ
˜šžœžœ˜Kš
œK™KKš
œ˜šœžœ
˜Kš
œ™—šžœ$žœžœ
žœžœžœ
˜ZKš
œ*™*—Kšžœ	˜K˜—šžœ$žœ
˜,Kš
œJ™JKš
œ˜Kš
œ#˜#Kš
œ˜Kš
œ˜—Kšžœ
˜—šžœ	žœ˜K™šœžœ
˜Kš
œ™—Kšœžœ"˜,K˜—Kšžœ	˜KšœŸ˜—K˜Kšžœ
˜——…—(X<ψ