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

CDSimpleOpsImpl: CEDAR PROGRAM 
IMPORTS CD, CDInstances, CDBasics, CDCommandOps,
CDEvents, CDOps, CDOrient, CDProperties, CDRects, CDStretchyExtras, CDValue, Rope, TerminalIO
EXPORTS CDSimpleOps  = 
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.Position, verbose: BOOL] =
BEGIN
sel: CD.Instance _ NIL;
FOR w: CD.InstanceList _ CDOps.InstList[design], w.rest WHILE w#NIL DO
IF ~w.first.selected THEN { 
IF CDInstances.PointToI[pos, w.first] THEN {sel _ w.first; EXIT}
};
ENDLOOP;
IF sel#NIL THEN {
sel.selected _ TRUE;
CDOps.ReOrderInstance[design, sel];
CDOps.RedrawInstance[design, sel];
IF verbose THEN TerminalIO.WriteRope[CDCommandOps.InstRope[sel]];
}
ELSE IF verbose THEN {
FOR w: CD.InstanceList _ CDOps.InstList[design], w.rest WHILE w#NIL DO
IF w.first.selected THEN { 
IF CDInstances.PointToI[pos, w.first] THEN {
TerminalIO.WriteRopes[CDCommandOps.InstRope[w.first], " again"];
RETURN
}
};
ENDLOOP;
TerminalIO.WriteRope[" no pointed object"];
}
END;

DeSelect: PUBLIC PROC [design: CD.Design, pos: CD.Position, verbose: BOOL] =
BEGIN 
inst: CD.Instance _ CDInstances.InstanceAt[CDOps.InstList[design], pos, TRUE];
IF inst#NIL THEN 
BEGIN
IF ~inst.selected THEN ERROR;
inst.selected _ FALSE;
CDOps.RedrawInstance[design, inst];
CDOps.ReOrderInstance[design, inst];
END;
IF verbose THEN TerminalIO.WriteRope[CDCommandOps.InstRope[inst]];
END;

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

DeselectAll: PUBLIC PROC [design: CD.Design] =
BEGIN
doItSingleWise: NAT = 4;
sel: CD.InstanceList = CDInstances.OnlySelected[CDOps.InstList[design]];
b: CD.Rect;
cnt: INT;
[b, cnt] _ BoundingRectAndCount[list: sel];
CDInstances.DeSelectList[sel];
IF cnt<=doItSingleWise THEN 
FOR l: CD.InstanceList _ sel, l.rest WHILE l#NIL DO
CDOps.RedrawInstance[design, l.first]
ENDLOOP
ELSE CDOps.DelayedRedraw[design, b];
END;

SelectAll: PUBLIC PROC [design: CD.Design] =
BEGIN
b: CD.Rect _ CDInstances.BoundingRectO[list: CDOps.InstList[design], selectedOnly: FALSE];
FOR w: CD.InstanceList _ CDOps.InstList[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.Rect] =
BEGIN 
FOR w: CD.InstanceList _ CDOps.InstList[design], w.rest WHILE w#NIL DO
IF NOT w.first.selected 
AND CDBasics.Intersect[area, CDInstances.InstRectI[w.first]] THEN {
w.first.selected _ TRUE;
CDOps.RedrawInstance[design, w.first, FALSE];
};
ENDLOOP;
END;

AreaDeSelectTouched: PROC [design: CD.Design, area: CD.Rect] =
BEGIN 
FOR w: CD.InstanceList _ CDOps.InstList[design], w.rest WHILE w#NIL DO
IF w.first.selected 
AND CDBasics.Intersect[area, CDInstances.InstRectI[w.first]] THEN {
w.first.selected _ FALSE;
CDOps.RedrawInstance[design, w.first];
};
ENDLOOP;
END;

AreaSelectContained: PROC [design: CD.Design, area: CD.Rect] =
BEGIN 
FOR w: CD.InstanceList _ CDOps.InstList[design], w.rest WHILE w#NIL DO
IF CDBasics.Inside[CDInstances.InstRectI[w.first], area] THEN w.first.selected _ TRUE
ENDLOOP;
CDOps.DelayedRedraw[design, area, FALSE];
END;

AreaDeSelectContained: PROC [design: CD.Design, area: CD.Rect] =
BEGIN 
FOR w: CD.InstanceList _ CDOps.InstList[design], w.rest WHILE w#NIL DO
IF CDBasics.Inside[CDInstances.InstRectI[w.first], area] THEN w.first.selected _ FALSE
ENDLOOP;
CDOps.DelayedRedraw[design, area];
END;

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

AreaDeSelect: PUBLIC PROC [design: CD.Design, area: CD.Rect, 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.InstanceList;
[selected: toDelete, others: newContents] _ CDInstances.SplitSelected[CDOps.InstList[design]];
CDOps.SetInstList[design, newContents];
FOR w: CD.InstanceList _ toDelete, w.rest WHILE w#NIL DO
count _ count+1;
CDOps.RedrawInstance[design, w.first, TRUE];
ENDLOOP;
IF verbose THEN {
IF count#1 THEN {
TerminalIO.WriteInt[count];
TerminalIO.WriteRope[" objects"]
}
ELSE TerminalIO.WriteRope[CDCommandOps.InstRope[toDelete.first]]
};
RememberShortTime[design, toDelete];
END;

RedrawMoved: PROC [design: CD.Design, r: CD.Rect, offset: CD.Position] =
BEGIN
moved: CD.Rect _ 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;

MoveSelected: PUBLIC PROC [design: CD.Design, offset: CD.Position, stretchy: CDSimpleOps.StretchyMode] =
BEGIN
IF stretchy=option THEN
IF CDValue.FetchInt[design, $CDxStretchyMove, global]=1 THEN stretchy_yes;
IF stretchy=yes THEN 
StretchyMoveSelected[design, offset] 
ELSE 
SimpleMoveSelected[design, offset]
END;

SimpleMoveSelected: PUBLIC PROC [design: CD.Design, offset: CD.Position] =
BEGIN
sel: CD.InstanceList = CDInstances.OnlySelected[CDOps.InstList[design]];
bounding: CD.Rect = CDInstances.BoundingRectO[sel];
FOR w: CD.InstanceList _ sel, w.rest WHILE w#NIL DO
w.first.location _ CDBasics.AddPoints[w.first.location, offset];
ENDLOOP;
RedrawMoved[design, bounding, offset]
END;

CopySelected: PUBLIC PROC [design: CD.Design, offset: CD.Position] =
BEGIN
new: CD.InstanceList_NIL;
sel: CD.InstanceList = CDInstances.OnlySelected[CDOps.InstList[design]];
bounding: CD.Rect _ CDInstances.BoundingRectO[sel]; 
FOR w: CD.InstanceList _ sel, w.rest WHILE w#NIL DO
inst: CD.Instance _ NEW[CD.InstanceRep];
inst.ob _ w.first.ob;
inst.location _ CDBasics.AddPoints[w.first.location, offset];
inst.orientation _ w.first.orientation;
inst.properties _ CDProperties.DCopyProps[w.first.properties];
inst.selected _ TRUE;
new _ CONS[inst, new];
w.first.selected _ FALSE;
ENDLOOP;
CDOps.IncludeInstanceList[design, new, FALSE];
RedrawMoved[design, bounding, offset];
END;

Transform: PROC [inst: CD.Instance, cellRect: CD.Rect, transformation: CD.Orientation] =
BEGIN
r: CD.Rect _ CDOrient.MapRect[
itemInCell: CDOrient.RectAt[
CDBasics.SubPoints[inst.location, CDBasics.BaseOfRect[cellRect]],
inst.ob.size, 
inst.orientation],
cellSize: CDBasics.SizeOfRect[cellRect], 
cellInstOrient: transformation, 
cellInstPos: CDBasics.BaseOfRect[cellRect]
];
inst.location _ CDBasics.BaseOfRect[r];
inst.orientation _ CDOrient.ComposeOrient[itemOrientInCell: inst.orientation, cellOrientInWorld: transformation];  
END;

TransformSelected: PUBLIC PROC [design: CD.Design, transform: CD.Orientation] =   
BEGIN
sel: CD.InstanceList = CDInstances.OnlySelected[CDOps.InstList[design]];
b: CD.Rect _ CDInstances.BoundingRectO[sel];
ib: CD.Rect = CDInstances.BoundingRectI[sel];
FOR w: CD.InstanceList _ sel, w.rest WHILE w#NIL DO
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.Rect] =   
BEGIN
sel: CD.InstanceList = CDInstances.OnlySelected[CDOps.InstList[design]];
b: CD.Rect _ CDInstances.BoundingRectO[sel];
newB: CD.Rect _ CDOrient.MapRect[
itemInCell: b,
cellSize: CDBasics.SizeOfRect[base], 
cellInstOrient: transform, 
cellInstPos: CDBasics.BaseOfRect[base]
];
FOR w: CD.InstanceList _ sel, w.rest WHILE w#NIL DO
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[class: REF] =  
BEGIN
WITH class SELECT FROM
il: CD.InstanceList => 
FOR l: CD.InstanceList _ il, l.rest WHILE l#NIL DO
Forgett[l.first]
ENDLOOP;
inst: CD.Instance => {inst.properties _ NIL; inst.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, n: INT_0] =
BEGIN
del: REF _ GiveRemembered[design];
IF del=NIL THEN RETURN;
WITH del SELECT FROM
il: CD.InstanceList => CDOps.IncludeInstanceList[design, il];
inst: CD.Instance => CDOps.IncludeInstance[design, inst]
ENDCASE => NULL;
END;

FlushDeletedCache: PUBLIC PROC [design: CD.Design] =
BEGIN
dl: REF RememberBuffer;
IF design^.actual.first.deletedList=NIL THEN RETURN;
dl _ NARROW[design^.actual.first.deletedList];
dl.next _ (dl.next+remSize-1) MOD remSize;
DO
dl.next _ (dl.next+remSize-1) MOD remSize;
IF dl.a[dl.next]=NIL THEN EXIT;
Forgett[dl.a[dl.next]];
dl.a[dl.next] _ NIL;
ENDLOOP
END;

-- xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx

Primality: TYPE = {primary, secondary};

ChangeWireLength: PROC [design: CD.Design, inst: CD.Instance, amount: CD.Number] =
BEGIN
sz: CD.Position = CD.InterestSize[inst.ob];
r: CD.Rect _ CDInstances.InstRectO[inst];
newOb: CD.Object_NIL;
IF NOT WireTyped[inst.ob] THEN ERROR;
newOb _ CDRects.CreateRect[CD.Position[x: sz.x, y: sz.y+amount], inst.ob.layer];
IF newOb=NIL THEN RETURN;
IF inst.ob.class#newOb.class THEN ERROR; 
inst.ob _ newOb;
r _ CDBasics.Surround[r, CDInstances.InstRectO[inst]];
CDOps.DelayedRedraw[design, r];
END;

StretchyMoveSP: PROC[design: CD.Design, offset: CD.Position, selectedApps, nonSelectedApps: CD.InstanceList] =
BEGIN
primApps: CD.InstanceList _ NIL; 
primList, secondList, nonPrimList: StretchList _ NIL;
rect: CD.Rect;
rect _ CDInstances.BoundingRectO[selectedApps];
FOR l: CD.InstanceList _ nonSelectedApps, l.rest WHILE l#NIL DO
IF WireTyped[l.first.ob] THEN {
me: REF StretchRec_NEW[StretchRec_StretchRec[
ap: l.first,
conductRect: CDInstances.InstRectI[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.InstanceList _ selectedApps, l.rest WHILE l#NIL DO
MoveInst[design, l.first, offset]
ENDLOOP;
END;

StretchyMoveSelected: PROC[design: CD.Design, offset: CD.Position] =
BEGIN
selectedApps, nonSelectedApps: CD.InstanceList _ NIL; 
[selectedApps, nonSelectedApps] _ CDInstances.SplitSelected[CDOps.InstList[design]];
StretchyMoveSP[design, offset, selectedApps, nonSelectedApps]
END;

StretchList: TYPE = LIST OF REF StretchRec;
StretchRec: TYPE = RECORD [
ap: CD.Instance,
conductRect: CD.Rect, -- 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.Position, class: Primality] =
BEGIN
move: CD.Position_offset;
IF ~wire.near AND ~wire.far THEN RETURN;
IF class#primary THEN {IF wire.horizontal THEN move.y_0 ELSE move.x_0};
IF wire.near AND ~wire.far THEN {
IF class#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;
MoveInst[design, wire.ap, move]
END;

HasMatch: PROC [me: REF StretchRec, list: CD.InstanceList, class: Primality] RETURNS [BOOL] =
BEGIN
near, far: BOOL;
nearEdge, farEdge: CD.Rect;
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.InstanceList _ list, l.rest WHILE l#NIL DO
r: CD.Rect = CDInstances.InstRectI[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 class#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.Rect = CDInstances.InstRectI[me.ap];
IF ~CDStretchyExtras.Match[l.first.ob, rect, me.ap.ob.layer, class=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;

MoveInst: PROC [design: CD.Design, inst: CD.Instance, offset: CD.Position] =
BEGIN
r: CD.Rect _ CDInstances.InstRectO[inst];
inst.location _ CDBasics.AddPoints[inst.location, offset];
RedrawMoved[design, r, offset];
END;

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

END. 

CDSimpleOpsImpl.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, March 26, 1986 4:46:57 pm 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
�Êÿ˜
codeš
œ.™.Kšœ
Ïm
œ8™CKš
œ,™,Kš
œ>™>—K˜š
Ïk	˜	Kšžœ
˜K˜Kš
œ˜K˜
K˜	Kš
œ	˜	K˜K˜	K˜
K˜Kš
œ˜Kš
œ˜Kšœžœ	žœ˜K˜—K˜šÐblœžœ
žœ
˜Kšžœ)˜0Kš
œ]˜]Kšžœ˜—Kš
ž˜K˜RK˜š
Ïnœžœ
žœ
žœžœ˜@Kš
œ™Kš
ž˜Kšœžœ
˜Kšœžœ˜!šžœžœ˜Kš
œ(˜(Kš
ž˜K˜—Kš
œ˜Kšœ;žœ˜Ašžœžœ˜Kš
œ˜Kšœ9žœ˜@K˜
—Kšžœ
˜—K˜š œžœ
žœ
žœžœžœ˜JKš
ž˜Kšœžœžœ
˜š	žœžœ/žœžœ
ž˜Fšžœžœ˜Kšžœ$žœžœ
˜@K˜—Kšžœ
˜—šžœžœ
žœ˜Kšœžœ
˜Kš
œ=™=Kš
œ#˜#Kš
œ"˜"Kšžœ	žœ2˜AKš
œ
˜
—šžœ
žœ	žœ˜š	žœžœ/žœžœ
ž˜Fšžœžœ˜šžœ$žœ˜,Kš
œ@˜@Kš
ž˜Kš
œ
˜
—K˜—Kšžœ
˜—Kš
œ+˜+K˜
—Kšžœ
˜K˜—š œžœ
žœ
žœžœžœ˜LKšžœ
˜Kšœžœ@žœ˜Nšžœžœ
žœ
˜Kš
ž˜Kšžœžœ
žœ
˜Kšœžœ
˜Kš
œ#˜#Kš
œ>™>Kš
œ$˜$Kšžœ
˜—Kšžœ	žœ3˜BKšžœ
˜K˜—š
 œžœžœžœ
žœ˜OKšžœ	žœžœ˜5Kš
ž˜š
žœžœ
žœ
žœžœžœ
ž˜>Kš
žœžœ
žœžœ
žœ
˜5K˜Kš
œB˜BKšžœ
˜—Kšžœ
˜—K˜š œžœ
žœ
žœ
˜.Kš
ž˜Kšœžœ˜KšœžœA˜HKšœžœ˜Kšœžœ
˜	Kš
œ+˜+Kš
œ˜šžœžœ
˜š	žœžœžœžœ
ž˜3Kš
œ%˜%Kš
ž˜——Kšžœ ˜$Kšžœ
˜K˜—š 	œžœ
žœ
žœ
˜,Kš
ž˜Kš
œ$™$KšœžœNžœ˜Zš	žœžœ/žœžœ
ž˜FKšœž˜Kšžœ
˜—Kšœžœ˜&Kšžœ
˜K˜—š œžœ
žœžœ˜<Kšžœ
˜š	žœžœ/žœžœ
ž˜Fšžœ
žœ˜Kšžœ:žœ˜CKšœžœ
˜Kšœ&žœ˜-K˜—Kšžœ
˜—Kšžœ
˜K˜—š œžœ
žœžœ˜>Kšžœ
˜š	žœžœ/žœžœ
ž˜Fšžœ˜Kšžœ:žœ˜CKšœžœ
˜Kš
œ&˜&K˜—Kšžœ
˜—Kšžœ
˜K˜—š œžœ
žœžœ˜>Kšžœ
˜š	žœžœ/žœžœ
ž˜FKšžœ7žœž˜UKšžœ
˜—Kšœ"žœ˜)Kšžœ
˜K˜—š œžœ
žœžœ˜@Kšžœ
˜š	žœžœ/žœžœ
ž˜FKšžœ7žœž˜VKšžœ
˜—Kš
œ"˜"Kšžœ
˜K˜—š 
œžœ
žœ
žœžœžœ˜RKšžœ
˜Kšžœžœ ž
˜7Kšžœ"˜'Kšžœ
˜K˜—š œžœ
žœ
žœžœžœ˜TKšžœ
˜Kšžœžœ"ž
˜9Kšžœ$˜)Kšžœ
˜K˜—š
 œžœ
žœ
žœžœ˜@Kš
ž˜Kšœžœ˜Kšœžœ˜'Kš
œ^˜^Kš
œ'˜'š	žœžœ!žœžœ
ž˜8Kš
œ˜Kšœ&žœ˜,Kšžœ
˜—šžœ	žœ˜šžœ	žœ˜Kš
œ˜Kš
œ ˜ K˜
—Kšžœ<˜@Kš
œ˜—K˜$Kšžœ
˜K˜—š
 œžœ
žœžœžœ˜HKš
ž˜Kšœžœ%˜.šžœž˜$Kšœ9žœ
˜>—šžœ˜Kš
œ˜Kšœ$Ïc+˜OKš
œ
˜
—Kšžœ
˜K˜—š
 œžœ
žœ
žœžœ0˜hKš
ž˜šžœž˜Kšžœ6žœ˜J—šžœžœ
˜Kšœ$ž
˜%—šžœ
˜Kš
œ"˜"—Kšžœ
˜—K˜š
 œžœ
žœ
žœžœ˜JKš
ž˜KšœžœA˜HKšœ
žœ'˜3š	žœžœžœžœ
ž˜3K˜@Kšžœ
˜—K˜%Kšžœ
˜K˜—š
 œžœ
žœ
žœžœ˜DKš
ž˜Kšœžœžœ
˜KšœžœA˜HKšœ
žœ(˜4š	žœžœžœžœ
ž˜3Kšœžœžœ
žœ˜(Kš
œ˜Kš
œ=˜=Kš
œ'˜'Kš
œ>˜>Kšœž˜Kšœžœ˜Kšœžœ
˜Kšžœ
˜—Kšœ'žœ˜.Kš
œ&˜&Kšžœ
˜K˜—š
 	œžœžœžœžœ˜XKš
ž˜šœžœ˜˜K˜AK˜K˜—K˜)K˜ K˜*K˜—K˜'K˜sKšžœ
˜K˜—š
 œžœ
žœ
žœžœ˜RKš
ž˜KšœžœA˜HKšœžœ'˜,Kšœžœ'˜-š	žœžœžœžœ
ž˜3Kš
œ!˜!Kšžœ
˜—Kš
œ˜š
œ˜Kš
œN˜NKš
œ#˜#Kš
œ˜Kš
œ$˜$K˜—Kšœžœ˜&Kšžœ
˜K˜—š œžœ
žœ
žœžœžœ˜eKš
ž˜KšœžœA˜HKšœžœ'˜,šœžœ˜!K˜K˜%K˜K˜&K˜—š	žœžœžœžœ
ž˜3Kš
œ#˜#Kšžœ
˜—Kš
œ˜Kš
œ!˜!Kšžœ
˜K˜—Kš¡œ
¡œ
¡œ
¡œ
¡œ
¡œ
˜$K˜Kšœ	žœ˜šœžœžœ
˜Kšœžœžœ
žœžœ
žœ˜(Kšœžœ˜K˜—š œžœžœ˜Kš
œ™Kš
œ6™6Kš
ž˜šžœžœ
ž˜šœžœ˜š	žœžœžœžœ
ž˜2Kš
œ˜Kšžœ
˜——Kšœžœ žœžœ˜<Kšžœžœ
˜—Kšžœ
˜K˜—š œžœžœžœ˜3Kš
ž˜Kšœžœ˜Kšžœžœ
žœžœ˜ZKšœžœ˜)K˜K˜Kšœžœ	˜"Kšžœ
˜K˜—š
 œžœžœ	žœžœ˜3Kš
ž˜Kšœžœ
˜Kšœžœ˜Kš
žœžœ
žœ
žœžœ˜5Kšœžœ˜)Kšœžœ	˜*K˜Kšœžœ
˜Kšžœ˜Kšžœ
˜K˜—š
 œžœ
žœ
žœžœ˜5Kš
ž˜Kšœžœ˜"Kšžœžœ
žœ
žœ
˜šžœžœ
ž˜Kšœžœ7˜=Kšœžœ0˜8Kšžœžœ
˜—Kšžœ
˜K˜—š œžœ
žœ
žœ
˜4Kš
ž˜Kšœžœ˜Kšžœ"žœ
žœ
žœ
˜4Kšœžœ#˜.Kšœžœ	˜*š
ž˜Kšœžœ	˜*Kšžœžœ
žœ
žœ
˜K˜Kšœžœ
˜Kš
ž˜—Kšžœ
˜K˜—K˜KK˜Kšœžœ˜'K˜š
 œžœ
žœžœžœ
˜RKš
ž˜Kš
œ@™@Kšœžœžœ˜+Kšœžœ$˜)Kšœžœžœ
˜Kšžœ
žœžœ
žœ
˜%Kšœžœ3˜PKšžœžœ
žœ
ž˜šžœžœ
žœ˜)Kš
œ?™?—Kš
œ˜Kš
œ6˜6Kš
œ˜Kšžœ
˜K˜—š
 œžœ	žœžœ*žœ˜nKš
ž˜Kšœ
žœžœ˜!Kšœ1žœ
˜5Kšœžœ˜Kš
œ/˜/š	žœžœ(žœžœ
ž˜?šžœžœ˜šœžœžœ˜-Kš
œ˜Kš
œ,˜,Kšœ;¡˜UKš
œ˜—Kš
žœ*žœ%žœ
žœžœ˜š
Kšžœžœ˜(Kš
œ˜—Kšžœ
˜—šžœ&žœžœ
ž˜7Kšžœ(žœžœ˜UKšžœ
˜—šžœ%žœžœ
ž˜6Kš
œ.˜.Kšžœ
˜—šžœ#žœžœ
ž˜4Kš
œ,˜,Kšžœ
˜—š	žœžœ%žœžœ
ž˜<Kš
œ!˜!Kšžœ
˜—Kšžœ
˜—K˜š œžœ	žœžœ˜DKš
ž˜Kšœžœžœ˜6Kš
œT˜TKš
œ=˜=Kšžœ
˜—K˜Kš	œ
žœžœ
žœ
žœ˜+šœžœžœ˜Kšœžœ
˜Kšœ
žœ¡˜"Kšœžœžœ¡/˜CKšœžœžœ¡-˜AKšœžœž˜K˜—K˜š
 
œžœ
žœžœžœ˜cKš
ž˜Kš
œH™HKšœžœ˜Kšžœžœžœ
žœ
˜(Kš
žœžœžœžœ
žœ˜Gšžœžœžœ˜!Kš
žœžœžœžœ
žœ˜GKšœ$žœžœ
žœ˜UK˜—šžœžœ
žœ˜!Kšžœžœžœ˜3Kšœ#žœžœ
žœ˜TK˜—Kšžœžœ
žœ
žœ
˜$Kš
œ˜Kšžœ
˜—K˜š œžœžœžœ!žœžœ˜]Kš
œ4™4Kš
ž˜Kšœžœ
˜Kšœžœ˜Kšœ&¡6˜\šžœ/žœ˜7Kš
œ˜Kš
œ ˜ K˜
—šžœ˜Kš
œ˜Kš
œ ˜ Kšœžœ
˜K˜—š	žœžœžœžœ
ž˜4Kšœžœ'˜,Kš
œ'˜'Kš
œ%˜%šžœžœžœ˜šžœžœ˜Kš
œ%™%Kšžœ!žœž˜:Kš	žœ
žœžœ>žœž˜nK˜
—Kšžœ
žœ
žœžœ
žœ
ž˜<šžœ
žœ+žœ˜8Kšœžœ%˜-KšžœYžœž˜rK˜
—Kšžœžœ
˜Kšœžœ˜Kšœžœ˜K˜—Kšžœ
˜—Kšžœ
žœ˜Kšžœ
˜—K˜š
 œžœ
žœžœžœ˜LKš
ž˜Kšœžœ$˜)Kš
œ:˜:Kš
œ˜Kšžœ
˜—K˜š 	œžœžœ	žœžœžœ˜9Kšžœ˜Kš
œ˜—K˜Kšžœ˜K˜—…—:ÆRÝ