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

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

AddARect: PROC[design: CD.Design, r: CD.Rect,  l: CD.Layer] =
BEGIN
ob: CD.Object;
sz: CD.Position _ CDBasics.SizeOfRect[r];
orient: CD.Orientation _ CDOrient.original;
IF sz.y<sz.x THEN {
w: CD.Number _ sz.x; 
sz.x _ sz.y; 
sz.y _ w; 
orient _ CDOrient.rotate90
};
IF sz.x<=0 THEN {TerminalIO.WriteRope["Empty object not included\n"]; RETURN};
ob _ CDRects.CreateRect[sz, l];
CDOps.AddAnObject[
design: design, 
ob: ob, 
location: CDBasics.BaseOfRect[r], 
orientation: orient]
END;


AddRect: PROC [comm: CDSequencer.Command] =
BEGIN
TerminalIO.WriteRope["Add rect\n"]; 
AddARect[comm.design, CDBasics.ToRect[comm.sPos, comm.pos], comm.l];
END;

AddWire: PROC [comm: CDSequencer.Command] =
BEGIN
InternalAddWire[comm: comm, firstOnly: FALSE]
END;

ContinueWire: PROC [comm: CDSequencer.Command] =
BEGIN
InternalAddWire[comm: comm, firstOnly: TRUE]
END;

InternalAddWire: PROC [comm: CDSequencer.Command, firstOnly: BOOL_FALSE] =
BEGIN
start: CD.Position _ comm.sPos; 
stop: CD.Position _ comm.pos;
wireWidth: CD.Number _ comm.n;
IF wireWidth=0 THEN {AddRect[comm]; RETURN};
TerminalIO.WriteRope["Add 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.WriteRope[" 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.WriteRope[" 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];
}
}
END;

DeleteSelected: PROC [comm: CDSequencer.Command] =
BEGIN
TerminalIO.WriteRope["Delete selected "]; 
CDSimpleOps.DeleteSelected[comm.design];
TerminalIO.WriteLn[]; 
END;

Undelete: PROC [comm: CDSequencer.Command] =
BEGIN
TerminalIO.WriteRope["Undelete\n"]; 
CDSimpleOps.Undelete[comm.design]
END;


AbortCommand: PROC [comm: CDSequencer.Command] =
BEGIN
TerminalIO.WriteRope["Try to abort current command\n"]; 
CDSequencer.AbortTheCommand[comm.design]
END;

SelectExclusive: PROC [comm: CDSequencer.Command] =
BEGIN
TerminalIO.WriteRope["Select pointed"];
CDSimpleOps.DeselectAll[comm.design];
CDSimpleOps.Select[comm.design, comm.pos];
TerminalIO.WriteLn[];
END;

ReSelectExclusive: PROC [design: CD.Design, pos: CD.Position, verbose: BOOL_TRUE] RETURNS [done: BOOL_TRUE] =
BEGIN
Deselect: PROC[a: CD.Instance] = 
INLINE BEGIN
IF a.selected THEN {
a.selected _ FALSE;
CDCommandOps.RedrawInstance[design, a]
}
END;
DeselectList: PROC[list: CD.InstanceList] = 
BEGIN
FOR w: CD.InstanceList _ list, w.rest WHILE w#NIL DO
Deselect[w.first]
ENDLOOP
END;
ap: CD.Instance _ NIL; --any application where pos points to
FOR w: CD.InstanceList _ CDOps.InstList[design], w.rest WHILE w#NIL DO
IF CDInstances.PointToI[pos, w.first] THEN {
IF w.first.selected THEN {
DeselectList[w.rest]; 
CDOps.ReOrderInstance[design, w.first];
IF verbose THEN CDCommandOps.WriteInfo[w.first];
RETURN
}
ELSE IF ap=NIL THEN ap _ w.first
}
ELSE Deselect[w.first]
ENDLOOP;
IF ap#NIL THEN {
ap.selected _ TRUE; 
CDOps.ReOrderInstance[design, ap];
CDCommandOps.RedrawInstance[design, ap, FALSE];
IF verbose THEN CDCommandOps.WriteInfo[ap]
}
ELSE {
done _ FALSE;
IF verbose THEN TerminalIO.WriteRope["  (no object)"];
}
END;

RectDist: PROC[pos: CD.Position, r: CD.Rect] RETURNS [CD.Number] =
BEGIN
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)
]]
END;

CloseReSelectExclusive: PROC [design: CD.Design, pos: CD.Position, verbose: BOOL_TRUE, dist: CD.Number_100] =
BEGIN
IF ~ReSelectExclusive[design, pos, verbose] THEN {
ap: 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 THEN {ap _ w.first; dist _ d}
ENDLOOP;
IF ap#NIL THEN {
ap.selected _ TRUE;
CDCommandOps.RedrawInstance[design, ap, FALSE];
IF verbose THEN {
TerminalIO.WriteRope[" found close object"];
CDCommandOps.WriteInfo[ap]
}
}
}
END;

ReSelectExclusiveComm: PROC [comm: CDSequencer.Command] =
BEGIN
TerminalIO.WriteRope["Select"];
[] _ ReSelectExclusive[comm.design, comm.pos];
TerminalIO.WriteLn[];
END;

--crazy heuristics to determine which kind of selection is wanted
lastPos: CD.Position; 
lastA: REF _ NIL;
lastTime: BasicTime.GMT _ BasicTime.earliestGMT;

SameAsLast: PROC[comm: CDSequencer.Command] RETURNS [yes: BOOL] =
BEGIN
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 lastA=comm.a AND BasicTime.Period[lastTime, now]<=2;
lastPos _ comm.pos;
lastA _ comm.a;
lastTime _ now;
END;

CloseReSelectComm: PROC [comm: CDSequencer.Command] =
BEGIN
TerminalIO.WriteRope["select "];
IF SameAsLast[comm] THEN CDSimpleOps.DeselectAll[comm.design]; 
[] _ CloseReSelectExclusive[comm.design, comm.pos, TRUE, 50];
TerminalIO.WriteLn[];
END;

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

DoubleAddSelectComm: PROC [comm: CDSequencer.Command] =
BEGIN
IF SameAsLast[comm] THEN {
TerminalIO.WriteRope["Change selection  "]; 
[] _ DeSelectLast[comm.design, comm.pos, TRUE];
}
ELSE TerminalIO.WriteRope["Add selection  "];
CDSimpleOps.Select[comm.design, comm.pos];
TerminalIO.WriteLn[];
END;

DeselectPointed: PROC [comm: CDSequencer.Command] =
BEGIN
TerminalIO.WriteRope["Remove selection "]; 
CDSimpleOps.DeSelect[comm.design, comm.pos];
TerminalIO.WriteLn[];
END;

DeSelectLast: PROC [design: CD.Design, pos: CD.Position, usePos: BOOL_TRUE] RETURNS [done: BOOL_FALSE] =
BEGIN 
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;
CDCommandOps.RedrawInstance[design, sel]
}
END;

DeselectLastSelected: PROC [comm: CDSequencer.Command] =
BEGIN
TerminalIO.WriteRope["Remove selection "]; 
[] _ DeSelectLast[comm.design, comm.pos, TRUE];
TerminalIO.WriteLn[];
END;

AddSelection: PROC [comm: CDSequencer.Command] =
BEGIN
TerminalIO.WriteRope["Add selection  "]; 
CDSimpleOps.Select[comm.design, comm.pos];
TerminalIO.WriteLn[];
END;

DeselectAll: PROC [comm: CDSequencer.Command] =
BEGIN
TerminalIO.WriteRope["Deselect all\n"]; 
CDSimpleOps.DeselectAll[comm.design]
END;

SelectAll: PROC [comm: CDSequencer.Command] =
BEGIN
TerminalIO.WriteRope["Select all\n"]; 
CDSimpleOps.SelectAll[comm.design]
END;

AreaAddSelect: PROC [comm: CDSequencer.Command] =
BEGIN
TerminalIO.WriteRope["Inclusive select area\n"]; 
CDSimpleOps.AreaSelect[comm.design, CDBasics.ToRect[comm.pos, comm.sPos]]
END;

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

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

AreaOnlySelect: PROC [comm: CDSequencer.Command] =
BEGIN
TerminalIO.WriteRope["Select area\n"]; 
CDSimpleOps.DeselectAll[comm.design];
CDSimpleOps.AreaSelect[comm.design, CDBasics.ToRect[comm.pos, comm.sPos]]
END;

ADeSelect: PROC [comm: CDSequencer.Command] =
BEGIN
TerminalIO.WriteRope["Deselect "]; 
IF comm.pos=comm.sPos THEN CDSimpleOps.DeSelect[comm.design, comm.pos]
ELSE CDSimpleOps.AreaDeSelect[comm.design, CDBasics.ToRect[comm.pos, comm.sPos]];
TerminalIO.WriteLn[];
END;

AreaDeSelect: PROC [comm: CDSequencer.Command] =
BEGIN
TerminalIO.WriteRope["Deselect area\n"]; 
CDSimpleOps.AreaDeSelect[comm.design, CDBasics.ToRect[comm.pos, comm.sPos]]
END;

AreaDeSelectTouching: PROC [comm: CDSequencer.Command] =
BEGIN
TerminalIO.WriteRope["Deselect touching\n"]; 
CDSimpleOps.AreaDeSelect[comm.design, CDBasics.ToRect[comm.pos, comm.sPos], TRUE]
END;



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[$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.
by Christian Jacobi,  June 29, 1983 4:44 pm 
last edited Christian Jacobi,  November 11, 1985 4:55:57 pm 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 ap is pointed we already did return
--Distance between a point and a rectangle
--select pointed application exclusive;
--(but dont select an other application if the pointed one is already the right one)
--select pointed application exclusive;
--(but dont select an other application 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
Κ|˜š
œ*™*Jšœ
Οm
œ7™BJš
œ,™,Jš
œ?™?—J˜š
Οk	˜	Icodešœ	ž
˜
Jšžœ
˜J˜	Jš
œ
˜
Jš
œ˜Jš
œ˜J˜J˜	J˜J˜J˜J˜—šΟnœžœ
ž˜Jšžœh˜o—Jš
ž˜J˜š
Ÿœžœ	žœžœžœ	˜=Jš
ž˜Jšœžœ˜Jšœžœ#˜)Jšœžœ!˜+šžœžœ˜Jšœžœ˜Jš
œ
˜
Jš
œ
˜
Jš
œ˜Jš
œ˜—Jšžœ	žœ7žœ˜NJš
œ˜˜J˜J˜J˜"Jš
œ˜—Jšžœ
˜J˜—J˜šŸœžœ˜+Jš
ž˜J˜$Jš
œD˜DJšžœ
˜—J˜šŸœžœ˜+Jš
œG™GJš
ž˜Jšœ'žœ
˜-Jš
ž˜—J˜šŸœžœ˜0Jš
ž˜Jšœ'žœ
˜,Jšžœ
˜—J˜šŸœžœ(žœ
žœ˜JJš
œ=™=Jš
œ$™$Jš
ž˜Jšœžœ˜ Jšœžœ˜Jšœžœ˜Jšžœ
žœžœ˜,J˜$šžœ
Οcœžœ˜$šžœžœ˜0Jšžœžœžœ
 ˜Mšžœ
žœ/žœ
˜:Jšœ2žœ˜:—Jš
œ˜Jš
œ<˜<Jš
ž˜Jš
œ˜—Jšœ œ	™š	žœžœžœ
ž
œ
 ˜IJš
œ˜Jš
œ;˜;Jš
œ
˜
—šžœ
 ˜#Jšžœžœ˜3Jšžœžœ0˜;Jš
œ˜Jš
œ<˜<Jšžœžœ
žœ
˜Jš
œF˜FJš
œ<˜<Jš
œ
˜
—J˜
—šžœ
 ˜"šžœžœ˜1Jšžœžœžœ
 ˜Ošžœ
žœ/žœ
˜:Jšœ2žœ˜:—Jš
œ˜Jš
œ<˜<Jš
ž˜J˜—Jšœ œ
 
œ
™š	žœžœžœ
ž
œ
 ˜GJš
œ˜Jš
œ;˜;Jš
œ
˜
—šžœ
 ˜!Jšžœžœ˜3Jšžœžœ2˜=Jš
œ˜Jš
œ<˜<Jšžœžœ
žœ
˜Jš
œF˜FJš
œ<˜<Jš
œ
˜
—J˜
—Jšžœ
˜J˜—šŸœžœ˜2Jš
ž˜J˜*Jš
œ(˜(J˜Jšžœ
˜J˜—šŸœžœ˜,Jš
ž˜J˜$Jš
œ!˜!Jšžœ
˜J˜—J˜šŸœžœ˜0Jš
ž˜J˜8Jš
œ(˜(Jšžœ
˜—K˜šŸœžœ˜3Kš
ž˜K˜'Kš
œ%˜%Kš
œ*˜*K˜Kšžœ
˜K˜—šŸœžœ
žœžœžœ
žœžœž	œ˜mKš
ž˜šŸœžœžœ
˜!Kšžœ
ž˜šžœžœ˜Kšœ
žœ
˜Kš
œ&˜&K˜
—Kšžœ
˜—šŸœžœžœ˜,Kš
ž˜š	žœžœžœžœ
ž˜4Kš
œ˜Kš
ž˜—Kšžœ
˜—Kšœžœžœ %˜<š	žœžœ/žœžœ
ž˜Fšžœ$žœ˜,Kš
œ™šžœžœ˜Kš
œ˜Kš
œ'˜'Kšžœ	žœ!˜0Kš
ž˜Kš
œ
˜
—Kšžœ
žœžœ
žœ
˜ Kš
œ
˜
—Kšžœ˜Kšžœ
˜—Kš
œ3™3šžœžœ
žœ˜Kšœžœ˜Kš
œ"˜"Kšœ(žœ˜/Kšžœ	žœ˜*K˜
—šžœ˜Kšœžœ
˜
Kšžœ	žœ'˜6K˜
—Kšžœ
˜K˜—šŸœžœžœžœžœžœ
˜BK™*Kš
ž˜šžœžœ
˜Kš
œ
žœžœžœ
žœžœžœ˜NKš
œ
žœžœžœ
žœžœžœ˜MK˜—Kšžœ
˜—K˜šŸœžœ
žœžœžœ
žœžœ˜mKš
ž˜šžœ*žœ˜2Kšœžœžœ
˜š	žœžœ/žœžœ
ž˜FKšœžœ8˜=Kšžœžœ˜'Kšžœ
˜—šžœžœ
žœ˜Kšœžœ
˜Kšœ(žœ˜/šžœ	žœ˜Kš
œ,˜,Kš
œ˜K˜
—K˜
—K˜
—Kšžœ
˜K˜—šŸœžœ˜9Kš
œ'™'K™TKš
ž˜K˜Kš
œ.˜.K˜Kšžœ
˜K˜—š
 A˜AKšœ	žœ˜Kšœžœžœ
˜Kšœžœ˜0—K˜šŸ
œžœžœžœ˜AKš
ž˜Kš
œ2˜2šŸœžœ
žœžœžœžœ˜AKšžœžœžœ
žœ˜:Kš
œ˜—Kšœžœ˜%Kšœ%žœžœ$˜]Kš
œ˜Kš
œ˜Kš
œ˜Kšžœ
˜—K˜šŸœžœ˜5Kš
œ'™'K™TK™"K™'Kš
ž˜K˜ Kšžœžœ'˜?Kšœ3žœ˜=K˜Kšžœ
˜—K˜šΠbnœžœ˜7Kš
ž˜šŸœžœ
žœžœžœž˜;Kš
ž˜Kšžœžœžœ
žœ˜9Kšžœ
˜—Kš
œ2˜2Kšžœžœ˜=Kšžœ˜Kšžœ
˜K˜—š‘œžœ˜7Kš
ž˜šžœžœ˜K˜,Kšœ)žœ˜/K˜
—Kšžœ)˜-Kš
œ*˜*K˜Kšžœ
˜K˜—šŸœžœ˜3Kš
ž˜K˜+Kš
œ,˜,Kš
œ˜Kšžœ
˜K˜—šŸœžœ
žœžœžœ
žœžœžœ
žœ˜hKšžœ
˜Kšœžœžœ
˜š	žœžœ/žœžœ
ž˜Fšžœžœ˜Kšžœ	žœ$žœ˜DK˜—Kšžœ
˜—šžœžœ
žœ˜Kšœžœ
˜Kšœžœ
˜Kš
œ(˜(K˜
—Kšžœ
˜K˜—šŸœžœ˜8Kš
ž˜K˜+Kšœ)žœ˜/Kš
œ˜Kšžœ
˜K˜—šŸœžœ˜0Kš
ž˜K˜)Kš
œ*˜*K˜Kšžœ
˜K˜—šŸœžœ˜/Kš
ž˜K˜(Kš
œ$˜$Kšžœ
˜K˜—šŸ	œžœ˜-Kš
ž˜K˜&Kš
œ"˜"Kšžœ
˜—K˜šŸ
œžœ˜1Kš
ž˜K˜1Kš
œI˜IKšžœ
˜—K˜šŸœžœ˜2Kš
œ(™(Kš
ž˜šŸœžœ
žœžœžœž˜;Kš
ž˜Kšžœžœžœ
žœ˜9Kšžœ
˜—Kš
œ2˜2Kšžœžœ˜>šžœ˜K˜1Kš
œI˜IK˜
—Kšžœ
˜—K˜šŸœžœ˜9Kš
ž˜K˜5KšœJžœ
˜OKšžœ
˜—K˜šŸœžœ˜2Kš
ž˜K˜'Kš
œ%˜%Kš
œI˜IKšžœ
˜—K˜šŸ	œžœ˜-Kš
œ™Kš
ž˜K˜#Kšžœžœ,˜FKšžœM˜QKš
œ˜Kšžœ
˜—K˜šŸœžœ˜0Kš
ž˜K˜)Kš
œK˜KKšžœ
˜—K˜šŸœžœ˜8Kš
ž˜K˜-KšœLžœ
˜QKšžœ
˜—K˜J˜J˜Jš
œF˜FJ˜1Jš
œ1˜1J˜:J˜7J˜/Kš
œF˜FKš
œN˜NKš
œ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š
œ>˜>Jšžœ
˜—…—.’@Φ