DIRECTORY
CD,
CDBasics,
CDDrawQueue,
CDCells,
CDCommandOps,
CDExtras,
CDInstances,
CDMenus,
CDOps, 
CDPanel,
CDProperties,
CDSequencer,
CDValue,
CDViewer,
CDVPrivate,
CDVScale,
IO,
Rope,
TerminalIO,
ViewerClasses USING [Viewer],
ViewerOps USING [PaintViewer, GetViewer, SetViewer];

CDVCommands: CEDAR PROGRAM
IMPORTS CDBasics, CDDrawQueue, CDCells, CDCommandOps, CDExtras, CDInstances, CDMenus, CDOps, CDPanel, CDProperties, CDSequencer, CDValue, CDViewer, CDVScale, IO, TerminalIO, ViewerOps = 
BEGIN
VRef: TYPE = CDVPrivate.VRef;

RepaintViewer: PROC[vRef: VRef] = 
INLINE BEGIN
CDDrawQueue.Flush[vRef.ct];
CDDrawQueue.QueueInsertDrawCommand[vRef.ct, CDDrawQueue.Request[$changeScale, CDBasics.universe]];
END;

WriteLnScale: PROC [v: REF] =
BEGIN
WITH v SELECT FROM
viewer: ViewerClasses.Viewer => WriteLnScale[viewer.data];
me: VRef => TerminalIO.WriteF1[" (scale: %g)\n", IO.int[me.scale.nscale]];
ENDCASE => TerminalIO.WriteLn[];
END;

ChangeScale: PROC [me: VRef, newScale: INT] =
BEGIN
newScale _ MIN[MAX[0, newScale],  CDVScale.scaleNum-1];
IF me.scale.nscale = newScale THEN TerminalIO.WriteRope["No scale change"]
ELSE {
oldDesignCenterOffset, newDesignCenterOffset: CD.Position;
viewerCenterOffset: CD.Position _ [me.viewer.cw/2, me.viewer.ch/2];
off: CD.Position _ me.scale.off;
dscale: CDVScale.ScaleRec;
CDDrawQueue.Flush[me.ct];
TerminalIO.WriteRope["Change scale"];
dscale _ CDVScale.MakeScale[nscale: me.scale.nscale, grid: me.scale.grid];
oldDesignCenterOffset _ CDVScale.ViewerToDesignPosition[dscale, viewerCenterOffset];
dscale _ CDVScale.MakeScale[nscale: newScale, grid: me.scale.grid];
newDesignCenterOffset _ CDVScale.ViewerToDesignPosition[dscale, viewerCenterOffset];
off _ CDBasics.SubPoints[
CDBasics.AddPoints[off, oldDesignCenterOffset], 
newDesignCenterOffset
];
dscale _ CDVScale.MakeScale[off: off, nscale: newScale, grid: me.scale.grid];
me.intendedScale _ dscale;
RepaintViewer[me];
};
WriteLnScale[me.viewer];
END;

ScaleUp: PROC [comm: CDSequencer.Command] =
BEGIN
vRef: VRef = NARROW[comm.ref];
i: INT _ vRef.scale.nscale;
i _ IF i>0 THEN i-1 ELSE 0;
ChangeScale[vRef, i]; 
END;

ScaleDown: PROC [comm: CDSequencer.Command] =
BEGIN
vRef: VRef = NARROW[comm.ref];
ChangeScale[vRef, vRef.scale.nscale+1]; 
END;

MoveScreen: PROC [comm: CDSequencer.Command] =
BEGIN
vRef: VRef = NARROW[comm.ref];
off: CD.Position;
CDDrawQueue.Flush[vRef.ct];
TerminalIO.WriteRope["Move window\n"];
off.x _ vRef.scale.off.x-(comm.pos.x-comm.sPos.x);
off.y _ vRef.scale.off.y-(comm.pos.y-comm.sPos.y); 
vRef.intendedScale _ CDVScale.MakeScale[
off:  off,
nscale: vRef.scale.nscale,
grid: vRef.scale.grid
];
RepaintViewer[vRef];
END;

GetViewerInt: PROC [viewer: ViewerClasses.Viewer, at: ATOM] RETURNS [i: INT _ -1] = {
WITH ViewerOps.GetViewer[viewer, at] SELECT FROM
ri: REF INT => i _ ri^;
ENDCASE => NULL;
};

GridInfoComm: PROC [comm: CDSequencer.Command] =
BEGIN 
newGrid: INT _ -1;
lambda: INT _ comm.design.technology.lambda;
viewer: ViewerClasses.Viewer _ CDViewer.GetViewer[comm];
IF viewer#NIL THEN {
g: INT;
TerminalIO.WriteF1["input grid info (currently%g)\n", IO.rope[CDExtras.ToLambda[GetViewerInt[viewer, $Grid], lambda]]];
SELECT TerminalIO.RequestSelection[choice: LIST["1", " 2", " 4", " 8", "16", "32", "default", "type lambda", "type int"], label: "grid"] FROM
1 => g _ lambda; 
2 => g _ 2*lambda;
3 => g _ 4*lambda;
4 => g _ 8*lambda;
5 => g _ 16*lambda;
6 => g _ 32*lambda;
7 => g _ CDValue.FetchInt[boundTo: CDViewer.DesignOf[viewer], key: $CDxInitGrid, propagation: global];
8 => g _ MIN[INT[2600/lambda], TerminalIO.RequestInt["grid: "]]*lambda;
9 => g _ MIN[INT[2600], TerminalIO.RequestInt["grid: "]];
ENDCASE => g _ -1;
IF g>0 AND g<=2600 THEN { 
ViewerOps.SetViewer[viewer: viewer, data: NEW[INT_g], op: $Grid];
newGrid _ GetViewerInt[viewer, $Grid];
}
};
IF newGrid<=0 THEN TerminalIO.WriteRope["failed\n"] 
ELSE TerminalIO.WriteF1["   grid set to %g \n", IO.rope[CDExtras.ToLambda[newGrid, lambda]]]
END;


SetSimplificationComm: PROC[comm: CDSequencer.Command] =
BEGIN       
vRef: VRef = NARROW[comm.ref];
n: INT;
TerminalIO.WriteRope["input viewer simplification profile\n"];
CDDrawQueue.Flush[vRef.ct];
n _ TerminalIO.RequestSelection[
choice: LIST["very simplified", "simplified", "standard", "detailed", "very detailed", "all"],
label: "simplification treshold"
];
SELECT n FROM
1 => vRef.suppressFactorForCells _ 0.4;
2 => vRef.suppressFactorForCells _ 0.7; 
3 => vRef.suppressFactorForCells _ 1; 
4 => vRef.suppressFactorForCells _ 1.6;
5 => vRef.suppressFactorForCells _ 2.6;
6 => vRef.suppressFactorForCells _ 0;
ENDCASE => vRef.suppressFactorForCells _ 1;
RepaintViewer[vRef]
END;

TicksInfoComm: PROC[comm: CDSequencer.Command] =
BEGIN       
newTick: INT _ -2;
lambda: INT _ comm.design.technology.lambda;
viewer: ViewerClasses.Viewer _ CDViewer.GetViewer[comm];
IF viewer#NIL THEN {
n: INT;
ticks: INT _ GetViewerInt[viewer, $Ticks];
TerminalIO.WriteF1["input tick (currently%g)\n", IO.rope[CDExtras.ToLambda[ticks, lambda]]];
n _ TerminalIO.RequestSelection[choice: LIST["off", "  4", "  8", " 16", " 32", "type", "type int"], label: "Ticks"];
SELECT n FROM
1 => ticks _ 0;
2 => ticks _ 4*lambda; 
3 => ticks _ 8*lambda; 
4 => ticks _ 16*lambda;
5 => ticks _ 32*lambda;
6 => {
n: INT _ TerminalIO.RequestInt["Ticks: "];
IF n>=0 AND n<=LAST[INTEGER]/lambda-1 THEN ticks _ n*lambda
};
7 => {
n: INT _ TerminalIO.RequestInt["Ticks (int): "];
IF n>=0 AND n<=LAST[INTEGER]-1 THEN ticks _ n
};
ENDCASE => NULL;
ViewerOps.SetViewer[viewer: viewer, data: NEW[INT_ticks], op: $Ticks];
newTick _ GetViewerInt[viewer, $Ticks];
};
IF newTick<-1 THEN TerminalIO.WriteRope["   failed\n"] 
ELSE IF newTick<=0 THEN TerminalIO.WriteRope["   ticks off\n"]
ELSE TerminalIO.WriteF1["   ticks set to %g \n", IO.rope[CDExtras.ToLambda[newTick, lambda]]]
END;

InstanceNames: PROC [comm: CDSequencer.Command] =
BEGIN 
v: ViewerClasses.Viewer = CDViewer.GetViewer[comm];
TerminalIO.WriteRope["display instance names\n"]; 
IF v#NIL THEN ViewerOps.PaintViewer[v, client, FALSE, $DrawInstanceNames]
END;

SignalNames: PROC [comm: CDSequencer.Command] =
BEGIN 
v: ViewerClasses.Viewer = CDViewer.GetViewer[comm];
TerminalIO.WriteRope["display signal names\n"]; 
IF v#NIL THEN ViewerOps.PaintViewer[v, client, FALSE, $DrawSignalNames]
END;

GetOppositViewer: PROC[comm: CDSequencer.Command] RETURNS [ViewerClasses.Viewer] =
BEGIN
vl: CDViewer.ViewerList = CDViewer.ViewersOf[comm.design];
viewer: ViewerClasses.Viewer = CDViewer.GetViewer[comm];
onColor: BOOL = (viewer=NIL OR viewer.column=color);
FOR l: CDViewer.ViewerList _ vl, l.rest WHILE l#NIL DO
IF ~l.first.iconic THEN IF (l.first.column=color)#onColor THEN RETURN [l.first];
ENDLOOP;
FOR l: CDViewer.ViewerList _ vl, l.rest WHILE l#NIL DO
IF ~l.first.iconic THEN IF l.first.column#viewer.column THEN RETURN [l.first];
ENDLOOP;
FOR l: CDViewer.ViewerList _ vl, l.rest WHILE l#NIL DO
IF ~l.first.iconic THEN IF l.first#viewer THEN RETURN [l.first];
ENDLOOP;
RETURN [viewer];
END;

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

SmallScale: PROC [comm: CDSequencer.Command] RETURNS [BOOL] =
BEGIN
min: CD.Number = 30;
RETURN [min>ABS[comm.pos.x-comm.sPos.x] AND min>ABS[comm.pos.y-comm.sPos.y]]
END;

viewer: ViewerClasses.Viewer = GetOppositViewer[comm];
TerminalIO.WriteRope["Position a viewer\n"];
IF viewer#NIL THEN 
IF SmallScale[comm] THEN CDViewer.ShowPosition[viewer: viewer, pos: comm.sPos]
ELSE CDViewer.ShowAndScale[viewer: viewer, rect: CDBasics.ToRect[comm.pos, comm.sPos]];
END;

savedScale: CDVScale.ScaleRec _ CDVScale.MakeScale[];
secondarySave: CDVScale.ScaleRec _ CDVScale.MakeScale[];

RestoreViewComm: PROC [comm: CDSequencer.Command] =
BEGIN
scale: CDVScale.ScaleRec _ savedScale;
viewer: ViewerClasses.Viewer = CDViewer.GetViewer[comm];
TerminalIO.WriteRope["restore view\n"];
IF viewer#NIL THEN {
vRef: VRef = NARROW[viewer.data];
CDDrawQueue.Flush[vRef.ct];
IF vRef.scale.off=scale.off AND vRef.scale.nscale=scale.nscale THEN 
scale _ secondarySave;
secondarySave _ vRef.scale;
vRef.intendedScale _ CDVScale.MakeScale[off: scale.off, nscale: scale.nscale, grid: vRef.scale.grid];
RepaintViewer[vRef];
}
END;

SaveScale    : PROC [viewer: ViewerClasses.Viewer] =
BEGIN
vRef: VRef = NARROW[viewer.data];
savedScale _ vRef.scale
END;

ShowRect: PROC [comm: CDSequencer.Command] =
BEGIN
viewer: ViewerClasses.Viewer = CDViewer.GetViewer[comm];
TerminalIO.WriteRope["Scale viewer"];
SaveScale[viewer];
IF comm.pos=comm.sPos THEN CDViewer.ShowPosition[viewer: viewer, pos: comm.pos]
ELSE CDViewer.ShowAndScale[viewer: viewer, rect: CDBasics.ToRect[comm.pos, comm.sPos]];
WriteLnScale[viewer];
END;

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

ResetScale: PROC [viewer: ViewerClasses.Viewer] =
BEGIN
b: CD.Rect;
TerminalIO.WriteRope["reset scale (view all)"];
b _ CDExtras.BoundingBox[CDViewer.DesignOf[viewer]];
IF CDBasics.NonEmpty[b] THEN CDViewer.ShowAndScale[viewer: viewer, rect: b];
WriteLnScale[viewer];
END;

viewer: ViewerClasses.Viewer _ CDViewer.GetViewer[comm];
SaveScale[viewer];
ResetScale[viewer];
END;

ResetScaleToSelectedComm: PROC [comm: CDSequencer.Command] =
BEGIN
b: CD.Rect;
viewer: ViewerClasses.Viewer = CDViewer.GetViewer[comm];
TerminalIO.WriteRope["reset scale to selection"];
b _ CDInstances.BoundingRectO[list: CDOps.InstList[comm.design], selectedOnly: TRUE];
IF CDBasics.NonEmpty[b] THEN {
SaveScale[viewer];
CDViewer.ShowAndScale[viewer: viewer, rect: b];
WriteLnScale[viewer];
}
ELSE TerminalIO.WriteRope["  no selection\n"];
END;

ResetScaleToPushedComm: PROC [comm: CDSequencer.Command] =
BEGIN
b: CD.Rect;
viewer: ViewerClasses.Viewer = CDViewer.GetViewer[comm];
SaveScale[viewer];
TerminalIO.WriteRope["reset scale (to view all of pushed cell)"];
b _ CDInstances.BoundingRectO[list: CDOps.InstList[comm.design], selectedOnly: FALSE];
IF CDBasics.NonEmpty[b] THEN CDViewer.ShowAndScale[viewer: viewer, rect: b];
WriteLnScale[viewer];
END;

DrawModeComm: PROC [comm: CDSequencer.Command] =
BEGIN
vRef: VRef = NARROW[comm.ref];
n: INT;
TerminalIO.WriteRope["input drawing modes\n"];
n _ TerminalIO.RequestSelection[
choice: LIST["draw environment", "dont draw env.", "draw symbolic ob", "dont draw sym.", "draw borders", "dont draw borders"],
label: "drawing modes"
];
SELECT n FROM
1 => {
vRef.environment _ TRUE;
CDProperties.PutProp[comm.design, $CDxDrawEnvironment, NIL]
};
2 => {
vRef.environment _ FALSE;
CDProperties.PutProp[comm.design, $CDxDrawEnvironment, $FALSE]
};
3 => {
vRef.symbolics _ TRUE; 
CDProperties.PutProp[comm.design, $CDxDrawSymbolics, NIL]
};
4 => {
vRef.symbolics _ FALSE;
CDProperties.PutProp[comm.design, $CDxDrawSymbolics, $FALSE]
};
5 => {
vRef.b4 _ FALSE;
CDProperties.PutProp[comm.design, $CDxSkipBorder, $FALSE]
};
6 => {
vRef.b4 _ TRUE;
CDProperties.PutProp[comm.design, $CDxSkipBorder, NIL]
};
ENDCASE => TerminalIO.WriteRope["skipped\n"];
IF n#0 THEN RepaintViewer[vRef]
END;


ShowViewers: PROC [comm: CDSequencer.Command] =
BEGIN
vRef: VRef = NARROW[comm.ref];
TerminalIO.WriteRope["show viewers\n"];
CDDrawQueue.QueueInsertDrawCommand[vRef.ct, CDDrawQueue.Request[$ShowViewers,  CDBasics.universe]]
END;

SplitViewer: PROC [comm: CDSequencer.Command] =
BEGIN
TerminalIO.WriteRope["split viewer\n"];
[] _ CDViewer.CreateViewer[comm.design]
END;

SetCellSimplification: PROC [comm: CDSequencer.Command] =
BEGIN
scale: CDVScale.ScaleRec _ NARROW[comm.ref, VRef].scale;
TerminalIO.WriteRope["make selected cells barely visible\n"]; 
FOR l: CD.InstanceList _ CDOps.InstList[comm.design], l.rest WHILE l#NIL DO
IF l.first.selected AND CDCells.IsCell[l.first.ob] THEN {
cptr: CD.CellPtr ~ NARROW[l.first.ob.specificRef];
simplifyOn: CD.Number _ CDVScale.DesignToViewerScalar[scale, l.first.ob.size.y];
cptr.simplifyOn _ simplifyOn;
CDCommandOps.RedrawInstance[comm.design, l.first];
};
ENDLOOP;
END;


CDPanel.DefineButton[tech: NIL, name: " new view ", proc: SplitViewer, queue: dontQueue, topLine: TRUE];
CDSequencer.ImplementCommand[$ScaleLessDetail, ScaleDown,, dontQueue];
CDSequencer.ImplementCommand[$ScaleMoreDetail, ScaleUp,, dontQueue];
CDSequencer.ImplementCommand[$MoveScreen, MoveScreen,, dontQueue];
CDSequencer.ImplementCommand[$DisplayNames, SignalNames,, doQueue];
CDSequencer.ImplementCommand[$DisplayInstanceNames, InstanceNames,, doQueue];
CDSequencer.ImplementCommand[$ShowRectX, ShowRectX,, dontQueue];
CDSequencer.ImplementCommand[$ShowRect, ShowRect,, dontQueue];
CDSequencer.ImplementCommand[$ResetScaleAll, ResetScaleComm,, dontQueue];
CDSequencer.ImplementCommand[$ResetScaleTop, ResetScaleToPushedComm,, dontQueue];
CDSequencer.ImplementCommand[$ResetScaleSel, ResetScaleToSelectedComm,, dontQueue];
CDSequencer.ImplementCommand[$DisplayViewers, ShowViewers,, doQueue];
CDSequencer.ImplementCommand[$SplitViewer, SplitViewer,, dontQueue];
CDSequencer.ImplementCommand[$GridInfo, GridInfoComm,, dontQueue];
CDSequencer.ImplementCommand[$TicksInfo, TicksInfoComm,, doQueue];
CDSequencer.ImplementCommand[$DrawMode, DrawModeComm,, doQueue];
CDSequencer.ImplementCommand[$SetSimplification, SetSimplificationComm,, dontQueue];
CDSequencer.ImplementCommand[$RestoreView, RestoreViewComm,, dontQueue];
CDSequencer.ImplementCommand[$SetCellSimplification, SetCellSimplification];
CDMenus.CreateEntry[$CellMenu, "visibility #", $CellSimplification];
CDMenus.CreateEntry[$CellMenu, "set visible", $SetCellSimplification];
END.


®CDVCommands.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, February 19, 1986 7:46:00 pm PST
--gets viewer on different screen if possible,
--else different viewer, if possible...
--SaveScale[viewer]; NO you don't want that, its better to have one fixed point
6 => vRef.b2 _ TRUE;
7 => vRef.b2 _ FALSE;
�Ê;
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˜K˜Kšœžœ
˜Kšœ
žœ%˜4—K˜šÐblœžœ
ž˜Kšžœ—
žœ˜º
—Kš
ž˜Kšœžœ˜K˜šÏn
œžœ˜"Kšžœ
ž˜Kš
œ˜Kš
œb˜bKšžœ
˜K˜—š œžœžœ˜Kš
ž˜šžœžœ
ž˜Kš
œ:˜:Kšœ1žœ˜JKšžœ˜ —Kšžœ
˜—K˜š œžœžœ˜-Kš
ž˜Kšœžœ
žœ%˜7Kšžœžœ(˜Jšžœ˜Kšœ.žœ
˜:Kšœžœ-˜CKšœžœ˜ Kš
œ˜Kš
œ˜K˜%Kš
œJ˜JKš
œT˜TKš
œC˜CKš
œT˜Tš
œ˜Kš
œ0˜0Kš
œ˜Kš
œ˜—Kš
œM˜MKš
œ˜Kš
œ˜Kš
œ˜—Kš
œ˜Kšžœ
˜K˜—š œžœ˜+Kš
ž˜Kšœ
žœ˜Kšœžœ˜Kšœžœžœžœ˜K˜Kšžœ
˜K˜—š 	œžœ˜-Kš
ž˜Kšœ
žœ˜Kš
œ(˜(Kšžœ
˜K˜—š 
œžœ˜.Kš
ž˜Kšœ
žœ˜K˜Kš
œ˜K˜&K˜2K˜3š
œ(˜(Kš
œ
˜
Kš
œ˜Kš
œ˜Kš
œ˜—Kš
œ˜Kšžœ
˜K˜—š
 œžœ$žœžœžœ
˜Ušžœ!žœ
ž˜0Jšœžœ
žœ˜Jšžœžœ
˜—K˜K˜—š œžœ˜0Kšžœ
˜Kšœ	žœ˜Kšœžœ!˜,Kš
œ8˜8šžœžœ
žœ˜Kšœžœ
˜Kšœ6žœ?˜wšžœ%žœZž˜�
K˜K˜K˜K˜K˜K˜Kš
œf˜fKšœ	žœ
žœ7˜GKšœ	žœ
žœ)˜9Kšžœ˜—šžœžœ	žœ˜Kšœ*žœ
žœ˜AKš
œ&˜&K˜
—K˜—Kšžœžœ"˜4Kšžœ,žœ*˜\Kšžœ
˜K˜K˜—š œžœ˜8Kšžœ˜Kšœ
žœ˜Kšœž˜Kš
œ>˜>Kš
œ˜š
œ ˜ KšœžœR˜^K˜ K˜—šžœž˜
Kš
œ'˜'Kš
œ(˜(Kš
œ&˜&Kš
œ'˜'Kš
œ'˜'Kš
œ%˜%Kšžœ$˜+—Kš
œ˜Kšžœ
˜K˜—š 
œžœ˜0Kšžœ˜Kšœ	žœ˜Kšœžœ!˜,Kš
œ8˜8šžœžœ
žœ˜Kšœžœ
˜Kšœžœ ˜*Kšœ1žœ)˜\Kšœ(žœI˜ušžœž˜
K˜K˜K˜K˜K˜š
œ˜Kšœžœ$˜*Kš
žœžœžœ
žœžœ˜;Kš
œ˜—š
œ˜Kšœžœ*˜0Kš
žœžœžœ
žœžœ
˜-Kš
œ˜—Kšžœžœ
˜—Kšœ*žœ
žœ˜FKš
œ'˜'K˜—Kšžœžœ%˜7Kšžœ
žœžœ'˜>Kšžœ-žœ*˜]Kšžœ
˜K˜—š 
œžœ˜1Kšžœ
˜Kš
œ3˜3Kš
œ2˜2Kšžœžœ
žœ"žœ˜IKšžœ
˜K˜—š œžœ˜/Kšžœ
˜Kš
œ3˜3Kš
œ0˜0Kšžœžœ
žœ"žœ˜GKšžœ
˜K˜—š œžœžœ˜RKš
œ.™.Kš
œ'™'Kš
ž˜Kš
œ:˜:Kš
œ8˜8Kšœ	žœžœ
žœ˜4šžœ%žœžœ
ž˜6Kš
žœžœ
žœ žœ
žœ˜PKšžœ
˜—šžœ%žœžœ
ž˜6Kš
žœžœ
žœžœ
žœ˜NKšžœ
˜—šžœ%žœžœ
ž˜6Kš
žœžœ
žœžœ
žœ˜@Kšžœ
˜—Kšžœ
˜Kšžœ
˜K˜—šÐbn	œžœ˜-Kš
ž˜K˜š 
œžœžœžœ˜=Kš
ž˜Kšœžœ
˜Kšžœžœžœžœ˜LKšžœ
˜—K˜Kš
œ6˜6Kš
œ,˜,šžœžœ
žœ
˜Kšžœžœ6˜NKšžœS˜W—Kšžœ
˜—K˜Kš
œ5˜5Kš
œ8˜8K˜š œžœ˜3Kš
ž˜Kš
œ&˜&Kš
œ8˜8Kš
œ'˜'šžœžœ
žœ˜Kšœ
žœ˜!Kš
œ˜Kš
œO™Ošžœžœ žœ
˜DKš
œ˜—Kš
œ˜Kš
œe˜eKš
œ˜K˜
—Kšžœ
˜—K˜š 
œžœ!˜4Kš
ž˜Kšœ
žœ˜!Kš
œ˜Kšžœ
˜—K˜š œžœ˜,Kš
ž˜Kš
œ8˜8Kš
œ%˜%Kš
œ˜Kšžœžœ5˜OKšžœS˜WKš
œ˜Kšžœ
˜—K˜š¡œžœ˜2Kš
ž˜K˜š¡
œžœ!˜1Kš
ž˜Kšœžœ˜Kš
œ/˜/Kš
œ4˜4Kšžœžœ0˜LKš
œ˜Kšžœ
˜K˜—Kš
œ8˜8Kš
œ˜Kš
œ˜Kšžœ
˜—K˜š¡œžœ˜<Kš
ž˜Kšœžœ˜Kš
œ8˜8Kš
œ1˜1KšœOžœ˜Ušžœžœ˜Kš
œ˜Kš
œ/˜/Kš
œ˜K˜
—Kšžœ*˜.Kšžœ
˜—K˜š¡œžœ˜:Kš
ž˜Kšœžœ˜Kš
œ8˜8Kš
œ˜Kš
œA˜AKšœOžœ˜VKšžœžœ0˜LKš
œ˜Kšžœ
˜—K˜š œžœ˜0Kš
ž˜Kšœ
žœ˜Kšœžœ
˜Kš
œ.˜.š
œ ˜ Kšœžœr˜~Kš
œ˜K˜—šžœž˜
š
œ˜Kšœžœ
˜Kšœ7žœ
˜;K˜—š
œ˜Kšœžœ
˜Kš
œ>˜>K˜—š
œ˜Kšœžœ˜Kšœ5žœ
˜9Kš
œ˜—š
œ˜Kšœžœ
˜Kš
œ<˜<K˜—š
œ˜Kšœ
žœ
˜Kš
œ9˜9K˜—š
œ˜Kšœ
žœ
˜Kšœ2žœ
˜6K˜—Kšœžœ
™Kšœžœ
™Kšžœ&˜-—Kšžœžœ˜Kšžœ
˜—K˜K˜š¡œžœ˜/Kš
ž˜Kšœ
žœ˜Kš
œ'˜'Kš
œb˜bKšžœ
˜—K˜š¡œžœ˜/Kš
ž˜Kš
œ'˜'K˜'Kšžœ
˜—K˜š œžœ˜9Kš
ž˜Kšœžœ˜8K˜>š	žœžœ4žœžœ
ž˜Kšžœžœžœ˜9Kšœžœžœ˜2KšœžœB˜PKš
œ˜Kš
œ2˜2Kš
œ˜—Kšžœ
˜—Kšžœ
˜K˜—K˜KšœžœDžœ˜hKš
œF˜FKš
œD˜DKš
œB˜BKš
œC˜CKš
œM˜MKš
œ@˜@Kš
œ>˜>Kš
œI˜IKš
œQ˜QKš
œS˜SKš
œE˜EKš
œD˜DKš
œB˜BKš
œB˜BKš
œ@˜@Kš
œT˜TKš
œH˜HKš
œL˜LKš
œD˜DKš
œF˜FKšžœ
˜K˜—…—4(D