DIRECTORY Buttons, CedarProcess, CtBasic, Commander, CommanderOps, Controls, Convert, Draw2d, FileNames, FS, G3dBasic, G3dControl, G3dMatrix, G3dTool, Icons, Imager, ImagerBackdoor, ImagerFont, ImplicitSlice, MessageWindow, Real, Rope, SF, TEditSelection, TiogaMenuOps, VFonts, ViewerClasses, ViewerOps, ViewerTools;

ImplicitSliceImpl: CEDAR PROGRAM

IMPORTS Buttons, CedarProcess, CtBasic, Commander, CommanderOps, Controls, Convert, Draw2d, FileNames, FS, G3dControl, G3dMatrix, G3dTool, Icons, Imager, ImagerBackdoor, ImagerFont, MessageWindow, Real, Rope, TEditSelection, TiogaMenuOps, VFonts, ViewerOps, ViewerTools
EXPORTS ImplicitSlice

~ BEGIN
CommandProc:		TYPE ~ Commander.CommandProc;
ButtonList: 			TYPE ~ Controls.ButtonList;
ClickProc: 			TYPE ~ Controls.ClickProc;
Control: 				TYPE ~ Controls.Control;
ControlList: 			TYPE ~ Controls.ControlList;
SampleMap:			TYPE ~ CtBasic.SampleMap;
SampleMaps:			TYPE ~ CtBasic.SampleMaps;
DrawProc: 			TYPE ~ Draw2d.DrawProc;
Pair: 					TYPE ~ G3dBasic.Pair;
Triple: 				TYPE ~ G3dBasic.Triple;
Slice:					TYPE ~ G3dControl.Slice;
Context:				TYPE ~ Imager.Context;
Function:				TYPE ~ ImplicitSlice.Function;
Pix:					TYPE ~ ImplicitSlice.Pix;
PixRep:				TYPE ~ ImplicitSlice.PixRep;
PixSequence:			TYPE ~ ImplicitSlice.PixSequence;
Tool:					TYPE ~ ImplicitSlice.Tool;
ToolRep:				TYPE ~ ImplicitSlice.ToolRep;
ROPE: 				TYPE ~ Rope.ROPE;
Viewer: 				TYPE ~ ViewerClasses.Viewer;
icon: Icons.IconFlavor _ Icons.NewIconFromFile["ImplicitSurfaces.icon", 0];

MakeTool: PUBLIC PROC [
toolName: ROPE,
functions: LIST OF Function _ NIL,
clientDraw: DrawProc _ NIL,
clientData: REF ANY _ NIL,
extraControls: ControlList _ NIL,
extraButtons: ButtonList _ NIL]
RETURNS [t: Tool]
~ {
t _ NEW[ToolRep];
t.clientDraw _ clientDraw;
t.clientData _ clientData;
t.slice _ G3dControl.InitSlice[proc: SliceControl, data: t];
t.slice.phi.value _ 90.0;
FOR b: ButtonList _ extraButtons, b.rest WHILE b # NIL DO b.first.row _ 1; ENDLOOP;
extraButtons _ CONS[Controls.ClickButton["Help", Help, t, 0], extraButtons];
extraButtons _ CONS[Controls.ClickButton["IP Out", IPOut, t, 0], extraButtons];
extraButtons _ CONS[Controls.ClickButton["Display-Ops", DisplayOps, t, 0], extraButtons];
extraButtons _ CONS[Controls.TextButton["MoveSlice: ","-.03", CheckValue, t, 0], extraButtons];
extraButtons _ CONS[Controls.TextButton["H: ", "80 ", CheckValue, t, 0], extraButtons];
extraButtons _ CONS[Controls.TextButton["W: ", "80 ", CheckValue, t, 0], extraButtons];
extraButtons _ CONS[Controls.ClickButton["Name", NamePix, t, 0], extraButtons];
extraButtons _ CONS[Controls.ClickButton["STOP", Stop, t, 0], extraButtons];
extraButtons _ CONS[Controls.ClickButton["StartAndMove", StartAndMove, t, 0], extraButtons];
extraButtons _ CONS[Controls.ClickButton["Start", Start, t, 0], extraButtons];
extraButtons _ CONS[Controls.ClickButton["Mode: Slice", ToggleMode, t, 0], extraButtons];
extraControls _ CONS[t.slice.size, extraControls];
extraControls _ CONS[t.slice.theta, extraControls];
extraControls _ CONS[t.slice.phi, extraControls];
extraControls _ CONS[t.slice.z, extraControls];
extraControls _ CONS[t.slice.y, extraControls];
extraControls _ CONS[t.slice.x, extraControls];
FOR f: LIST OF Function _ functions, f.rest WHILE f # NIL DO AddPix[t, f.first]; ENDLOOP;
t.renderTool _ G3dTool.MakeTool[
name: toolName,
ops: [TRUE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE, FALSE],
extraButtons: extraButtons,
extraControls: extraControls,
controlSizes: [15, 200, 60, 20, 60, 150, 150],
arcBallSize: 80,
nViews: 3,
client: [mouse: Mouse3d, destroy: Destroy, draw: Draw, data: t],
noOpen: TRUE];
t.viewer2d _ Controls.OuterViewer[mouse: Mouse2d, clientData: t, destroy: Destroy];
t.renderTool.outer.icon _ icon;
t.typescript _ t.renderTool.typescript;
t.valueViewer _ ViewerOps.CreateViewer[
flavor: $ValueViewer, paint: FALSE, info: [data: t, scrollable: FALSE, wx: 510, wy: 16, ww: 80, wh: 80, border: FALSE, parent: t.renderTool.outer]];
ViewerOps.AddProp[t.valueViewer, $CreatedInOuterViewer, $True];
ViewerOps.OpenIcon[t.renderTool.outer];
};

Destroy: Controls.DestroyProc ~ {NARROW[clientData, Tool].stop _ TRUE};
SliceControl: Controls.ControlProc ~ {
t: Tool _ NARROW[control.clientData];
t.pixPicked _ NIL;
G3dControl.UpdateSlice[t.slice];
IF control.whatChanged = $TypedIn OR control.mouse.button = right THEN Repaint[t, $Slice];
};

Mouse3d: Controls.MouseProc ~ {
t: Tool _ NARROW[clientData];
IF mouse.controlKey THEN {
x: G3dMatrix.Matrix _ G3dTool.GetView[viewer, t.renderTool].camera.matrix;
t.pixPicked _ t.pixes[0];
t.point _ SELECT t.mode FROM
slice => G3dMatrix.TripleFromScreenAndPlane[[mouse.pos.x, mouse.pos.y], t.slice.plane, x],
ENDCASE => t.renderTool.sprite;
IF t.pixPicked # NIL AND t.pixPicked.valueProc # NIL THEN {
t.value _ t.pixPicked.valueProc[t.point, t.clientData];
ViewerOps.PaintViewer[t.valueViewer, client, FALSE];
};
};
};

Mouse2d: Controls.MouseProc ~ {
t: Tool ~ NARROW[clientData];
IF mouse.state = up AND mouse.pos.y <= t.ySize THEN
FOR n: NAT IN [0..t.pixes.length) DO
t.pixPicked _ t.pixes[n];
IF mouse.pos.x IN [t.pixPicked.box.min.f..t.pixPicked.box.max.f] THEN {
t.point _ GetPixPoint[t, t.pixPicked, mouse.pos.x, mouse.pos.y];
Repaint[t, $PixPicked];
EXIT;
};
ENDLOOP;
};
Repaint: PUBLIC PROC [tool: Tool, whatChanged: REF ANY _ NIL] ~ {
G3dTool.Repaint[tool.renderTool, whatChanged];
};

PaintValueViewer: ViewerClasses.PaintProc ~ {
Action: PROC ~ {
IF whatChanged = NIL THEN Draw2d.Circle[context, [size, size], size];
Draw2d.Circle[context, [size, size], radius, t.value > 0.0];
};
t: Tool _ NARROW[self.data];
size: INTEGER _ self.ww/2;
radius: REAL _ ABS[t.value]*self.ww;
Draw2d.DoWithBuffer[context, Action];
};

Draw: DrawProc ~ {
t: Tool ~ NARROW[data];
DiagramPix: PROC [pix: Pix] ~ {
IF v.index = 0 AND pix # NIL AND pix.diagramProc # NIL
THEN pix.diagramProc[context, t.point, t.clientData, whatChanged, viewer];
};
DrawSlice: PROC ~ {
IF t.mode = slice AND t.showSlice
THEN G3dControl.DrawSlice[context, t.slice, v.camera.matrix, vp];
};
v: G3dTool.View _ G3dTool.GetView[viewer, t.renderTool];
vp: G3dMatrix.Viewport _ G3dView.GetViewport[viewer];
SELECT whatChanged FROM
$Clear => Draw2d.Clear[context];
$Slice => G3dTool.Restore[context, v];
$FinishingTouches => {DiagramPix[t.pixPicked]; DrawSlice[]};
ENDCASE =>
IF t.clientDraw # NIL THEN t.clientDraw[context, t.clientData, whatChanged, viewer];
IF t.cdContext # NIL THEN context _ t.cdContext;
};
DisplayOps: ClickProc ~ {
t: Tool _ NARROW[clientData];
SELECT Controls.PopUpRequest[["Display Options"], LIST[
Controls.BoolRequest[t.showSlice, "Show Slice"]]] FROM
1 => t.showSlice _ NOT t.showSlice;
ENDCASE => RETURN;
IF Controls.GetPopUpButton[] = right THEN Repaint[t];
};

ToggleMode: ClickProc ~ {
t: Tool _ NARROW[clientData];
IF t.mode = slice
THEN {t.mode _ sprite; Buttons.ReLabel[parent, "Mode: Sprite"]}
ELSE {t.mode _ slice; Buttons.ReLabel[parent, "Mode: Slice"]};
t.renderTool.drawSprite _ t.mode = sprite;
Repaint[t];
};

doc: ROPE _ FileNames.StripVersionNumber[FS.FileInfo["ImplicitSurfacesDoc.tioga"].fullFName];

Help: ClickProc ~ {
v: Viewer _ TiogaMenuOps.Open[doc,, right];
TEditSelection.FindRope[v, "ImplicitSlice Buttons and Controls"];
};

IPOut: ClickProc ~ {
t: Tool _ NARROW[clientData];
Draw2d.IPOut[Controls.TypescriptReadFileName[t.typescript], Draw, t];
};

NamePix: ClickProc ~ {SetUpPix[NARROW[clientData], 0.5, FALSE, TRUE]};

SetParameters: PROC [t: Tool] ~ {
FOR b: LIST OF Controls.Button _ t.renderTool.buttons, b.rest WHILE b # NIL DO
E: PROC [r: ROPE] RETURNS [BOOL] ~ {RETURN[Rope.Equal[b.first.name, r, FALSE]]};
N: PROC [o: REAL] RETURNS [i: REAL] ~ {
r: ROPE _ ViewerTools.GetContents[b.first.textViewer];
i _ Convert.RealFromRope[r ! Convert.Error => {Blink["Bad value"]; i _ o; CONTINUE}];
};
SELECT TRUE FROM
E["MoveSlice: "]	=> t.moveSlice _ N[t.moveSlice];
E["W: "]		=> t.xSize _ Real.Round[N[t.xSize]];
E["H: "]		=> t.ySize _ Real.Round[N[t.ySize]];
ENDCASE;
ENDLOOP;
ResizePixes[t];
};

CheckValue: ClickProc ~ {
button: Controls.Button _ NARROW[ViewerOps.FetchProp[parent, $ButtonText]];
IF button # NIL THEN {
r: ROPE _ ViewerTools.GetContents[button.textViewer];
[] _ Convert.RealFromRope[r ! Convert.Error => {Blink["Bad value"]; CONTINUE}];
};
};
Stop: ClickProc ~ {
t: Tool _ NARROW[clientData];
t.stop _ TRUE;
Controls.TypescriptWrite[t.typescript, " . . . aborted.\n"];
};

Start: ClickProc ~ {StartShade[NARROW[clientData], Shade]};
StartAndMove: ClickProc ~ {StartShade[NARROW[clientData], ShadeAndMoveSlice]};

StartShade: PROC [t: Tool, proc: CedarProcess.ForkableProc] ~ {
t.stop _ FALSE;
SetParameters[t];
[] _ CedarProcess.Fork[proc, t, [background, TRUE]];
t.stop _ FALSE;
};

Shade: CedarProcess.ForkableProc ~ {
t: Tool _ NARROW[data];
SetUpPix[t, 0.0, TRUE, TRUE];
FOR y: NAT IN [1..t.ySize-1) DO
FOR x: NAT IN [1..t.xSize-1) DO
t.point _ GetPixPoint[t, t.pixes[0], x, y];
FOR n: NAT IN [0..t.pixes.length) DO
pix: Pix _ t.pixes[n];
value: REAL _ pix.valueProc[t.point, t.clientData];
pVal: CARDINAL _ Real.Round[MIN[255.0, MAX[0., 255.0*value]]];
xx: NAT _ x+pix.box.min.f;
yy: NAT _ y+pix.box.min.s;
IF t.stop THEN RETURN;
SELECT pix.maps.bpp FROM
8 => CtBasic.PutBWPixel[pix.maps[0].map, xx, yy, pVal];
24 => CtBasic.PutRGBPixel[pix.maps, xx, yy, [pVal, pVal, pVal]];
ENDCASE;
ENDLOOP;
ENDLOOP;
ENDLOOP;
};

ShadeAndMoveSlice: CedarProcess.ForkableProc ~ {
t: Tool _ NARROW[data];
box: SF.Box _ t.cdMaps.box;
FOR y: NAT _ box.min.s, y+t.ySize WHILE y < box.max.s DO
FOR x: NAT _ box.min.f, x+t.xSize WHILE x < box.max.f DO
FOR n: NAT IN [0..t.pixes.length) DO
IF t.stop THEN RETURN;
t.pixes[n].maps _ CtBasic.CopyOfMaps[t.cdMaps, x, y, t.xSize, t.ySize];
ENDLOOP;
[] _ Shade[t];
G3dControl.MoveSliceInZ[t.slice, t.moveSlice];
Repaint[t];
ENDLOOP;
ENDLOOP;
};

ImagerShade: CedarProcess.ForkableProc ~ {
t: Tool _ NARROW[data];
t.cdContext _ CtBasic.InitCd[gray];
Repaint[t, $Clear];
[] _ Shade[t];
t.cdContext _ CtBasic.InitCd[smooth];
Repaint[t];
t.cdContext _ NIL;
};
AddPix: PROC [t: Tool, f: Function] ~ {
xStart: NAT _ IF t.pixes # NIL THEN t.xSize*t.pixes.length ELSE 0;
pix: Pix _ NEW[PixRep];
new: REF PixSequence _ NEW[PixSequence[IF t.pixes # NIL THEN t.pixes.length+1 ELSE 1]];
FOR n: NAT IN [0..new.length-1) DO new[n] _ t.pixes[n]; ENDLOOP;
t.pixes _ new;
pix.name _ f.name;
pix.diagramProc _ f.diagramProc;
pix.valueProc _ f.valueProc;
SetPixSize[pix, xStart, 0, t.xSize, t.ySize, t.cdMaps];
t.pixes[t.pixes.length-1] _ pix;
};

SetPixSize: PROC [pix: Pix, x, y, w, h: NAT, cd: SampleMaps] ~ {
pix.maps _ CtBasic.CopyOfMaps[cd, x, y, w, h];
pix.box _ pix.maps.box;
pix.context _ CtBasic.InitCd[smooth, TRUE, FALSE, FALSE];
CtBasic.TransformContextToMap[
pix.context, SELECT pix.maps.bpp FROM 8 => pix.maps[0].map ENDCASE => pix.maps[1].map];
pix.start _ ImagerFont.RopeEscapement[ImagerBackdoor.GetFont[pix.context], pix.name];
pix.start _ [-0.5*pix.start.x, -0.9];
};

ResizePixes: PROC [t: Tool] ~ {
IF t.pixes # NIL THEN FOR n: NAT IN [0..t.pixes.length) DO
SetPixSize[t.pixes[n], n*t.xSize, 0, t.xSize, t.ySize, t.cdMaps];
ENDLOOP;
};

GetPixPoint: PROC [t: Tool, pix: Pix, x, y: NAT] RETURNS [Triple] ~ {
map: SampleMap _ IF pix.maps.bpp = 8 THEN pix.maps[0].map ELSE pix.maps[1].map;
realPair: CtBasic.RealPair _ CtBasic.PairFromMapCoords[x, y, map];
RETURN[G3dMatrix.TransformPair[[realPair.x, realPair.y], t.slice.matrix]];
};

SetUpPix: PROC [t: Tool, gray: REAL, clear, name: BOOL] ~ {
FOR n: NAT IN [0..t.pixes.length) DO
pix: Pix _ t.pixes[n];
Imager.SetGray[pix.context, gray];
Imager.SetStrokeWidth[pix.context, 0.02];
IF clear THEN CtBasic.FillMaps[pix.maps, 100, 100, 100, 100];
IF name THEN Draw2d.Label[pix.context, pix.start, pix.name];
ENDLOOP;
};
Blink: PROC [rope: ROPE] ~ {
MessageWindow.Append[rope, TRUE];
MessageWindow.Blink[];
};

PixelValueFromValue: PROC [value: REAL] RETURNS [CARDINAL] ~ {
RETURN[Real.Round[MIN[255.0, MAX[0.0, 255.0*value]]]];
};

Registration:	TYPE ~ RECORD [
name:					ROPE,								-- name of option
command:			CommandProc,					-- proc to be called
doc:					ROPE								-- documentation of option
];

registry:		LIST OF Registration _ NIL;
font:			VFonts.Font ~ VFonts.EstablishFont["Tioga", 10];
tabWidth:		INT _ 2*VFonts.StringWidth["\t"];		-- VFonts says 12; but should be 24
toolOptions:	ROPE _ NIL;
toolUsage:		ROPE _ "ImplicitSlice <option | ?>";

Register: PUBLIC PROC [name: ROPE, command: CommandProc, doc: ROPE] ~ {
colonTabs: ROPE _ ":";
nTabs: INT _ 2+MAX[84-VFonts.StringWidth[Rope.Cat[name, ":"]], 0]/tabWidth;
FOR n: INT IN [1..nTabs] DO colonTabs _ Rope.Concat[colonTabs, "\t"]; ENDLOOP;
FOR l: LIST OF Registration _ registry, l.rest WHILE l # NIL DO
IF NOT Rope.Equal[l.first.name, name, FALSE] THEN LOOP;
l.first _ [name, command, doc];
RETURN;
ENDLOOP;
registry _ CONS[[name, command, doc], registry];
toolOptions _ Rope.Cat[toolOptions, "\n\t", name, colonTabs, doc];
};

ToolOptions: PUBLIC PROC RETURNS [ROPE] ~ {RETURN[toolOptions]};

ExecuteOption: PUBLIC CommandProc ~ {
argv: CommanderOps.ArgumentVector _ CommanderOps.Parse[cmd];
IF argv.argc > 1 THEN SELECT TRUE FROM
Rope.Equal[argv[1], "reset", FALSE] => {
registry _ NIL;
toolOptions _ NIL;
};
ENDCASE => {
FOR l: LIST OF Registration _ registry, l.rest WHILE l # NIL DO
IF Rope.Equal[l.first.name, argv[1], FALSE] THEN {
[result, msg] _ l.first.command[cmd];
RETURN;
};
ENDLOOP;
RETURN[$Failure, "No such option."];
};
};

ImplicitSliceCmd: CommandProc ~ {
argv: CommanderOps.ArgumentVector _ CommanderOps.Parse[cmd];
IF argv.argc < 2 THEN RETURN[$Failure, toolUsage];
SELECT TRUE FROM
Rope.Equal[argv[1], "?"] =>
RETURN[$Failure, Rope.Cat["ImplicitSlice <option>, options include:\n", toolOptions]];
ENDCASE => [result, msg] _ ExecuteOption[cmd];
};
ViewerOps.RegisterViewerClass[
$ValueViewer, NEW[ViewerClasses.ViewerClassRec _ [paint: PaintValueViewer]]];

Commander.Register["ImplicitSlice", ImplicitSliceCmd, toolUsage];

END.
Z
ImplicitSliceImpl.mesa
Copyright Σ 1985, 1990 by Xerox Corporation.  All rights reserved.
Bloomenthal, August 10, 1992 5:30 pm PDT
Types
Implicit Slice Tool Creation
User Interaction
Display
Parameters and Options
Shading
Pix Procs
Support Procs
ViewerCoordsFromPair: PROC [p: Pair, viewer: Viewer] RETURNS [Pair] ~ {
RETURN[[viewer.cx+0.5*viewer.cw*(s.x+1.0), viewer.cy+0.5*viewer.ch*(s.y+1.0)]];
};

PairFromViewerCoords: PROC [pos: Pos, viewer: Viewer] RETURNS [Pair] ~ {
RETURN[[REAL[pos.x+pos.x]/viewer.cw-1.0, REAL[pos.y+pos.y]/viewer.ch-1.0]];
};
Registration and Dispatching
Start Code
Κ—•NewlineDelimiter

™™Jš
œB™BJ™(J˜JšΟk	œ³˜ΌJ˜—šΠblœœ
˜ J˜Jšœ†˜Jšœ˜J˜—Jšœ˜
headš
Οl™Jšœ
œ˜+Jšœœ˜*Jšœ
œ˜(Jšœœ˜%Jšœœ˜,Jšœœ˜&Jšœ
œ˜(Jšœœ˜$Jšœ	œ˜ Jšœœ˜#Jšœ
œ˜#Jšœœ˜"Jšœ
œ˜+Jšœœ˜"Jšœ	œ˜'Jšœœ˜0Jšœ	œ˜$Jšœœ˜)Jšœœœ
˜Jšœœ˜(—š
Ÿ™˜KJ˜—šΟnœœ˜Jšœ
œ
˜Jšœœ
œœ
˜"Jšœœ
˜Jšœœ
œœ
˜Jšœœ
˜!Jšœœ
˜Jšœ
˜J˜Jšœœ
˜J˜J˜J˜<J˜Jš
œ&œœ
œœ
˜SJšœœ9˜LJšœœ<˜OJšœœF˜YJš
œœ Οs
œ	‘
œ‘
œ‘
œ‘
œ˜_JšœœD˜WJšœœD˜WJšœœ<˜OJšœœ9˜LJš	œœ%‘
œ
‘
œ‘
œ˜\Jšœœ;˜NJšœœF˜YJšœœ˜2Jšœœ˜3Jšœœ˜1Jšœœ˜/Jšœœ˜/Jšœœ˜/Jšœœ
œœœ
œœ
˜Yš
œ ˜ J˜Jšœœœœœœœœ˜=Jš
œ˜J˜J˜.J˜J˜
Jš
œ@˜@Jšœœ˜—J˜SJ˜J˜'š
œ'˜'Jšœœœ+œ˜”
—Jš
œ?˜?J˜'J˜J˜—Jš œœœ˜G—š
Ÿ™š œ˜&Jšœ
œ˜%Jšœœ
˜J˜ Jšœ‘
‘
œœ˜ZJ˜J˜—š œ˜Jšœ
œ
˜šœœ˜J˜JJ˜šœ
œ˜Jšœ‘
œ‘
œ0‘
œ
‘
œ‘
œ˜ZJšœ˜—š
œœ
œœ
œ˜;Jš
œ7˜7Jšœ-œ˜4J˜—J˜—J˜J˜—šΠbnœ˜Jšœ
œ
˜šœœ˜3šœœ
œ˜$J˜šœ
œ0œ˜GJ˜@J˜Jšœ
˜J˜—Jšœ
˜——J˜——š
Ÿ™š
 œœœ
œœ˜AJš
œ.˜.J˜J˜—š œ˜-š œœ˜Jšœœ
œ,˜EJš
œ<˜<Jš
œ˜—Jšœ
œ˜Jšœœ
˜Jšœœœ˜$J˜%J˜J˜—š œ˜Jšœ
œ˜š 
œœ˜
codeš	œ
œœ
œ˜6LšœF˜J—L˜—š 	œœ˜š‘
œ‘
œ
‘
œ‘
‘
œ˜!Jš‘
œ‘
œ‘
œ˜A—J˜—J˜8J˜5šœ
˜J˜ Lš
œ&˜&Lš
œ<˜<šœ˜
Jšœœ
œ:˜T——Jšœœ
œ˜0J˜——š
Ÿ™š 
œ˜Jšœ
œ
˜šœ,œ
˜7šœ2˜6Jšœœ
˜#Jšœœ
˜——Jšœ#œ˜5J˜J˜—š 
œ˜Jšœ
œ
˜šœ˜Jšœ;˜?Jšœ:˜>—Jš
œ*˜*J˜J˜J˜—šœœ œ2˜]J˜—š œ˜J˜+J˜AJ˜J˜—š œ˜Jšœ
œ
˜J˜EJ˜J˜—š œœœœ˜FJ˜—š 
œœ˜!šœœ
œ0œœ
˜NJš 
œœœœœœœ˜Pš
 
œœœœœ˜'Icedaršœœ/˜6MšœI	œ˜UJ˜—šœ
œ
˜Jš
œ1˜1J˜.J˜.Jšœ
˜—Jšœ
˜—J˜J˜J˜—š 
œ˜Jšœœ+˜Kšœ
œ˜Mšœœ.˜5MšœDœ˜OJ˜—J˜——š
Ÿ™š œ˜Jšœ
œ
˜Jšœ	œ
˜J˜<J˜J˜—Jš œœ˜;š œœ"˜NJ˜—š 
œœ/˜?Jšœ	œ
˜J˜Jšœ-œ˜4Jšœ	œ
˜J˜J˜—š œ˜$Jšœ
œ˜Jšœœœ˜šœœ
œ˜šœœ
œ˜J˜+šœœ
œ˜$J˜Jšœœ(˜3Jšœœœœ˜>Jšœœ˜Jšœœ˜Jšœœ
œ
˜šœ˜Jš
œ7˜7Jš
œ@˜@Jšœ
˜—Jšœ
˜—Jšœ
˜—Jšœ
˜—J˜J˜—š œ˜0Jšœ
œ˜Jšœœ˜šœœœ˜8šœœœ˜8šœœ
œ˜$Jšœœ
œ
˜Jš
œG˜GJšœ
˜—J˜Jš
œ.˜.J˜Lšœ
˜—Lšœ
˜—J˜J˜—šΟbœ˜*Jšœ
œ˜Jš
œ#˜#J˜J˜Jš
œ%˜%J˜Jšœœ
˜J˜——š
Ÿ	™	š œœ˜'Jšœœœœ
œœ˜BJšœœ	˜Jš
œœœ
œœ
œœ˜WJš
œœ
œœœ
˜@J˜J˜J˜ J˜J˜7J˜ J˜J˜—š 
œœœ˜@Jš
œ.˜.J˜Jšœ%œœœ˜9š
œ˜Jšœ
œœœ˜W—J˜UJ˜%J˜J˜—š œœ˜š
œœ
œ
œœ
œ˜:J˜AJšœ
˜—J˜J˜—š œœœœ
˜EJšœœœœ˜OJš
œB˜BJšœD˜JJ˜J˜—š œœœœ˜;šœœ
œ˜$J˜L˜"L˜)Jšœœ0˜=Lšœœ0˜<Lšœ
˜—L˜——š
Ÿ
™
š œœœ˜Jšœœ˜!J˜J˜J˜—š
 œœ	œœœ˜>Jšœœœ˜6J˜J˜—š œœœ™GJšœI™OJ™J™—š œœœ™HJšœœœ™KJ™——š
Ÿ™šœœœ˜Jšœ
œ	Οc˜(Jšœ€˜0Jšœ	œ€˜/J˜J˜—Jšœ	œ
œœ
˜&J˜8Jšœ	œ €#˜QJšœœœ
˜šœ
œ ˜0J˜—š œœœœ˜GJšœœ˜Jšœœœ9˜KJš
œœ
œœ+œ
˜Nšœœ
œ!œœ
˜?Jš
œ
œ œœ
œ
˜7Jš
œ˜Jšœ
˜Jšœ
˜—Jšœœ!˜0Jš
œB˜BJ˜J˜—š œœ
œ
œœœ˜@J˜—š 
œœ˜%L˜<šœœ
œ
˜&šœœ˜(Jšœœ
˜Jšœœ
˜J˜—šœ˜šœœ
œ!œœ
˜?šœ#œœ˜2J˜%Jšœ
˜J˜—Jšœ
˜—Jšœ˜$J˜——J˜J˜—š’œ˜!L˜<Jšœœ
œ˜2šœ
œ
˜š
œ˜JšœP˜V—Jšœ'˜.—J˜——š
Ÿ
™
š
œ˜Jšœœ<˜MJ˜—Jš
œA˜AJ˜—Jšœ
˜—…—6VHG