DIRECTORY
Font, 
Imager, 
ImagerAISUtil,
ImagerBasic,
ImagerBrick,
ImagerDefault,
ImagerPrivate,
ImagerPD,
IO,
JaM, 
JaMImagerContexts,
JaMImager,
JaMIPrivate,
Real,
Rope,
UFPressFontReader,
UFFileManager,
ImagerHalftone
;

ImagerJaM: CEDAR PROGRAM
IMPORTS Font, Imager, IO, JaM, JaMImagerContexts, JaMIPrivate, JaMImager, Real, ImagerAISUtil, ImagerPD, Rope, UFPressFontReader, UFFileManager, ImagerBrick, ImagerHalftone
EXPORTS JaMIPrivate
= BEGIN

Context: TYPE = Imager.Context;
Pair: TYPE = ImagerBasic.Pair;
ROPE: TYPE = Rope.ROPE;
Transformation: TYPE = ImagerBasic.Transformation;

PopPair: PROC [state: JaM.State] RETURNS [Pair] = {
y: REAL _ JaM.PopReal[state];
x: REAL _ JaM.PopReal[state];
RETURN [[x, y]]
};

ConicTo: PROC [state: JaM.State] = {
info: JaMIPrivate.Info _ JaMIPrivate.GetInfo[state];
r: REAL _ JaM.PopReal[state];
p2: Pair _ PopPair[state];
p1: Pair _ PopPair[state];
IF info.trajectory # NIL THEN info.trajectory.first _ info.trajectory.first.ConicTo[p1, p2, r];
};

ArcTo: PROC [state: JaM.State] = {
info: JaMIPrivate.Info _ JaMIPrivate.GetInfo[state];
p2: Pair _ PopPair[state];
p1: Pair _ PopPair[state];
IF info.trajectory # NIL THEN info.trajectory.first _ info.trajectory.first.ArcTo[p1, p2];
};

Move: PROC [state: JaM.State] = {
Paint: PROC [dc: Context] = {dc.Move};
JaMImager.Painter[Paint, state];
};

Trans: PROC [state: JaM.State] = {
Paint: PROC [dc: Context] = {dc.Trans};
JaMImager.Painter[Paint, state];
};

SetXY: PROC [state: JaM.State] = {
p: Pair _ PopPair[state];
Paint: PROC [dc: Context] = {dc.SetXY[p]};
JaMImager.Painter[Paint, state];
};

SetXYRel: PROC [state: JaM.State] = {
p: Pair _ PopPair[state];
Paint: PROC [dc: Context] = {dc.SetXYRel[p]};
JaMImager.Painter[Paint, state];
};

MakeGray: PROC [state: JaM.State] = {
JaM.Push[state, Imager.MakeGray[JaM.PopReal[state]]];
};

Black: PROC [state: JaM.State] = {
JaM.Push[state, Imager.black];
};

White: PROC [state: JaM.State] = {
JaM.Push[state, Imager.white];
};

MakeStipple: PROC [state: JaM.State] = {
JaM.Push[state, Imager.MakeStipple[JaM.PopInt[state]]];
};

SetColor: PROC [state: JaM.State] = {
color: Imager.Color _ NARROW[JaM.Pop[state]];
Paint: PROC [dc: Context] = {dc.SetColor[color]};
JaMImager.Painter[Paint, state];
};

SetSampledColor: PROC [state: JaM.State] = {
aisName: ROPE _ JaM.PopRope[state];
color: ImagerBasic.SampledColor _ ImagerAISUtil.AISToColor[aisName];
Paint: PROC [dc: Context] = {
trans: Transformation _ NARROW[dc.state, ImagerDefault.State].T;
copy: ImagerBasic.SampledColor _ NEW[ImagerBasic.ColorRep.sampled _ color^];
copy.m _ trans;
dc.SetColor[copy];
};
JaMImager.Painter[Paint, state];
};

SetSampledBlack: PROC [state: JaM.State] = {
transparent: BOOLEAN _ JaM.PopBool[state];
pa: ImagerBasic.PixelArray _ NARROW[JaM.Pop[state]];
Paint: PROC [dc: Context] = {
dc.SetSampledBlack[pa, Imager.Rotate[0], transparent];
};
JaMImager.Painter[Paint, state];
};

GetCP: PROC [state: JaM.State] = {
cp: Pair _ [0, 0];
Paint: PROC [dc: Context] = {cp _ NARROW[dc.class, ImagerPrivate.Class].GetCP[dc]};
JaMImager.Painter[Paint, state];
state.PushReal[cp.x];
state.PushReal[cp.y];
};

SetStrokeWidth: PROC [state: JaM.State] = {
w: REAL _ JaM.PopReal[state];
Paint: PROC [dc: Context] = {dc.SetStrokeWidth[w]};
JaMImager.Painter[Paint, state];
};

SetStrokeEnd: PROC [state: JaM.State] = {
i: INT _ JaM.PopInt[state];
Paint: PROC [dc: Context] = {dc.SetStrokeEnd[IF i=1 THEN square ELSE IF i=2 THEN round ELSE butt]};
JaMImager.Painter[Paint, state];
};

SetNoImage: PROC [state: JaM.State] = {
b: BOOLEAN _ JaM.PopBool[state];
encode: ARRAY BOOLEAN OF INTEGER = [FALSE: 0, TRUE: 1];
Paint: PROC [dc: Context] = {
class: ImagerPrivate.Class _ NARROW[dc.class];
class.ISetInt[dc, $noImage, encode[b]]
};
JaMImager.Painter[Paint, state];
};

MaskFill: PROC [state: JaM.State] = {
info: JaMIPrivate.Info _ JaMIPrivate.GetInfo[state];
Paint: PROC [dc: Context] = {dc.MaskFill[info.trajectory]};
JaMImager.Painter[Paint, state];
};

MaskStroke: PROC [state: JaM.State] = {
info: JaMIPrivate.Info _ JaMIPrivate.GetInfo[state];
Paint: PROC [dc: Context] = {dc.MaskStroke[info.trajectory.first]};
IF info.trajectory # NIL THEN JaMImager.Painter[Paint, state];
};

MaskStrokeClosed: PROC [state: JaM.State] = {
info: JaMIPrivate.Info _ JaMIPrivate.GetInfo[state];
Paint: PROC [dc: Context] = {dc.MaskStrokeClosed[info.trajectory.first]};
IF info.trajectory # NIL THEN JaMImager.Painter[Paint, state];
};

MaskRectangle: PROC [state: JaM.State] = {
wh: Pair _ PopPair[state];
xy: Pair _ PopPair[state];
Paint: PROC [dc: Context] = {dc.MaskRectangle[xy.x, xy.y, wh.x, wh.y]};
JaMImager.Painter[Paint, state];
};

MaskVector: PROC [state: JaM.State] = {
p2: Pair _ PopPair[state];
p1: Pair _ PopPair[state];
Paint: PROC [dc: Context] = {dc.MaskVector[p1, p2]};
JaMImager.Painter[Paint, state];
};

StartUnderline: PROC [state: JaM.State] = {
Paint: PROC [dc: Context] = {dc.StartUnderline};
JaMImager.Painter[Paint, state];
};

MaskUnderline: PROC [state: JaM.State] = {
h: REAL _ JaM.PopReal[state];
dy: REAL _ JaM.PopReal[state];
Paint: PROC [dc: Context] = {
dc.MaskUnderline[dy, h];
};
JaMImager.Painter[Paint, state];
};

SetAmplifySpace: PROC [state: JaM.State] = {
e: REAL _ JaM.PopReal[state];
Paint: PROC [dc: Context] = {dc.SetAmplifySpace[e]};
JaMImager.Painter[Paint, state];
};

SetPriorityImportant: PROC [state: JaM.State] = {
b: BOOLEAN _ JaM.PopBool[state];
Paint: PROC [dc: Context] = {dc.SetPriorityImportant[b]};
JaMImager.Painter[Paint, state];
};

CorrectMask: PROC [state: JaM.State] = {
Paint: PROC [dc: Context] = {dc.CorrectMask};
JaMImager.Painter[Paint, state];
};

CorrectSpace: PROC [state: JaM.State] = {
p: Pair _ PopPair[state];
Paint: PROC [dc: Context] = {dc.CorrectSpace[p]};
JaMImager.Painter[Paint, state];
};

DoSave: PROC [state: JaM.State] = {
op: REF _ JaM.Pop[state];
info: JaMIPrivate.Info _ JaMIPrivate.GetInfo[state];
Body: PROC = {JaM.Execute[state, op]};
dcList: JaMImagerContexts.DCList _ info.dcList;
venabled: BOOLEAN _ info.venabled;
{ENABLE UNWIND => {info.dcList _ dcList; info.venabled _ venabled};
info.dcList _ NIL;
IF info.venabled THEN {
info.vdc.DoSave[Body];
};
info.venabled _ FALSE;
FOR dcListItem: JaMImagerContexts.DCList _ dcList, dcListItem.next UNTIL dcListItem = NIL DO
next: JaMImagerContexts.DCList _ dcListItem.next;
{ENABLE UNWIND => dcListItem.next _ next;
info.dcList _ dcListItem;
dcListItem.next _ NIL;
IF dcListItem.enabled THEN {
dcListItem.dc.DoSave[Body];
};
};
dcListItem.next _ next;
ENDLOOP;
};
info.dcList _ dcList;
info.venabled _ venabled;
};

DoSaveAll: PROC [state: JaM.State] = {
op: REF _ JaM.Pop[state];
info: JaMIPrivate.Info _ JaMIPrivate.GetInfo[state];
Body: PROC = {JaM.Execute[state, op]};
dcList: JaMImagerContexts.DCList _ info.dcList;
venabled: BOOLEAN _ info.venabled;
{ENABLE UNWIND => {info.dcList _ dcList; info.venabled _ venabled};
info.dcList _ NIL;
IF info.venabled THEN {
info.vdc.DoSaveAll[Body];
};
info.venabled _ FALSE;
FOR dcListItem: JaMImagerContexts.DCList _ dcList, dcListItem.next UNTIL dcListItem = NIL DO
next: JaMImagerContexts.DCList _ dcListItem.next;
{ENABLE UNWIND => dcListItem.next _ next;
info.dcList _ dcListItem;
dcListItem.next _ NIL;
IF dcListItem.enabled THEN {
dcListItem.dc.DoSaveAll[Body];
};
};
dcListItem.next _ next;
ENDLOOP;
};
info.dcList _ dcList;
info.venabled _ venabled;
};

Correct: PROC [state: JaM.State] = {
op: REF _ JaM.Pop[state];
info: JaMIPrivate.Info _ JaMIPrivate.GetInfo[state];
Body: PROC = {JaM.Execute[state, op]};
dcList: JaMImagerContexts.DCList _ info.dcList;
venabled: BOOLEAN _ info.venabled;
{ENABLE UNWIND => {info.dcList _ dcList; info.venabled _ venabled};
info.dcList _ NIL;
IF info.venabled THEN {
info.vdc.Correct[Body];
};
info.venabled _ FALSE;
FOR dcListItem: JaMImagerContexts.DCList _ dcList, dcListItem.next UNTIL dcListItem = NIL DO
next: JaMImagerContexts.DCList _ dcListItem.next;
{ENABLE UNWIND => dcListItem.next _ next;
info.dcList _ dcListItem;
dcListItem.next _ NIL;
IF dcListItem.enabled THEN {
dcListItem.dc.Correct[Body];
};
};
dcListItem.next _ next;
ENDLOOP;
};
info.dcList _ dcList;
info.venabled _ venabled;
};

SetCorrectMeasure: PROC [state: JaM.State] = {
p: Pair _ PopPair[state];
Paint: PROC [dc: Context] = {dc.SetCorrectMeasure[p]};
JaMImager.Painter[Paint, state];
};

SetCorrectTolerance: PROC [state: JaM.State] = {
p: Pair _ PopPair[state];
Paint: PROC [dc: Context] = {dc.SetCorrectTolerance[p]};
JaMImager.Painter[Paint, state];
};

SetCorrectShrink: PROC [state: JaM.State] = {
e: REAL _ JaM.PopReal[state];
Paint: PROC [dc: Context] = {dc.SetCorrectShrink[e]};
JaMImager.Painter[Paint, state];
};

Space: PROC [state: JaM.State] = {
e: REAL _ JaM.PopReal[state];
Paint: PROC [dc: Context] = {dc.Space[e]};
JaMImager.Painter[Paint, state];
};

IState: PROC [state: JaM.State] = {
s: IO.STREAM _ IO.ROS[];
Paint: PROC [dc: Context] = {
s.Put[IO.refAny[dc.state]];
s.PutChar['\n];
};
JaMImager.Painter[Paint, state];
JaM.Push[state, IO.RopeFromROS[s]];
};

AnyToRope: PROC [state: JaM.State] = {
r: REF _ JaM.Pop[state];
s: IO.STREAM _ IO.ROS[];
s.Put[IO.refAny[r]];
s.PutChar['\n];
JaM.Push[state, IO.RopeFromROS[s]];
};

PlatemakerTemplate: ImagerPD.PDFileDescriptionRep _ [
fileName: NIL,
deviceCode: mig,
sResolution: 880,
fResolution: 880,
imageSSize: 9680,
imageFSize: 7480,
nColors: 1,
bandSSize: 16,
maxLoadWords: 60000,
leftovers: TRUE,
copies: 1
];

PlateMakerParam: PROC[fileName: ROPE] RETURNS [param: ImagerPD.PDFileDescription] = {
param _ NEW[ImagerPD.PDFileDescriptionRep _ PlatemakerTemplate];
param.fileName _ fileName;
};

customRavenBrick: ImagerBrick.Brick _ NIL;

customHornetBrick: ImagerBrick.Brick _ NIL;

customPlatemakerBrick: ImagerBrick.Brick _ NIL;

SetLineScreen: PROC[state: JaM.State] = {
angle: REAL _ JaM.PopReal[state];
linesPerInch: REAL _ JaM.PopReal[state];
customPlatemakerBrick _ ImagerBrick.BuildBrick[freq: 880.0/linesPerInch, angle: angle, filter: ImagerHalftone.LineScreen];
customHornetBrick _ ImagerBrick.BuildBrick[freq: 384.0/linesPerInch, angle: angle+90, filter: ImagerHalftone.LineScreen];
customRavenBrick _ ImagerBrick.BuildBrick[freq: 300.0/linesPerInch, angle: angle+90, filter: ImagerHalftone.LineScreen];
};

OpenPlatemakerPD: PROC[state: JaM.State] = {
name: ROPE = JaM.PopRope[state];
context: Imager.Context _ Imager.Create[$PD, PlateMakerParam[name]];
JaMImagerContexts.AddContext[state, context, PDCallMe, $PD];
context.ScaleT[0.0254/72];
Imager.PutProp[context, $CustomBrick, customPlatemakerBrick];
};

PDCallMe: JaMImagerContexts.CallMe ~ {IF command = initdc THEN {context.Reset; context.ScaleT[0.0254/72]}};

OpenHornetPD: PROC[state: JaM.State] = {
name: ROPE = JaM.PopRope[state];
context: Imager.Context _ Imager.Create[$PD, ImagerPD.Hornet[name]];
JaMImagerContexts.AddContext[state, context, PDCallMe, $PD];
context.ScaleT[0.0254/72];
Imager.PutProp[context, $CustomBrick, customHornetBrick];
};

OpenRavenPD: PROC[state: JaM.State] = {
name: ROPE = JaM.PopRope[state];
context: Imager.Context _ Imager.Create[$PD, ImagerPD.Raven[name]];
JaMImagerContexts.AddContext[state, context, PDCallMe, $PD];
context.ScaleT[0.0254/72];
Imager.PutProp[context, $CustomBrick, customRavenBrick];
};

ClosePD: PROC[state: JaM.State] = {
dc: Context _ JaMImagerContexts.RemoveContext[state, $PD];
IF dc # NIL THEN [] _ Imager.SpecialOp[dc, $Close, NIL];
};

lastInt: REAL ~ 2147483647.0;

Trunc: PROC[state: JaM.State] = {
r: REAL = JaM.PopReal[state];
IF ABS[r] > lastInt THEN {JaM.PushReal[state, r]}
ELSE JaM.PushInt[state, Real.Fix[r]];
};

Round: PROC[state: JaM.State] = {
r: REAL = JaM.PopReal[state];
IF ABS[r] > lastInt THEN {JaM.PushReal[state, r]}
ELSE JaM.PushInt[state, Real.RoundLI[r]];
};

Floor: PROC[state: JaM.State] = {
r: REAL = JaM.PopReal[state];
IF ABS[r] > lastInt THEN {JaM.PushReal[state, r]}
ELSE {
i: INT _ Real.RoundLI[r];
WHILE i >= r DO i_i-1 ENDLOOP;
WHILE i < r DO i_i+1 ENDLOOP;
JaM.PushInt[state, i];
};
};

Ceil: PROC[state: JaM.State] = {
r: REAL = JaM.PopReal[state];
i: INT _ Real.RoundLI[r];
IF ABS[r] > lastInt THEN {JaM.PushReal[state, r]}
ELSE {
i: INT _ Real.RoundLI[r];
WHILE i <= r DO i_i+1 ENDLOOP;
WHILE i > r DO i_i-1 ENDLOOP;
JaM.PushInt[state, i];
};
};

MakeBitArray: PROC[state: JaM.State] = {
bits: PACKED ARRAY [0..1024) OF [0..1];
columns: INT _ JaM.PopInt[state];
rows: INT _ JaM.PopInt[state];
FOR i: INT DECREASING IN [0..columns*rows) DO
bits[i] _ JaM.PopInt[state];
ENDLOOP;
TRUSTED {JaM.Push[state, Imager.MakePixelArrayFromBits[@bits, columns, columns, rows]]};
};

MaskPixel: PROC[state: JaM.State] = {
pa: ImagerBasic.PixelArray _ NARROW[JaM.Pop[state]];
Paint: PROC [dc: Context] = {
dc.MaskPixel[pa];
};
JaMImager.Painter[Paint, state];
};

PixelArrayFromAC: PROC[state: JaM.State] = {
char: CHAR _ JaM.PopRope[state].Fetch[0];
acName: ROPE _ JaM.PopRope[state];
fontKey: UFPressFontReader.FontKey _ [UFFileManager.KeyOf[acName], 0];
pa: ImagerBasic.PixelArray _ UFPressFontReader.GetCharRaster[fontKey, char];
JaM.Push[state, pa];
};

deviceType: ATOM _ $Ideal;
NSRSetFont: PROC[state: JaM.State] = {
rotation: REAL _ JaM.PopReal[state];
size: REAL _ JaM.PopReal[state];
name: ROPE _ JaM.PopRope[state];
font: Font.FONT _ Font.Create[name, Imager.Concat[Imager.Scale[size], Imager.Rotate[rotation]], deviceType];
Paint: PROC [dc: Context] = {
dc.SetFont[font];
};
JaMImager.Painter[Paint, state];
};

Show: PROC[state: JaM.State] = {
text: ROPE _ JaM.PopRope[state];
Paint: PROC [dc: Context] = {
dc.ShowCharacters[text];
};
JaMImager.Painter[Paint, state];
};

Ddt: PROC[state: JaM.State] = {
any: REF _ JaM.Pop[state];
context: Imager.Context _ NIL;
Paint: PROC [dc: Context] = {
IF context = NIL THEN context _ dc;
};
RaiseError: PROC ~ {ERROR};
JaMImager.Painter[Paint, state];
RaiseError[! ABORTED => CONTINUE];
};

ImagerReset: PROC[state: JaM.State] = {
Paint: PROC [dc: Context] = {
brick: REF _ Imager.GetProp[dc, $CustomBrick];
dc.Reset;
dc.ScaleT[0.0254/72];
Imager.PutProp[dc, $CustomBrick, brick];
};
JaMImager.Painter[Paint, state];
};

RegisterImager: PUBLIC PROC [state: JaM.State] = {
JaM.Register[state, ".move", Move];
JaM.Register[state, ".trans", Trans];
JaM.Register[state, ".setxy", SetXY];
JaM.Register[state, ".setxyrel", SetXYRel];
JaM.Register[state, ".makegray", MakeGray];
JaM.Register[state, ".black", Black];
JaM.Register[state, ".white", White];
JaM.Register[state, ".makestipple", MakeStipple];
JaM.Register[state, ".setcolor", SetColor];
JaM.Register[state, ".setsampledcolor", SetSampledColor];
JaM.Register[state, ".setsampledblack", SetSampledBlack];
JaM.Register[state, ".makebitarray", MakeBitArray];
JaM.Register[state, ".maskpixel", MaskPixel];
JaM.Register[state, ".pixelarrayfromac", PixelArrayFromAC];
JaM.Register[state, ".conicto", ConicTo];
JaM.Register[state, ".arcto", ArcTo];
JaM.Register[state, ".getcp", GetCP];
JaM.Register[state, ".setstrokewidth", SetStrokeWidth];
JaM.Register[state, ".setstrokeend", SetStrokeEnd];
JaM.Register[state, ".setnoimage", SetNoImage];
JaM.Register[state, ".maskfill", MaskFill];
JaM.Register[state, ".maskstroke", MaskStroke];
JaM.Register[state, ".maskstrokeclosed", MaskStrokeClosed];
JaM.Register[state, ".maskrectangle", MaskRectangle];
JaM.Register[state, ".maskvector", MaskVector];
JaM.Register[state, ".startunderline", StartUnderline];
JaM.Register[state, ".maskunderline", MaskUnderline];
JaM.Register[state, ".setamplifyspace", SetAmplifySpace];
JaM.Register[state, ".setpriorityimportant", SetPriorityImportant];
JaM.Register[state, ".correctmask", CorrectMask];
JaM.Register[state, ".correctspace", CorrectSpace];
JaM.Register[state, ".dosave", DoSave];
JaM.Register[state, ".dosaveall", DoSaveAll];
JaM.Register[state, ".correct", Correct];
JaM.Register[state, ".setcorrectmeasure", SetCorrectMeasure];
JaM.Register[state, ".setcorrecttolerance", SetCorrectTolerance];
JaM.Register[state, ".setcorrectshrink", SetCorrectShrink];
JaM.Register[state, ".space", Space];
JaM.Register[state, ".istate", IState];
JaM.Register[state, ".anytorope", AnyToRope];
JaM.Register[state, ".openhornetpd", OpenHornetPD];
JaM.Register[state, ".openplatemakerpd", OpenPlatemakerPD];
JaM.Register[state, ".openravenpd", OpenRavenPD];
JaM.Register[state, ".closepd", ClosePD];
JaM.Register[state, ".nsrsetfont", NSRSetFont];
JaM.Register[state, ".show", Show];
JaM.Register[state, ".ddt", Ddt];
JaM.Register[state, ".setlinescreen", SetLineScreen];
JaM.Register[state, ".imagerreset", ImagerReset];


JaM.Register[state, ".trunc", Trunc];
JaM.Register[state, ".round", Round];
JaM.Register[state, ".floor", Floor];
JaM.Register[state, ".ceil", Ceil];
};

END.

 k
pImagerJaM.mesa
Michael Plass, March 1, 1984 8:39:14 am PST
Maureen Stone February 7, 1984 2:39:48 pm PST.
�Êë˜J™J™+š
œ.™.J˜—š
Ïk	˜	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š�œ�œ�œ
˜šœ�œ˜2J˜—šÏnœ�œ�œ˜3Jšœ�œ˜Jšœ�œ˜Jš�œ	˜J˜J˜—šžœ�œ˜$Jš
œ4˜4Jšœ�œ˜Jš
œ˜Jš
œ˜Jš�œ�œ
�œB˜_J˜J˜—šžœ�œ˜"Jš
œ4˜4Jš
œ˜Jš
œ˜Jš�œ�œ
�œ=˜ZJ˜J˜—šžœ�œ˜!Jšžœ�œ˜&Jš
œ ˜ J˜J˜—šžœ�œ˜"Jšžœ�œ˜'Jš
œ ˜ J˜J˜—šžœ�œ˜"Jš
œ˜Jšžœ�œ˜*Jš
œ ˜ J˜J˜—šžœ�œ˜%Jš
œ˜Jšžœ�œ"˜-Jš
œ ˜ J˜J˜—šžœ�œ˜%Jš
œ5˜5J˜J˜—šžœ�œ˜"Jš
œ˜J˜J˜—šžœ�œ˜"Jš
œ˜J˜J˜—šžœ�œ˜(Jš
œ7˜7J˜J˜—šžœ�œ˜%Jšœ�œ˜-Jšžœ�œ&˜1Jš
œ ˜ J˜J˜—šžœ�œ˜,Jšœ	�œ˜#Jš
œD˜Dšžœ�œ˜Jšœ�œ �
œ
˜@Jšœ!�œ(˜LJš
œ˜Jš
œ˜Jš
œ˜—Jš
œ ˜ J˜J˜—šžœ�œ˜,Jšœ
�œ˜*Jšœ�œ˜4šžœ�œ˜Jš
œ6˜6Jš
œ˜—Jš
œ ˜ J˜J˜—šžœ�œ˜"J˜Jšžœ�œ�œ+˜SJš
œ ˜ Jš
œ˜Jš
œ˜J˜J˜—šžœ�œ˜+Jšœ�œ˜Jšžœ�œ(˜3Jš
œ ˜ J˜J˜—šžœ�œ˜)Jšœ�œ˜Jšžœ�œ"�œ�œ�œ
�œ�œ�œ˜cJš
œ ˜ J˜J˜—šž
œ�œ˜'Jšœ�œ˜ Jš
œ�œ
�œ
�œ
�œ�œ�œ˜7šžœ�œ˜Jšœ�œ˜.Jš
œ&˜&Jš
œ˜—Jš
œ ˜ J˜J˜—šžœ�œ˜%Jš
œ4˜4Jšžœ�œ0˜;Jš
œ ˜ J˜J˜—šž
œ�œ˜'Jš
œ4˜4Jšžœ�œ8˜CJš�œ�œ
�œ!˜>J˜J˜—šžœ�œ˜-Jš
œ4˜4Jšžœ�œ>˜IJš�œ�œ
�œ!˜>J˜J˜—šž
œ�œ˜*Jš
œ˜Jš
œ˜Jšžœ�œ<˜GJš
œ ˜ J˜J˜—šž
œ�œ˜'Jš
œ˜Jš
œ˜Jšžœ�œ)˜4Jš
œ ˜ J˜J˜—šžœ�œ˜+Jšžœ�œ%˜0Jš
œ ˜ J˜J˜—šž
œ�œ˜*Jšœ�œ˜Jšœ�œ˜šžœ�œ˜Jš
œ˜Jš
œ˜—Jš
œ ˜ J˜J˜—šžœ�œ˜,Jšœ�œ˜Jšžœ�œ)˜4Jš
œ ˜ J˜J˜—šžœ�œ˜1Jšœ�œ˜ Jšžœ�œ.˜9Jš
œ ˜ J˜J˜—šžœ�œ˜(Jšžœ�œ"˜-Jš
œ ˜ J˜J˜—šžœ�œ˜)Jš
œ˜Jšžœ�œ&˜1Jš
œ ˜ J˜J˜—šžœ�œ˜#Jšœ�œ˜J˜4Jšžœ�œ˜&Jš
œ/˜/Jšœ
�œ˜"šœ
�œ
�œ5˜CJšœ�œ
˜š�œ�œ˜Jš
œ˜Jš
œ˜—Jšœ�œ
˜š�œ@�œ�œ
�˜\Jš
œ1˜1šœ
�œ
�œ˜)Jš
œ˜Jšœ�œ
˜š�œ�œ˜Jš
œ˜J˜—J˜—Jš
œ˜Jš
�˜—J˜—Jš
œ˜Jš
œ˜J˜J˜—šž	œ�œ˜&Jšœ�œ˜J˜4Jšžœ�œ˜&Jš
œ/˜/Jšœ
�œ˜"šœ
�œ
�œ5˜CJšœ�œ
˜š�œ�œ˜Jš
œ˜Jš
œ˜—Jšœ�œ
˜š�œ@�œ�œ
�˜\Jš
œ1˜1šœ
�œ
�œ˜)Jš
œ˜Jšœ�œ
˜š�œ�œ˜Jš
œ˜J˜—J˜—Jš
œ˜Jš
�˜—J˜—Jš
œ˜Jš
œ˜J˜J˜—šžœ�œ˜$Jšœ�œ˜J˜4Jšžœ�œ˜&Jš
œ/˜/Jšœ
�œ˜"šœ
�œ
�œ5˜CJšœ�œ
˜š�œ�œ˜Jš
œ˜Jš
œ˜—Jšœ�œ
˜š�œ@�œ�œ
�˜\Jš
œ1˜1šœ
�œ
�œ˜)Jš
œ˜Jšœ�œ
˜š�œ�œ˜Jš
œ˜J˜—J˜—Jš
œ˜Jš
�˜—J˜—Jš
œ˜Jš
œ˜J˜J˜—šžœ�œ˜.Jš
œ˜Jšžœ�œ+˜6Jš
œ ˜ J˜J˜—šžœ�œ˜0Jš
œ˜Jšžœ�œ-˜8Jš
œ ˜ J˜J˜—šžœ�œ˜-Jšœ�œ˜Jšžœ�œ*˜5Jš
œ ˜ J˜J˜—šžœ�œ˜"Jšœ�œ˜Jšžœ�œ˜*Jš
œ ˜ J˜J˜—šžœ�œ˜#Jš	œ�œ
�œ�œ
�œ˜šžœ�œ˜Jšœ�œ˜Jš
œ˜Jš
œ˜—Jš
œ ˜ Jšœ�œ˜#J˜J˜—šž	œ�œ˜&Jšœ�œ˜Jš	œ�œ
�œ�œ
�œ˜Jšœ�œ˜Jš
œ˜Jšœ�œ˜#J˜J˜—š
œ5˜5Jšœ
�œ
˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jšœ�œ
˜Jš
œ	˜	Jš
œ˜J˜—šžœ�œ�œ�œ(˜UJšœ�œ5˜@Jš
œ˜J˜J˜—šœ&�œ
˜*J˜—šœ'�œ
˜+J˜—šœ+�œ
˜/J˜—šž
œ�œ˜)Jšœ�œ˜!Jšœ�œ˜(Jš
œz˜zJš
œy˜yJš
œx˜xJ˜J˜—šžœ�œ˜,Jšœ�œ˜ Jš
œD˜DJš
œ<˜<Jš
œ˜Jš
œ=˜=J˜J˜—šžœ�œ�œ-˜kJ˜—šžœ�œ˜(Jšœ�œ˜ Jš
œD˜DJš
œ<˜<Jš
œ˜Jš
œ9˜9J˜J˜—šžœ�œ˜'Jšœ�œ˜ Jš
œC˜CJš
œ<˜<Jš
œ˜Jš
œ8˜8J˜J˜—šžœ�œ˜#Jš
œ:˜:Jš�œ�œ
�œ#�œ˜8J˜J˜—Jšœ	�œ˜J˜šžœ�œ˜!Jšœ�œ˜Jš�œ
�œ�œ˜1Jš�œ!˜%J˜J˜—šžœ�œ˜!Jšœ�œ˜Jš�œ
�œ�œ˜1Jš�œ%˜)J˜J˜—šžœ�œ˜!Jšœ�œ˜Jš�œ
�œ�œ˜1š�œ˜Jšœ�œ˜Jš�œ�œ�œ
˜Jš�œ�œ�œ
˜Jš
œ˜Jš
œ˜—J˜J˜—šžœ�œ˜ Jšœ�œ˜Jšœ�œ˜Jš�œ
�œ�œ˜1š�œ˜Jšœ�œ˜Jš�œ�œ�œ
˜Jš�œ�œ�œ
˜Jš
œ˜Jš
œ˜—J˜J˜—šžœ�œ˜(Jšœ�œ
�œ�œ˜'Jšœ	�œ˜!Jšœ�œ˜š	�œ�œ
�
œ
�œ�˜-Jš
œ˜Jš
�˜—Jš�œQ˜XJ˜J˜—šž	œ�œ˜%Jšœ�œ˜4šžœ�œ˜Jš
œ˜Jš
œ˜—Jš
œ ˜ J˜J˜—šžœ�œ˜,Jšœ�œ˜)Jšœ�œ˜"Jš
œF˜FJš
œL˜LJš
œ˜J˜J˜—Jšœ�œ
˜šž
œ�œ˜&Jšœ
�œ˜$Jšœ�œ˜ Jšœ�œ˜ Jšœ�œ]˜lšžœ�œ˜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˜J˜—šžœ�œ˜2Jš
œ#˜#Jš
œ%˜%Jš
œ%˜%Jš
œ+˜+Jš
œ+˜+Jš
œ%˜%Jš
œ%˜%Jš
œ1˜1Jš
œ+˜+Jš
œ9˜9Jš
œ9˜9Jš
œ3˜3Jš
œ-˜-Jš
œ;˜;Jš
œ)˜)Jš
œ%˜%Jš
œ%˜%Jš
œ7˜7Jš
œ3˜3Jš
œ/˜/Jš
œ+˜+Jš
œ/˜/Jš
œ;˜;Jš
œ5˜5Jš
œ/˜/Jš
œ7˜7Jš
œ5˜5Jš
œ9˜9Jš
œC˜CJš
œ1˜1Jš
œ3˜3Jš
œ'˜'Jš
œ-˜-Jš
œ)˜)Jš
œ=˜=Jš
œA˜AJš
œ;˜;Jš
œ%˜%Jš
œ'˜'Jš
œ-˜-Jš
œ3˜3Jš
œ;˜;Jš
œ1˜1Jš
œ)˜)Jš
œ/˜/Jš
œ#˜#J˜!J˜5Jš
œ1˜1J˜J˜Jš
œ%˜%Jš
œ%˜%Jš
œ%˜%Jš
œ#˜#J˜J˜—Jš�œ
˜J˜—J˜—…—@æTA