DIRECTORY
BasicTime,
CD,
CDBasics,
CDInstances,
CDLayers,
CDSimpleOps,
CDOps,
CDRects,
CDSequencer,
TerminalIO;

CDBasicCommands: CEDAR PROGRAM
IMPORTS BasicTime, CDInstances, CDLayers, CDSimpleOps, CDOps, CDSequencer, TerminalIO, CDRects, CDBasics = 
BEGIN

AddARect: PROC [design: CD.Design, r: CD.Rect,  l: CD.Layer] = {
IF CDBasics.NonEmpty[r] THEN {
ob: CD.Object;
sz: CD.Position _ CDBasics.SizeOfRect[r];
orient: CD.Orientation _ original;
IF sz.y<sz.x THEN {
w: CD.Number _ sz.x; sz.x _ sz.y; sz.y _ w; 
orient _ rotate90
};
ob _ CDRects.CreateRect[sz, l];
CDOps.IncludeObjectI[design: design, ob: ob, location: CDBasics.BaseOfRect[r], orientation: orient]
}
ELSE TerminalIO.PutRope["empty rect not included\n"];
};

AddRect: PROC [comm: CDSequencer.Command] = {
TerminalIO.PutRope["draw rect\n"]; 
AddARect[comm.design, CDBasics.ToRect[comm.sPos, comm.pos], comm.l];
};

AddWire: PROC [comm: CDSequencer.Command] = {
InternalAddWire[comm: comm, firstOnly: FALSE]
};

ContinueWire: PROC [comm: CDSequencer.Command] = {
InternalAddWire[comm: comm, firstOnly: TRUE]
};

InternalAddWire: PROC [comm: CDSequencer.Command, firstOnly: BOOL_FALSE] = {
start: CD.Position _ comm.sPos; 
stop: CD.Position _ comm.pos;
wireWidth: CD.Number _ comm.n;
IF wireWidth=0 THEN {AddRect[comm]; RETURN};
TerminalIO.PutRope["draw wire\n"]; 
IF --firstHorizontal-- comm.b THEN {
IF stop.x<=start.x AND stop.x>=start.x-wireWidth
AND (stop.y<start.y OR stop.y>start.y+wireWidth) THEN { --crazy vertical wire
IF ABS[start.y-stop.y]<comm.design.technology.lambda THEN 
{TerminalIO.PutRope[" empty Wire not added\n"]; RETURN};
stop.x _ start.x+wireWidth;
AddARect[comm.design, CDBasics.ToRect[start, stop], comm.l];
RETURN
};
IF stop.y>=start.y AND stop.y<=start.y+wireWidth THEN { --horizontal wire
stop.y _ start.y+wireWidth;
AddARect[comm.design, CDBasics.ToRect[start, stop], comm.l]
}
ELSE { --L shaped (firsthorizontal)
IF start.x<=stop.x THEN {stop.x _ stop.x+wireWidth}
ELSE {t: CD.Number=stop.x; stop.x _ start.x; start.x _ t}; 
stop.y _ start.y+wireWidth;
AddARect[comm.design, CDBasics.ToRect[start, stop], comm.l];
IF firstOnly THEN RETURN;
start.x _ comm.pos.x; stop.y _ comm.pos.y; stop.x _ start.x+wireWidth;
AddARect[comm.design, CDBasics.ToRect[start, stop], comm.l];
}
}
ELSE { -- NOT firstHorizontalVC --
IF stop.y<=start.y AND stop.y>=start.y-wireWidth 
AND (stop.x<start.x OR stop.x>start.x+wireWidth) THEN { --crazy horizontal wire
IF ABS[stop.x-start.x]<comm.design.technology.lambda THEN 
{TerminalIO.PutRope[" Empty Wire not added\n"]; RETURN};
stop.y _ start.y+wireWidth;
AddARect[comm.design, CDBasics.ToRect[start, stop], comm.l];
RETURN
};
IF stop.x>=start.x AND stop.x<=start.x+wireWidth THEN { --vertical wire
stop.x _ start.x+wireWidth;
AddARect[comm.design, CDBasics.ToRect[start, stop], comm.l]
}
ELSE { --L shaped (firstVertical)
IF start.y<=stop.y THEN {stop.y _ stop.y+wireWidth}
ELSE {t: CD.Number = stop.y; stop.y _ start.y; start.y _ t}; 
stop.x _ start.x+wireWidth;
AddARect[comm.design, CDBasics.ToRect[start, stop], comm.l];
IF firstOnly THEN RETURN;
start.y _ comm.pos.y; stop.y _ start.y+wireWidth; stop.x _ comm.pos.x;
AddARect[comm.design, CDBasics.ToRect[start, stop], comm.l];
}
}
};

DeleteSelected: PROC [comm: CDSequencer.Command] = {
TerminalIO.PutRope["delete selected "]; 
CDSimpleOps.DeleteSelected[comm.design];
TerminalIO.PutRope["\n"]; 
};

Undelete: PROC [comm: CDSequencer.Command] = {
TerminalIO.PutRope["un-delete\n"]; 
CDSimpleOps.Undelete[comm.design]
};

AbortCommand: PROC [comm: CDSequencer.Command] = {
TerminalIO.PutRope["try to abort current command\n"]; 
CDSequencer.AbortDesignsCommand[comm.design]
};

SelectExclusive: PROC [comm: CDSequencer.Command] = {
TerminalIO.PutRope["select pointed "];
CDSimpleOps.DeselectAll[comm.design];
CDSimpleOps.Select[comm.design, comm.pos];
TerminalIO.PutRope["\n"];
};

MatchLayer: PROC [template, found: CD.Layer] RETURNS [BOOL] = INLINE {
IF template#CD.undefLayer THEN
IF CDLayers.AbstractToPaint[template]#CDLayers.AbstractToPaint[found] THEN RETURN [FALSE];
RETURN [TRUE]
};

ReSelectExclusive: PROC [design: CD.Design, pos: CD.Position, verbose: BOOL_TRUE, layer: CD.Layer_CD.undefLayer] RETURNS [done: BOOL_TRUE] = {
Deselect: PROC [i: CD.Instance] = INLINE {
IF i.selected THEN {
i.selected _ FALSE;
CDOps.RedrawInstance[design, i]
}
};
DeselectList: PROC [list: CD.InstanceList] = {
FOR w: CD.InstanceList _ list, w.rest WHILE w#NIL DO
Deselect[w.first]
ENDLOOP
};
ValidForSelection: PROC [inst: CD.Instance] RETURNS [BOOL] = INLINE {
 RETURN [ CDInstances.PointToI[pos, inst] AND MatchLayer[layer, inst.ob.layer] ];
};
inst: CD.Instance _ NIL; --any instance where pos points to
FOR w: CD.InstanceList _ CDOps.InstList[design], w.rest WHILE w#NIL DO
IF ValidForSelection[w.first] THEN {
IF w.first.selected THEN {
DeselectList[w.rest]; 
CDOps.ReOrderInstance[design, w.first];
IF verbose THEN TerminalIO.PutRope[CDOps.InstRope[w.first]];
RETURN
}
ELSE IF inst=NIL THEN inst _ w.first
}
ELSE Deselect[w.first]
ENDLOOP;
IF inst#NIL THEN {
inst.selected _ TRUE; 
CDOps.ReOrderInstance[design, inst];
CDOps.RedrawInstance[design, inst, FALSE];
IF verbose THEN TerminalIO.PutRope[CDOps.InstRope[inst]]
}
ELSE {
done _ FALSE;
IF verbose THEN TerminalIO.PutRope[" (no object)"];
}
};

RectDist: PROC [pos: CD.Position, r: CD.Rect] RETURNS [CD.Number] = {
RETURN [MAX[
(IF pos.x<r.x1 THEN (r.x1-pos.x) ELSE IF pos.x>r.x2 THEN (pos.x-r.x2) ELSE 0),
(IF pos.y<r.y1 THEN (r.y1-pos.y) ELSE IF pos.y>r.y2 THEN (pos.y-r.y2) ELSE 0)
]]
};

CloseReSelectExclusive: PROC [design: CD.Design, pos: CD.Position, verbose: BOOL_TRUE, dist: CD.Number_100, layer: CD.Layer_CD.undefLayer] = {
IF ~ReSelectExclusive[design, pos, verbose, layer] THEN {
inst: CD.Instance _ NIL;
FOR w: CD.InstanceList _ CDOps.InstList[design], w.rest WHILE w#NIL DO
d: CD.Number = RectDist[pos, CDInstances.InstRectI[w.first]];
IF d<dist AND MatchLayer[layer, w.first.ob.layer] THEN {inst _ w.first; dist _ d}
ENDLOOP;
IF inst#NIL THEN {
inst.selected _ TRUE;
CDOps.RedrawInstance[design, inst, FALSE];
IF verbose THEN TerminalIO.PutRopes[" found close object ", CDOps.InstRope[inst]];
}
}
};

ReSelectExclusiveComm: PROC [comm: CDSequencer.Command] = {
TerminalIO.PutRope["select "];
[] _ ReSelectExclusive[comm.design, comm.pos];
TerminalIO.PutRope["\n"];
};

ReSelectExclusiveWithLayerComm: PROC [comm: CDSequencer.Command] = {
layer: CD.Layer _ CDLayers.AbstractToPaint[CDLayers.PlaceholderToAbstract[comm.design, CDLayers.CurrentLayer[comm.design]]];
TerminalIO.PutF["select with layer %g ", [rope[CDOps.LayerRope[layer]]]];
[] _ ReSelectExclusive[comm.design, comm.pos, TRUE, layer];
TerminalIO.PutRope["\n"];
};

lastPos: CD.Position; 
lastKey: REF _ NIL;
lastTime: BasicTime.GMT _ BasicTime.earliestGMT;

SameAsLast: PROC[comm: CDSequencer.Command] RETURNS [yes: BOOL] = {
lambda: CD.Number = comm.design.technology.lambda;
ReallyClose: PROC [p1, p2: CD.Position] RETURNS [BOOL] = INLINE {
RETURN [ABS[p1.x-p2.x]<=lambda AND ABS[p1.y-p2.y]<=lambda]
};
now: BasicTime.GMT _ BasicTime.Now[];
yes _ ReallyClose[lastPos, comm.pos] AND lastKey=comm.key AND BasicTime.Period[lastTime, now]<=2;
lastPos _ comm.pos;
lastKey _ comm.key;
lastTime _ now;
};

CloseReSelectComm: PROC [comm: CDSequencer.Command] = {
TerminalIO.PutRope["select "];
IF SameAsLast[comm] THEN CDSimpleOps.DeselectAll[comm.design]; 
[] _ CloseReSelectExclusive[comm.design, comm.pos, TRUE, 50];
TerminalIO.PutRope["\n"];
};

MultiOnlySelectComm: PROC [comm: CDSequencer.Command] = {
NotRect: PROC [p1, p2: CD.Position] RETURNS [BOOL] = INLINE {
RETURN [ABS[p1.x-p2.x]<=lambda OR ABS[p1.y-p2.y]<=lambda]
};
lambda: CD.Number = comm.design.technology.lambda;
IF NotRect[comm.pos, comm.sPos] THEN CloseReSelectComm[comm] 
ELSE AreaOnlySelect[comm];
};

DoubleAddSelectComm: PROC [comm: CDSequencer.Command] = {
IF SameAsLast[comm] THEN {
TerminalIO.PutRope["change selection  "]; 
[] _ DeSelectLast[comm.design, comm.pos, TRUE];
}
ELSE TerminalIO.PutRope["add selection  "];
CDSimpleOps.Select[comm.design, comm.pos];
TerminalIO.PutRope["\n"];
};

DeselectPointed: PROC [comm: CDSequencer.Command] = {
TerminalIO.PutRope["remove selection "]; 
CDSimpleOps.DeSelect[comm.design, comm.pos];
TerminalIO.PutRope["\n"];
};

DeSelectLast: PROC [design: CD.Design, pos: CD.Position, usePos: BOOL_TRUE] RETURNS [done: BOOL_FALSE] = {
sel: CD.Instance _ NIL;
FOR w: CD.InstanceList _ CDOps.InstList[design], w.rest WHILE w#NIL DO
IF w.first.selected THEN { 
IF ~usePos OR CDInstances.PointToI[pos, w.first] THEN sel _ w.first;
};
ENDLOOP;
IF sel#NIL THEN {
sel.selected _ FALSE;
done _ TRUE;
CDOps.RedrawInstance[design, sel]
}
};

DeselectLastSelected: PROC [comm: CDSequencer.Command] = {
TerminalIO.PutRope["remove selection "]; 
[] _ DeSelectLast[comm.design, comm.pos, TRUE];
TerminalIO.PutRope["\n"];
};

AddSelection: PROC [comm: CDSequencer.Command] = { 
TerminalIO.PutRope["add selection  "]; 
CDSimpleOps.Select[comm.design, comm.pos];
TerminalIO.PutRope["\n"];
};

DeselectAll: PROC [comm: CDSequencer.Command] = {
TerminalIO.PutRope["de-select all\n"]; 
CDSimpleOps.DeselectAll[comm.design]
};

SelectAll: PROC [comm: CDSequencer.Command] = {
TerminalIO.PutRope["select all\n"]; 
CDSimpleOps.SelectAll[comm.design]
};

AreaAddSelect: PROC [comm: CDSequencer.Command] = {
TerminalIO.PutRope["inclusive select area\n"]; 
CDSimpleOps.AreaSelect[comm.design, CDBasics.ToRect[comm.pos, comm.sPos]]
};

MultiAddSelect: PROC [comm: CDSequencer.Command] = {
NotRect: PROC [p1, p2: CD.Position] RETURNS [BOOL] = INLINE {
RETURN [ABS[p1.x-p2.x]<=lambda OR ABS[p1.y-p2.y]<=lambda]
};
lambda: CD.Number = comm.design.technology.lambda;
IF NotRect[comm.pos, comm.sPos] THEN DoubleAddSelectComm[comm]
ELSE {
TerminalIO.PutRope["select inclusive area\n"]; 
CDSimpleOps.AreaSelect[comm.design, CDBasics.ToRect[comm.pos, comm.sPos]]
}
};

AreaAddSelectTouching: PROC [comm: CDSequencer.Command] = {
TerminalIO.PutRope["select inclusive touching\n"]; 
CDSimpleOps.AreaSelect[comm.design, CDBasics.ToRect[comm.pos, comm.sPos], TRUE]
};

AreaOnlySelect: PROC [comm: CDSequencer.Command] = {
TerminalIO.PutRope["select area\n"]; 
CDSimpleOps.DeselectAll[comm.design];
CDSimpleOps.AreaSelect[comm.design, CDBasics.ToRect[comm.pos, comm.sPos]]
};

ADeSelect: PROC [comm: CDSequencer.Command] = {
TerminalIO.PutRope["de-select "]; 
IF comm.pos=comm.sPos THEN CDSimpleOps.DeSelect[comm.design, comm.pos]
ELSE CDSimpleOps.AreaDeSelect[comm.design, CDBasics.ToRect[comm.pos, comm.sPos]];
TerminalIO.PutRope["\n"];
};

AreaDeSelect: PROC [comm: CDSequencer.Command] = {
TerminalIO.PutRope["de-select area\n"]; 
CDSimpleOps.AreaDeSelect[comm.design, CDBasics.ToRect[comm.pos, comm.sPos]]
};

AreaDeSelectTouching: PROC [comm: CDSequencer.Command] = {
TerminalIO.PutRope["de-select touching\n"]; 
CDSimpleOps.AreaDeSelect[comm.design, CDBasics.ToRect[comm.pos, comm.sPos], TRUE]
};


CDSequencer.ImplementCommand[$AbortCommand, AbortCommand,, dontQueue];
CDSequencer.ImplementCommand[$DrawRect, AddRect];
CDSequencer.ImplementCommand[$DrawWire, AddWire];
CDSequencer.ImplementCommand[$ContinueWire, ContinueWire];
CDSequencer.ImplementCommand[$DeleteS, DeleteSelected];
CDSequencer.ImplementCommand[$Undel, Undelete];
CDSequencer.ImplementCommand[$OnlySelectP, SelectExclusive,, doQueue];
CDSequencer.ImplementCommand[$ReSelectOnlyP, ReSelectExclusiveComm,, doQueue];
CDSequencer.ImplementCommand[$ReSelectOnlyWithLayerP, ReSelectExclusiveWithLayerComm,, doQueue];
CDSequencer.ImplementCommand[$CloseReSelectOnlyP, CloseReSelectComm,, doQueue];
CDSequencer.ImplementCommand[$AddSelectP, AddSelection,, doQueue];

CDSequencer.ImplementCommand[$DeSelectLP, DeselectLastSelected,, doQueue];
CDSequencer.ImplementCommand[$DeSelectFP, DeselectPointed,, doQueue];
CDSequencer.ImplementCommand[$DeSelectS, DeselectAll,, doQueue];
CDSequencer.ImplementCommand[$SelectAll, SelectAll,, doQueue];
CDSequencer.ImplementCommand[$AreaOnlySelect, AreaOnlySelect,, doQueue];
CDSequencer.ImplementCommand[$MultiOnlySelect, MultiOnlySelectComm,, doQueue];

CDSequencer.ImplementCommand[$AreaAddSelect, AreaAddSelect,, doQueue];
CDSequencer.ImplementCommand[$AreaAddSelectTouching, AreaAddSelectTouching,, doQueue];
CDSequencer.ImplementCommand[$MultiAddSelect, MultiAddSelect,, doQueue];
CDSequencer.ImplementCommand[$DoubleAddSelect, DoubleAddSelectComm,, doQueue];

CDSequencer.ImplementCommand[$AreaDeSelect, AreaDeSelect,, doQueue];
CDSequencer.ImplementCommand[$AreaDeSelectTouching, AreaDeSelectTouching,, doQueue];
CDSequencer.ImplementCommand[$ADeSelect, ADeSelect,, doQueue];
END.
,CDBasicCommands.mesa   (part of ChipNDale)
Copyright c 1983, 1985 by Xerox Corporation.  All rights reserved.
Created by Christian Jacobi,  June 29, 1983 4:44 pm 
Last edited by: Christian Jacobi, January 15, 1987 11:58:10 am PST
--uses pos, sPos, n (for width), b (for firstHorizontal), l (for layer)
--this procedure knows EXACTLY the algorithm used for showing
--temporary wires in the cursor part
--not only crazy vertical
-- not only crazy horizontal 
--hit
--if a selected inst is pointed we already did return
--Distance between a point and a rectangle
--select pointed instance exclusive;
--(but dont select an other instance if the pointed one is already the right one)
--select pointed instance of right layer exclusive
crazy heuristics to determine which kind of selection is wanted
--select pointed instance exclusive;
--(but dont select an other instance if the pointed one is already the right one)
--if there is none, select closest
--cycle through if exactly sme position
--Auto select area or pointed or changed
--Auto deselect area or pointed
Κz˜
codeš
œ*™*Kšœ
Οm
œ7™BKš
œ4™4K™B—K˜š
Οk	˜	Kš
œ
˜
Kšžœ
˜K˜	Kš
œ˜Kš
œ	˜	Kš
œ˜K˜K˜K˜K˜K˜—šΟnœžœ
ž˜Kšžœd˜k—Kš
ž˜K˜š
Ÿœžœ	žœžœžœ˜@šžœžœ˜Kšœžœ˜Kšœžœ#˜)Kšœžœ˜"šžœžœ˜Kšœžœ'˜,Kš
œ˜Kš
œ˜—Kš
œ˜Kš
œc˜cK˜
—Kšžœ1˜5Kš
œ˜K˜—šŸœžœ ˜-Kš
œ#˜#Kš
œD˜DKš
œ˜—K˜šŸœžœ ˜-Kš
œG™GKšœ'žœ
˜-Kš
œ˜—K˜šŸœžœ ˜2Kšœ'žœ
˜,Kš
œ˜—K˜šŸœžœ(žœ
žœ˜LKš
œ=™=Kš
œ$™$Kšœžœ˜ Kšœžœ˜Kšœžœ˜Kšžœ
žœžœ˜,Kš
œ#˜#šžœ
Οcœžœ˜$šžœžœ˜0Kšžœžœžœ ˜Mšžœ
žœ/žœ
˜:Kšœ0žœ˜8—Kš
œ˜Kš
œ<˜<Kš
ž˜Kš
œ˜—Kšœ œ	™šžœžœžœ ˜IKš
œ˜Kš
œ;˜;Kš
œ
˜
—šžœ ˜#Kšžœžœ˜3Kšžœžœ0˜;Kš
œ˜Kš
œ<˜<Kšžœžœ
žœ
˜Kš
œF˜FKš
œ<˜<Kš
œ
˜
—K˜
—šžœ ˜"šžœžœ˜1Kšžœžœžœ ˜Ošžœ
žœ/žœ
˜:Kšœ0žœ˜8—Kš
œ˜Kš
œ<˜<Kš
ž˜K˜—Kšœ œ
 
œ
™šžœžœžœ ˜GKš
œ˜Kš
œ;˜;Kš
œ
˜
—šžœ ˜!Kšžœžœ˜3Kšžœžœ2˜=Kš
œ˜Kš
œ<˜<Kšžœžœ
žœ
˜Kš
œF˜FKš
œ<˜<Kš
œ
˜
—K˜
—Kš
œ˜K˜—šŸœžœ ˜4Kš
œ(˜(Kš
œ(˜(Kš
œ˜Kš
œ˜K˜—šŸœžœ ˜.Kš
œ#˜#Kš
œ!˜!Kš
œ˜K˜—šŸœžœ ˜2Kš
œ6˜6Kš
œ,˜,Kš
œ˜—K˜šŸœžœ ˜5Kš
œ&˜&Kš
œ%˜%Kš
œ*˜*Kš
œ˜Kš
œ˜K˜—šŸ
œžœžœžœžœžœ˜Fšžœ
žœž˜KšžœDžœžœ˜Z—Kšžœžœ
˜
Kš
œ˜—K˜šŸœžœ
žœžœžœ
žœ	žœžœ
žœžœ
žœ˜Ž
šŸœžœžœ
žœ˜*šžœžœ˜Kšœ
žœ
˜Kš
œ˜K˜
—Kš
œ˜—šŸœžœžœ˜.š	žœžœžœžœ
ž˜4Kš
œ˜Kš
ž˜—Kš
œ˜—šŸœžœžœžœžœžœ˜EKšœ
žœ#žœ$˜QK˜—Kšœžœžœ "˜;š	žœžœ/žœžœ
ž˜Fšžœžœ˜$Kš
 ™šžœžœ˜Kš
œ˜Kš
œ'˜'Kšžœ	žœ-˜<Kš
ž˜Kš
œ
˜
—Kšžœ
žœžœ
žœ˜$Kš
œ
˜
—Kšžœ˜Kšžœ
˜—Kš
 5™5šžœžœ
žœ˜Kšœžœ˜Kš
œ$˜$Kšœ#žœ˜*Kšžœ	žœ)˜8K˜
—šžœ˜Kšœžœ
˜
Kšžœ	žœ$˜3K˜
—Kš
œ˜K˜—šŸœžœžœžœžœžœ˜EK™*šžœžœ
˜Kš
œ
žœžœžœ
žœžœžœ˜NKš
œ
žœžœžœ
žœžœžœ˜MK˜—Kš
œ˜—K˜šŸœžœ
žœžœžœ
žœžœžœžœ˜Ž
šžœ1žœ˜9Kšœžœžœ
˜š	žœžœ/žœžœ
ž˜FKšœžœ8˜=Kšžœžœ%žœ˜QKšžœ
˜—šžœžœ
žœ˜Kšœžœ
˜Kšœ#žœ˜*Kšžœ	žœC˜RK˜
—K˜
—Kš
œ˜K˜—šŸœžœ ˜;Kš
œ$™$Kš
œQ™QKš
œ˜Kš
œ.˜.Kš
œ˜Kš
œ˜K˜—šŸœžœ ˜DKš
 2™2Kšœžœs˜|Kš
œI˜IKšœ.žœ	˜;Kš
œ˜Kš
œ˜K˜—š
œ?™?Kšœ	žœ˜Kšœ	žœžœ
˜Kšœžœ˜0—K˜šŸ
œžœžœžœ˜CKšœžœ(˜2šŸœžœ
žœžœžœžœ˜AKšžœžœžœ
žœ˜:Kš
œ˜—Kšœžœ˜%Kšœ%žœžœ$˜aKš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜—K˜šŸœžœ ˜7Kš
œ$™$Kš
œQ™QK™"K™'Kš
œ˜Kšžœžœ'˜?Kšœ3žœ˜=Kš
œ˜Kš
œ˜—K˜šΠbnœžœ ˜9šŸœžœ
žœžœžœžœ˜=Kšžœžœžœ
žœ˜9Kš
œ˜—Kšœžœ(˜2Kšžœžœ˜=Kšžœ˜Kš
œ˜K˜—š‘œžœ ˜9šžœžœ˜Kš
œ*˜*Kšœ)žœ˜/K˜
—Kšžœ'˜+Kš
œ*˜*Kš
œ˜Kš
œ˜K˜—šŸœžœ ˜5Kš
œ)˜)Kš
œ,˜,Kš
œ˜Kš
œ˜K˜—šŸœžœ
žœžœžœ
žœžœžœ
žœ˜jKšœžœžœ
˜š	žœžœ/žœžœ
ž˜Fšžœžœ˜Kšžœ	žœ$žœ˜DK˜—Kšžœ
˜—šžœžœ
žœ˜Kšœžœ
˜Kšœžœ
˜Kš
œ!˜!K˜
—Kš
œ˜—K˜šŸœžœ ˜:Kš
œ)˜)Kšœ)žœ˜/Kš
œ˜Kš
œ˜K˜—šŸœžœ!˜3Kš
œ'˜'Kš
œ*˜*Kš
œ˜Kš
œ˜K˜—šŸœžœ ˜1Kš
œ'˜'Kš
œ$˜$Kš
œ˜K˜—šŸ	œžœ ˜/Kš
œ$˜$Kš
œ"˜"Kš
œ˜—K˜šŸ
œžœ ˜3Kš
œ/˜/Kš
œI˜IKš
œ˜—K˜šŸœžœ ˜4Kš
œ(™(šŸœžœ
žœžœžœžœ˜=Kšžœžœžœ
žœ˜9Kš
œ˜—Kšœžœ(˜2Kšžœžœ˜>šžœ˜Kš
œ/˜/Kš
œI˜IK˜
—Kš
œ˜—K˜šŸœžœ ˜;Kš
œ3˜3KšœJžœ
˜OKš
œ˜—K˜šŸœžœ ˜4Kš
œ%˜%Kš
œ%˜%Kš
œI˜IKš
œ˜—K˜šŸ	œžœ ˜/Kš
œ™Kš
œ"˜"Kšžœžœ,˜FKšžœM˜QKš
œ˜Kš
œ˜—K˜šŸœžœ ˜2Kš
œ(˜(Kš
œK˜KKš
œ˜—K˜šŸœžœ ˜:Kš
œ,˜,KšœLžœ
˜QKš
œ˜—K˜K˜Kš
œF˜FK˜1Kš
œ1˜1K˜:K˜7K˜/Kš
œF˜FKš
œN˜NKš
œ`˜`Kš
œO˜OKš
œB˜BK˜Kš
œJ˜JKš
œE˜EKš
œ@˜@Kš
œ>˜>Kš
œH˜HKš
œN˜NK˜Kš
œF˜FKš
œV˜VKš
œH˜HKš
œN˜NK˜Kš
œD˜DKš
œT˜TKš
œ>˜>Kšžœ
˜—…—1 CΖ