DIRECTORY
CD,
CDApplications,
CDCommands,
CDCommandOps,
CDEvents,
CDBasics,
CDOps,
CDOrient,
CDProperties,
CDRects,
CDStretchyExtras,
CDValue,
Rope USING [IsEmpty, ROPE],
TerminalIO;

CDCommandsImpl: CEDAR PROGRAM 
IMPORTS CDApplications, CDBasics, CDCommandOps,
CDEvents, CDOps, CDOrient, CDProperties, CDRects, CDStretchyExtras, CDValue, Rope, TerminalIO
EXPORTS CDCommands  = 
BEGIN
renameEvent: CDEvents.EventRegistration_CDEvents.RegisterEventType[$RenameDesign];

RenameDesign: PUBLIC PROC [design: CD.Design, name: Rope.ROPE] =
BEGIN
dont: BOOL;
oldName: Rope.ROPE _ design.name;
IF Rope.IsEmpty[name] THEN {
TerminalIO.WriteRope["  not renamed\n"];
RETURN
};
design.name _ name;
dont _ CDEvents.ProcessEvent[renameEvent, design, oldName, TRUE];
IF dont THEN {
design.name _ oldName;
[] _ CDEvents.ProcessEvent[renameEvent, design, oldName, FALSE];
}
END;

Select: PUBLIC PROC [design: CD.Design, pos: CD.DesignPosition, verbose: BOOL] =
BEGIN
sel: CD.ApplicationPtr _ NIL;
FOR w: CD.ApplicationList _ CDOps.AppList[design], w.rest WHILE w#NIL DO
IF ~w.first.selected THEN { 
IF CDApplications.PointToI[pos, w.first] THEN {sel _ w.first; EXIT}
};
ENDLOOP;
IF sel#NIL THEN {
sel.selected _ TRUE;
CDOps.ReOrderApplication[design, sel];
CDCommandOps.RedrawApplication[design, sel];
IF verbose THEN CDCommandOps.WriteInfo[sel]
}
ELSE IF verbose THEN {
FOR w: CD.ApplicationList _ CDOps.AppList[design], w.rest WHILE w#NIL DO
IF w.first.selected THEN { 
IF CDApplications.PointToI[pos, w.first] THEN {
CDCommandOps.WriteInfo[w.first];
TerminalIO.WriteRope[" again"];
RETURN
}
};
ENDLOOP;
TerminalIO.WriteRope[" no pointed object"];
}
END;

DeSelect: PUBLIC PROC [design: CD.Design, pos: CD.DesignPosition, verbose: BOOL] =
BEGIN 
aptr: CD.ApplicationPtr _ CDApplications.AplicationAt[CDOps.AppList[design], pos, TRUE];
IF aptr#NIL THEN 
BEGIN
IF ~aptr.selected THEN ERROR;
aptr.selected _ FALSE;
CDCommandOps.RedrawApplication[design, aptr];
CDOps.ReOrderApplication[design, aptr];
END;
IF verbose THEN CDCommandOps.WriteInfo[aptr];
END;

BoundingRectAndCount: PROC[list: CD.ApplicationList, selectedOnly: BOOLEAN_FALSE] 
RETURNS [bound: CD.DesignRect_CDBasics.empty, cnt: INT_0] =
BEGIN
FOR tem: LIST OF CD.ApplicationPtr _ list, tem.rest WHILE tem#NIL DO
IF selectedOnly AND NOT tem.first.selected THEN LOOP;
cnt _ cnt+1;
bound _ CDBasics.Surround[bound, CDApplications.ARectO[tem.first]]
ENDLOOP;
END;

DeselectAll: PUBLIC PROC [design: CD.Design] =
BEGIN
doItSingleWise: NAT = 4;
sel: CD.ApplicationList = CDApplications.OnlySelected[CDOps.AppList[design]];
b: CD.DesignRect;
cnt: INT;
[b, cnt] _ BoundingRectAndCount[list: sel];
CDApplications.DeSelectList[sel];
IF cnt<=doItSingleWise THEN 
FOR l: CD.ApplicationList _ sel, l.rest WHILE l#NIL DO
CDCommandOps.RedrawApplication[design, l.first]
ENDLOOP
ELSE CDOps.DelayedRedraw[design, b];
END;

SelectAll: PUBLIC PROC [design: CD.Design] =
BEGIN
b: CD.Rect _ CDApplications.BoundingRectO[list: CDOps.AppList[design], selectedOnly: FALSE];
FOR w: CD.ApplicationList _ CDOps.AppList[design], w.rest WHILE w#NIL DO
w.first.selected _ TRUE
ENDLOOP;
CDOps.DelayedRedraw[design, b, FALSE];
END;

AreaSelectTouched: PROC [design: CD.Design, area: CD.DesignRect] =
BEGIN 
FOR w: CD.ApplicationList _ CDOps.AppList[design], w.rest WHILE w#NIL DO
IF NOT w.first.selected 
AND CDBasics.Intersect[area, CDApplications.ARectI[w.first]] THEN {
w.first.selected _ TRUE;
CDCommandOps.RedrawApplication[design, w.first, FALSE];
};
ENDLOOP;
END;

AreaDeSelectTouched: PROC [design: CD.Design, area: CD.DesignRect] =
BEGIN 
FOR w: CD.ApplicationList _ CDOps.AppList[design], w.rest WHILE w#NIL DO
IF w.first.selected 
AND CDBasics.Intersect[area, CDApplications.ARectI[w.first]] THEN {
w.first.selected _ FALSE;
CDCommandOps.RedrawApplication[design, w.first];
};
ENDLOOP;
END;

AreaSelectContained: PROC [design: CD.Design, area: CD.DesignRect] =
BEGIN 
FOR w: CD.ApplicationList _ CDOps.AppList[design], w.rest WHILE w#NIL DO
IF CDBasics.Inside[CDApplications.ARectI[w.first], area] THEN w.first.selected _ TRUE
ENDLOOP;
CDOps.DelayedRedraw[design, area, FALSE];
END;

AreaDeSelectContained: PROC [design: CD.Design, area: CD.DesignRect] =
BEGIN 
FOR w: CD.ApplicationList _ CDOps.AppList[design], w.rest WHILE w#NIL DO
IF CDBasics.Inside[CDApplications.ARectI[w.first], area] THEN w.first.selected _ FALSE
ENDLOOP;
CDOps.DelayedRedraw[design, area];
END;

AreaSelect: PUBLIC PROC [design: CD.Design, area: CD.DesignRect, includePartial: BOOL] =
BEGIN 
IF includePartial THEN AreaSelectTouched[design, area] 
ELSE AreaSelectContained[design, area];
END;

AreaDeSelect: PUBLIC PROC [design: CD.Design, area: CD.DesignRect, includePartial: BOOL] =
BEGIN 
IF includePartial THEN AreaDeSelectTouched[design, area] 
ELSE AreaDeSelectContained[design, area];
END;

DeleteSelected: PUBLIC PROC [design: CD.Design, verbose: BOOL] =
BEGIN
count: INT _ 0;
toDelete, newContents: CD.ApplicationList;
[selected: toDelete, others: newContents] _ CDApplications.SplitSelected[CDOps.AppList[design]];
CDOps.SetAppList[design, newContents];
FOR w: CD.ApplicationList _ toDelete, w.rest WHILE w#NIL DO
count _ count+1;
CDCommandOps.RedrawApplication[design, w.first, TRUE];
ENDLOOP;
IF verbose THEN {
IF count#1 THEN {
TerminalIO.WriteInt[count];
TerminalIO.WriteRope[" objects"]
}
ELSE CDCommandOps.WriteInfo[toDelete.first]
};
RememberShortTime[design, toDelete];
END;

RedrawMoved: PROC [design: CD.Design, r: CD.DesignRect, offset: CD.DesignPosition] =
BEGIN
moved: CD.DesignRect _ CDBasics.MoveRect[r, offset];
IF CDBasics.Intersect[r, moved] THEN
CDOps.DelayedRedraw[design, CDBasics.Surround[r, moved], TRUE]
ELSE {
CDOps.DelayedRedraw[design, r];
CDOps.DelayedRedraw[design, moved]; -- use eraseFirst because also used by copy
}
END;

StretchyMoveMode: PROC[design: CD.Design] RETURNS [BOOL] =
BEGIN
mode: INT = CDValue.FetchInt[boundTo: design, key: $CDxStretchyMove, propagation: global, ifNotFound: 0];
RETURN [mode=1]
END;

MoveSelected: PUBLIC PROC [design: CD.Design, offset: CD.DesignPosition, stretchy: CDCommands.StretchyMode] =
BEGIN
IF stretchy=yes OR ((stretchy=option) AND StretchyMoveMode[design]) THEN StretchyMoveSelected[design, offset]
ELSE SimpleMoveSelected[design, offset]
END;

MovePointed: PUBLIC PROC [design: CD.Design, offset: CD.DesignPosition, pos: CD.DesignPosition, stretchy: CDCommands.StretchyMode] =
BEGIN
IF stretchy=yes OR ((stretchy=option) AND StretchyMoveMode[design]) THEN StretchyMovePointed[design, offset, pos]
ELSE SimpleMovePointed[design, offset, pos]
END;

SimpleMoveSelected: PUBLIC PROC [design: CD.Design, offset: CD.DesignPosition] =
BEGIN
sel: CD.ApplicationList = CDApplications.OnlySelected[CDOps.AppList[design]];
bounding: CD.DesignRect = CDApplications.BoundingRectO[sel];
FOR w: CD.ApplicationList _ sel, w.rest WHILE w#NIL DO
w.first.location _ CDBasics.AddPoints[w.first.location, offset];
ENDLOOP;
RedrawMoved[design, bounding, offset]
END;

SimpleMovePointed: PUBLIC PROC [design: CD.Design, offset: CD.DesignPosition, pos: CD.DesignPosition] =
BEGIN
app: CD.ApplicationPtr = CDApplications.AplicationAt[CDOps.AppList[design], pos];
IF app#NIL THEN {
bounding: CD.DesignRect = CDApplications.ARectO[app];
app.location _ CDBasics.AddPoints[app.location, offset];
RedrawMoved[design, bounding, offset]
}
END;

CopySelected: PUBLIC PROC [design: CD.Design, offset: CD.DesignPosition] =
BEGIN
new: CD.ApplicationList_NIL;
sel: CD.ApplicationList = CDApplications.OnlySelected[CDOps.AppList[design]];
bounding: CD.DesignRect _ CDApplications.BoundingRectO[sel]; 
FOR w: CD.ApplicationList _ sel, w.rest WHILE w#NIL DO
aptr: CD.ApplicationPtr _ NEW[CD.Application];
aptr.ob _ w.first.ob;
aptr.location _ CDBasics.AddPoints[w.first.location, offset];
aptr.orientation _ w.first.orientation;
aptr.properties _ CDProperties.CopyProps[w.first.properties];
aptr.selected _ TRUE;
new _ CONS[aptr, new];
w.first.selected _ FALSE;
ENDLOOP;
CDOps.IncludeApplicationList[design, new, FALSE];
RedrawMoved[design, bounding, offset];
END;

TransformSelected: PUBLIC PROC [design: CD.Design, transform: CD.Orientation] =   
BEGIN
sel: CD.ApplicationList = CDApplications.OnlySelected[CDOps.AppList[design]];
b: CD.DesignRect _ CDApplications.BoundingRectO[sel];
ib: CD.DesignRect = CDApplications.BoundingRectI[sel];
FOR w: CD.ApplicationList _ sel, w.rest WHILE w#NIL DO
CDApplications.Transform[w.first, ib, transform]
ENDLOOP;
CDOps.DelayedRedraw[design, b];
b _ CDOrient.MapRect[
itemInCell: CDBasics.MoveRect[b, CDBasics.NegOffset[CDBasics.BaseOfRect[ib]]],
cellSize: CDBasics.SizeOfRect[ib], 
cellInstOrient: transform, 
cellInstPos: CDBasics.BaseOfRect[ib]
];
CDOps.DelayedRedraw[design, b, FALSE];
END;

BaseTransformSelected: PUBLIC PROC [design: CD.Design, transform: CD.Orientation, base: CD.DesignRect] =   
BEGIN
sel: CD.ApplicationList = CDApplications.OnlySelected[CDOps.AppList[design]];
b: CD.DesignRect _ CDApplications.BoundingRectO[sel];
newB: CD.DesignRect _ CDOrient.MapRect[
itemInCell: b,
cellSize: CDBasics.SizeOfRect[base], 
cellInstOrient: transform, 
cellInstPos: CDBasics.BaseOfRect[base]
];
FOR w: CD.ApplicationList _ sel, w.rest WHILE w#NIL DO
CDApplications.Transform[w.first, base, transform]
ENDLOOP;
CDOps.DelayedRedraw[design, b];
CDOps.DelayedRedraw[design, newB]
END;

-- -- -- -- -- -- -- -- -- -- -- -- 

remSize: CARDINAL = 20;
RememberBuffer: TYPE = RECORD[
a: ARRAY [0..remSize) OF REF _ ALL[NIL],
next: CARDINAL_0];

Forgett: PROC[p: REF] =  
BEGIN
WITH p SELECT FROM
al: CD.ApplicationList => 
FOR l: CD.ApplicationList _ al, l.rest WHILE l#NIL DO
Forgett[l.first]
ENDLOOP;
app: CD.ApplicationPtr => {app.properties _ NIL; app.ob _ NIL};
ENDCASE => NULL;
END;

RememberShortTime: PROC [d: CD.Design, what: REF] =
BEGIN
dl: REF RememberBuffer;
IF d^.actual.first.deletedList=NIL THEN d^.actual.first.deletedList _ NEW[RememberBuffer];
dl _ NARROW[d^.actual.first.deletedList];
Forgett[dl.a[dl.next]];
dl.a[dl.next] _ what;
dl.next _ (dl.next+1) MOD remSize;
END;

GiveRemembered: PROC [d: CD.Design] RETURNS [REF] =
BEGIN
x: REF;
dl: REF RememberBuffer;
IF d^.actual.first.deletedList=NIL THEN RETURN [NIL];
dl _ NARROW[d^.actual.first.deletedList];
dl.next _ (dl.next+remSize-1) MOD remSize;
x _ dl.a[dl.next];
dl.a[dl.next] _ NIL;
RETURN [x];
END;

Undelete: PUBLIC PROC [design: CD.Design] =
BEGIN
del: REF _ GiveRemembered[design];
IF del=NIL THEN RETURN;
WITH del SELECT FROM
al: CD.ApplicationList => CDOps.IncludeApplicationList[design, al];
app: CD.ApplicationPtr => CDOps.IncludeApplication[design, app]
ENDCASE => NULL;
END;

-- xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

Primality: TYPE = {primary, secondary};

ChangeWireLength: PROC [design: CD.Design, aptr: CD.ApplicationPtr, amount: CD.DesignNumber] =
BEGIN
sz: CD.DesignPosition = CDBasics.SizeOfRect[aptr.ob.p.insideRect[aptr.ob]];
r: CD.DesignRect _ CDApplications.ARectO[aptr];
newOb: CD.ObPtr_NIL;
IF NOT WireTyped[aptr.ob] THEN ERROR;
newOb _ CDRects.CreateRect[CD.DesignPosition[x: sz.x, y: sz.y+amount], aptr.ob.layer];
IF newOb=NIL THEN RETURN;
IF aptr.ob.p#newOb.p THEN ERROR; 
aptr.ob _ newOb;
r _ CDBasics.Surround[r, CDApplications.ARectO[aptr]];
CDOps.DelayedRedraw[design, r];
END;

StretchyMoveSP: PROC[design: CD.Design, offset: CD.DesignPosition, selectedApps, nonSelectedApps: CD.ApplicationList] =
BEGIN
primApps: CD.ApplicationList _ NIL; 
primList, secondList, nonPrimList: StretchList _ NIL;
rect: CD.DesignRect;
rect _ CDApplications.BoundingRectO[selectedApps];
FOR l: CD.ApplicationList _ nonSelectedApps, l.rest WHILE l#NIL DO
IF WireTyped[l.first.ob] THEN {
me: REF StretchRec_NEW[StretchRec_StretchRec[
ap: l.first,
conductRect: CDApplications.ARectI[l.first],
horizontal: CDOrient.IncludesOddRot90[l.first.orientation] -- (length in y direction)
]];
IF CDBasics.Intersect[rect, me.conductRect] AND HasMatch[me, selectedApps, primary] THEN {primList _ CONS[me, primList]; primApps _ CONS[me.ap, primApps]}
ELSE nonPrimList _ CONS[me, nonPrimList]
};
ENDLOOP;
FOR l: StretchList _ nonPrimList, l.rest WHILE l#NIL DO
IF HasMatch[l.first, primApps, secondary] THEN secondList _ CONS[l.first, secondList]
ENDLOOP;
FOR l: StretchList _ secondList, l.rest WHILE l#NIL DO
FiddleWire[design, l.first, offset, secondary]
ENDLOOP;
FOR l: StretchList _ primList, l.rest WHILE l#NIL DO
FiddleWire[design, l.first, offset, primary]
ENDLOOP;
FOR l: CD.ApplicationList _ selectedApps, l.rest WHILE l#NIL DO
MoveApplication[design, l.first, offset]
ENDLOOP;
END;

StretchyMoveSelected: PROC[design: CD.Design, offset: CD.DesignPosition] =
BEGIN
selectedApps, nonSelectedApps: CD.ApplicationList _ NIL; 
[selectedApps, nonSelectedApps] _ CDApplications.SplitSelected[CDOps.AppList[design]];
StretchyMoveSP[design, offset, selectedApps, nonSelectedApps]
END;

StretchyMovePointed: PROC[design: CD.Design, offset: CD.DesignPosition, pos: CD.DesignPosition] =
BEGIN
selectedApps, nonSelectedApps: CD.ApplicationList _ NIL; 
[selectedApps, nonSelectedApps] _ CDApplications.SplitPointed[CDOps.AppList[design], pos];
StretchyMoveSP[design, offset, selectedApps, nonSelectedApps]
END;
StretchList: TYPE = LIST OF REF StretchRec;
StretchRec: TYPE = RECORD [
ap: CD.ApplicationPtr,
conductRect: CD.DesignRect, -- hint only
near: BOOL _ FALSE,  -- match at near edge (relative to the origin)
far: BOOL _ FALSE,  -- match at far edge (relative to the origin)
horizontal: BOOL _ FALSE
];

FiddleWire: PROC [design: CD.Design, wire: REF StretchRec, offset: CD.DesignPosition, p: Primality] =
BEGIN
move: CD.DesignPosition_offset;
IF ~wire.near AND ~wire.far THEN RETURN;
IF p#primary THEN {IF wire.horizontal THEN move.y_0 ELSE move.x_0};
IF wire.near AND ~wire.far THEN {
IF p#primary THEN {IF wire.horizontal THEN move.y_0 ELSE move.x_0};
ChangeWireLength[design, wire.ap, -(IF wire.horizontal THEN offset.x ELSE offset.y)];
};
IF ~wire.near AND wire.far THEN {
IF wire.horizontal THEN {move.x_0} ELSE {move.y_0};
ChangeWireLength[design, wire.ap, (IF wire.horizontal THEN offset.x ELSE offset.y)];
};
IF wire.near AND wire.far THEN NULL;
MoveApplication[design, wire.ap, move]
END;

HasMatch: PROC [me: REF StretchRec, list: CD.ApplicationList, p: Primality] RETURNS [BOOL] =
BEGIN
near, far: BOOL;
nearEdge, farEdge: CD.DesignRect;
nearEdge _ farEdge _ me.conductRect;  -- edges at near or far end of wire, parallel to width
IF ~CDOrient.IncludesOddRot90[me.ap.orientation] THEN {
farEdge.y1 _ me.conductRect.y2;
nearEdge.y2 _ me.conductRect.y1;
}
ELSE {
farEdge.x1 _ me.conductRect.x2;
nearEdge.x2 _ me.conductRect.x1;
me.horizontal _ TRUE;
};
FOR l: CD.ApplicationList _ list, l.rest WHILE l#NIL DO
r: CD.DesignRect = CDApplications.ARectI[l.first];
near _ CDBasics.Intersect[nearEdge, r];
far _ CDBasics.Intersect[farEdge, r];
IF near OR far THEN {
IF WireTyped[l.first.ob] THEN {
IF l.first.ob.layer#me.ap.ob.layer THEN near _ far _ FALSE
ELSE IF p#primary AND me.horizontal=CDOrient.IncludesOddRot90[l.first.orientation] THEN near _ far _ FALSE
}
ELSE IF ISTYPE[l.first.ob.specificRef, CD.CellPtr] THEN NULL
ELSE IF CDStretchyExtras.HasMatchProc[l.first.ob] THEN {
rect: CD.DesignRect = CDApplications.ARectI[me.ap];
IF ~CDStretchyExtras.Match[l.first.ob, rect, me.ap.ob.layer, p=primary, me.horizontal] THEN near _ far _ FALSE
}
ELSE near _ far _ FALSE;
me.near _ me.near OR near;
me.far _ me.far OR far;
};
ENDLOOP;
RETURN [me.near OR me.far]
END;

MoveApplication: PROC [design: CD.Design, ap: CD.ApplicationPtr, offset: CD.DesignPosition] =
BEGIN
r: CD.DesignRect _ CDApplications.ARectO[ap];
ap.location _ CDBasics.AddPoints[ap.location, offset];
RedrawMoved[design, r, offset]
END;

WireTyped: PROC [ob: CD.ObPtr] RETURNS [BOOL] = INLINE {RETURN [ob.p.wireTyped]};

END. 

CDCommandsImpl.mesa       (part of Chipndale)
Copyright c 1983, 1985  by Xerox Corporation.  All rights reserved.
by Christian Jacobi, July 12, 1983 10:56 am 
last edited by Christian Jacobi, April 11, 1985 9:29:15 am PST
--is only local name
--reorder list,  future select selects next lower application
--reorder list,  future select op finds next lower application
--dont care about redrawing too much
--helps the garbage collector, 
--special may prevent circularities through properties
--??? for now CDRects.CreateRect is ONLY method to create wires 
--this checks if old object was created with CDRects.CreateRect

--??? change slow case distinction, but now better is easy to understand
-- checks weather me has some match with any of list
--??? Only CDRects.CreateRect for now
�ʘš
œ-™-Jšœ
Ïm
œ8™CJš
œ,™,Jš
œ>™>—J˜š
Ïk	˜	Jšžœ
˜J˜Jš
œ˜J˜
J˜	Jš
œ	˜	J˜J˜	J˜
J˜Jš
œ˜Jš
œ˜Jšœžœ	žœ˜J˜J˜—šÏbœžœ
žœ
˜Jšžœ(˜/Jš
œ]˜]Jšžœ˜—Jš
ž˜J˜RJ˜š
Ïnœžœ
žœ
žœžœ˜@Jš
œ™Jš
ž˜Jšœžœ
˜Jšœžœ˜!šžœžœ˜Jš
œ(˜(Jš
ž˜J˜—Jš
œ˜Jšœ;žœ˜Ašžœžœ˜Jš
œ˜Jšœ9žœ˜@J˜
—Jšžœ
˜—J˜š œžœ
žœ
žœžœžœ˜PJš
ž˜Jšœžœžœ
˜š	žœžœ1žœžœ
ž˜Hšžœžœ˜Jšžœ'žœžœ
˜CJ˜—Jšžœ
˜—šžœžœ
žœ˜Jšœžœ
˜Jš
œ=™=Jš
œ&˜&Jš
œ,˜,Jšžœ	žœ˜+Jš
œ
˜
—šžœ
žœ	žœ˜š	žœžœ1žœžœ
ž˜Hšžœžœ˜šžœ'žœ˜/Jš
œ ˜ Jš
œ˜Jš
ž˜Jš
œ
˜
—J˜—Jšžœ
˜—Jš
œ+˜+J˜
—Jšžœ
˜J˜—š œžœ
žœ
žœžœžœ˜RJšžœ
˜JšœžœJžœ˜Xšžœžœ
žœ
˜Jš
ž˜Jšžœžœ
žœ
˜Jšœžœ
˜Jš
œ-˜-Jš
œ>™>Jš
œ'˜'Jšžœ
˜—Jšžœ	žœ˜-Jšžœ
˜J˜—š
 œžœžœ žœ
žœ˜RJšžœ	žœ!žœ˜;Jš
ž˜š
žœžœ
žœ
žœ!žœžœ
ž˜DJš
žœžœ
žœžœ
žœ
˜5J˜Jš
œB˜BJšžœ
˜—Jšžœ
˜—J˜š œžœ
žœ
žœ
˜.Jš
ž˜Jšœžœ˜JšœžœF˜MJšœžœ˜Jšœžœ
˜	Jš
œ+˜+Jš
œ!˜!šžœžœ
˜š	žœžœžœžœ
ž˜6Jš
œ/˜/Jš
ž˜——Jšžœ ˜$Jšžœ
˜J˜—š 	œžœ
žœ
žœ
˜,Jš
ž˜Jš
œ$™$JšœžœPžœ˜\š	žœžœ1žœžœ
ž˜HJšœž˜Jšžœ
˜—Jšœžœ˜&Jšžœ
˜J˜—š œžœ
žœžœ˜BJšžœ
˜š	žœžœ1žœžœ
ž˜Hšžœ
žœ˜Jšžœ:žœ˜CJšœžœ
˜Jšœ0žœ˜7J˜—Jšžœ
˜—Jšžœ
˜J˜—š œžœ
žœžœ˜DJšžœ
˜š	žœžœ1žœžœ
ž˜Hšžœ˜Jšžœ:žœ˜CJšœžœ
˜Jš
œ0˜0J˜—Jšžœ
˜—Jšžœ
˜J˜—š œžœ
žœžœ˜DJšžœ
˜š	žœžœ1žœžœ
ž˜HJšžœ7žœž˜UJšžœ
˜—Jšœ"žœ˜)Jšžœ
˜J˜—š œžœ
žœžœ˜FJšžœ
˜š	žœžœ1žœžœ
ž˜HJšžœ7žœž˜VJšžœ
˜—Jš
œ"˜"Jšžœ
˜J˜—š 
œžœ
žœ
žœžœžœ˜XJšžœ
˜Jšžœžœ ž
˜7Jšžœ"˜'Jšžœ
˜J˜—š œžœ
žœ
žœžœžœ˜ZJšžœ
˜Jšžœžœ"ž
˜9Jšžœ$˜)Jšžœ
˜J˜—š
 œžœ
žœ
žœžœ˜@Jš
ž˜Jšœžœ˜Jšœžœ˜*Jš
œ`˜`Jš
œ&˜&š	žœžœ$žœžœ
ž˜;Jš
œ˜Jšœ0žœ˜6Jšžœ
˜—šžœ	žœ˜šžœ	žœ˜Jš
œ˜Jš
œ ˜ J˜
—Jšžœ'˜+Jš
œ˜—J˜$Jšžœ
˜J˜—š
 œžœ
žœžœžœ˜TJš
ž˜Jšœžœ+˜4šžœž˜$Jšœ9žœ
˜>—šžœ˜Jš
œ˜Jšœ$Ïc+˜OJš
œ
˜
—Jšžœ
˜J˜—š
 œžœ	žœ	žœžœ˜:Jš
ž˜Jšœžœ`˜iJšžœ	˜Jšžœ
˜—J˜š
 œžœ
žœ
žœžœ5˜mJš
ž˜Jšžœžœžœžœ%˜mJšžœ#˜'Jšžœ
˜—J˜š œžœ
žœ
žœžœžœ5˜„
Jš
ž˜Jšžœžœžœžœ)˜qJšžœ'˜+Jšžœ
˜—J˜š
 œžœ
žœ
žœžœ˜PJš
ž˜JšœžœF˜MJšœ
žœ0˜<š	žœžœžœžœ
ž˜6J˜@Jšžœ
˜—J˜%Jšžœ
˜J˜—š œžœ
žœ
žœžœžœ˜gJš
ž˜JšœžœJ˜Qšžœžœ
žœ˜Jšœ
žœ)˜5Jš
œ8˜8J˜%J˜
—Jšžœ
˜J˜—š
 œžœ
žœ
žœžœ˜JJš
ž˜Jšœžœžœ
˜JšœžœF˜MJšœ
žœ1˜=š	žœžœžœžœ
ž˜6Jšœžœžœ
žœ˜.Jš
œ˜Jš
œ=˜=Jš
œ'˜'Jš
œ=˜=Jšœž˜Jšœžœ˜Jšœžœ
˜Jšžœ
˜—Jšœ*žœ˜1Jš
œ&˜&Jšžœ
˜J˜—š
 œžœ
žœ
žœžœ˜RJš
ž˜JšœžœF˜MJšœžœ0˜5Jšœžœ0˜6š	žœžœžœžœ
ž˜6Jš
œ0˜0Jšžœ
˜—Jš
œ˜š
œ˜Jš
œN˜NJš
œ#˜#Jš
œ˜Jš
œ$˜$J˜—Jšœžœ˜&Jšžœ
˜J˜—š œžœ
žœ
žœžœžœ˜kJš
ž˜JšœžœF˜MJšœžœ0˜5šœžœ˜'J˜J˜%J˜J˜&J˜—š	žœžœžœžœ
ž˜6Jš
œ2˜2Jšžœ
˜—Jš
œ˜Jš
œ!˜!Jšžœ
˜J˜—Jš¡œ
¡œ
¡œ
¡œ
¡œ
¡œ
˜$J˜Jšœ	žœ˜šœžœžœ
˜Jšœžœžœ
žœžœ
žœ˜(Jšœžœ˜J˜—š œžœžœ˜Jš
œ™Jš
œ6™6Jš
ž˜šžœžœ
ž˜šœžœ˜š	žœžœžœžœ
ž˜5Jš
œ˜Jšžœ
˜——Jšœžœ%žœžœ˜?Jšžœžœ
˜—Jšžœ
˜J˜—š œžœžœžœ˜3Jš
ž˜Jšœžœ˜Jšžœžœ
žœžœ˜ZJšœžœ˜)J˜J˜Jšœžœ	˜"Jšžœ
˜J˜—š
 œžœžœ	žœžœ˜3Jš
ž˜Jšœžœ
˜Jšœžœ˜Jš
žœžœ
žœ
žœžœ˜5Jšœžœ˜)Jšœžœ	˜*J˜Jšœžœ
˜Jšžœ˜Jšžœ
˜J˜—š œžœ
žœ
žœ
˜+Jš
ž˜Jšœžœ˜"Jšžœžœ
žœ
žœ
˜šžœžœ
ž˜Jšœžœ=˜CJšœžœ8˜?Jšžœžœ
˜—Jšžœ
˜J˜—J˜KJ˜Jšœžœ˜'J˜š
 œžœ
žœžœžœ˜^Jš
ž˜Jš
œ@™@JšœžœE˜KJšœžœ*˜/Jšœžœžœ
˜Jšžœ
žœžœ
žœ
˜%Jšœžœ9˜VJšžœžœ
žœ
ž˜šžœžœ
žœ˜!Jš
œ?™?—Jš
œ˜Jš
œ6˜6Jš
œ˜Jšžœ
˜J˜—š
 œžœ	žœžœ0žœ˜wJš
ž˜Jšœ
žœžœ˜$Jšœ1žœ
˜5Jšœžœ˜Jš
œ2˜2š	žœžœ+žœžœ
ž˜Bšžœžœ˜šœžœžœ˜-Jš
œ˜Jš
œ,˜,Jšœ;¡˜UJš
œ˜—Jš
žœ*žœ%žœ
žœžœ˜š
Jšžœžœ˜(Jš
œ˜—Jšžœ
˜—šžœ&žœžœ
ž˜7Jšžœ(žœžœ˜UJšžœ
˜—šžœ%žœžœ
ž˜6Jš
œ.˜.Jšžœ
˜—šžœ#žœžœ
ž˜4Jš
œ,˜,Jšžœ
˜—š	žœžœ(žœžœ
ž˜?Jš
œ(˜(Jšžœ
˜—Jšžœ
˜—J˜š œžœ	žœžœ˜JJš
ž˜Jšœžœžœ˜9Jš
œV˜VJš
œ=˜=Jšžœ
˜—J˜š
 œžœ	žœžœžœ˜aJš
ž˜Jšœžœžœ˜9Jš
œZ˜ZJš
œ=˜=Jšžœ
˜—J™Jš	œ
žœžœ
žœ
žœ˜+šœžœžœ˜Jšœžœ˜Jšœ
žœ
¡˜(Jšœžœžœ¡/˜CJšœžœžœ¡-˜AJšœžœž˜J˜—J˜š
 
œžœ
žœžœžœ ˜eJš
ž˜Jš
œH™HJšœžœ˜Jšžœžœžœ
žœ
˜(Jš
žœžœžœžœ
žœ˜Cšžœžœžœ˜!Jš
žœžœžœžœ
žœ˜CJšœ$žœžœ
žœ˜UJ˜—šžœžœ
žœ˜!Jšžœžœžœ˜3Jšœ#žœžœ
žœ˜TJ˜—Jšžœžœ
žœ
žœ
˜$Jš
œ&˜&Jšžœ
˜—J˜š œžœžœžœ žœžœ˜\Jš
œ4™4Jš
ž˜Jšœžœ
˜Jšœžœ˜!Jšœ&¡6˜\šžœ/žœ˜7Jš
œ˜Jš
œ ˜ J˜
—šžœ˜Jš
œ˜Jš
œ ˜ Jšœžœ
˜J˜—š	žœžœ žœžœ
ž˜7Jšœžœ-˜2Jš
œ'˜'Jš
œ%˜%šžœžœžœ˜šžœžœ˜Jš
œ%™%Jšžœ!žœž˜:Jš	žœ
žœžœ>žœž˜jJ˜
—Jšžœ
žœ
žœžœ
žœ
ž˜<šžœ
žœ+žœ˜8Jšœžœ+˜3JšžœUžœž˜nJ˜
—Jšžœžœ
˜Jšœžœ˜Jšœžœ˜J˜—Jšžœ
˜—Jšžœ
žœ˜Jšžœ
˜—J˜š
 œžœ
žœ
žœžœ˜]Jš
ž˜Jšœžœ(˜-Jš
œ6˜6Jš
œ˜Jšžœ
˜—J˜Jš 	œžœžœžœžœžœžœ˜QJ˜Jšžœ˜J˜—…—=ZU‡