DIRECTORY
GraphicsBasic,
Graphics,
CGVector,
CGCubic,
CGPath,
UFCubicScan,
Inline,
Mopcodes,
Real,
Scaled
;
UFCubicScanImpl: CEDAR MONITOR
IMPORTS Graphics, CGPath, CGVector, Inline, Real, Scaled
EXPORTS UFCubicScan
= BEGIN OPEN UFCubicScan;
BITAND: PROC[a, b: CARDINAL] RETURNS [CARDINAL] = TRUSTED MACHINE CODE {Mopcodes.zAND};
BITOR: PROC[a, b: CARDINAL] RETURNS [CARDINAL] = TRUSTED MACHINE CODE {Mopcodes.zOR};
BITXOR: PROC[a, b: CARDINAL] RETURNS [CARDINAL] = TRUSTED MACHINE CODE {Mopcodes.zXOR};
Floor8: PROC[a: CARDINAL] RETURNS [NAT] = INLINE {RETURN[Inline.BITSHIFT[a, -8]]};
Mid: PROC[a, b: CARDINAL] RETURNS [CARDINAL] = INLINE {RETURN[Inline.BITSHIFT[(a+b),-1]]};
Rec6: TYPE = RECORD[a,b,c,d,e,f: CARDINAL];
Vec: TYPE = RECORD [x, y: CARDINAL];
XValueFor: PUBLIC PROCEDURE [cubic: CubicRec, y: Scaled.Value] RETURNS [INTEGER] = {
OPEN cubic;
yRel: CARDINAL;
IF y.Ceiling[] < ymin THEN RETURN [LAST[INTEGER]];
IF y.Floor[] > ymax THEN RETURN [FIRST[INTEGER]];
yRel _ y.MINUS[Scaled.FromInt[ymin]].Scale[8].Round[];
IF yRel <= y0 THEN IF yRel < y0 OR openAt0 THEN RETURN [LAST[INTEGER]];
IF yRel >= y3 THEN IF yRel > y3 OR openAt3 THEN RETURN [FIRST[INTEGER]];
WHILE y3 - y0 > 3
AND 0 # BITAND[
BITOR[BITXOR[x0, x1], BITOR[BITXOR[x1, x2], BITXOR[x2, x3]]],
LAST[CARDINAL]-255
] DO
a: Vec _ [Mid[x0, x1], Mid[y0, y1]];
b: Vec _ [Mid[x1, x2], Mid[y1, y2]];
c: Vec _ [Mid[x2, x3], Mid[y2, y3]];
ab: Vec _ [Mid[a.x, b.x], Mid[a.y, b.y]];
bc: Vec _ [Mid[b.x, c.x], Mid[b.y, c.y]];
p: Vec _ [Mid[ab.x, bc.x], Mid[ab.y, bc.y]];
IF yRel<p.y THEN [x1, y1, x2, y2, x3, y3] _ Rec6[a.x, a.y, ab.x, ab.y, p.x, p.y]
ELSE IF yRel=p.y THEN RETURN [Floor8[p.x]+xmin]
ELSE [x0, y0, x1, y1, x2, y2] _ Rec6[p.x, p.y, bc.x, bc.y, c.x, c.y]
ENDLOOP;
RETURN [Floor8[x3]+xmin]
};
RecScaled8: PROC [a,b,c,d,e,f,g,h: Scaled.Value] RETURNS [Scaled.Value, Scaled.Value, Scaled.Value, Scaled.Value, Scaled.Value, Scaled.Value, Scaled.Value, Scaled.Value] = {RETURN [a,b,c,d,e,f,g,h]};
ScaledBezier: TYPE = RECORD [x0, y0, x1, y1, x2, y2, x3, y3: Scaled.Value];
Split: PROCEDURE [bezier: ScaledBezier] RETURNS [ScaledBezier, ScaledBezier] = {
ScaledVec: TYPE = RECORD [x, y: Scaled.Value];
Mid: PROC [a, b: Scaled.Value] RETURNS [Scaled.Value] = {RETURN [a.PLUS[b].PLUS[Scaled.epsilon].Scale[-1]]};
a: ScaledVec _ [Mid[bezier.x0, bezier.x1], Mid[bezier.y0, bezier.y1]];
b: ScaledVec _ [Mid[bezier.x1, bezier.x2], Mid[bezier.y1, bezier.y2]];
c: ScaledVec _ [Mid[bezier.x2, bezier.x3], Mid[bezier.y2, bezier.y3]];
ab: ScaledVec _ [Mid[a.x, b.x], Mid[a.y, b.y]];
bc: ScaledVec _ [Mid[b.x, c.x], Mid[b.y, c.y]];
p: ScaledVec _ [Mid[ab.x, bc.x], Mid[ab.y, bc.y]];
RETURN [[bezier.x0, bezier.y0, a.x, a.y, ab.x, ab.y, p.x, p.y], [p.x, p.y, bc.x, bc.y, c.x, c.y, bezier.x3, bezier.y3]]
};
Allocate: PUBLIC PROCEDURE RETURNS [devicePath: DevicePath] = {
devicePath _ NEW[DevicePathRec];
devicePath.length _ 0;
devicePath.numberOfOutlines _ 0;
devicePath.seq _ NEW[DevicePathSeqRec[10]];
};
Release: PUBLIC PROCEDURE [devicePath: DevicePath] = {devicePath _ NIL};
Reset: PUBLIC PROCEDURE [devicePath: DevicePath] = {
devicePath.length _ 0;
devicePath.numberOfOutlines _ 0;
};
AppendMonotoneShortPiece: PROCEDURE [devicePath: DevicePath, bezier: ScaledBezier] = {
OPEN bezier;
cubic: Cubic _ IF devicePath.length < devicePath.seq.maxLength THEN devicePath.seq[devicePath.length] ELSE NIL;
IF cubic = NIL THEN cubic _ NEW[CubicRec];
IF devicePath.length = devicePath.seq.maxLength THEN {
new: REF DevicePathSeqRec _ NEW[
DevicePathSeqRec[MIN[LAST[NAT]-3, devicePath.length+devicePath.length/3+1]]
];
FOR i: NAT IN [0..devicePath.length) DO
new[i] _ devicePath.seq[i];
ENDLOOP;
devicePath.seq _ new;
};
devicePath.seq[devicePath.length] _ cubic;
devicePath.length _ devicePath.length + 1;
cubic.ascending _ TRUE;
IF y3.LESS[y0] THEN {
[x0, y0, x1, y1, x2, y2, x3, y3] _ RecScaled8[x3, y3, x2, y2, x1, y1, x0, y0];
cubic.ascending _ FALSE;
};
cubic.outlineNumber _ devicePath.numberOfOutlines;
cubic.xmin _ MIN[x0.Floor[], x1.Floor[], x2.Floor[], x3.Floor[]];
cubic.ymin _ y0.Floor[];
cubic.ymax _ y3.Ceiling[];
cubic.x0 _ x0.MINUS[Scaled.FromInt[cubic.xmin]].PLUS[Scaled.half].Scale[8].Round[];
cubic.x1 _ x1.MINUS[Scaled.FromInt[cubic.xmin]].PLUS[Scaled.half].Scale[8].Round[];
cubic.x2 _ x2.MINUS[Scaled.FromInt[cubic.xmin]].PLUS[Scaled.half].Scale[8].Round[];
cubic.x3 _ x3.MINUS[Scaled.FromInt[cubic.xmin]].PLUS[Scaled.half].Scale[8].Round[];
cubic.y0 _ y0.MINUS[Scaled.FromInt[cubic.ymin]].Scale[8].Round[];
cubic.y1 _ y1.MINUS[Scaled.FromInt[cubic.ymin]].Scale[8].Round[];
cubic.y2 _ y2.MINUS[Scaled.FromInt[cubic.ymin]].Scale[8].Round[];
cubic.y3 _ y3.MINUS[Scaled.FromInt[cubic.ymin]].Scale[8].Round[];
IF cubic.y0 = cubic.y3 THEN devicePath.length _ devicePath.length - 1;
};
AppendMonotonePiece: PROCEDURE [devicePath: DevicePath, b: ScaledBezier] = {
xmin: INTEGER _ MIN[b.x0.Floor[], b.x1.Floor[], b.x2.Floor[], b.x3.Floor[]];
xmax: INTEGER _ MAX[b.x0.Ceiling[], b.x1.Ceiling[], b.x2.Ceiling[], b.x3.Ceiling[]];
ymin: INTEGER _ MIN[b.y0.Floor[], b.y1.Floor[], b.y2.Floor[], b.y3.Floor[]];
ymax: INTEGER _ MAX[b.y0.Ceiling[], b.y1.Ceiling[], b.y2.Ceiling[], b.y3.Ceiling[]];
b1, b2: ScaledBezier;
IF xmax - xmin < LAST[NAT]/256 AND ymax - ymin < LAST[NAT]/256 THEN AppendMonotoneShortPiece[devicePath, b]
ELSE {
[b1, b2] _ Split[b];
AppendMonotonePiece[devicePath, b1];
AppendMonotonePiece[devicePath, b2];
};
};
AppendMonotoneBezier: PROCEDURE [devicePath: DevicePath, bezier: CGCubic.Bezier] = {
s: ScaledBezier _ [
Scaled.FromReal[bezier.b0.x], Scaled.FromReal[bezier.b0.y], 
Scaled.FromReal[bezier.b1.x], Scaled.FromReal[bezier.b1.y], 
Scaled.FromReal[bezier.b2.x], Scaled.FromReal[bezier.b2.y], 
Scaled.FromReal[bezier.b3.x], Scaled.FromReal[bezier.b3.y]
];
AppendMonotonePiece[devicePath, s]
};
Interpolate: PROCEDURE [t: REAL, a, b: CGVector.Vec] RETURNS [r: CGVector.Vec] =
BEGIN OPEN CGVector;
r _ Add[Mul[b, t], Mul[a, 1-t]];
END;
SubDivide: PROCEDURE [b: CGCubic.Bezier, t: REAL] RETURNS [low, high: CGCubic.Bezier] =
BEGIN OPEN b;
q1, q2, q3, qp1, qp2, q: CGVector.Vec;
q1 _ Interpolate[t, b0, b1];
q2 _ Interpolate[t, b1, b2];
q3 _ Interpolate[t, b2, b3];
qp1 _ Interpolate[t, q1, q2];
qp2 _ Interpolate[t, q2, q3];
q _ Interpolate[t, qp1, qp2];
low _ [b0: b0, b1: q1, b2: qp1, b3: q];
high _ [b0: q, b1: qp2, b2: q3, b3: b3];
END;
AppendBezier: PROCEDURE [devicePath: DevicePath, bezier: CGCubic.Bezier] = {
c0: REAL = bezier.b0.y;
c1: REAL = 3*(bezier.b1.y - c0);
t: REAL = 3*(bezier.b2.y - bezier.b1.y);
c2: REAL = t - c1;
c3: REAL = bezier.b3.y - c0 - t;
d0: REAL = c1;
d1: REAL = 2*c2;
d2: REAL = 3*c3;
t0, t1: REAL _ -1;
IF d2 # 0.0 THEN {
b: REAL = d1/d2;
c: REAL = d0/d2;
d: REAL = b*b-4*c;
IF d>=0 THEN {
sqrt: REAL = Real.SqRt[d];
t0 _ (-b-sqrt)/2;
t1 _ (-b+sqrt)/2;
};
}
ELSE IF d1#0.0 THEN t0 _ -d0/d1;
t0 _ MIN[1.0, MAX[0.0, t0]];
t1 _ MIN[1.0, MAX[0.0, t1]];
IF t0 > t1 THEN {t: REAL _ t0; t0 _ t1; t1 _ t};
IF 0.0 < t0 AND t0 < t1 AND t1 < 1.0 THEN {
low, middle, high: CGCubic.Bezier;
[middle, high] _ SubDivide[bezier, t1];
[low, middle] _ SubDivide[middle, t0/t1];
Delta[low.b2.y-low.b3.y]; low.b2.y _ low.b3.y;
Delta[middle.b1.y-middle.b0.y]; middle.b1.y _ middle.b0.y;
Delta[middle.b2.y-middle.b3.y]; middle.b2.y _ middle.b3.y;
Delta[high.b1.y-high.b0.y]; high.b1.y _ high.b0.y;
AppendMonotoneBezier[devicePath, low];
AppendMonotoneBezier[devicePath, middle];
AppendMonotoneBezier[devicePath, high];
}
ELSE IF t0 IN (0.0..1.0) OR t1 IN (0.0..1.0) THEN {
low, high: CGCubic.Bezier;
[low, high] _ SubDivide[bezier, IF t0 IN (0.0..1.0) THEN t0 ELSE t1];
Delta[low.b2.y-low.b3.y]; low.b2.y _ low.b3.y;
Delta[high.b1.y-high.b0.y]; high.b1.y _ high.b0.y;
AppendMonotoneBezier[devicePath, low];
AppendMonotoneBezier[devicePath, high];
}
ELSE AppendMonotoneBezier[devicePath, bezier];
};
numberOfDeltas: INT _ 0;
sumOfAbsDeltas: REAL _ 0.0;
maxDelta: REAL _ 0.0;
Delta: PROCEDURE [delta: REAL] = {
numberOfDeltas _ numberOfDeltas + 1;
sumOfAbsDeltas _ sumOfAbsDeltas + ABS[delta];
IF ABS[delta] > maxDelta THEN maxDelta _ ABS[delta];
};
DeltaStats: PROCEDURE RETURNS [n: INT, sum: REAL, max: REAL] = {
n _ numberOfDeltas;
sum _ sumOfAbsDeltas;
max _ maxDelta;
numberOfDeltas _ 0;
sumOfAbsDeltas _ maxDelta _ 0.0;
};
PushPath: PUBLIC PROCEDURE [
devicePath: DevicePath,
path: GraphicsBasic.Path,
map: PROC [GraphicsBasic.Vec] RETURNS [GraphicsBasic.Vec] _ NIL
] = {
firstPoint, lastPoint: GraphicsBasic.Vec;
started: BOOLEAN _ FALSE;
outlineStart: NAT _ devicePath.length;
Move: PROC [v: GraphicsBasic.Vec] = {
IF started THEN Close[];
outlineStart _ devicePath.length;
started _ TRUE;
firstPoint _ lastPoint _ v;
};
Line: PROC [v: GraphicsBasic.Vec] = {
started _ TRUE;
AppendBezier[devicePath, [lastPoint, Interpolate[0.3333333, lastPoint, v], Interpolate[0.6666667, lastPoint, v], v]];
lastPoint _ v;
};
Curve: PROC [v1, v2, v3: GraphicsBasic.Vec] = {
started _ TRUE;
AppendBezier[devicePath, [lastPoint, v1, v2, v3]];
lastPoint _ v3;
};
Close: PROC = {
IF started AND lastPoint # firstPoint THEN Line[firstPoint];
FOR j: NAT IN [outlineStart..devicePath.length) DO
i: NAT = IF j = outlineStart THEN devicePath.length-1 ELSE j-1;
cubicI: Cubic = devicePath.seq[i];
cubicJ: Cubic = devicePath.seq[j];
iup: BOOLEAN = cubicI.ascending;
jup: BOOLEAN = cubicJ.ascending;
IF iup THEN cubicI.openAt3 _ FALSE
ELSE cubicI.openAt0 _ NOT jup;
IF jup THEN cubicJ.openAt0 _ iup
ELSE cubicJ.openAt3 _ FALSE;
ENDLOOP;
started _ FALSE;
};
CGPath.MapAndFilter[path, map, Move, Line, Curve, Close];
devicePath.numberOfOutlines _ devicePath.numberOfOutlines + 1;
}; 
PopPath: PUBLIC PROCEDURE [devicePath: DevicePath] = {
devicePath.numberOfOutlines _ devicePath.numberOfOutlines-1;
WHILE devicePath.length > 0 AND devicePath.seq[devicePath.length-1].outlineNumber = devicePath.numberOfOutlines DO
devicePath.length _ devicePath.length - 1;
ENDLOOP;
};
PathFromDevicePath: PROCEDURE [devicePath: DevicePath] RETURNS [path: GraphicsBasic.Path] = {
started: BOOLEAN _ FALSE;
lastX, lastY: REAL;
path _ Graphics.NewPath[];
FOR i: NAT IN [0..devicePath.length) DO
cubic: Cubic _ devicePath.seq[i];
X: PROC [xRel: CARDINAL] RETURNS [REAL] = {RETURN[cubic.xmin-0.5+(xRel/256.0)]};
Y: PROC [yRel: CARDINAL] RETURNS [REAL] = {RETURN[cubic.ymin+(yRel/256.0)]};
IF NOT started THEN {
IF cubic.ascending THEN Graphics.MoveTo[path, X[cubic.x0], Y[cubic.y0]]
ELSE Graphics.MoveTo[path, X[cubic.x3], Y[cubic.y3]];
started _ TRUE;
};
[lastX, lastY] _ Graphics.LastPoint[path];
lastX _ lastX - X[IF cubic.ascending THEN cubic.x0 ELSE cubic.x3];
lastY _ lastY - Y[IF cubic.ascending THEN cubic.y0 ELSE cubic.y3]; 
IF lastX # 0.0 OR lastY # 0.0 THEN lastX _ lastY _ 0.0; -- Breakpoint here to check for broken paths
IF cubic.ascending THEN Graphics.CurveTo[path, X[cubic.x1], Y[cubic.y1], X[cubic.x2], Y[cubic.y2], X[cubic.x3], Y[cubic.y3]]
ELSE Graphics.CurveTo[path, X[cubic.x2], Y[cubic.y2], X[cubic.x1], Y[cubic.y1], X[cubic.x0], Y[cubic.y0]]
ENDLOOP;
};
ActivePieceTable: TYPE = REF ActivePieceTableRec;
ActivePieceTableRec: TYPE = RECORD [
SEQUENCE maxLength: NAT OF ActivePieceRec
];
ActivePieceRec: TYPE = RECORD [
sortKey: INTEGER,
pieceIndex: NAT
];
activePieceTable: ActivePieceTable _ NIL;
AllocActivePieceTable: ENTRY PROC [size: NAT] RETURNS [a: ActivePieceTable] = {
IF activePieceTable # NIL AND activePieceTable.maxLength >= size THEN {a _ activePieceTable; activePieceTable _ NIL}
ELSE a _ NEW[ActivePieceTableRec[size]]
};
FreeActivePieceTable: ENTRY PROC [a: ActivePieceTable] = {
IF activePieceTable = NIL OR a.maxLength > activePieceTable.maxLength THEN
activePieceTable _ a
};
Sort: PROCEDURE [table: ActivePieceTable, start, startPlusLength: NAT] = {
FOR i: NAT IN [start..startPlusLength) DO
a: ActivePieceRec _ table[i];
b: ActivePieceRec;
j: NAT _ i;
WHILE j>0 AND a.sortKey < (b _ table[j-1]).sortKey DO table[j] _ b; j _ j-1 ENDLOOP;
table[j] _ a;
ENDLOOP;
};
WrapTable: TYPE = REF WrapTableRec;
WrapTableRec: TYPE = RECORD [
SEQUENCE maxLength: NAT OF INTEGER
];
wrapTable: WrapTable _ NIL;
AllocWrapTable: ENTRY PROC [size: NAT] RETURNS [w: WrapTable] = {
IF wrapTable # NIL AND wrapTable.maxLength >= size THEN {w _ wrapTable; wrapTable _ NIL}
ELSE w _ NEW[WrapTableRec[size]]
};
FreeWrapTable: ENTRY PROC [w: WrapTable] = {
IF wrapTable = NIL OR w.maxLength > wrapTable.maxLength THEN
wrapTable _ w
};
ScanConvert: PUBLIC PROCEDURE [devicePath: DevicePath, LineProc: PROC[xmin, xmax, y: INTEGER]] = {
length: NAT _ devicePath.length;
outlines: NAT _ devicePath.numberOfOutlines;
active: ActivePieceTable _ AllocActivePieceTable[length];
wrap: WrapTable _ AllocWrapTable[outlines];
firstActive, firstUnActivated: NAT _ 0;
y: INTEGER _ FIRST[INTEGER];
FOR i: NAT IN [0..length) DO
active[i] _ [sortKey: devicePath.seq[i].ymin, pieceIndex: i];
ENDLOOP;
Sort[active, 0, length];
WHILE firstActive<length DO
nonZeroWrapCount: NAT _ 0;
xStart: INTEGER _ FIRST[INTEGER];
FOR i: NAT IN [0..outlines) DO
wrap[i] _ 0;
ENDLOOP;
IF firstActive=firstUnActivated THEN y _ active[firstUnActivated].sortKey
ELSE y _ y+1;
WHILE firstUnActivated<length AND y=active[firstUnActivated].sortKey DO
firstUnActivated _ firstUnActivated+1;
ENDLOOP;
FOR i: NAT IN [firstActive..firstUnActivated) DO
active[i].sortKey _ XValueFor[devicePath.seq[active[i].pieceIndex]^, Scaled.FromInt[y].PLUS[Scaled.half]];
ENDLOOP;
Sort[active, firstActive, firstUnActivated];
WHILE firstActive<firstUnActivated AND active[firstActive].sortKey = FIRST[INTEGER] DO
firstActive _ firstActive+1;
ENDLOOP;
FOR i: NAT IN [firstActive..firstUnActivated) DO
a: ActivePieceRec _ active[i];
k: NAT _ devicePath.seq[a.pieceIndex].outlineNumber;
w: INTEGER _ wrap[k];
IF a.sortKey = LAST[INTEGER] THEN EXIT;
IF CARDINAL[Inline.BITAND[w, 1]] = 0 THEN {
nonZeroWrapCount _ nonZeroWrapCount + 1;
IF nonZeroWrapCount = outlines THEN xStart _ a.sortKey;
};
IF devicePath.seq[a.pieceIndex].ascending THEN w _ w + 1 ELSE w _ w - 1;
IF CARDINAL[Inline.BITAND[w, 1]] = 0 THEN {
IF nonZeroWrapCount = outlines AND a.sortKey > xStart THEN
LineProc[xStart, a.sortKey, y];
nonZeroWrapCount _ nonZeroWrapCount - 1;
};
wrap[k] _ w;
ENDLOOP;
ENDLOOP;
FreeActivePieceTable[active];
FreeWrapTable[wrap];
};
END.
ŠUFCubicScanImpl.mesa
Created February 16, 1983
Edited by Michael Plass, March 2, 1983 2:00 pm
Returns LAST[INTEGER] if y is below the piece, FIRST[INTEGER] if it is above, otherwise the x-intercept rounded to the nearest integer.
Let garbage collector get it.
Free old sequence here
First find the coefficients of the y projection.
Now find the coefficients of the derivative.
Find where the derivative vanishes.
Now break it up as needed
This is used to monitor the effects of roundoff error in the computation of the monotone pieces.  The globals are meant to be examined with the debugger.
Useful for debugging the DevicePath building code
Κ
˜Jš
œ™J™J™.
unitš
Οk	˜	J˜J˜	J˜	J˜J˜Jš
œ˜J˜J˜	J˜Jš
œ˜J˜
—šœœ
˜Jšœ1˜8Jšœ˜Jšœœ
œ
˜Jšœœœœœœ
œ
œ˜WJšœœœœœœ
œ
œ˜UJšœœœœœœ
œ
œ˜WJšΟnœœœœœœœœ
˜RJšžœœœœœœœœ
˜ZKšœœœœ˜+Kšœœœœ˜$š
ž	œœ
	œ$œœ˜TJš	œœ
œœ
œK™‡
Jšœ˜Jšœœ
˜Jš
œœ
œœ
œ˜2Jš
œœ
œœ
œ˜1Jšœ	œ(˜6Jšœœ
œœ	œ
œœ
œ˜GJšœœ
œœ	œ
œœ
œ˜Hšœ˜šœœ
˜Jš
œ
œ
œ
œ
œ˜=Jšœ
œ˜Jšœ˜—Jš
œ$˜$Jš
œ$˜$Jš
œ$˜$Jš
œ)˜)Jš
œ)˜)Jš
œ,˜,Jšœ
œ@˜PJšœ
œ
œ
œ˜/Jšœ@˜DJšœ
˜—Jšœ˜Jš
œ˜—Kšž
œœ!œuœ˜Η
Kšœœœ0˜Kšžœ	œœ!˜PJšœœœ˜.Jšžœœœœœœ˜lJš
œF˜FJš
œF˜FJš
œF˜FJš
œ/˜/Jš
œ/˜/Jš
œ2˜2Jšœq˜wJ˜—šžœœ
	œ
œ˜?Jšœ
œ˜ Jš
œ˜Jš
œ ˜ Jšœœ˜+J˜—šžœœ
	œ*œ˜HJ™—šžœœ
	œ˜4Jš
œ˜Jš
œ ˜ Jš
œ˜—šžœ	œ3˜VJšœ˜Jš	œœ.œ#œ
œ
˜oJšœ	œ
œ	œ˜*šœ-œ˜6šœœœ
˜ Jšœœ
œ
œ.˜KJš
œ˜—šœœ
œ˜'Jš
œ˜Jš
˜—Jš
œ™Jš
œ˜Jš
œ˜—Jš
œ*˜*Jš
œ*˜*Jšœœ
˜šœœœ˜Jš
œN˜NJšœœ
˜J˜—Jš
œ2˜2Jšœ
œ1˜AJš
œ˜Jš
œ˜Jšœœœ˜SJšœœœ˜SJšœœœ˜SJšœœœ˜SJšœœ.˜AJšœœ.˜AJšœœ.˜AJšœœ.˜AJšœœ+˜FJš
œ˜—šžœ	œ.˜LJšœœœ9˜LJšœœœA˜TJšœœœ9˜LJšœœœA˜TJš
œ˜Jšœœ
œœœ
œœ(˜kšœ˜Jš
œ˜Jš
œ$˜$Jš
œ$˜$J˜—J˜—šžœ	œ5˜Tš
œ˜Jš
œ<˜<Jš
œ<˜<Jš
œ<˜<Jš
œ:˜:J˜—Jš
œ"˜"Jš
œ˜—šžœ	œœœ˜PJšœ
œ
˜J˜ Jšœ
˜—šž	œ	œœœ˜WJšœ
œ˜
J˜&J˜J˜J˜J˜J˜J˜Jš
œ'˜'Jš
œ(˜(Jšœ
˜—šžœ	œ5˜L™0Jšœœ˜Jšœœ˜ Jšœœ!˜(Jšœœ
˜Jšœœ˜ —™,Jšœœ˜Jšœœ˜Jšœœ˜—™#Jšœœ˜šœ
œ˜Jšœœ	˜Jšœœ	˜Jšœœ˜šœœ˜Jšœœ˜J˜J˜Jš
œ˜—Jš
œ
˜
—Jšœ
œœ
˜ —™Jšœœœ˜Jšœœœ˜Jšœ	œœ˜0šœ
œ	œ
œ˜+Jš
œ"˜"Jš
œ'˜'Jš
œ)˜)Jš
œ.˜.Jš
œ:˜:Jš
œ:˜:Jš
œ2˜2Jš
œ&˜&Jš
œ)˜)Jš
œ'˜'Jš
œ
˜
—šœ
œœœœœ˜3Jš
œ˜Jš	œ œœœœ˜EJš
œ.˜.Jš
œ2˜2Jš
œ&˜&Jš
œ'˜'Jš
œ
˜
—Jšœ*˜.—Jš
œ˜—Kšœœ˜Jšœœ˜Jšœ
œ˜šžœ	œ	œ˜"J™™
Jš
œ$˜$Jšœ"œ˜-Jšœ
œœœ˜4Jš
œ˜—šž
œ	œ
œœœœ˜@Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ ˜ Jš
œ˜—šžœœ
	œ˜J˜Jš
œ˜Jšœœœ˜?Jš
œ˜Jš
œ)˜)Jšœ	œœ
˜Jšœœ˜&šžœœ˜%Jšœ	œ	˜Jš
œ!˜!Jšœ
œ
˜Jš
œ˜Jš
œ˜—šžœœ˜%Jšœ
œ
˜Jš
œu˜uJš
œ˜Jš
œ˜—šžœœ$˜/Jšœ
œ
˜Jš
œ2˜2Jš
œ˜Jš
œ˜—šžœœ˜Jšœ	œœ˜<šœœ
œ#˜2Jš	œœœœœ˜?Jš
œ"˜"Jš
œ"˜"Jšœœ˜ Jšœœ˜ Jšœœ˜"Jšœœ˜Jšœœ˜ Jšœœ
˜Jš
˜—Jšœ
œ
˜Jš
œ˜—Jš
œ9˜9Jš
œ>˜>Jš
œ˜—šžœœ
	œ˜6Jš
œ<˜<šœœQ˜rJš
œ*˜*Jš
˜—Jš
œ˜—šžœ	œœ˜]Jš
œ1™1Jšœ	œœ
˜Jšœœ
˜Jš
œ˜šœœ
œ˜'Jš
œ!˜!Jšž
œœœœœœ˜PJšž
œœœœœœ˜Lšœ
œ	œ˜Jšœœ0˜GJšœ1˜5Jšœ
œ
˜J˜—Jš
œ*˜*Jšœœœ
œ˜BJšœœœ
œ˜CJšœ
œ
œΟc,˜dJšœœe˜|Jšœe˜iJšœ
˜—Jš
œ˜—Kšœœœ˜1šœœœ˜$Jšœœ
œ˜)J˜—šœœœ˜Jšœ	œ
˜Jšœ˜J˜—Kšœ%œ
˜)š
žœœ
œœœ˜OJš
œœ
œ$œ+œ
˜tJšœœ˜'Jš
œ˜—šžœœ
œ˜:šœœ
œ*˜JJš
œ˜—Jš
œ˜—šžœ	œ3œ˜Jšœœ
œ˜)Jš
œ˜Jš
œ˜Jšœœ˜Jšœœ&œœ
˜TJš
œ
˜
Jš
˜—Jš
œ˜—Kšœœœ˜#šœœœ˜Jšœœ
œ
˜"J˜—Kšœœ
˜š
žœœ
œœœ˜AJš
œ
œ
œœœ
˜XJšœœ˜ Jš
œ˜—šž
œœ
œ˜,šœ
œ
œ#˜<Jš
œ
˜
—Jš
œ˜—šžœœ
	œžœœœ˜bJšœœ˜ Jšœ
œ˜,Jš
œ9˜9Jš
œ+˜+Jšœœ˜'Jšœœœ
œ˜šœœ
œ
˜Jš
œ=˜=Jš
˜—Jš
œ˜šœ˜Jšœœ˜Jšœœœ
œ˜!šœœ
œ˜Jš
œ˜Jšœ
˜—Jšœœ%˜IJšœ	˜
šœœ$˜GJš
œ&˜&Jšœ
˜—šœœ
œ!˜0JšœWœ˜jJš
˜—Jš
œ,˜,š	œœœ
œ˜VJš
œ˜Jšœ
˜—šœœ
œ!˜0Jš
œ˜Jšœœ.˜4Jšœœ˜Jš
œ
œ
œœ
œ
˜'šœ
œœœ˜+Jš
œ(˜(Jšœœ˜7J˜—Jšœ(œœ˜Hšœ
œœœ˜+šœœ	œ˜:Jš
œ˜—Jš
œ(˜(J˜—Jš
œ˜Jš
˜—Jš
˜—Jš
œ˜Jš
œ˜Jš
œ˜—Kšœ
˜——…—7BJΦ