DIRECTORY
CD,
CDInstances,
CDBasics,
CDCommandOps,
CDCallSpecific,
CDCurves,
CDLayers,
CDOps,
CDOrient,
CDPrivate,
CDSequencer,
CDSymbolicObjects,
IO, 
PriorityQueue,
Real,
Rope,
TerminalIO;

CDCurvesCommands: CEDAR PROGRAM 
IMPORTS CDBasics, CDCallSpecific, CDCommandOps, CDCurves, CDLayers, CDOps, CDOrient, CDSequencer, CDSymbolicObjects, IO, PriorityQueue, Real, Rope, TerminalIO
SHARES CDCurves =
BEGIN

LP: TYPE = LIST OF CD.Position;

Write: PROC[r: Rope.ROPE] = {TerminalIO.WriteRope[r]};


DistanceSq: PROC[p1, p2: CD.Position] RETURNS [REAL] =
BEGIN
dx: REAL = Real.Float[p1.x]-Real.Float[p2.x];
dy: REAL = Real.Float[p1.y]-Real.Float[p2.y];
RETURN [dx*dx+dy*dy]
END;

Distance: PROC [p1, p2: CD.Position] RETURNS [REAL] = 
BEGIN
RETURN [Real.SqRt[DistanceSq[p1, p2]]]
END;

DistancePairP: PROC[p1, p2, p: CD.Position] RETURNS [REAL] =
BEGIN
RETURN [ABS[Distance[p1, p]+Distance[p2, p]-Distance[p2, p1]]]
END;

StretchPoints: PROC [points: LP, from, to: CD.Position] RETURNS [new: LP_NIL] =
BEGIN
pos: INT _ 0;
cnt: INT _ 0;
dmin: REAL _ LAST[INT];
FOR p: LP _ points, p.rest WHILE p#NIL DO 
d: REAL = DistanceSq[p.first, from];
cnt _ cnt+1;
IF d<dmin THEN {pos_cnt; dmin_d};
ENDLOOP;
FOR i: INT IN [1..pos) DO
new _ CONS[points.first, new];
points _ points.rest;
ENDLOOP;
new _ CONS[to, new];
points _ points.rest;
FOR p: LP _ points, p.rest WHILE p#NIL DO 
new _ CONS[p.first, new];
ENDLOOP;
END; 

IncludePoint: PROC [points: LP, from, to: CD.Position] RETURNS [new: LP_NIL] =
BEGIN
after: INT _ 0;
cnt: INT _ 0;
dmin: REAL _ LAST[INT];
last: CD.Position;
d: REAL;
FOR p: LP _ points, p.rest WHILE p#NIL AND p.rest#NIL DO 
d _ DistancePairP[p.first, p.rest.first, from];
last _ p.first;
cnt _ cnt+1;
IF d<dmin THEN {after_cnt; dmin_d};
ENDLOOP;
d _ DistancePairP[points.first, last, from];
IF d<dmin THEN after_0;
FOR i: INT IN [1..after] DO
new _ CONS[points.first, new];
points _ points.rest;
ENDLOOP;
new _ CONS[to, new];
FOR p: LP _ points, p.rest WHILE p#NIL DO 
new _ CONS[p.first, new];
ENDLOOP;
END; 

RemovePoint: PROC [points: LP, from, to: CD.Position] RETURNS [new: LP_NIL] =
BEGIN
pos: INT _ 0;
cnt: INT _ 0;
dmin: REAL _ LAST[INT];
FOR p: LP _ points, p.rest WHILE p#NIL DO 
d: REAL = DistanceSq[p.first, from];
cnt _ cnt+1;
IF d<dmin THEN {pos_cnt; dmin_d};
ENDLOOP;
FOR i: INT IN [1..pos) DO
new _ CONS[points.first, new];
points _ points.rest;
ENDLOOP;
IF cnt>3 THEN points _ points.rest 
ELSE Write["degenerated polygon not created\n"];
FOR p: LP _ points, p.rest WHILE p#NIL DO 
new _ CONS[p.first, new];
ENDLOOP;
END;

OffsetInPlace: PROC [pl: LP, off: CD.Number] = {
FOR l: LP _ pl, l.rest WHILE l#NIL DO 
l.first _ [l.first.x+off, l.first.y+off]
ENDLOOP;
};

OrientedPoints: PROC [inst: CD.Instance] RETURNS [copy: LP_NIL] =
BEGIN
pl: LP; 
WITH inst.ob.specificRef SELECT FROM
cp: CDCurves.CurvePtr => pl _ cp.points;
ENDCASE => ERROR;
FOR p: LP _ pl, p.rest WHILE p#NIL DO 
orientedP: CD.Position = CDOrient.MapPoint[
pointInCell: p.first,
cellSize: inst.ob.size,
cellInstOrient: inst.orientation,
cellInstPos: inst.location].pointInWorld;
copy _ CONS[orientedP, copy];
ENDLOOP;
END; 

FindMarks: PROC [design: CD.Design, predicate: CDSymbolicObjects.InstEnumerator_NIL] RETURNS [pq: PriorityQueue.Ref] = {
pq _ PriorityQueue.Create[SortPred];
FOR w: CD.InstanceList _ CDOps.InstList[design], w.rest WHILE w#NIL DO
IF CDSymbolicObjects.IsMark[w.first.ob] AND (predicate=NIL OR predicate[w.first]) THEN  
PriorityQueue.Insert[pq, w.first];
ENDLOOP;
};

SelectPMarksComm: PROC [comm: CDSequencer.Command] = {
cnt: INT _ 0;
FOR w: CD.InstanceList _ CDOps.InstList[comm.design], w.rest WHILE w#NIL DO
IF CDSymbolicObjects.IsMark[w.first.ob] AND FromPS[w.first] THEN  
IF ~w.first.selected THEN {
w.first.selected _ TRUE; cnt _ cnt+1;
CDOps.RedrawInstance[comm.design, w.first, FALSE]
};
ENDLOOP;
TerminalIO.WriteF["add-select curve control marks; %g more mark(s) selected\n  ", [integer[cnt]]];
MarksStatistic[comm.design];
};

RemOwnerComm: PROC [comm: CDSequencer.Command] = {
Write[" remove owner of marks\n"];
FOR w: CD.InstanceList _ CDOps.InstList[comm.design], w.rest WHILE w#NIL DO
IF w.first.selected AND CDSymbolicObjects.IsMark[w.first.ob] THEN  
CDSymbolicObjects.SetOwner[w.first, NIL];
ENDLOOP;
};

SetOwnerComm: PROC [comm: CDSequencer.Command] = {
Write[" convert marks to curve control marks\n"];
FOR w: CD.InstanceList _ CDOps.InstList[comm.design], w.rest WHILE w#NIL DO
IF w.first.selected AND CDSymbolicObjects.IsMark[w.first.ob] THEN  
IF ~FromPS[w.first] THEN SetOrder[w.first];
ENDLOOP;
};

MarksStatisticComm: PROC [comm: CDSequencer.Command] = {
Write["count marks: "];
MarksStatistic[comm.design];
};

MarksStatistic: PROC [design: CD.Design] = {
oMcnt, pMcnt, oXcnt, notSelPMcnt: INT _ 0;
FOR w: CD.InstanceList _ CDOps.InstList[design], w.rest WHILE w#NIL DO
IF w.first.selected THEN {
IF CDSymbolicObjects.IsMark[w.first.ob] THEN
IF FromPS[w.first] THEN pMcnt _ pMcnt+1
ELSE oMcnt _ oMcnt +1
ELSE oXcnt _ oXcnt + 1
}
ELSE IF CDSymbolicObjects.IsMark[w.first.ob] AND FromPS[w.first] THEN 
notSelPMcnt _ notSelPMcnt+1;
ENDLOOP;
TerminalIO.WriteF[" %g curve control marks", [integer[pMcnt]]];
IF oMcnt#0 THEN TerminalIO.WriteF[" %g other-marks", [integer[oMcnt]]];
IF oXcnt#0 THEN TerminalIO.WriteF[" %g other-objects", [integer[oXcnt]]];
Write[" selected"];
IF notSelPMcnt#0 THEN TerminalIO.WriteF[" %g curve control marks NOT selected", [integer[notSelPMcnt]]];
TerminalIO.WriteLn[];
};

ConvertPSToMarks: PROC [comm: CDSequencer.Command] =
BEGIN
i: CD.Instance _ CDCommandOps.TheInstance[comm, "split up curve object"];
IF i#NIL THEN {
IF CDCurves.IsPolygon[i.ob] OR CDCurves.IsSpline[i.ob] OR CDCurves.IsFilledCurve[i.ob] OR CDCurves.IsLine[i.ob] THEN {
cp: CDCurves.CurvePtr _ NARROW[i.ob.specificRef];
cnt: INT _ 0; oldPoints: LP _ OrientedPoints[i];
CDOps.RemoveInstance[comm.design, i];
FOR pl: LP _ oldPoints, pl.rest WHILE pl#NIL DO
r: CD.Rect _ CDBasics.RectAt[[pl.first.x-cp.w/2, pl.first.y-cp.w/2], [0, 0]];
si: CD.Instance _ CDSymbolicObjects.CreateSymInst[denotes: r, layer: i.ob.layer];
SetOrder[si]; si.selected _ TRUE;
CDOps.IncludeInstance[comm.design, si];
ENDLOOP;
}
ELSE Write["selected ob is neither polygon nor spline; not done\n"];
}; 
END;

Selected: CDSymbolicObjects.InstEnumerator ={
RETURN [inst.selected]
};

FromPS: CDSymbolicObjects.InstEnumerator ={
RETURN [CDSymbolicObjects.GetOwner[inst]=$CurveControl]
};

SelectedOrFromPS: CDSymbolicObjects.InstEnumerator ={
RETURN [inst.selected OR CDSymbolicObjects.GetOwner[inst]=$CurveControl]
};

SortPred: PriorityQueue.SortPred = {
RETURN [ Rope.Compare[ CDSymbolicObjects.GetName[NARROW[x]], CDSymbolicObjects.GetName[NARROW[y] ], FALSE] < equal];
};

MarksToPSComm: PROC [comm: CDSequencer.Command] =
BEGIN

MarksToPS: PROC [design: CD.Design, pq: PriorityQueue.Ref, layer: CD.Layer, key: ATOM, w: CD.Number _ 0] = {
ob: CD.Object; offset: CD.Position; pl: LIST OF CD.Position _ NIL;
SELECT key FROM
$s => {w _ (w+1)/2*2};
$p => {w _ 0};
$l => {w _ (w+1)/2*2};
$f => {w _ 0};
ENDCASE => ERROR;
FOR c: INT IN [0..PriorityQueue.Size[pq]) DO
i: CD.Instance _ NARROW[PriorityQueue.Remove[pq]];
pos: CD.Position _ CDBasics.BaseOfRect[CDSymbolicObjects.Denotes[i]];
pl _ CONS[[pos.x+w/2, pos.y+w/2], pl];
CDOps.RemoveInstance[design, i];
ENDLOOP;
SELECT key FROM
$s => [ob: ob, offset: offset] _ CDCurves.CreateSpline[pl, w, layer];
$p => [ob: ob, offset: offset] _ CDCurves.CreatePolygon[pl, layer];
$l => [ob: ob, offset: offset] _ CDCurves.CreateLine[pl, w, layer];
$f => [ob: ob, offset: offset] _ CDCurves.CreateFilledCurve[pl, layer];
ENDCASE => ERROR;
IF ob=NIL THEN Write["  not done\n"]
ELSE CDOps.IncludeObjectI[design, ob, offset];
};

key: ATOM; min: INT;
predicate: CDSymbolicObjects.InstEnumerator;
pq: PriorityQueue.Ref;
Write[" convert marks to "];
IF comm.n<=1 THEN
SELECT comm.key FROM
$MakeSplineS => {Write["[0 size spline] "]; comm.key _ $MakeFilledCurveS};
$MakeLineS => {Write["[0 size line] "]; comm.key _ $MakePolygonS};
$MakeSplineB => {Write["[0 size spline] "]; comm.key _ $MakeFilledCurveB};
$MakeLineB => {Write["[0 size line] "]; comm.key _ $MakePolygonB};
ENDCASE => NULL;
SELECT comm.key FROM
$MakePolygonS => {
Write["polygon (selected)"]; predicate _ Selected; key _ $p; min _ 3};
$MakeSplineS => {Write["spline (selected)"]; predicate _ Selected; key _ $s; min _ 4; min _ 4};
$MakeLineS => {
Write["line (selected)"]; predicate _ Selected; key _ $l; min _ 2};
$MakeFilledCurveS => {
Write["filled curve (selected)"]; predicate _ Selected; key _ $f; min _ 4};
$MakePolygonB => {
Write["polygon (selected+origin)"]; predicate _ SelectedOrFromPS; key _ $p; min _ 3};
$MakeSplineB => {
Write["spline (selected+origin)"]; predicate _ SelectedOrFromPS; key _ $s; min _ 4};
$MakeLineB => {
Write["line (selected+origin)"]; predicate _ SelectedOrFromPS; key _ $l; min _ 2};
$MakeFilledCurveB => {
Write["filled curve (selected+origin)"]; predicate _ SelectedOrFromPS; key _ $f; min _ 4};
ENDCASE => {Write["failed\n"]; RETURN};
pq _ FindMarks[comm.design, predicate];
IF pq.Size[]<min THEN TerminalIO.WriteF["   must use %g or more marks\n", [integer[min]]]
ELSE MarksToPS[comm.design, pq, comm.l, key, comm.n];
END;


cnt: INT _ 0;

SetOrder: PROC [inst: CD.Instance] = {
CDSymbolicObjects.SetOwner[inst, $CurveControl];
CDSymbolicObjects.SetName[inst, IO.PutFR["CP-%05g", [integer[cnt _ cnt+10]]]];
};

DrawControlMarkComm: PROC [comm: CDSequencer.Command] =
BEGIN 
inst: CD.Instance;
r: CD.Rect = CDBasics.RectAt[comm.pos, [0, 0]];
Write["draw unnamed control-mark\n"];
inst _ CDSymbolicObjects.CreateSymInst[denotes: r];
SetOrder[inst];
CDOps.IncludeInstance[comm.design, inst];
END;

RenameMarkComm: PROC [comm: CDSequencer.Command] =
BEGIN 
Write["rename and make mark a control mark\n"];
FOR w: CD.InstanceList _ CDOps.InstList[comm.design], w.rest WHILE w#NIL DO
IF w.first.selected THEN {
IF CDSymbolicObjects.IsMark[w.first.ob] THEN SetOrder[w.first] ELSE Write[" object is not mark\n"];
RETURN;
}  
ENDLOOP;
Write[" no mark found\n"];
END;

ChangeLayer: CDCallSpecific.CallProc =
BEGIN
new: CD.Object _ NEW[CD.ObjectRep_inst.ob^];
layer: CD.Layer _ WITH x SELECT FROM
lr: CDPrivate.LayerRef => lr.number,
ENDCASE => CDLayers.CurrentLayer[design];
new.layer _ CDLayers.AbstractToPaint[layer];
new.properties _ NIL;
inst.ob _ new; 
repaintMe _ TRUE;
END;


CDSequencer.ImplementCommand[$DrawPolygonMark, DrawControlMarkComm];
CDSequencer.ImplementCommand[$PolygonRenumber, RenameMarkComm];
CDSequencer.ImplementCommand[$SplitPolygon, ConvertPSToMarks,, doQueueAndMark];

CDSequencer.ImplementCommand[$MakePolygonS, MarksToPSComm,, doQueueAndMark];
CDSequencer.ImplementCommand[$MakePolygonB, MarksToPSComm,, doQueueAndMark];
CDSequencer.ImplementCommand[$MakeLineS, MarksToPSComm,, doQueueAndMark];
CDSequencer.ImplementCommand[$MakeLineB, MarksToPSComm,, doQueueAndMark];
CDSequencer.ImplementCommand[$MakeFilledCurveS, MarksToPSComm,, doQueueAndMark];
CDSequencer.ImplementCommand[$MakeFilledCurveB, MarksToPSComm,, doQueueAndMark];
CDSequencer.ImplementCommand[$MakeSplineS, MarksToPSComm,, doQueueAndMark];
CDSequencer.ImplementCommand[$MakeSplineB, MarksToPSComm,, doQueueAndMark];

CDSequencer.ImplementCommand[$RSelPMarks, SelectPMarksComm,, doQueueAndMark];
CDSequencer.ImplementCommand[$SetOwnMarkP, SetOwnerComm,, doQueueAndMark];
CDSequencer.ImplementCommand[$RemOwnMarkP, RemOwnerComm,, doQueueAndMark];
CDSequencer.ImplementCommand[$MStatC, MarksStatisticComm,, doQueue];

CDCallSpecific.Register[$ChangeLayer, CDCurves.splineClass, ChangeLayer];
CDCallSpecific.Register[$ChangeLayer, CDCurves.lineClass, ChangeLayer];
CDCallSpecific.Register[$ChangeLayer, CDCurves.polygonClass, ChangeLayer];
CDCallSpecific.Register[$ChangeLayer, CDCurves.filledCurveClass, ChangeLayer];
END. 


	4CDCurvesCommands.mesa
Copyright c 1985, 1986 by Xerox Corporation.  All rights reserved.
Created by Christian Jacobi, March 30, 1985 12:19:40 pm PST 
Last Edited by: Christian Jacobi, August 24, 1986 8:11:28 pm PDT

OldDrawPolygonComm: PROC [comm: CDSequencer.Command] =
BEGIN
ob: CD.Object;
offset: CD.Position;
p1: CD.Position _ comm.sPos; --from
p2: CD.Position _ comm.pos; --to
points: LIST OF CD.Position;
Write["Draw a polygon\n"]; 
IF ABS[p1.x-p2.x]<4 THEN p2.x _ p1.x+10;
IF ABS[p1.y-p2.y]<4 THEN p2.y _ p1.y+10;
points _ LIST[p1, p2, [p2.x, p1.y]];
[ob, offset] _ CDCurves.CreatePolygon[points, comm.l];
IF ob=NIL THEN Write["  not done\n"] ELSE CDOps.IncludeObjectI[comm.design, ob, offset]
END;
--returns th square of the distance
--returns some bad hack representing distance
--to is ignored
--inst must be instance of a curve object
StretchPolygonComm: PROC [comm: CDSequencer.Command] =
BEGIN
inst: CD.Instance;
p: PROC [points: LP, from, to: CD.Position] RETURNS [LP];
r: Rope.ROPE;
SELECT comm.key FROM
$MovePolygonPoint => {p _ StretchPoints; r _ "stretch polygon"};
$AddPolygonPoint => {p _ IncludePoint; r _ "add point to polygon"};
$RemovePolygonPoint => {p _ RemovePoint; r _ "remove point from polygon"};
ENDCASE => {Write["unknown command\n"]; RETURN};
inst _ CDCommandOps.TheInstance[comm, r];
IF inst#NIL THEN {
WITH inst.ob.specificRef SELECT FROM
t: CDCurves.CurvePtr => {
offset: CD.Position;
ob: CD.Object;
oldPoints: LP _ OrientedPoints[inst];
newPoints: LP _ p[oldPoints, comm.sPos, comm.pos];
[ob: ob, offset: offset] _ CDCurves.CreatePolygon[newPoints, inst.ob.layer];
IF ob=NIL THEN {Write["  not done\n"]; RETURN};
CDOps.DelayedRedraw[comm.design, CDInstances.InstRectO[inst]];
inst.ob _ ob;
inst.orientation _ CD.original;
inst.location _ offset;
CDOps.DelayedRedraw[comm.design, CDInstances.InstRectO[inst], FALSE];
}
ENDCASE => Write["selected ob is not polygon; not done\n"];
}; 
END;
--at this point we have to now the class implementation
--to know that the specifiRref field is treated readonly...
--old command set

CDSequencer.ImplementCommand[$DrawPolygon, OldDrawPolygonComm];
CDSequencer.ImplementCommand[$MovePolygonPoint, StretchPolygonComm];
CDSequencer.ImplementCommand[$AddPolygonPoint, StretchPolygonComm];
CDSequencer.ImplementCommand[$RemovePolygonPoint, StretchPolygonComm];

--new command set
Κ˜
codeš
œ™Kšœ
Οm
œ7™BKš
œ<™<K™@K™—š
Οk	˜	Kšžœ
˜Kš
œ˜Kš
œ	˜	Kš
œ
˜
Kš
œ˜Kš
œ	˜	Kš
œ	˜	Kš
œ˜K˜	Kš
œ
˜
Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜—K˜šΠblœžœ
žœ
˜ Kšžœ—
˜ž
Kšžœ˜—Kš
ž˜K˜Kš	œžœžœ
žœ
žœ
˜K˜KšΟnœžœ	žœ˜6K˜š œžœ™6Jš
ž™Jšœžœ™Jšœžœ
™JšœžœΟc™#Jšœžœ‘™ Jšœžœ
žœ
žœ
™Jš
œ™Jšžœ
žœžœ™(Jšžœ
žœžœ™(Jšœ	žœ™$Jš
œ6™6Jšžœžœ
žœžœ.™WJšžœ
™—K˜š
 
œžœ	žœžœžœ˜6Kš
œ#™#Kš
ž˜Kšœžœ%˜-Kšœžœ%˜-Kšžœ˜Kšžœ
˜—K˜š
 œžœ
žœžœžœ˜6Kš
ž˜Kšžœ ˜&Kšžœ
˜—K˜š
 
œžœžœžœžœ˜<Kš
œ-™-Kš
ž˜Kšžœžœ3˜>Kšžœ
˜—K˜š
 
œžœžœžœ
žœ˜OKš
ž˜Kšœžœ˜
Kšœžœ˜
Kšœžœžœ
žœ˜šžœžœžœ
žœ
˜*Kšœžœ˜$Kš
œ˜Kšžœžœ˜!Kšžœ
˜—šžœžœ
žœ
ž˜Kšœžœ˜Kš
œ˜Kšžœ
˜—Kšœžœ
˜Kš
œ˜šžœžœžœ
žœ
˜*Kšœžœ˜Kšžœ
˜—Kšžœ˜—K˜š
 œžœžœžœ
žœ˜NKš
ž˜Kšœžœ˜Kšœžœ˜
Kšœžœžœ
žœ˜Kšœžœ
˜Kšœžœ
˜šžœžœžœ
žœžœ
žœ
˜9Kš
œ/˜/Kš
œ˜Kš
œ˜Kšžœžœ˜#Kšžœ
˜—Kš
œ,˜,Kšžœžœ	˜šžœžœ
žœž˜Kšœžœ˜Kš
œ˜Kšžœ
˜—Kšœžœ
˜šžœžœžœ
žœ
˜*Kšœžœ˜Kšžœ
˜—Kšžœ˜—K˜š
 œžœžœžœ
žœ˜MKš
œ™Kš
ž˜Kšœžœ˜
Kšœžœ˜
Kšœžœžœ
žœ˜šžœžœžœ
žœ
˜*Kšœžœ˜$Kš
œ˜Kšžœžœ˜!Kšžœ
˜—šžœžœ
žœ
ž˜Kšœžœ˜Kš
œ˜Kšžœ
˜—Kšžœžœ˜#Kšžœ,˜0šžœžœžœ
žœ
˜*Kšœžœ˜Kšžœ
˜—Kš
ž˜—K˜š 
œžœžœ˜0šžœžœžœ
žœ
˜&Kš
œ(˜(Kšžœ
˜—K˜—K˜š
 œžœžœžœžœ˜AKš
œ)™)Kš
ž˜Kš
œ˜šžœžœ
ž˜$Kš
œ(˜(Kšžœžœ
˜—šžœžœžœ
žœ
˜&šœžœ˜+Kš
œ˜Kš
œ˜Kš
œ!˜!Kš
œ)˜)—Kšœžœ˜Kšžœ
˜—Kšžœ˜—K˜š
 	œžœ
žœ5žœžœ˜xKš
œ$˜$š	žœžœ/žœžœ
ž˜Fš
žœ&žœžœ
žœžœ˜XKš
œ"˜"—Kšžœ
˜—Kš
œ˜—K˜š œžœ ˜6Kšœžœ˜
š	žœžœ4žœžœ
ž˜Kšžœ&žœžœ˜Bšžœžœ˜Kšœžœ˜%Kšœ+žœ
˜1K˜——Kšžœ
˜—Kš
œb˜bKš
œ˜K˜—K˜š œžœ ˜2Kš
œ"˜"š	žœžœ4žœžœ
ž˜Kšžœžœ&žœ˜CKšœ$žœ˜)—Kšžœ
˜—K˜—K˜š œžœ ˜2Kš
œ1˜1š	žœžœ4žœžœ
ž˜Kšžœžœ&žœ˜CKšžœžœ˜+—Kšžœ
˜—K˜—K˜š œžœ ˜8Kš
œ˜Kš
œ˜Kš
œ˜—K˜š œžœ
žœ˜,Kšœ"žœ˜*š	žœžœ/žœžœ
ž˜Fšžœžœ˜šžœ&ž˜,Kšžœžœ˜'Kšžœ˜—Kšžœ˜Kš
œ
˜
—šžœ
žœ&žœžœ
˜FKš
œ˜—Kšžœ
˜—Kš
œ?˜?Kšžœ	žœ8˜GKšžœ	žœ:˜IKš
œ˜KšžœžœS˜hKš
œ˜Kš
œ˜—K˜š œžœ˜4Kš
ž˜KšœžœD˜Išžœžœ
žœ˜š
žœžœžœžœžœ˜vKšœžœ˜1Kšœžœ(˜0Kš
œ%˜%šžœžœžœ
ž˜/KšœžœH˜MKšœžœK˜QKšœžœ
˜!Kš
œ'˜'Kšžœ
˜—K˜
—Kšžœ@˜DKš
œ˜—Kšžœ
˜—K˜š œ%˜-Kšžœ˜Kš
œ˜—K˜š œ%˜+Kšžœ1˜7Kš
œ˜—K˜š œ%˜5Kšžœžœ0˜HKš
œ˜—K˜š œ˜$Kšžœ+žœ žœžœ˜tK˜—K˜š 
œžœ˜1Kš
ž˜K˜š 	œžœ
žœ'žœ
žœžœ˜lKš
œžœžœžœ
žœ
žœžœ
˜Bšžœž˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kšžœžœ
˜—šžœžœ
žœž˜,Kšœžœžœ˜2Kšœžœ>˜EKšœžœ˜&Kš
œ ˜ Kšžœ
˜—šžœž˜Kš
œE˜EKš
œC˜CKšœž
œ=˜CKš
œG˜GKšžœžœ
˜—Kšžœžœ
žœ˜$Kšžœ*˜.Kš
œ˜—K˜Kšœžœ˜Kš
œ,˜,Kš
œ˜Kš
œ˜šžœž˜šžœ
ž˜Kš
œJ˜JKš
œB˜BKš
œJ˜JKš
œB˜BKšžœžœ
˜——šžœ
ž˜š
œ˜Kš
œF˜F—Kš
œ_˜_š
œ˜Kš
œC˜C—š
œ˜Kš
œK˜K—š
œ˜Kš
œU˜U—š
œ˜Kš
œT˜T—š
œ˜Kš
œR˜R—š
œ˜Kš
œZ˜Z—Kšžœžœ˜'—Kš
œ'˜'KšžœžœD˜YKšžœ1˜5Kšžœ
˜—K˜š œžœ™6Kš
ž™Kšœžœ
™Kšœžœžœžœ™9Kšœžœ
™
šžœ
ž™Kš
œ@™@Kš
œC™CKš
œJ™JKšžœ žœ™0—Kš
œ)™)šžœžœ
žœ™šžœžœ
ž™$š
œ™Kšœžœ
™Kšœžœ™Kš
œ%™%Kš
œ2™2Kš
œL™LKšžœžœ
žœžœ™/Kš
œ>™>Kš
œ
™
Kšœžœ
™Kš
œ™Kšœ>žœ™EK™
—Kšžœ4™;—Kš
œ™—Kšžœ
™—K˜Kšœžœ˜
K˜š œžœžœ˜&Kš
œ0˜0Kšœ žœ,˜NK˜—K˜š œžœ˜7Kšžœ
˜Kšœžœ
˜Kšœžœ*˜/Kš
œ%˜%Kš
œ3˜3Kš
œ˜Kš
œ)˜)Kšžœ
˜—K˜š œžœ˜2Kšžœ
˜Kš
œ/˜/š	žœžœ4žœžœ
ž˜Kšžœžœ˜Kšžœ&žœžœ ˜cKšžœ
˜Kš
œ˜—Kšžœ
˜—Kš
œ˜Kšžœ
˜—K˜šΠbnœ˜&Kš
ž˜Kš
œ7™7Kš
œ;™;Kšœžœ
žœ˜,šœžœ	žœžœ
ž˜$Kš
œ$˜$Kšžœ"˜)—Kš
œ,˜,Kšœžœ
˜Kš
œ˜Kšœžœ
˜Kšžœ
˜K˜—Kš
œ™™Kš
œ?™?Kš
œD™DKš
œC™Cš
œF™FK™——Kš
œ™K˜Kš
œD˜DKš
œ?˜?Kš
œO˜OK˜Kš
œL˜LKš
œL˜LKš
œI˜IKš
œI˜IKš
œP˜PKš
œP˜PKš
œK˜KKš
œK˜KK˜Kš
œM˜MKš
œJ˜JKš
œJ˜JKš
œD˜DK˜Kš
œI˜IKš
œG˜GKš
œJ˜JKš
œN˜NKšžœ˜K˜K˜—…—-ψG»