DIRECTORY
Basics USING [BITSHIFT, bitsPerWord, LongMult],
CD,
CDApplications,
CDBasics,
CDColors,
CDOps,
CDOrient,
CDPrivate,
CDTexts,
CDVPrivate,
CDVScale,
Graphics, 
GraphicsBasic,
GraphicsColor, 
GraphicsOps, 
PrincOps USING [BBptr, BitAddress, BBTable, SrcDesc, BitBltFlags, GrayParm],
PrincOpsUtils USING [BITBLT],
Real,
Rope,
RuntimeError,
Terminal,
TerminalExtras,
ViewerClasses,
ViewerSpecs;

CDVDraw: CEDAR MONITOR
IMPORTS Basics, CD, CDApplications, CDBasics, CDOps, CDOrient, CDVPrivate, CDVScale, Graphics, GraphicsOps, PrincOpsUtils, Real, RuntimeError, Terminal, TerminalExtras
EXPORTS CDVPrivate, CD --DrawRef's private fields-- =
BEGIN

ViewerPrivateRep: PUBLIC TYPE ~ CDVPrivate.MyGraphicRec;
ViewerSaveRep: PUBLIC TYPE ~ INTEGER;   -- XXX placeholder

MyGraphicRef: TYPE ~ CDVPrivate.MyGraphicRef;
MyGraphicRec: TYPE ~ CDVPrivate.MyGraphicRec;
maxInfluence: CD.DesignNumber ~ 0;
virtual: Terminal.Virtual ~ Terminal.Current[];
defaultFont: Graphics.FontRef ~ GraphicsOps.DefaultFont[];

errrorReport: RECORD [
text: Rope.ROPE,
me: MyGraphicRef, 
r: CD.Rect, 
color: REF CDColors.Brick
];

bitBltFlagsForPaint: PrincOps.BitBltFlags = PrincOps.BitBltFlags[
direction: forward,
disjoint: TRUE,
disjointItems: TRUE,
gray: TRUE,
srcFunc: null,
dstFunc: or
];

bitBltFlagsForOutline: PrincOps.BitBltFlags = PrincOps.BitBltFlags[
direction: forward,
disjoint: TRUE,
disjointItems: TRUE,
gray: TRUE,
srcFunc: null,
dstFunc: or
];

bitBltFlagsForClearPattern: PrincOps.BitBltFlags = PrincOps.BitBltFlags[
direction: forward,
disjoint: TRUE,
disjointItems: TRUE,
gray: TRUE,
srcFunc: complement,
dstFunc: and
];

blackBrick: REF CDColors.Brick = NEW[CDColors.Brick_ALL[LAST[CARDINAL]]];
whiteBrick: REF CDColors.Brick = NEW[CDColors.Brick_ALL[0]];

BitBlitDraw: PROC[me: MyGraphicRef, r: CD.Rect, color: REF CDColors.Brick] =
TRUSTED 
INLINE BEGIN
ENABLE {
UNWIND => NULL;
RuntimeError.UNCAUGHT => {
errrorReport.text _ "BitBlitDraw";
errrorReport.me _ me;
errrorReport.r_r;
errrorReport.color_color;
IF CDVPrivate.catchAny THEN GOTO SomeError ELSE REJECT;
};
};
xBit, x1, x2, y1, y2: CARDINAL;
vr: CD.Rect;
IF ~CDBasics.NonEmpty[r] THEN RETURN;
vr _ CDVScale.DesignToViewerRect[me.scale, r];
x1 _ MAX[vr.x1, 0]; 
y1 _ MAX[vr.y1, 0]; 
IF vr.x2<=0 OR vr.y2<=0 THEN RETURN;
x2 _ MIN[vr.x2, me.viewer.cw]; 	
y2 _ MIN[vr.y2, me.viewer.ch];
IF x1>=x2 OR y1>=y2 THEN RETURN;
xBit _ Basics.BITSHIFT[x1+me.vx, me.logbpp];
me.pBBptr.width _ Basics.BITSHIFT[x2-x1, me.logbpp];
me.pBBptr.height _ y2-y1;
y1 _ me.vy-y2;
me.pBBptr.dst _ [
me.screen 
+ Basics.LongMult[y1, me.scWidthWords]
+ LONG[(xBit/Basics.bitsPerWord)],,
xBit MOD Basics.bitsPerWord
];
me.pBBptr.src _ [ 
LOOPHOLE[ 
LOOPHOLE[color, LONG CARDINAL] +
y1 MOD 4, LONG POINTER],,
xBit MOD Basics.bitsPerWord];
me.pBBptr.srcDesc.gray.yOffset _ y1 MOD 4;
IF me.bpp=1 THEN PrincOpsUtils.BITBLT[me.pBBptr]
ELSE {
TerminalExtras.LockColorFrame[vt: virtual, 
xmin: x1+me.vx, 
ymin: y1, 
xmax: x2+me.vx, 
ymax: y1+me.pBBptr.height
];
PrincOpsUtils.BITBLT[me.pBBptr];
TerminalExtras.UnlockColorFrame[virtual]
};
EXITS
SomeError => NULL;
END;

BitBlitSave: ENTRY PROC[me: MyGraphicRef, r: CD.Rect, color: REF CDColors.Brick, clearPattern: REF CDColors.Brick_NIL] =
TRUSTED  BEGIN
ENABLE {
UNWIND => NULL;
RuntimeError.UNCAUGHT => {
errrorReport.text _ "BitBlitSave";
errrorReport.me _ me;
errrorReport.r_r;
errrorReport.color_color;
IF CDVPrivate.catchAny THEN GOTO SomeError ELSE REJECT;
};
};
xBit, x1, x2, y1, y2: CARDINAL;
vr: CD.Rect;
r _ CDBasics.Intersection[r, me.deviceDrawRef.worldClip];
IF ~CDBasics.NonEmpty[r] THEN RETURN;
vr _ CDVScale.DesignToViewerRect[me.scale, r];
x1 _ MAX[vr.x1, 0]; 
y1 _ MAX[vr.y1, 0]; 
IF vr.x2<=0 OR vr.y2<=0 THEN RETURN;
x2 _ MIN[vr.x2, me.viewer.cw]; 
y2 _ MIN[vr.y2, me.viewer.ch];
IF x1>=x2 OR y1>=y2 THEN RETURN;
xBit _ Basics.BITSHIFT[x1+me.vx, me.logbpp];
me.xBBptr.width _ Basics.BITSHIFT[x2-x1, me.logbpp];
me.xBBptr.height _ y2-y1;
y1 _ me.vy-y2; -- now y1 is device top pixel
me.xBBptr.srcDesc _ PrincOps.SrcDesc[gray[PrincOps.GrayParm[
yOffset: y1 MOD 4,
widthMinusOne: 0, --words
heightMinusOne: 3 --lines 
]]];
me.xBBptr.dst _ [
me.screen 
+ Basics.LongMult[y1, me.scWidthWords]
+ LONG[(xBit/Basics.bitsPerWord)],,
xBit MOD Basics.bitsPerWord
];
IF me.bpp#1 THEN TerminalExtras.LockColorFrame[vt: virtual, 
xmin: x1+me.vx, 
ymin: y1, 
xmax: x2+me.vx, 
ymax: y1+me.xBBptr.height
];
IF clearPattern#NIL THEN {
me.xBBptr.flags _ bitBltFlagsForClearPattern;
me.xBBptr.src _ [ 
LOOPHOLE[ 
LOOPHOLE[clearPattern, LONG CARDINAL] +
y1 MOD 4, LONG POINTER],,
xBit MOD Basics.bitsPerWord];
PrincOpsUtils.BITBLT[me.xBBptr];
};
me.xBBptr.src _ [ 
LOOPHOLE[ 
LOOPHOLE[color, LONG CARDINAL] +
y1 MOD 4, LONG POINTER],,
xBit MOD Basics.bitsPerWord];
me.xBBptr.flags _ bitBltFlagsForOutline;
PrincOpsUtils.BITBLT[me.xBBptr];
IF me.bpp#1 THEN TerminalExtras.UnlockColorFrame[virtual];
EXITS
SomeError => NULL;
END;

BitBlitOutLine: ENTRY PROC[r: CD.Rect, pr: CD.DrawRef] = 
BEGIN
ENABLE {
UNWIND => NULL;
RuntimeError.UNCAUGHT => {
errrorReport.text _ "BitBlitOutLine";
errrorReport.me _ pr.viewerPrivate;
errrorReport.r_r;
IF CDVPrivate.catchAny THEN GOTO SomeError ELSE REJECT;
};
};
me: MyGraphicRef ~ pr.viewerPrivate;
vr, clipr: CD.Rect;

DrawBlack: --INTERNAL-- PROC[me: MyGraphicRef, x1, y1, x2, y2: INTEGER] = 
TRUSTED INLINE BEGIN
xBits: CARDINAL ~ Basics.BITSHIFT[x1+INTEGER[me.vx], me.logbpp]; 
me.xBBptr.width _ Basics.BITSHIFT[x2-x1, me.logbpp];
me.xBBptr.height _ y2-y1;
me.xBBptr.dst _ [
me.screen 
+ Basics.LongMult[INTEGER[me.vy]-y2, me.scWidthWords] 
+ LONG[(xBits/Basics.bitsPerWord)],,
xBits MOD Basics.bitsPerWord
];
PrincOpsUtils.BITBLT[me.xBBptr];
END;

IF r.x2>me.dClip.x2 THEN r.x2_me.dClip.x2+1;
IF r.y2>me.dClip.y2 THEN r.y2_me.dClip.y2+1;
IF r.x1<me.dClip.x1 THEN r.x1_me.dClip.x1-1;
IF r.y1<me.dClip.y1 THEN r.y1_me.dClip.y1-1;
vr _ CDVScale.DesignToViewerRect[me.scale, r];
clipr _ CDBasics.Intersection[
CDVScale.DesignToViewerRect[me.scale, me.deviceDrawRef.worldClip], 
vr
];
clipr.x1 _ MAX[clipr.x1, 0];
clipr.y1 _ MAX[clipr.y1, 0];
clipr.x2 _ MIN[clipr.x2, LONG[me.viewer.cw]];
clipr.y2 _ MIN[clipr.y2, LONG[me.viewer.ch]];
IF clipr.x1>=clipr.x2 OR clipr.y1>=clipr.y2 THEN RETURN; 
--harder empty test than CDBasics
--necessary because we add/subtract one
TRUSTED {
me.xBBptr.src _ [LOOPHOLE[blackBrick, LONG POINTER],,0];
me.xBBptr.flags _ bitBltFlagsForOutline;
me.xBBptr.srcDesc _ PrincOps.SrcDesc[gray[PrincOps.GrayParm[
yOffset: 0,
widthMinusOne: 0, --words
heightMinusOne: 0 --lines 
]]];
};
IF me.bpp#1 THEN {
TerminalExtras.LockColorFrame[vt: virtual,
xmin: clipr.x1+me.vx, 
ymin: me.vy+1-clipr.y2, 
xmax: clipr.x2+me.vx-1, 
ymax: me.vy-clipr.y1
];
};
IF vr.x1>=clipr.x1 THEN DrawBlack[me, clipr.x1, clipr.y1, clipr.x1+1, clipr.y2]; --left
IF vr.y2<=clipr.y2 THEN DrawBlack[me, clipr.x1, clipr.y2-1, clipr.x2, clipr.y2]; --top
IF vr.x2<=clipr.x2 THEN DrawBlack[me, clipr.x2-1, clipr.y1, clipr.x2, clipr.y2]; --right
IF vr.y1>=clipr.y1 THEN DrawBlack[me, clipr.x1, clipr.y1, clipr.x2, clipr.y1+1]; --bottom
IF me.bpp#1 THEN TerminalExtras.UnlockColorFrame[virtual]; 
EXITS
SomeError => NULL;
END;

BitBlitDrawRectForViewers: ENTRY PROC[r: CD.Rect, l: CD.Level, pr: CD.DrawRef] =
BEGIN
ENABLE UNWIND => NULL;
me: MyGraphicRef = pr.viewerPrivate; 
BitBlitDraw[me, CDBasics.Intersection[r, pr.worldClip], me.colorTable[l]];
END;

SaveRectForViewers: ENTRY PROCEDURE[r: CD.Rect, l: CD.Level, pr: CD.DrawRef] =
BEGIN
ENABLE UNWIND => NULL;
me: MyGraphicRef = pr.viewerPrivate; 
IF me.saveList=NIL OR me.saveList.first.next>=CDVPrivate.saveListSize THEN 
me.saveList _ CONS[CDVPrivate.SavedRectArraySeq[next: 0], me.saveList];
me.saveList.first.x[me.saveList.first.next] _ [r: CDBasics.Intersection[r, pr.worldClip], l: l];
me.saveList.first.next _ me.saveList.first.next+1
END;

SetGround: --CD.SetGroundProc-- PROC [pr: CD.DrawRef, pushedOut: BOOL] =
BEGIN
WITH pr.devicePrivate SELECT FROM
me: MyGraphicRef => 
me.colorTable _ me.personalColors[me.display][IF pushedOut THEN back ELSE normal]
ENDCASE => NULL;
END;

DrawCommentForViewers: PUBLIC PROC[r: CD.DesignRect, comment: Rope.ROPE, pr: CD.DrawRef] = 
BEGIN
topToFontLine: NAT ~ 9+2;
fontHeight: NAT ~ 12;
leftMargin: NAT ~ 2;
bothMargin: NAT ~ 2*leftMargin;
me: MyGraphicRef _ NARROW[pr.devicePrivate];
vr: CD.Rect _ CDVScale.DesignToViewerRect[me.scale, r];
IF vr.y2-vr.y1>fontHeight THEN {
xw: REAL ~ Graphics.RopeWidth[font: defaultFont, rope: comment].xw;
IF vr.x2-vr.x1>xw+bothMargin THEN {
me.viewerContext.SetColor[Graphics.black];
me.viewerContext.SetCP[vr.x1+leftMargin, vr.y2-topToFontLine];
me.viewerContext.DrawRope[comment];
}
};
END;

RepaintRectAreaInViewer: PUBLIC PROC[me: MyGraphicRef, rect: CD.DesignRect, eraseFirst: BOOL] =
BEGIN
ENABLE {
RuntimeError.UNCAUGHT => IF CDVPrivate.catchAny THEN GOTO SomeError ELSE REJECT
};
interestRect: CD.DesignRect;
UpdateDrawInformation[me];
me.deviceDrawRef.worldClip _ interestRect _ CDBasics.Intersection[rect, me.dClip];
IF CDBasics.NonEmpty[interestRect] THEN {
[] _ Graphics.SetPaintMode[me.viewerContext, transparent];
RepaintBackground[me, interestRect, eraseFirst];
CDOps.QuickDrawDesign[me.actualDesign, me.deviceDrawRef];
[] _ Graphics.SetPaintMode[me.viewerContext, opaque];
IF me.saveList#NIL THEN {
l: CDVPrivate.SaveList _ me.saveList;
me.saveList _ NIL;
WHILE l#NIL DO
FOR i: INTEGER IN [0..l.first.next) DO
BitBlitSave[me, l.first.x[i].r, me.colorTable[l.first.x[i].l], me.greyTable[l.first.x[i].l]];
ENDLOOP;
l _ l.rest
ENDLOOP;
};
FOR pl: CDVPrivate.PainterList _ me.painterList, pl.rest WHILE pl#NIL DO
IF CDBasics.Intersect[interestRect, pl.first.rect] THEN
pl.first.proc[me, pl.first, interestRect !
RuntimeError.UNCAUGHT => IF CDVPrivate.catchAny THEN CONTINUE ELSE REJECT
]
ENDLOOP
}
EXITS SomeError=> NULL
END;

RepaintBackground: PUBLIC ENTRY PROC[me: MyGraphicRef, r: CD.DesignRect, eraseFirst: BOOL] = 
BEGIN
ENABLE {
UNWIND => NULL;
RuntimeError.UNCAUGHT => {
errrorReport.text _ "background";
errrorReport.me _ me;
errrorReport.r _ r;
IF CDVPrivate.catchAny THEN GOTO SomeError ELSE REJECT
};
};

DrawOutside: --INTERNAL-- PROC [r: CD.DesignRect] =
BEGIN
BitBlitDraw[me, CDBasics.Intersection[r, me.dClip], me.colorTable[CD.backGround]];
END;

IF eraseFirst THEN {
TRUSTED {me.pBBptr.flags.dstFunc _ null};
BitBlitDraw[me, CDBasics.Intersection[r, me.dClip], whiteBrick];
TRUSTED {me.pBBptr.flags.dstFunc _ or};
};
IF me.actualDesign.actual.first.mightReplace#NIL AND ~me.suppressOutsidePushedCell AND
me.actualDesign.actual.first.mightReplace.ob#NIL THEN 
CDBasics.DecomposeRect[r: r, 
test: CDApplications.ARectO[me.actualDesign.actual.first.mightReplace], 
outside: DrawOutside
];
EXITS
SomeError => NULL;
END;

InitForBBLT: PROC [me: MyGraphicRef] = 
BEGIN
x, y: REAL;
IF me.viewer.column=color THEN TRUSTED {
m: Terminal.ColorMode = Terminal.GetColorMode[virtual];
IF m.full OR m.bitsPerPixelChannelA=0 THEN ERROR CDVPrivate.notSupportedColorMode;
me.bpp _ m.bitsPerPixelChannelA; 
me.screen _ virtual.colorBitmapA;
me.scWidth _ virtual.colorWidth;  -- pixels 
me.scWidthBits _ virtual.colorWidth*me.bpp;
me.scHeight _ virtual.colorHeight;
IF me.bpp=4 THEN {
me.display _ bit4;
me.logbpp _ 2;
}
ELSE IF me.bpp=8 THEN {
me.display _ bit8;
me.logbpp _ 3;
}
ELSE ERROR;
}
ELSE { -- b+w
me.display _ bw;
me.bpp _ 1;
me.logbpp _ 0;
me.scWidth _ ViewerSpecs.screenW/Basics.bitsPerWord;
me.scWidthBits _ ViewerSpecs.screenW;
me.scHeight _ ViewerSpecs.screenH;
me.screen _ Terminal.GetBitBltTable[virtual].bbt.dst.word;
};
me.colorTable _ me.personalColors[me.display][normal];
me.greyTable _ me.personalColors[me.display][grey];
[x, y] _ GraphicsOps.UserToDevice[me.viewerContext, 0, 0]; -- in device in pixels
me.vx _ Real.RoundI[x];
me.vy _ Real.RoundI[y]; --bottom most pixel of viewer
me.scWidthWords _ me.scWidthBits/Basics.bitsPerWord;
TRUSTED BEGIN
me.pBBptr^ _ PrincOps.BBTable[
dst: TRASH,
dstBpl: LOOPHOLE[me.scWidthBits, INTEGER],
src: TRASH,
srcDesc: PrincOps.SrcDesc[gray[PrincOps.GrayParm[
yOffset: 0, --is actually trash
widthMinusOne: 0, --words
heightMinusOne: 3 --lines 
]]],
width: TRASH,
height: TRASH,
flags: bitBltFlagsForPaint
];
me.xBBptr^ _ me.pBBptr^;
END;
END;

InternalCreateDrawInformation: INTERNAL PROC [me: MyGraphicRef] =
BEGIN
s: REAL;
pr: CD.DrawRef ~ CD.NewNullDeviceDrawRef[me.actualDesign];
pr.drawRect _ BitBlitDrawRectForViewers;
pr.outLineProc _ BitBlitOutLine;
pr.drawComment _ DrawCommentForViewers;
pr.deviceContext _ Graphics.CopyContext[me.viewerContext];
s _ CDVScale.DesignToViewerFactor[me.scale]; 
pr.scaleHint _ s*me.suppressFactorForCells; 
Graphics.Scale[pr.deviceContext, s, s];
Graphics.Translate[pr.deviceContext, -me.scale.off.x, -me.scale.off.y];
pr.contextFilter _ defaultContextFilter;
pr.devicePrivate _ me;
pr.stopFlag _ me.stoprequest;
pr.suppressOutsidePushedCell _ me.suppressOutsidePushedCell; 
pr.setGround _ SetGround; 
me.dClip _ pr.worldClip _ CDVScale.GetClipRecord[me.scale, me.viewer.cw, me.viewer.ch];
pr.minimalSize _  --XXX--
MIN[(me.dClip.x2-me.dClip.x1)/8, (me.dClip.y2-me.dClip.y1)/8];
InitForBBLT[me];
pr.saveRect _ (IF me.display=bit8 THEN BitBlitDrawRectForViewers ELSE SaveRectForViewers);
me.deviceDrawRef _ pr;
pr.viewerPrivate _ me;  -- this line last! it tells DummyNotify that the rest is initialized
END;

UpdateDrawInformation: ENTRY PROC [me: MyGraphicRef] =
BEGIN ENABLE UNWIND => NULL;
s: REAL;
pr: CD.DrawRef;
IF me.deviceDrawRef=NIL THEN InternalCreateDrawInformation[me];
pr _ me.deviceDrawRef;
pr.deviceContext _ Graphics.CopyContext[me.viewerContext];
s _ CDVScale.DesignToViewerFactor[me.scale]; 
Graphics.Scale[pr.deviceContext, s, s];
Graphics.Translate[pr.deviceContext, -me.scale.off.x, -me.scale.off.y];
pr.contextFilter _ defaultContextFilter;
END; 

CreateDrawInformation: PUBLIC ENTRY PROC [me: MyGraphicRef] =
BEGIN ENABLE UNWIND => NULL;
InternalCreateDrawInformation[me]
END; 

defaultContextFilter: REF CD.ContextFilter = NEW[CD.ContextFilter];
FOR l: CD.Level IN CD.Level DO
defaultContextFilter[l].paintMode _ transparent;
defaultContextFilter[l].doit _ TRUE;
ENDLOOP;
defaultContextFilter[CD.backGround].doit _ FALSE;
END.



ˆCDVDraw.mesa
Copyright c 1983, 1984 by Xerox Corporation.  All rights reserved.
Christian Jacobi   August 5, 1983 11:07 am 
last edited by Christian Jacobi   November 5, 1984 10:24:10 am PST
-- r ALLREADY CLIPPED
--DONE OUTSIDE r _ CDBasics.Intersection[r, me.deviceDrawRef.worldClip];
--draw exclusive high border pixels
--no empty test; is guaranteed by caller
--clip to area where
--1) small enogh: it does not crash on scaling later
--2) big enogh: if drawn, it does not draw artificial lines 
--RepaintBackground
----------
--fixed pBBptr initializations
--done in viewerprocess: me.pBBptr _ PrincOpsUtils.AlignedBBTable[@bBTableSpace];
�ÊŒ˜š
œ™Jšœ
Ïm
œ7™BJš
œ+™+Jš
œB™BJ˜—š
Ïk	˜	Jšœžœžœ˜/Jšžœ
˜J˜J˜	J˜	J˜J˜	J˜
J˜Jš
œ˜J˜	J˜
J˜J˜J˜
Jšœ	žœ>˜LJšœžœžœ˜Jš
œ˜J˜Jš
œ
˜
Jš
œ	˜	Jš
œ˜Jš
œ˜J˜J˜—šÏbœžœ
ž˜Jšžœžœ•
˜§
Jšžœ
žœ
Ïcœ˜5—Jš
ž˜J˜Jšœžœ
žœ˜8Jšœžœ
žœžœ ˜:J˜Jšœžœ˜-Jšœžœ˜-Jšœžœ˜"Jš
œ/˜/Jš
œ:˜:J˜šœžœ˜Jšœžœ
˜Jš
œ˜Jšœžœ˜Jšœžœ˜Jš
œ˜—J˜š
œA˜AJ˜Jšœ
žœ
˜Jšœžœ
˜Jšœžœ
˜Jš
œ˜Jš
œ˜J˜—J˜š
œC˜CJ˜Jšœ
žœ
˜Jšœžœ
˜Jšœžœ
˜Jš
œ˜Jš
œ˜J˜—J˜š
œH˜HJ˜Jšœ
žœ
˜Jšœžœ
˜Jšœžœ
˜Jš
œ˜Jš
œ˜J˜—J˜Jšœžœžœžœ
žœ
žœ˜IJšœžœžœžœ˜<J˜šÏnœžœžœžœ˜LJšžœ
˜Jš
œ™Jšžœ
ž˜šžœ˜Jšžœžœ
˜šœ
žœ˜Jš
œ"˜"Jš
œ˜Jš
œ˜Jš
œ˜Jš
žœžœ
žœžœ
žœ
˜7J˜—J˜—Jšœžœ
˜Jšœžœ˜Jš
œH™HJšžœžœ
žœ
˜%Jš
œ.˜.Jšœžœ˜Jšœžœ˜Jšžœ
žœ
žœ
žœ
˜$Jšœžœ˜ Jšœžœ˜Jšžœžœžœ
žœ
˜ Jš
œ,˜,Jš
œ4˜4Jš
œ˜Jš
œ˜š
œ˜˜
Jš
œ&˜&Jšœžœ˜#—Jšœžœ˜J˜—š
œ˜šžœ˜
šžœžœ
žœ˜ Jšœžœžœ
žœ˜—Jšœžœ˜——Jšœ$žœ˜*Jšžœ
žœžœ˜0šžœ˜š
œ+˜+Jš
œ˜Jš
œ
˜
Jš
œ˜Jš
œ˜Jš
œ˜—Jšœžœ˜ Jš
œ(˜(J˜—š
ž˜Jšœ
žœ
˜—Jšžœ
˜—J˜š¡œžœ
žœžœžœžœžœ˜xJšžœž˜šžœ˜Jšžœžœ
˜šœ
žœ˜Jš
œ"˜"Jš
œ˜Jš
œ˜Jš
œ˜Jš
žœžœ
žœžœ
žœ
˜7J˜—J˜—Jšœžœ
˜Jšœžœ˜Jš
œ9˜9Jšžœžœ
žœ
˜%Jš
œ.˜.Jšœžœ˜Jšœžœ˜Jšžœ
žœ
žœ
žœ
˜$Jšœžœ˜Jšœžœ˜Jšžœžœžœ
žœ
˜ Jš
œ,˜,Jš
œ4˜4Jš
œ˜Jšœ ˜,š
œ<˜<Jšœžœ˜Jšœ ˜Jšœ œ
˜Jš
œ˜—š
œ˜˜
Jš
œ&˜&Jšœžœ˜#—Jšœžœ˜J˜—šžœ
žœ,˜<Jš
œ˜Jš
œ
˜
Jš
œ˜Jš
œ˜Jš
œ˜—šžœžœ
žœ˜Jš
œ-˜-š
œ˜šžœ˜
šžœžœ
žœ˜'Jšœžœžœ
žœ˜—Jšœžœ˜——Jšœžœ˜ J˜—š
œ˜šžœ˜
šžœžœ
žœ˜ Jšœžœžœ
žœ˜—Jšœžœ˜——Jš
œ(˜(Jšœžœ˜ Jšžœ
žœ*˜:š
ž˜Jšœ
žœ
˜—Jšžœ
˜—J˜š
¡œžœ
žœžœžœ˜9Jš
ž˜šžœ˜Jšžœžœ
˜šœ
žœ˜Jš
œ%˜%Jš
œ#˜#Jš
œ˜Jš
žœžœ
žœžœ
žœ
˜7J˜—J˜—J˜$Jšœžœ˜J˜š¡	œ œ
žœ#žœ˜JJš
œ#™#Jšžœ
žœ
ž˜Jš
œ(™(Jšœžœžœ˜AJš
œ4˜4Jš
œ˜š
œ˜˜
Jšœžœ˜6Jšœžœ˜$—Jšœžœ˜J˜—Jšœžœ˜ Jšžœ
˜J˜—š
œ™J™4J™<—Jšžœžœ˜,Jšžœžœ˜,Jšžœžœ˜,Jšžœžœ˜,Jš
œ.˜.š
œ˜Jš
œC˜CJš
œ˜Jš
œ˜—Jšœžœ˜Jšœžœ˜Jšœžœžœ˜-Jšœžœžœ˜-šžœžœžœ
žœ˜9Jš
 !˜!Jš
 '˜'—šžœ˜	Jšœžœ
žœ
žœ˜8Jš
œ(˜(š
œ<˜<Jš
œ˜Jšœ ˜Jšœ œ
˜Jš
œ˜—J˜—šžœ
žœ˜š
œ*˜*Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜—Jš
œ˜—Jšžœžœ: ˜WJšžœžœ: ˜VJšžœžœ: ˜XJšžœžœ: ˜YJšžœ
žœ+˜;š
ž˜Jšœ
žœ
˜—Jšžœ
˜J˜—š¡œžœ
žœžœ
žœžœ˜PJš
ž˜Jšžœ
žœžœ
˜Jš
œ%˜%Jš
œJ˜JJšžœ
˜J˜—š¡œžœ
ž	œžœ
žœžœ˜NJš
ž˜Jšžœ
žœžœ
˜Jš
œ%˜%šžœ
žœ
žœ1žœ
˜KJšœžœ5˜G—Jš
œ`˜`Jš
œ1˜1Jšžœ
˜—J˜š
¡	œ œ
žœžœžœ˜HJš
ž˜šžœžœ
ž˜!š
œ˜Jšœ.žœžœžœ˜Q—Jšžœžœ
˜—Jšžœ
˜—J˜š¡œžœ
žœžœžœžœ˜[Jš
ž˜Jšœžœ˜Jšœžœ˜Jšœžœ˜Jšœžœ˜Jšœžœ˜,Jšœžœ1˜7šžœžœ˜ Jšœžœ;˜Cšžœžœ˜#Jš
œ*˜*Jš
œ>˜>Jš
œ#˜#J˜
—J˜—Jšžœ
˜J˜—š
¡œžœ
žœžœžœ˜_Jš
ž˜šžœ˜Jšœ
žœžœžœ
žœžœ
ž˜OJš
œ˜—Jšœžœ˜Jš
œ˜Jš
œR˜Ršžœ!žœ˜)J˜:Jš
œ0˜0Jš
œ9˜9J˜5šžœ
žœ
žœ˜Jš
œ%˜%Jšœžœ
˜šžœžœ
ž˜šžœžœ
žœž˜&Jš
œ]˜]Jšžœ
˜—Jš
œ
˜
Jšžœ
˜—J˜—šžœ6žœžœ
ž˜Hšžœ1ž˜7š
œ*˜*Jšœ
žœžœžœ
žœ
žœ
ž˜IJš
œ
˜
——Jš
ž˜—Jš
œ
˜
—Jšžœ
ž˜Jšžœ
˜J˜—š¡œžœ
žœ
žœžœžœ˜]Jš
ž˜šžœ˜Jšžœžœ
˜šœ
žœ˜Jš
œ!˜!Jš
œ˜Jš
œ˜Jš	žœžœ
žœžœ
ž˜6J˜—Jš
œ˜—J˜š¡œ œ
žœžœ˜3Jš
ž˜JšœBžœ˜RJšžœ
˜J˜—Jš
œ™šžœžœ˜Jšžœ"˜)Jš
œ@˜@Jšžœ ˜'J˜—šžœ+žœ
žœž˜VJšœ-žœ
žœ
˜6˜Jš
œH˜HJ˜J˜——š
ž˜Jšœ
žœ
˜—Jšžœ
˜J˜—š¡œžœ˜'Jš
ž˜Jšœžœ
˜šžœžœ
žœ˜(Jš
œ7˜7Jšžœžœžœ
žœ"˜RJš
œ!˜!Jš
œ!˜!Jšœ" 
˜,Jš
œ+˜+Jš
œ"˜"šžœ
žœ˜Jš
œ˜Jš
œ˜J˜
—šžœ
žœ
žœ˜Jš
œ˜Jš
œ˜J˜
—Jšžœ
žœ
˜J˜
—šžœ ˜
Jš
œ˜J˜Jš
œ˜Jš
œ4˜4J˜%J˜"Jš
œ:˜:J˜—Jš
œ6˜6Jš
œ3˜3Jšœ; ˜QJ˜Jšœ ˜5Jš
œ4˜4Jš
œ
™
Jš
œ™Jš
œQ™Qšžœ
ž˜
š
œ˜Jšœžœ
˜Jšœžœžœ˜*Jšœžœ
˜š
œ1˜1Jšœ ˜Jšœ ˜Jšœ œ
˜Jš
œ˜—Jšœžœ
˜
Jšœžœ
˜Jš
œ˜J˜—Jš
œ˜Jšžœ
˜—Jšžœ
˜—J˜š¡œžœ
žœ˜AJš
ž˜Jšœžœ
˜Jšœžœžœ'˜:Jš
œ(˜(J˜ Jš
œ'˜'Jš
œ:˜:Jš
œ-˜-Jš
œ,˜,J˜'Jš
œG˜GJš
œ(˜(Jš
œ˜J˜Jš
œ=˜=Jš
œ˜Jš
œW˜Wšœ ˜Jšžœ;˜>—Jš
œ˜Jšœžœžœžœ˜ZJš
œ˜Jšœ D˜\Jšžœ
˜—J˜š¡œžœ
žœ˜6Jšžœ
žœ
žœžœ
˜Jšœžœ
˜Jšœžœ	˜Jšžœžœ
žœ#˜?Jš
œ˜Jš
œ:˜:Jš
œ-˜-J˜'Jš
œG˜GJš
œ(˜(Jšžœ˜J˜—š¡œžœ
žœ
žœ˜=Jšžœ
žœ
žœžœ
˜Jš
œ!˜!Jšžœ˜J˜—Jš	œžœ
žœžœ
žœ˜Cš	žœžœžœ
žœž˜Jš
œ0˜0Jšœžœ
˜$Jšžœ
˜—Jšœžœžœ
˜1Jšžœ
˜J˜—…—7 L4