DIRECTORY
CD USING [CreateDrawRef, Design, DrawProc, DrawRectProc, DrawRef, highLightShade, Instance, InstanceList, Layer, Orientation, original, Position, Rect],
CDBasics USING [BaseOfRect, Extend, SizeOfRect, ToRect, universe],
CDDirectory USING [Name],
CDInstances USING [NewInstance],
CDOps USING [LayerName],
CDOrient USING [ComposeOrient, DecomposeOrient, DeMapRect, MapRect, RectAt],
CDProperties USING [GetProp],
CDRects USING [CreateBareRect],
CDViewer USING [ViewerList, ViewersOf],
CDViewHighlight USING [ShowInstance],
CornerStitching,
Properties USING [GetProp],
RefTab  USING [EachPairAction, Pairs],
Rope USING [Cat],
SX,
SXAccessInternal,
SXAtoms USING [SignalName, spinifex],
SXHighlightNode,
SXQuadTree USING [Dimension, Enumerate, PerRectProc],
TerminalIO USING [WriteRope];
SXHighlightNodeImpl: CEDAR PROGRAM
IMPORTS CD, CDBasics, CDDirectory, CDInstances, CDOps, CDOrient, CDProperties, CDRects, CDViewer, CDViewHighlight, CornerStitching, Properties, RefTab, Rope, SX, SXAccessInternal, SXAtoms, SXQuadTree, TerminalIO
EXPORTS SXHighlightNode =
BEGIN
RemoveHighlightNode: PUBLIC PROC [design: CD.Design] =
BEGIN
vl: CDViewer.ViewerList _ CDViewer.ViewersOf[design];
FOR list: CDViewer.ViewerList _ vl, list.rest WHILE list#NIL DO
CDViewHighlight.ShowInstance[list.first, NIL, TRUE, $SX];
ENDLOOP;
END;	-- RemoveHighlightNode
IncludeHighLight: PROC [design: CD.Design, rect: CD.Rect] =
BEGIN
vl: CDViewer.ViewerList _ CDViewer.ViewersOf[design];
app: CD.Instance = CDInstances.NewInstance[
ob: CDRects.CreateBareRect[CDBasics.SizeOfRect[rect], CD.highLightShade],
location: CDBasics.BaseOfRect[rect] 
];
FOR list: CDViewer.ViewerList _ vl, list.rest WHILE list#NIL DO
CDViewHighlight.ShowInstance[list.first, app, FALSE, $SX];
ENDLOOP;
END;	-- IncludeHighLight
HighlightNode: PUBLIC PROC [design: CD.Design, pos: CD.Position, lev: CD.Layer] =
BEGIN
WITH CDProperties.GetProp[design.technology, SXAtoms.spinifex] SELECT FROM
tpOK: REF SX.TechHandle => {
FOR mapList: LIST OF SX.MapRec _ tpOK.cdLayerMapping[lev], mapList.rest WHILE mapList#NIL DO
IF mapList.first.value = NIL THEN {
rootCir: REF SX.Circuit = SXAccessInternal.GetSXData[design.actual.first.dummyCell.ob].circuit;
data: REF SearchData _ NEW[SearchData _ [
layer: lev, 
nodeLayer: mapList.first.spinifexLayer, 
tech: tpOK, 
rootCir: rootCir, 
cir: rootCir
]];
GoForIt[data, design, pos];
RETURN
};
REPEAT FINISHED => {
TerminalIO.WriteRope[Rope.Cat["	", CDOps.LayerName[lev], " is not conducting\n"]];
RETURN
}
ENDLOOP;
};
ENDCASE => TerminalIO.WriteRope["technology does not support spinifex\n"];
END;	-- HighlightNode
GoForIt: PROC [sd: REF SearchData, design: CD.Design, pos: CD.Position] =
BEGIN
AddSplodge: CornerStitching.PerTileProc = 
BEGIN
rect: CD.Rect = CDOrient.MapRect[tile.Area, sd.rootSize, sd.rootOrient, sd.rootPos];
IncludeHighLight[design, rect];
END;
dr: CD.DrawRef = CD.CreateDrawRef[design];
nodeGeom: REF CornerStitching.Tesselation;
RemoveHighlightNode[design];
dr.drawChild _ CompensateDummyCell;	-- Used for outermost cell only, dr.drawChild set to SearchChild for recursive calls inside CompensateDummyCell.
dr.drawRect _ CheckRect;
dr.devicePrivate _ sd;
IF design.actual.first.mightReplace#NIL THEN {
sd.rootSize _ sd.pushSize _ design.actual.first.mightReplace.ob.size;
sd.rootPos _ sd.pushPos _ design.actual.first.mightReplace.location;
sd.rootOrient _ sd.pushOrient _ design.actual.first.mightReplace.orientation
};
dr.interestClip _ CDBasics.Extend[CDBasics.ToRect[pos, pos], 1];
design.actual.first.dummyCell.ob.class.drawMe[design.actual.first.dummyCell, [0,0], CD.original, dr];
IF sd.node = NIL THEN {
TerminalIO.WriteRope[ Rope.Cat[ "	Failed to find geometry on layer: \"", CDOps.LayerName[sd.layer], "\" at indicated point.\n"]];
RETURN
};
[sd.node, sd.applChain] _ sd.rootCir.FindRootNode[sd.node, sd.applChain];
WITH Properties.GetProp [sd.node.properties, SXAtoms.SignalName] SELECT FROM
sig: REF SX.SignalName => {
TerminalIO.WriteRope[Rope.Cat["	Highlighting: ", sig.name,".\n"]]
};
ENDCASE => {
TerminalIO.WriteRope["	Highlighting node.\n"]
};
IF sd.applChain#NIL THEN -- Node appeared on some subcircuit, rather than root.  
sd.cir _ SXAccessInternal.GetSXData[sd.applChain.first.ob].circuit
ELSE
sd.cir _ sd.rootCir;
nodeGeom _ CornerStitching.NewTesselation[];
Paint[sd, nodeGeom];

[] _ nodeGeom.EnumerateArea[CDBasics.universe, AddSplodge];
END;	-- GoForIt
SearchData: TYPE = RECORD [
layer: CD.Layer,
nodeLayer: SX.SpinifexLayerIndex,
tech: REF SX.TechHandle,
rootCir: REF SX.Circuit,	--  Highest Spinifex SX.Circuit found in application chain.
cir: REF SX.Circuit,
node: REF SX.CircuitNode _ NIL,
applChain: LIST OF CD.Instance _ NIL,
pushSize: CD.Position _ [0,0],
pushPos: CD.Position _ [0,0],
pushOrient: CD.Orientation _ CD.original,
rootSize: CD.Position _ [0,0],
rootPos: CD.Position _ [0,0],
rootOrient: CD.Orientation _ CD.original
];
CompensateDummyCell: CD.DrawProc =
BEGIN
data: REF SearchData = NARROW[pr.devicePrivate];
oldClip: CD.Rect = pr.interestClip;
pr.drawChild _ SearchChild;
pr.interestClip _ CDOrient.DeMapRect[itemInWorld: oldClip, cellSize: data.pushSize, cellInstOrient: data.pushOrient, cellInstPos: data.pushPos];
pos _ CDBasics.BaseOfRect[CDOrient.DeMapRect[
CDOrient.RectAt[pos: pos, size: inst.ob.size, orient: orient], 
data.pushSize, 
data.pushOrient, 
data.pushPos
]];
orient _ CDOrient.DecomposeOrient[orient, data.pushOrient];
SearchChild[inst, pos, orient, pr];
pr.interestClip _ oldClip;
pr.drawChild _ CompensateDummyCell
END;	-- CompensateDummyCell
SearchChild: CD.DrawProc =
BEGIN
sx: REF SX.LogicalCell = SXAccessInternal.GetSXData[inst.ob];
IF sx#NIL AND sx.circuit#NIL AND sx.analysisState=useCircuit THEN {
subcircuit: REF SX.Circuit _ sx.circuit;
data: REF SearchData = NARROW[pr.devicePrivate];
oldClip: CD.Rect = pr.interestClip;
cir: REF SX.Circuit = data.cir;
root: REF SX.Circuit = data.rootCir;
appl: CD.Instance;
oldChain: LIST OF CD.Instance = data.applChain;
data.cir _ subcircuit;
IF data.rootCir = NIL THEN {
data.rootCir _ subcircuit;
data.rootSize _ inst.ob.size;
data.rootPos _ CDBasics.BaseOfRect[CDOrient.MapRect[
CDOrient.RectAt[pos: pos, size: data.rootSize, orient: orient], 
data.pushSize, 
data.pushOrient, 
data.pushPos
]];
data.rootOrient _ CDOrient.ComposeOrient[orient, data.pushOrient]
};
pr.interestClip _ CDOrient.DeMapRect[
itemInWorld: oldClip, 
cellSize: inst.ob.size, 
cellInstOrient: orient, 
cellInstPos: pos
];
IF cir # NIL THEN {
FOR aList: CD.InstanceList _ cir.subcircuits, aList.rest WHILE aList # NIL DO
appl _ aList.first;
IF appl.location=pos AND appl.orientation=orient AND appl.ob=inst.ob THEN EXIT;
REPEAT FINISHED => {
ERROR
};
ENDLOOP;
data.applChain _ CONS[appl, data.applChain];
};
inst.ob.class.drawMe[inst, [0,0], CD.original, pr];
IF cir # NIL THEN data.cir _ cir;
IF pr.stopFlag^ = FALSE THEN {
data.applChain _ oldChain;
data.rootCir _ root
};
pr.interestClip _ oldClip
}
ELSE {
data: REF SearchData = NARROW[pr.devicePrivate];
sx: REF SX.LogicalCell = SXAccessInternal.GetSXData[inst.ob];
IF sx#NIL AND sx.analysisState=notYetDone AND data.cir#NIL THEN {
TerminalIO.WriteRope[Rope.Cat["  ", CDDirectory.Name[inst.ob], " has not been extracted\n"]];
ERROR ABORTED
};
inst.ob.class.drawMe[inst, pos, orient, pr]
} 
END;	-- SearchChild
CheckRect: CD.DrawRectProc =
BEGIN
IF l = NARROW[pr.devicePrivate, REF SearchData].layer THEN {
SearchNode: SXQuadTree.PerRectProc = 
BEGIN
WITH r.nodeInformation SELECT FROM
n: REF SX.CircuitNode => sData.node _ n; -- XXX FIX HERE, pr.stopFlag should be set only if node is found.
ENDCASE;
pr.stopFlag^ _ TRUE
END;	-- SearchNode
sData: REF SearchData = NARROW[pr.devicePrivate];
IF sData.cir = NIL THEN {
TerminalIO.WriteRope["	design has not been analyzed.\n"];
ERROR ABORTED
};
SXQuadTree.Enumerate [quadTree: sData.cir.spinifexLayers[sData.nodeLayer], clipRect: pr.interestClip, PerRect: SearchNode]
}
END;	-- CheckRect
Paint: PROC [data: REF SearchData, protoPaint: REF CornerStitching.Tesselation] =
BEGIN
Compose: PROC [pos: CD.Position, orient: CD.Orientation, size: CD.Position, applChain: LIST OF CD.Instance] RETURNS [combPos: CD.Position, combOrient: CD.Orientation] =
BEGIN
IF applChain.rest # NIL THEN {
[pos, orient] _ Compose[pos, orient, applChain.rest.first.ob.size, applChain.rest];
combPos _ CDBasics.BaseOfRect[CDOrient.MapRect[
CDOrient.RectAt[
pos: applChain.first.location, 
size: applChain.first.ob.size, 
orient: applChain.first.orientation
], 
applChain.rest.first.ob.size, 
orient, 
pos
]];
combOrient _ CDOrient.ComposeOrient[applChain.first.orientation, orient]
}
ELSE {
combPos _ CDBasics.BaseOfRect[CDOrient.MapRect[
CDOrient.RectAt[ 
pos: applChain.first.location, 
size: applChain.first.ob.size, 
orient: applChain.first.orientation
], 
size, 
orient, 
pos
]];
combOrient _ CDOrient.ComposeOrient[applChain.first.orientation, orient]
}
END;	-- Compose
PerCell: PROC [circuit: REF SX.Circuit, node: REF SX.CircuitNode, pos: CD.Position, orient: CD.Orientation, size: CD.Position] =
BEGIN
PaintNode: SXQuadTree.PerRectProc = -- PROC [r: REF Rectangle, data: REF ANY] -- 
BEGIN
IF r.nodeInformation=data THEN {
newR: CD.Rect = CDOrient.MapRect[
itemInCell: SXQuadTree.Dimension [r],
cellSize: size, 
cellInstOrient: orient, 
cellInstPos: pos
];
protoPaint.ChangeRect[newR, SXAtoms.spinifex]
}
END;	-- PaintNode
SearchForPortConnection: RefTab.EachPairAction = 
BEGIN
FOR ml: SX.MergeRecList _ NARROW[val], ml.rest WHILE ml # NIL DO
IF ml.first.becomes = node THEN {
applChain: LIST OF CD.Instance = ml.first.applChain;
subCircuit: REF SX.Circuit = SXAccessInternal.GetSXData[applChain.first.ob].circuit; 
subnode: REF SX.CircuitNode = NARROW[key];
subPos: CD.Position;
subOrient: CD.Orientation;
[subPos, subOrient] _ Compose[pos, orient, size, applChain];
PerCell[subCircuit, subnode, subPos, subOrient, applChain.first.ob.size];
}
ENDLOOP;
RETURN [FALSE]
END;	-- SearchForPortConnection
FOR layer: SX.SpinifexLayerIndex IN [0..data.tech.numSpinifexLayers) DO
SXQuadTree.Enumerate [quadTree: circuit.spinifexLayers[layer], clipRect: CDBasics.universe, PerRect: PaintNode, data: node]
ENDLOOP;
IF circuit.mergeDirectory#NIL THEN
[] _ circuit.mergeDirectory.Pairs[SearchForPortConnection]
END;	-- PerCell
pos: CD.Position _ [0,0];
orient: CD.Orientation _ CD.original;
ac: LIST OF CD.Instance = data.applChain; -- list of cells down to the node.
IF ac#NIL THEN
[pos, orient] _ Compose[pos, orient, [0,0], ac];
PerCell[data.cir, data.node, pos, orient, IF ac = NIL THEN [0,0] ELSE ac.first.ob.size]
END;	-- Paint
END.

ΤSXHighlightNodeImpl.mesa
Copyright c 1984, 1985 by Xerox Corporation.  All rights reserved.
Written by: Mark Shand, August 8, 1984 11:39:46 am PDT
Last Edited by: Shand, September 3, 1984 5:51:16 am PDT
Last Edited by: Jacobi, July 25, 1985 3:22:38 pm PDT
Last edited by: gbb November 6, 1985 5:56:46 pm PST
IncludeHighLight: PROC [design: CD.Design, rect: CD.Rect] =
BEGIN
app: CD.Instance = CDInstances.NewInstance[
ob: CDRects.CreateBareRect[CDBasics.SizeOfRect[rect], CD.highLightShade],
location: CDBasics.BaseOfRect[rect] 
];
CDOps.IncludeInstance[design, app];
CDProperties.PutPropOnInstance[app, $highLightNode, $highLightNode];
END;	-- IncludeHighLight
RemoveHighlightNode: PUBLIC PROC [design: CD.Design] =
BEGIN
IsHighLight: PROC [app: CD.Instance] RETURNS [BOOL] =
INLINE BEGIN
RETURN [app=NIL OR 
CDProperties.GetPropFromInstance[app, $highLightNode]=$highLightNode
]
END;
al: CD.InstanceList _ CONS[NEW[CD.InstanceRep], CDOps.InstList[design]];
list: CD.InstanceList _ al;
WHILE list.rest#NIL DO
IF IsHighLight[list.rest.first] THEN {
CDOps.DelayedRedraw[design, CDInstances.InstRectO[list.rest.first]];
list.rest _ list.rest.rest
}
ELSE list _ list.rest
ENDLOOP;
CDOps.SetInstList[design, al.rest];
END;	-- RemoveHighlightNode
OK if NIL!
--[tile: TilePtr, data: REF ANY] -- 
-- find the node we wish to highlight.
-- find the highest layer node to which the node we wish to highlight is merged.
-- find all rectangles connected to the high-layer node.
-- add rectangles to the currently pushed ChipNDale cell which cover all the rectangles in the highlighted node.
-- PROC [aptr: CD.Instance, pos: CD.Position, orient: CD.Orientation, pr: REF CD.DrawInformation] 
-- For outermost cell transforms must be precompensated for transform compositions which occur in DrawMe.  In subcells such precompensation is not required.
-- Now really start searching.
--PROC [aptr: CD.Instance, pos: CD.Position, orient: CD.Orientation, pr: REF CD.DrawInformation] 
--This object is a logical subcircuit.
--PROC[r: Rect, l: Layer, pr: DrawRef] -- 
--PROC[r: REF Rectangle, data: REF ANY] -- 
--PROC[key: RefTab.Key, val: RefTab.Val] RETURNS [quit: BOOLEAN] -- 

Edited on March 4, 1985 4:23:17 pm PST, by Jacobi
removing errors reprogrammed, without using drawprocs
Edited on March 5, 1985 8:59:52 am PST, by Jacobi
made readable
Edited on April 8, 1985 2:51:21 pm PST, by Jacobi
use of SXAccessInternal instead of properties; SpinifexCellPredicate removed
Edited on May 6, 1985 11:26:55 am PDT, by Beretta
Converted to ChipNDale CD20
Edited on July 25, 1985 3:20:45 pm PDT, by Jacobi
Use of CDViewHighlight instead of changing the design
I don't like the loop over all viewers, but I don't want to change the interface and can't know which is the right viewer...


Κj˜
code™Kšœ
Οm
œ7™BK™6K™7K™4K™3—š
Οk	˜	Kšžœ
˜˜
Jšœ	žœ4˜BJšœžœ˜Kšœžœ˜ Kšœžœ
˜Jšœ	žœ>˜LKšœ
žœ˜Jšœžœ˜Jšœ	žœ˜'Jš
œ%˜%Jš
œ˜Kšœžœ˜Jšœžœ˜&Jšœžœ˜Jš
œ˜J˜Jšœžœ˜%Jš
œ˜Kšœžœ%˜5Jšœžœ
˜—
code2šΟbœžœ
ž˜"Iunitšžœ
žœ”
žœ3˜Σ
Mšžœ˜—Mš
ž˜šΟnœžœ
žœžœ™;Kš
ž™šœžœ$™+Kšœ6žœ™IKš
œ$™$Kš
œ™—Kš
œ#™#Kš
œD™DKšžœΟc™—š œžœ
žœ
™6Jš
ž™š
 œžœžœžœžœ™5Jšžœ
ž™šžœžœ
žœ
™Jš
œD™DJ™
—Jšžœ
™—Mš	œžœžœ
žœ
žœ'™HJšœžœ™šžœžœ
ž™šžœžœ™&Jš
œD™DJš
œ™J™
—Jšžœ™Jšžœ
™—Jš
œ#™#Kšžœ‘™—š œžœ
žœ
žœ
˜6Jš
ž˜Kš
œ5˜5šžœ+žœžœ
ž˜?Kšœ)žœžœ˜9Kšžœ
˜—Kšžœ‘˜—š œžœ
žœžœ˜;Kš
ž˜Kš
œ5˜5šœžœ$˜+Kšœ6žœ˜IKš
œ$˜$Kš
œ˜—šžœ+žœžœ
ž˜?Kšœ.žœ˜:Kšžœ
˜—Kšžœ‘˜—š 
œžœ
žœ
žœžœžœ	˜QKš
ž˜šžœ;žœ
ž˜Jšœžœ
žœ˜š
žœ
žœ
žœ
žœ1žœ	žœ
ž˜\šžœžœ
žœ˜#šœ	žœ
žœP˜_Kšœžœ
™
—šœžœžœ˜)Kš
œ˜Kš
œ(˜(Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜—Kš
œ˜Kš
ž˜K˜—šžœ
žœ˜Kš
œR˜RKš
ž˜K˜
—Kšžœ
˜—K˜—KšžœC˜J—Kšžœ‘˜—š
 œžœžœžœžœ˜IJš
ž˜šŸ
œ ˜*Kš‘#œ
™$Kš
ž˜KšœžœL˜TKš
œ˜Kšžœ
˜—Mšœžœžœ˜*Kšœ
žœ˜*Kš
œ˜Kšœ$‘!œ‘œ‘œ‘
˜”
Kš
œ˜Kš
œ˜šžœ"žœ
žœ˜.Kš
œE˜EKš
œD˜DKš
œL˜LK˜—Kš
œ@˜@Mš
œ&™&JšœTžœ˜ešžœžœ
žœ˜Jš
œ
˜
Jš
ž˜J˜—Mš
œP™PKš
œI˜Išžœ=žœ
ž˜Lšœžœ
žœ˜Kš
œA˜AK˜—šžœ˜Kš
œ-˜-Kš
œ˜——šžœžœ
žœ
‘8˜QKš
œB˜B—š
ž˜Kš
œ˜—Mš
œ8™8Jš
œ,˜,Jš
œ˜J˜Kš
œp™pKš
œ;˜;Kšžœ‘
˜—šœžœžœ˜Kšœžœ˜Kš
œ!˜!Kšœžœ˜Kšœ	žœ
‘;˜TKšœžœ˜Kšœžœžœ
˜Kš	œžœ
žœ
žœžœ
˜%Kšœ
žœ˜Kšœ	žœ˜Kšœžœžœ
˜)Kšœ
žœ˜Kšœ	žœ˜Kšœžœžœ	˜(K˜—šŸœžœ˜"Kš
œb™bKš
ž˜Kšœžœžœ˜0Kšœ	žœ˜#Kš
œ˜K™œ
Kš
œ
˜
š
œ-˜-Kš
œ?˜?Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜—Kš
œ;˜;K™Kš
œ#˜#Kš
œ˜Kš
œ"˜"Kšžœ‘˜—š Ÿœžœ˜Kš
œa™aKš
ž˜Kšœžœ
žœ3˜=šžœžœ
žœžœ
žœžœ˜CK™&Kšœžœ
žœ˜(Kšœžœžœ˜0Kšœ	žœ˜#Kšœžœ
žœ˜Kšœžœ
žœ˜$Kšœžœ
˜Kšœ
žœ
žœ
žœ˜/Kš
œ˜šžœžœ
žœ˜Kš
œ˜Kš
œ˜š
œ4˜4Kš
œ@˜@Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜—Kš
œA˜AK˜—š
œ%˜%Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜—šžœžœ
žœ˜š	žœžœ,žœ	žœ
ž˜MKš
œ˜Kš
žœžœžœžœ
žœ
˜Ošžœ
žœ˜Kš
ž˜K˜—Kšžœ
˜—Kšœžœ˜,Kš
œ˜—Kšœ"žœ˜3Kšžœžœ
žœ˜!šžœžœ
žœ˜Kš
œ˜Kš
œ˜K˜—Kš
œ˜Kš
œ
˜
—šžœ˜Kšœžœžœ˜0Kšœžœ
žœ3˜=šžœžœ
žœžœ
žœ
žœ˜AKš
œ]˜]Kšžœ
ž˜
K˜—Kš
œ+˜+K˜—Kšžœ‘˜—šŸ	œžœ˜Jš
œ*™*Jš
ž˜šžœžœžœžœ˜<šŸ
œ˜%Kš
œ+™+Kš
ž˜šžœžœ
ž˜"Kšœžœ
žœ ‘A˜jKšžœ
˜—Kšœž˜Kšžœ‘
˜—Mšœžœžœ˜1šžœ
žœ
žœ˜Kš
œ9˜9Kšžœ
ž˜
Kš
œ˜—Kš
œz˜zK˜
—Jšžœ‘˜—š œžœžœžœ˜QJš
ž˜š œžœžœžœžœžœ
žœ
žœžœžœžœ˜¨
Kš
ž˜šžœžœ
žœ˜Kš
œS˜Sš
œ/˜/š
œ˜Kš
œ˜Kš
œ˜Kš
œ#˜#Kš
œ˜—Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜—Kš
œH˜HK˜
—šžœ˜š
œ/˜/š
œ˜Kš
œ˜Kš
œ˜Kš
œ#˜#Kš
œ˜—Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜—Kš
œH˜HKš
œ
˜
—Kšžœ‘
˜—š œžœžœžœ
žœžœžœžœ˜€
Jš
ž˜šŸ	œ‘,œ
˜QKš
ž˜šžœžœ˜ šœžœ˜!Kš
œ%˜%Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜—Kš
œ-˜-K˜
—Kšžœ‘˜—šŸœΠck
˜1Kš
œD™DKš
ž˜šžœžœžœžœžœ
ž˜@šžœžœ˜!Kšœžœ
žœ
žœ˜4Kšœžœ
žœC˜UKšœ	žœ
žœžœ˜*Kšœžœ
˜Kšœžœ
˜Kš
œ<˜<Kš
œI˜IK˜
—Kšžœ
˜—Kšžœžœ
˜Kšžœ‘˜—šžœžœžœ"ž˜GKš
œ{˜{Kšžœ
˜—•StartOfExpansion2[x: 
RefTab.Ref, action: 
RefTab.EachPairAction]šžœžœ
ž˜"K˜:—Kšžœ‘
˜—Mšœžœ˜Kšœžœžœ
˜%Kšœžœ
žœ
žœ‘"˜Lšžœžœ
ž˜Kš
œ0˜0—Kš	œ*žœžœ
žœžœ˜WKšžœ‘˜
—Lšžœ
˜J™™1J™5—™1J™
—™1J™L—™1K™—™1J™5J™|—J™J™—…—)BV