DIRECTORY
CD, 
CDInstances,
CDCells,
CDCellsInteractions,
CDDirectory,
CDDirectoryOps,
PopUpMenus,
CDEvents,
CDBasics,
CDMarks,
CDOps,
CDOrient,
CDProperties,
CDSequencer,
CDSequencerExtras, 
Rope,
TerminalIO;

CDCellsInteractionsImpl: CEDAR PROGRAM 
IMPORTS CDCells, CDInstances, CDDirectory, CDDirectoryOps, CDEvents, CDBasics, CDMarks, PopUpMenus, CDOps, CDOrient, CDProperties, CDSequencer, CDSequencerExtras, Rope, TerminalIO
EXPORTS CDCellsInteractions
SHARES CD =
BEGIN

EventRegistration: TYPE = CDEvents.EventRegistration;

beforeReplace: EventRegistration = CDEvents.RegisterEventType[$BeforeCellReplacement];
afterReplace: EventRegistration = CDEvents.RegisterEventType[$AfterCellReplacement];
pushEvent: EventRegistration = CDEvents.RegisterEventType[$AfterPush];
popEvent: EventRegistration = CDEvents.RegisterEventType[$AfterPop];
createEvent: EventRegistration = CDEvents.RegisterEventType[$InteractiveCreatedCell];

fullPopMenu: PopUpMenus.Menu = PopUpMenus.Create["Pop from cell", "select menu entry to go back outside"];
partialPopMenu: PopUpMenus.Menu = PopUpMenus.Create["Pop from cell", "replace is not possible! it would create recursion"];
emptyPopMenu: PopUpMenus.Menu = PopUpMenus.Create["Pop from cell: empty cell", "cell is empty; you can not create an empty cell"];
expandPopMenu: PopUpMenus.Menu = PopUpMenus.Create["Pop from expanded object"];

expandResultKey: REF = NEW[INT];

Init: PROC [] = {
[] _ PopUpMenus.Entry[fullPopMenu, "flush", NIL, $flush, "undo all modifications of cell"];
[] _ PopUpMenus.Entry[partialPopMenu, "flush", NIL, $flush, "undo all modifications of cell"];
[] _ PopUpMenus.Entry[emptyPopMenu, "flush", NIL, $flush, "undo all modifications of cell"];
[] _ PopUpMenus.Entry[fullPopMenu, "new cell", NIL, $new, "create a new cell; original cell is unmodified"];
[] _ PopUpMenus.Entry[partialPopMenu, "new cell", NIL, $new, "create a new cell; original cell is unmodified"];
[] _ PopUpMenus.Entry[fullPopMenu, "replace", NIL, $replace, "make edits permanent in all instances of cell"];
[] _ PopUpMenus.Entry[expandPopMenu, "flush", NIL, $flush, "undo all modifications of cell"];
[] _ PopUpMenus.Entry[expandPopMenu, "new cell this instance", NIL, $new, "create a new cell; original object is unmodified"];
[] _ PopUpMenus.Entry[expandPopMenu, "new cell and replace all instances", NIL, $newAll, "tries to forget original object"];
}; 

CreateCellObject: PROC [use: CD.InstanceList, orient: CD.Orientation _ CDOrient.original] RETURNS [CD.Object] = {
ob: CD.Object = CDCells.CreateEmptyCell[];
cp: CD.CellPtr = NARROW[ob.specificRef];
gOutR: CD.Rect = CDInstances.BoundingRectO[use]; -- coordsys of use, non oriented
ob.size _ CDOrient.OrientedSize[CDBasics.SizeOfRect[gOutR], orient];
cp.contents _ CDInstances.DeComposedList[use, CDBasics.BaseOfRect[gOutR], ob.size, orient];
cp.ir _ cp.dIr _ CDInstances.BoundingRectI[cp.contents];
cp.simplifyOn _ 50.0/MAX[ob.size.y, 1];
RETURN [ob]
};

IncludeAndNameCell: PROC [design: CD.Design, cell: CD.Object, interactive: BOOL _ TRUE, allowAbort: BOOL _ FALSE] RETURNS [done: BOOL] = {
IF ~interactive THEN {
[] _ CDDirectory.Include[design, cell];
RETURN [done_TRUE];
};
DO 
fiddle: BOOL _ FALSE; aborted: BOOL _ FALSE; name: Rope.ROPE;
name _ TerminalIO.RequestRope["enter object name: "  
! TerminalIO.UserAbort => {aborted _ TRUE; fiddle _ TRUE; CONTINUE}
];
IF aborted THEN {
TerminalIO.WriteRope[" **name input aborted\n"];
IF allowAbort THEN RETURN [done_FALSE];
};
IF Rope.IsEmpty[name] THEN {
fiddle _ TRUE; 
name _ "-no name";
};
IF Rope.Fetch[name, name.Length[]-1]='@ THEN {
fiddle _ TRUE;
name _ Rope.Substr[name, 0, name.Length[]-1];
}; 
IF CDDirectory.Include[design, cell, name, fiddle] THEN { 
TerminalIO.WriteRopes[CDDirectory.Name[cell], " included\n"]; 
RETURN [done_TRUE];
};
TerminalIO.WriteRopes[name, " does already exist\nnot accepted, please repeat\n"];
ENDLOOP;
};

CreateCellSelected: PUBLIC PROC [design: CD.Design, name: Rope.ROPE _ NIL] RETURNS [done: BOOL _ FALSE, cellOb: CD.Object _ NIL] = {

RemoveSelectedFromWorld: PROC [design: CD.Design] RETURNS [remove: CD.InstanceList] = {
keep: CD.InstanceList;
[others: keep, selected: remove] _ CDInstances.SplitSelected[CDOps.InstList[design]];
CDOps.SetInstList[design, keep];
};

sel: CD.InstanceList = RemoveSelectedFromWorld[design];
inst: CD.Instance = NEW[CD.InstanceRep];
b: CD.Rect = CDInstances.BoundingRectO[sel];
cp: CD.CellPtr;
inst.ob _ cellOb _ CreateCellObject[use: sel];
cp _ NARROW[cellOb.specificRef];
cp.name _ name;
inst.location _ CDBasics.BaseOfRect[b];
inst.selected _ TRUE;
IF NOT CDBasics.NonEmpty[b] THEN {
TerminalIO.WriteRope["no empty cell\n"]; 
RETURN [done: FALSE, cellOb: NIL]
};
IF name=NIL THEN {
IF ~IncludeAndNameCell[design: design, cell: cellOb, allowAbort: TRUE, interactive: TRUE].done THEN {
CDOps.IncludeInstanceList[design, sel, FALSE];
RETURN [done: FALSE, cellOb: NIL]
};
}
ELSE [] _ CDDirectory.Include[design, cellOb];
CDOps.IncludeInstance[design, inst, TRUE]; -- redraw removes seletion
[] _ CDEvents.ProcessEvent[createEvent, design, cellOb];
RETURN [done: TRUE, cellOb: cellOb]
};

PushInCellInstance: PUBLIC PROC [design: CD.Design, inst: CD.Instance, convertIfNecessary: BOOL _ TRUE] RETURNS [done: BOOL _ FALSE] = {

IsCellInstance: PROC [inst: CD.Instance] RETURNS [yes: BOOL _ FALSE] = {
SELECT TRUE FROM
inst=NIL => TerminalIO.WriteRope[" no object\n"];
inst.ob=NIL OR inst.ob.specificRef=NIL => TerminalIO.WriteRope[" bad object\n"]; 
ISTYPE[inst.ob.specificRef, CD.CellPtr] => yes _ TRUE;
ENDCASE => TerminalIO.WriteRopes[" object is not cell but ", CDOps.ObjectInfo[inst.ob], "\n"];
};

CheckRecursionForPush: PROC [design: CD.Design, ob: CD.Object] RETURNS [yes: BOOL _ FALSE] = {
FOR l: LIST OF CD.PushRec _ design.actual, l.rest WHILE l#NIL DO
IF l.first.mightReplace#NIL AND l.first.mightReplace.ob=ob THEN RETURN [yes _ TRUE]
ENDLOOP;
};

old: CD.Object _ inst.ob; --the original object; or if not a cell: the original conversion
WHILE old#NIL AND ~CDCells.IsCell[old] AND convertIfNecessary DO
ob2: CD.Object _ CDDirectory.ExpandComplete[old, design, design];
IF ob2=NIL OR ob2=old THEN {TerminalIO.WriteRope["expand failed\n"]; RETURN [FALSE]};
old _ ob2;
CDProperties.PutProp[inst, expandResultKey, ob2];
ENDLOOP;
IF CDCells.IsCell[old] THEN {
dummy: CD.Object = CDCells.CreateEmptyCell[];
oldCp: CD.CellPtr = NARROW[old.specificRef];
newCp: CD.CellPtr = NARROW[dummy.specificRef];
dummyCellInst: CD.Instance;
dummy.size _ CDBasics.highposition;
IF CheckRecursionForPush[design, old] THEN {
TerminalIO.WriteRopes[" recursive push into ", CDOps.ObjectInfo[old], " not possible\n"]; 
RETURN [FALSE];
};
newCp^ _ oldCp^; --copies interest rect ....
newCp.ir _ CDOrient.MapRect[
itemInCell: oldCp.ir,
cellSize: inst.ob.size, 
cellInstOrient: inst.orientation, 
cellInstPos: inst.location
];
newCp.dIr _ CDOrient.MapRect[
itemInCell: oldCp.dIr,
cellSize: inst.ob.size, 
cellInstOrient: inst.orientation, 
cellInstPos: inst.location
];
newCp.contents _ CDInstances.ComposedList[
il: newCp.contents, 
cellPos: inst.location, 
cellSize: inst.ob.size, 
cellOrient: inst.orientation
];
dummyCellInst _ NEW[CD.InstanceRep_[
ob: dummy, 
selected: TRUE,
properties: CDProperties.DCopyProps[inst.properties]
]];
CDProperties.CopyProps[inst.ob.properties, dummy];
CDOps.RemoveInstance[design, inst]; 
design^.actual _ CONS[
CD.PushRec[dummyCell: dummyCellInst, specific: newCp, mightReplace: inst], 
design^.actual
];
CDProperties.PutObjectProp[dummy, $dummyCell, $TRUE];
[] _ CDEvents.ProcessEvent[pushEvent, design];
RETURN [done _ TRUE];
}
};

PopFromCell: PUBLIC PROC [design: CD.Design, m: CDCellsInteractions.Method_interactive, name: Rope.ROPE_NIL] RETURNS [done: BOOL] = {
done _ IPopFromCell[design, m, name];
IF done THEN [] _ CDEvents.ProcessEvent[popEvent, design];
};

IPopFromCell: PROC [design: CD.Design, m: CDCellsInteractions.Method, name: Rope.ROPE] RETURNS [done: BOOL_FALSE] = {
currentRect, originalRect: CD.Rect; --cd coords
currentInst, originalInst: CD.Instance;
currentCell, originalCell: CD.Object;
currentCP: CD.CellPtr;
recursive: BOOL _ FALSE;

CheckRecursionForPop: PROC [mark: CDMarks.MarkRange] = {
CDMarks.MarkUnMarkedInclusiveChildren[design, currentCell, mark];
recursive _ (originalInst.ob.marked=mark);
};

RemoveExpandedStuff: PROC [design: CD.Design, originalInst: CD.Instance] = {
IF ~CDCells.IsCell[originalInst.ob] THEN
WITH CDProperties.GetProp[originalInst, expandResultKey] SELECT FROM
ob: CD.Object => {
CDProperties.PutProp[originalInst, expandResultKey, NIL];
[] _ CDDirectoryOps.RemoveIfUnused[design, ob];
};
ENDCASE => NULL;
};

DoFlush: PROC [] = {
b: BOOL _ design^.actual.first.indirectlyChanged;
TerminalIO.WriteRope["flush\n"];
design^.actual _ design^.actual.rest;
design^.actual.first.indirectlyChanged _ TRUE;
IF b THEN design^.actual.first.indirectlyChanged _ TRUE;
CDOps.IncludeInstance[design, originalInst, FALSE];
RemoveExpandedStuff[design, originalInst];
};

HackSetOwner: PROC [ob: CD.Object, design: CD.Design] = {
CDProperties.PutObjectProp[ob, $OwnerDesign, design.reserved];
};

Offset: PROC [newSize, oldSize: CD.Position] RETURNS [offset: CD.Position] = {
fakeOrigin: CD.Position; --world coordinates
fakeOrigin _ CDOrient.MapPoint[
pointInCell: [0, 0],
cellSize: newSize,
cellInstOrient: currentInst.orientation,
cellInstPos: currentInst.location
].pointInWorld;
offset _  CDOrient.DeMapPoint[
pointInWorld: fakeOrigin,
cellSize: oldSize,
cellInstOrient: originalInst.orientation,
cellInstPos: originalInst.location
].pointInCell;
};

DoReplace: PROC [] = {
needsRep: BOOL _ FALSE;
originalCP: CD.CellPtr _ NARROW[originalCell.specificRef];
[] _ CDEvents.ProcessEvent[beforeReplace, design, originalCell];
TerminalIO.WriteRope["replace\n"];
CDProperties.CopyProps[currentCell.properties, originalCell, $Replace];
HackSetOwner[originalCell, design];
design^.actual _ design^.actual.rest;
design^.actual.first.indirectlyChanged _ TRUE;
needsRep _ originalRect#currentRect OR originalCP.ir#currentCP.ir OR currentCP.dIr#originalCP.dIr OR originalCP.useDIr#currentCP.useDIr;
originalCP.contents _ currentCP.contents;
originalCP.useDIr _ currentCP.useDIr;
originalCP.ir _ currentCP.ir;
IF needsRep THEN { 
oldSize: CD.Position _ originalCell.size;
newSize: CD.Position _ CDOrient.OrientedSize[CDBasics.SizeOfRect[currentRect], originalInst.orientation];
offset: CD.Position _ Offset[newSize, oldSize];
originalCell.size _ newSize;
originalCP.origin _ CDBasics.SubPoints[originalCP.origin, offset];
IF ~originalCP.useDIr THEN 
originalCP.ir _ CDBasics.MoveRect[originalCP.ir, CDBasics.NegOffset[offset]];
CDDirectory.RepositionObject[design: design, 
ob: originalCell, 
oldSize: oldSize, 
baseOff: offset
];
};
originalInst.location _ currentInst.location;
CDOps.IncludeInstance[design, originalInst, FALSE];
[] _ CDEvents.ProcessEvent[afterReplace, design, originalCell];
CDDirectory.PropagateChange[originalCell, design];
CDSequencerExtras.MarkChangedIOOnly[design];
};

DoNewCell: PROC [interactive: BOOL_FALSE, all: BOOL_FALSE] = {
IF all THEN TerminalIO.WriteRope["new cell and replace all instances\n"]
ELSE TerminalIO.WriteRope["new cell for this instance\n"];
currentInst.ob _ currentCell; 
design^.actual _ design^.actual.rest;
design^.actual.first.indirectlyChanged _ TRUE;
design^.actual.first.changed _ TRUE;
IF ~IncludeAndNameCell[design, currentCell, interactive, FALSE].done THEN ERROR;
CDOps.IncludeInstance[design, currentInst, FALSE];
[] _ CDEvents.ProcessEvent[createEvent, design, currentCell];
CDDirectory.PropagateChange[currentCell, design];
IF ~currentCP.useDIr THEN  {
offset: CD.Position _ Offset[currentCell.size, originalCell.size];
currentCP.ir _ CDBasics.MoveRect[currentCP.ir, CDBasics.NegOffset[offset]];
};
IF ~CDCells.IsCell[originalCell] AND all THEN {
CDDirectory.ReplaceObject[design: design, old: originalCell, new: currentCell]
};
CDSequencer.MarkChanged[design];
CDProperties.PutObjectProp[currentCell, $dummyCell, NIL];
RemoveExpandedStuff[design, originalInst]
};

menu: PopUpMenus.Menu _ fullPopMenu;
IF design^.actual.rest=NIL THEN {
TerminalIO.WriteRope["not in cell\n"]; 
RETURN [FALSE]
};
originalInst _ design^.actual.first.mightReplace;
originalCell _ originalInst.ob;
originalRect _ CDOrient.RectAt[originalInst.location, originalCell.size, originalInst.orientation]; 
TerminalIO.WriteRopes["Pop from ", CDOps.ObjectInfo[originalCell], "\n"];
CDInstances.DeSelectList[CDOps.InstList[design]];
currentRect _ CDInstances.BoundingRectO[CDOps.InstList[design]]; -- design coordinates
currentCell _ CreateCellObject[CDOps.InstList[design], originalInst.orientation];
currentCP _ NARROW[currentCell.specificRef];
currentCP.useDIr _ design^.actual.first.specific.useDIr;
IF ~currentCP.useDIr THEN
currentCP.ir _ CDOrient.DeMapRect[
itemInWorld: design^.actual.first.specific.ir,
cellSize: originalCell.size, 
cellInstOrient: originalInst.orientation, 
cellInstPos: originalInst.location
].itemInCell;
currentInst _ NEW[CD.InstanceRep _ [
ob: currentCell,
location: CDBasics.BaseOfRect[currentRect],
orientation: originalInst.orientation,
selected: TRUE,
properties: CDProperties.DCopyProps[design^.actual.first.dummyCell.properties] 
]];
CDProperties.CopyProps[design^.actual.first.dummyCell.ob.properties, currentCell];
IF m=flush OR (m=interactive AND ~design^.actual.first.changed) THEN {
DoFlush[]; RETURN [TRUE]
};
IF CDBasics.NonEmpty[currentRect] THEN { 
IF m=newcell THEN {DoNewCell[interactive: FALSE]; RETURN [TRUE]};
CDMarks.DoWithMark[design, CheckRecursionForPop];
IF recursive THEN { 
TerminalIO.WriteRope[" Original cell used inside, replace not possible\n"];
IF m=replace THEN {DoNewCell[interactive: FALSE, all: FALSE]; RETURN [TRUE]};
menu _ partialPopMenu;
}
ELSE IF ~CDCells.IsCell[originalCell] THEN { 
IF m=replace THEN {DoNewCell[interactive: FALSE, all: TRUE]; RETURN [TRUE]};
menu _ expandPopMenu;
}
ELSE { --ok, normal case
IF m=replace THEN {
DoReplace[]; 
RETURN [TRUE]
};
}
}
ELSE {  -- empty
TerminalIO.WriteRope[" create empty cell not possible\n"];
IF m#interactive THEN {DoFlush[]; RETURN [TRUE]};
menu _ emptyPopMenu;
};
SELECT PopUpMenus.Call[menu] FROM
$flush => DoFlush[];
$replace => DoReplace[];
$new => DoNewCell[interactive: TRUE, all: FALSE];
$newAll => DoNewCell[interactive: TRUE, all: TRUE];
ENDCASE => {TerminalIO.WriteRope["skipped\n"]; RETURN [FALSE]};
RETURN [TRUE];
};

Init[];
END.
.CDCellsInteractionsImpl.mesa   (part of ChipNDale)
Copyright c 1983, 1986 by Xerox Corporation.  All rights reserved.
Created by Christian Jacobi,   June 24, 1983 5:00 pm 
Last Edited by: Christian Jacobi, September 1, 1986 4:40:27 pm PDT
-- not yet included in design
--interactive
-- removes the selected instances from design and returns them
--undo the command
--verbose if inst is not a cell
--Returns "pushing into ob would cause recursion"
--if originalInst wasn't a cell, tries to remove results of original expansion
--HACK for CDDirectory--
Κή˜
codeš
œ2™2Kšœ
Οm
œ7™BKš
œ5™5K™BK˜—š
Ο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šœžœ˜5K˜K˜VK˜TK˜FK˜D˜UK˜—Kš
œj˜jKš
œ{˜{Kš
œ‚
˜‚
Kš
œO˜OK˜Kšœžœžœ
žœ˜ K˜šΟnœžœ˜Kšœ,žœ,˜[Kšœ/žœ,˜^Kšœ-žœ,˜\Kšœ/žœ:˜lKšœ2žœ:˜oKšœ.žœ=˜nKšœ.žœ,˜]Kšœ?žœ<˜~KšœKžœ.˜|Kš
œ˜—K˜š œžœžœžœ"žœžœ˜qKš
œ™Kšœžœ$˜*Kšœžœžœ˜(Kšœžœ(Οc ˜QKš
œD˜DKš
œ[˜[Kš
œ8˜8Kšœžœ˜'Kšžœ˜Kš
œ˜—K˜š œžœ
žœžœžœžœžœžœžœžœ˜Š
šžœžœ˜Kš
œ'˜'Kšžœžœ˜K˜—Kš
‘
™
šžœ
˜Kšœžœžœžœžœ
žœ
˜=š
œ5˜5Kšœ%žœžœžœ
˜CKš
œ˜—šžœ	žœ˜Kš
œ0˜0Kšžœžœ
žœžœ˜'K˜—šžœžœ˜Kšœ	žœ˜Kš
œ˜Kš
œ˜—šžœ&žœ˜.Kšœ	žœ
˜Kš
œ-˜-Kš
œ˜—šžœ1žœ˜:K˜>Kšžœžœ˜K˜—Kš
œR˜RKšžœ
˜—Kš
œ˜—K˜š œžœ
žœ
žœžœ
žœžœžœ
žœ
žœ	žœ˜„
K˜š
 œžœ
žœ	žœžœ˜WKš
œ>™>Kšœžœ˜Kš
œU˜UKš
œ ˜ Kšž
œ
˜—K˜Kšœžœ0˜7Kšœžœžœ
žœ˜(Kšœžœ'˜,Kšœžœ	˜Kš
œ.˜.Kšœžœ˜ K˜K˜'Kšœžœ
˜šžœ
žœžœ˜"Kš
œ)˜)Kšžœžœ
žœ
˜!Kš
œ˜—šžœžœ
žœ˜šžœ?žœžœžœ˜eKš
œ™Kšœ'žœ˜.Kšžœžœ
žœ
˜!K˜—K˜
—Kšžœ*˜.Kšœ$žœ‘˜EKš
œ8˜8Kšžœžœ˜#Kš
œ˜—K˜š œžœ
žœžœžœžœžœžœ
žœ˜ˆ
K˜š œžœžœžœžœžœ˜HKš
œ™šžœ
žœ
ž˜Kšœžœ)˜1Kšœžœ
žœžœ+˜QKšžœžœžœ
˜6KšžœW˜^—Kš
œ˜K˜—š œžœ
žœ
žœ	žœžœžœ˜^Kš
‘1™1š
žœžœ
žœ
žœ!žœžœ
ž˜@Kšžœžœ
žœžœ
žœžœ
˜SKšžœ
˜—Kš
œ˜—K˜Kšœžœ‘@˜Zš	žœžœ
žœžœž˜@Kšœžœ:˜AKšžœžœ
žœ	žœ+žœžœ˜UKš
œ
˜
Kš
œ1˜1Kšžœ
˜—šžœžœ˜Kšœžœ$˜-Kšœžœžœ˜,Kšœžœžœ˜.Kšœžœ
˜Kš
œ#˜#šžœ$žœ˜,Kš
œZ˜ZKšžœžœ˜Kš
œ˜—Kšœ‘˜,š
œ˜Kš
œ˜K˜K˜"K˜K˜—š
œ˜Kš
œ˜K˜K˜"K˜K˜—š
œ*˜*Kš
œ˜K˜K˜K˜K˜—šœžœ
žœ˜$Kš
œ˜Kšœ
žœ
˜Kš
œ4˜4Kš
œ˜—Kš
œ2˜2Kš
œ$˜$šœžœ
˜KšžœI˜KK˜K˜—Kš
œ5˜5K˜.Kšžœ	žœ˜K˜
—Kš
œ˜—K˜š œžœ
žœ
žœ?žœ
žœžœžœ˜…
K˜%Kšžœžœ.˜:Kš
œ˜—K˜š œžœ
žœ3žœ
žœž
œ˜uKšœžœ‘˜/Kšœžœ
˜'Kšœžœ˜%Kšœžœ	˜Kšœžœžœ
˜K˜š œžœ˜8Kš
œA˜AKš
œ*˜*Kšž
œ
˜—K˜š œžœ
žœžœ˜LKš
œN™Nšžœ"ž˜(šžœ5žœ
ž˜Dšœžœ˜Kšœ4žœ˜9Kš
œ/˜/K˜—Kšžœžœ
˜——Kš
œ˜—K˜š œžœ˜Kšœžœ*˜1K˜ K˜%Kšœ)žœ
˜.Kšžœžœ*žœ
˜8Kšœ,žœ˜3Kš
œ*˜*Kš
œ˜K˜—š œžœžœžœ˜9Kš
œ>˜>K˜—K˜š
 œžœžœžœ
žœ˜NKšœžœ‘˜,š
œ˜Kš
œ˜Kš
œ˜Kš
œ(˜(Kš
œ!˜!Kš
œ˜—š
œ˜Kš
œ˜Kš
œ˜Kš
œ)˜)Kš
œ"˜"Kš
œ˜—J˜—K˜š 	œžœ˜Kšœ
žœžœ
˜Kšœžœžœ˜:Kš
œ@˜@K˜"Kš
œG˜Gš
œ™Kš
œ#˜#—K˜%Kšœ)žœ
˜.Kšœ$žœžœžœ$˜ˆ
Kš
œ)˜)Kš
œ%˜%Kš
œ˜šžœ
žœ˜Kšœ	žœ˜)Kšœ	žœ^˜iKšœžœ%˜/Kš
œ˜Kš
œB˜Bšžœžœ
˜Kš
œM˜M—š
œ-˜-Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜—Kš
œ˜—Kš
œ-˜-Kšœ,žœ˜3Kš
œ?˜?Kš
œ2˜2Kš
œ,˜,Kšž
œ
˜—K˜š 	œžœžœ
žœžœ
žœ˜>Kšžœžœ=˜HKšžœ6˜:Kš
œ˜K˜%Kšœ)žœ
˜.Kšœžœ
˜$Kšžœ7žœžœ
žœ
˜PKšœ+žœ˜2Kš
œ=˜=Kš
œ1˜1šžœžœ˜Kšœžœ8˜BKš
œK˜KK˜—šžœžœžœ˜/Kš
œN˜NKš
œ˜—Kš
œ ˜ Kšœ4žœ˜9Kš
œ)˜)Kš
œ˜—K˜Kš
œ$˜$šžœžœ
žœ˜!Kš
œ'˜'Kšžœžœ
˜Kš
œ˜—Kš
œ1˜1Kš
œ˜Kš
œd˜dKš
œI˜IKš
œ1˜1KšœA‘˜VKš
œQ˜QKšœžœ˜,Kš
œ8˜8šžœž˜š
œ"˜"Kš
œ.˜.Kš
œ˜Kš
œ*˜*Kš
œ"˜"Kš
œ
˜
——šœžœ
žœ˜$Kš
œ˜Kš
œ+˜+Kš
œ&˜&Kšœ
žœ
˜Kš
œO˜OK˜—Kš
œR˜Ršžœ	žœžœ žœ˜FKšœžœžœ
˜Kš
œ˜—šžœ žœ˜)Kš
žœžœžœžœžœ˜AKš
œ1˜1šžœžœ˜K˜KKšžœžœžœžœžœžœ˜MKš
œ˜Kš
œ
˜
—šžœ
žœžœ˜-Kšžœžœžœžœžœžœ˜LKš
œ˜Kš
œ
˜
—šžœ‘˜šžœžœ˜Kš
œ
˜
Kšžœžœ
˜
Kš
œ˜—Kš
œ
˜
—Kš
œ
˜
—šžœ
‘	˜K˜:Kšžœžœ
žœžœ˜1Kš
œ˜Kš
œ˜—šžœž˜!Kš
œ˜Kš
œ˜Kšœžœžœ˜1Kšœ"žœžœ˜3Kšžœ(žœžœ˜?—Kšžœžœ˜Kšž
œ
˜—K˜K˜Kšžœ
˜—…—8(I4