DIRECTORY
FS,
Imager USING [Context, ShowText],
ImagerFont USING [MapText, XStringProc],
Interpress USING [AddMaster, LogProc, OpenMaster, OpenMasterRep],
IO,
IPInterpreter,
IPMaster USING [Block, Body, BodyRep, BYTE, EncodingValue, GetHeader, GetOpFromEv, GetSkeleton, GetToken, IntFromSequenceData, Node, NodeRep, Op, OpFromEv, RealFromSequenceData, SequenceType, Skeleton, SkipBytes, SkipToEndOfBody, Token],
RefText USING [ReserveChars],
RopeFile,
Rope;

IPExecImpl: CEDAR PROGRAM
IMPORTS FS, IO, Imager, ImagerFont, Interpress, IPInterpreter, IPMaster, RefText, Rope, RopeFile
EXPORTS Interpress, IPInterpreter
~ BEGIN OPEN IPInterpreter, IPMaster;

ROPE: TYPE ~ Rope.ROPE;
STREAM: TYPE ~ IO.STREAM;

Token: TYPE ~ IPMaster.Token;
Body: TYPE ~ IPMaster.Body;
Block: TYPE ~ IPMaster.Block;
Node: TYPE ~ IPMaster.Node;
NodeRep: TYPE ~ IPMaster.NodeRep;
BYTE: TYPE ~ IPMaster.BYTE;

MarkRecovery: PUBLIC ERROR ~ CODE;
Bug: PUBLIC ERROR ~ CODE;

Run: TYPE ~ RECORD[start, len: INT];
RunList: TYPE ~ LIST OF Run;

DoString: PROC [self: Ref, text: REF TEXT] ~ {
string: ImagerFont.XStringProc ~ { ImagerFont.MapText[text: text, charAction: charAction] };
PushVector[self, VectorFromString[string]];
};

DoIdentifier: PROC [self: Ref, text: REF TEXT] ~ {
len: NAT ~ text.length;
warn: BOOL _ FALSE;
FOR i: NAT IN[0..len) DO
char: CHAR ~ text[i];
SELECT char FROM
IN['a..'z], IN['A..'Z] => NULL;
IN['0..'9], '- => IF i=0 THEN warn _ TRUE;
ENDCASE => warn _ TRUE;
ENDLOOP;
IF len=0 THEN warn _ TRUE;
PushIdentifier[self, Rope.FromRefText[text]];
IF warn THEN MasterWarning[$invalidEncoding, "Invalid Identifier"];
};

DoInteger: PROC [self: Ref, text: REF TEXT] ~ {
len: NAT ~ text.length;
IF len<=4 THEN {
val: INT ~ IPMaster.IntFromSequenceData[text];
PushNum[self, [int[val]]];
}
ELSE {
val: REAL ~ IPMaster.RealFromSequenceData[text];
PushNum[self, [real[val]]];
};
};

DoRational: PROC [self: Ref, text: REF TEXT] ~ {
len: NAT ~ text.length;
half: NAT ~ len/2;
IF half<=4 THEN {
n: INT ~ IPMaster.IntFromSequenceData[text: text, start: 0, len: half];
d: INT ~ IPMaster.IntFromSequenceData[text: text, start: half, len: half];
IF n IN INTEGER AND d IN INTEGER THEN PushNum[self, [rational[n: n, d: d]]]
ELSE PushNum[self, [real[REAL[n]/REAL[d]]]];
}
ELSE {
n: REAL ~ IPMaster.RealFromSequenceData[text: text, start: 0, len: half];
d: REAL ~ IPMaster.RealFromSequenceData[text: text, start: half, len: half];
PushNum[self, [real[n/d]]];
};
IF (half+half)#len THEN MasterWarning[$invalidEncoding, 
IO.PutFR1["Invalid sequenceRational (length=%g)", IO.int[len]]];
};

DoInsertFile: PROC [self: Ref, text: REF TEXT] ~ {
MasterWarning[$unimplemented, "Not implemented: sequenceInsertFile"];
};

Fetch16: PROC [rope: ROPE, startByte: INT] RETURNS [CARDINAL] ~ {
b0: CARDINAL ~ Rope.Fetch[rope, startByte]-'\000;
b1: CARDINAL ~ Rope.Fetch[rope, startByte+1]-'\000;
RETURN [b0*256+b1];
};

NameOfFileForStream: PROC [stream: IO.STREAM] RETURNS [rope: ROPE _ NIL] ~ {
openFile: FS.OpenFile;
ok: BOOL _ FALSE;
openFile _ FS.OpenFileFromStream[stream ! FS.Error, IO.Error => {ok _ FALSE; CONTINUE}];
IF ok THEN rope _ FS.GetName[openFile! FS.Error => CONTINUE].fullFName;
};

smallish: INT _ 10000;
maxChunkSize: INT ~ LAST[NAT]-SIZE[TEXT[0]]*2-4;
RopeFromRuns: PROC [stream: IO.STREAM, runs: LIST OF Run, sequenceLength: INT] RETURNS [rope: ROPE _ NIL] ~ {
size: INT _ 0;
filename: ROPE _ NIL;
IF sequenceLength > smallish AND (filename _ NameOfFileForStream[stream]) # NIL THEN {
ropeFile: ROPE ~ RopeFile.Create[name: filename, buffers: 1, raw: TRUE];
FOR r: LIST OF Run _ runs, r.rest UNTIL r = NIL DO
run: Run ~ r.first;
rope _ Rope.Concat[rope, Rope.Substr[ropeFile, run.start, run.len]];
size _ size + run.len;
ENDLOOP;
}
ELSE {
saveIndex: INT ~ IO.GetIndex[stream];
FOR r: LIST OF Run _ runs, r.rest UNTIL r = NIL DO
run: Run _ r.first;
UNTIL run.len = 0 DO
chunkSize: NAT ~ MIN[run.len, maxChunkSize];
text: Rope.Text ~ Rope.NewText[chunkSize];
zero: [0..0];
IO.SetIndex[stream, run.start];
TRUSTED {zero _ IO.GetBlock[stream, LOOPHOLE[text], 0, chunkSize]-chunkSize};
rope _ Rope.Concat[rope, text];
size _ size + chunkSize;
run.start _ run.start + chunkSize;
run.len _ run.len - chunkSize;
ENDLOOP;
ENDLOOP;
IO.SetIndex[stream, saveIndex];
};
IF size # sequenceLength THEN ERROR;
};

opFromEncodingValue: IPMaster.OpFromEv ~ IPMaster.GetOpFromEv[];

InvalidEncodingValue: PROC [ev: IPMaster.EncodingValue] ~ {
MasterWarning[$invalidEncoding, 
IO.PutFR1["Invalid encoding value (%g)", IO.int[ORD[ev]]]];
};

ExecuteToEndOfBody: PROC [self: Ref] ~ {
stream: STREAM ~ self.stream;
sequenceData: {nil, text, runs, skip} _ nil;
sequenceType: SequenceType _ nil;
sequenceLength: INT _ 0;
sequenceRuns: INT _ 0;
text: REF TEXT _ NIL;
buffer: REF TEXT ~ self.buffer;
runsHead, runsTail: LIST OF Run _ NIL;
BeginSequence: PROC [seq: SequenceType] ~ {
SELECT sequenceType _ seq FROM
sequenceString, sequenceIdentifier, sequenceInsertFile, sequenceComment, 
sequenceInteger, sequenceRational, sequenceReal => sequenceData _ text;
sequenceLargeVector, sequencePackedPixelVector, sequenceCompressedPixelVector, sequenceAdaptivePixelVector => sequenceData _ runs;
ENDCASE => sequenceData _ skip;
SELECT sequenceData FROM
text => { text _ buffer; text.length _ 0 };
runs => { runsHead _ runsTail _ NIL };
ENDCASE;
sequenceLength _ 0;
};
ExtendSequence: PROC [length: INT] ~ {
SELECT sequenceData FROM
nil => {
MasterWarning[$invalidEncoding, "Misplaced sequenceContinued"];
SkipBytes[stream, length];
};
text => {
len: NAT ~ length;
nBytesRead: NAT _ 0;
IF (text.maxLength-text.length)<len THEN text _ RefText.ReserveChars[text, len];
nBytesRead _ IO.GetBlock[self: stream, block: text, startIndex: text.length, count: len];
IF nBytesRead#len THEN ERROR IO.EndOfStream[stream];
};
runs => {
prevTail: LIST OF Run ~ runsTail;
runsTail _ LIST[[start: IO.GetIndex[stream], len: length]];
IF prevTail=NIL THEN runsHead _ runsTail ELSE prevTail.rest _ runsTail;
SkipBytes[stream, length];
};
skip => SkipBytes[stream, length];
ENDCASE => ERROR;
sequenceRuns _ sequenceRuns+1;
sequenceLength _ sequenceLength+length;
};
FinishSequence: PROC ~ {
SELECT sequenceType FROM
sequenceString => DoString[self, text];
sequenceIdentifier => DoIdentifier[self, text];
sequenceInteger => DoInteger[self, text];
sequenceRational => DoRational[self, text];
sequenceInsertFile => DoInsertFile[self, text];
sequenceComment => NULL;
sequenceLargeVector => {
rope: ROPE ~ RopeFromRuns[self.stream, runsHead, sequenceLength];
b: NAT ~ Rope.Fetch[rope, 0]-'\000;
vector: Vector ~ VectorFromBytes[bytes: Rope.Substr[rope, 1], bytesPerElement: b, signed: TRUE];
PushVector[self, vector];
};
sequencePackedPixelVector => {
rope: ROPE ~ RopeFromRuns[self.stream, runsHead, sequenceLength];
bitsPerSample: [1..1] ~ Fetch16[rope, 0]; -- only one bit per sample supported here
scanLength: NAT ~ Fetch16[rope, 2];
dataBitsPerLine: NAT ~ bitsPerSample*scanLength;
padBitsPerLine: NAT ~ NAT[32 - (dataBitsPerLine MOD 32)] MOD 32;
vector: Vector ~ VectorFromBits[bytes: Rope.Substr[rope, 4], dataBitsPerLine: dataBitsPerLine, padBitsPerLine: padBitsPerLine];
PushVector[self, vector];
};
sequenceCompressedPixelVector => MasterWarning[$unimplemented, 
"Not implemented: sequenceCompressedPixelVector"];
sequenceAdaptivePixelVector => MasterWarning[$unimplemented, 
"Not implemented: sequenceAdaptivePixelVector"];
sequenceContinued => MasterWarning[$invalidEncoding, 
"Misplaced sequenceContinued"];
ENDCASE => MasterWarning[$invalidEncoding, 
IO.PutFR1["Invalid sequence type (%g)", IO.int[ORD[sequenceType]]]];
sequenceData _ nil;
sequenceType _ nil;
};
DO -- for each Token
token: Token ~ GetToken[stream: self.stream, flushComments: FALSE];
IF token.seq=sequenceContinued THEN { ExtendSequence[token.len]; LOOP };
self.context.token _ token;
IF sequenceType=sequenceString THEN {
done: BOOL _ TRUE;
SELECT token.op FROM
show => Imager.ShowText[context: self.imager, text: text];
showandxrel => Imager.ShowText[context: self.imager, text: text, xrel: TRUE];
ENDCASE => done _ FALSE;
IF done THEN { sequenceData _ nil; LOOP };
};
IF sequenceData#nil THEN FinishSequence[];
IF token.op=endBody THEN EXIT;
SELECT token.type FROM
op => {
ev: IPMaster.EncodingValue ~ token.op;
op: IPMaster.Op ~ opFromEncodingValue[ev];
IF op#nil THEN Apply[self, op] ELSE InvalidEncodingValue[ev];
};
num => PushNum[self, [int[token.num]]];
seq => { BeginSequence[token.seq]; ExtendSequence[token.len] };
ENDCASE => ERROR;
ENDLOOP;
};


BeginBody: PROC [self: Ref] RETURNS [INT] ~ {
token: Token ~ IPMaster.GetToken[self.stream];
self.context.token _ token;
IF NOT token.op=beginBody THEN MasterError[$missingBody, "Missing body"];
RETURN[token.index];
};

SkipInlineBody: PUBLIC PROC [self: Ref] ~ {
index: INT ~ BeginBody[self];
IPMaster.SkipToEndOfBody[self.stream];
};

GetInlineBody: PUBLIC PROC [self: Ref] RETURNS [Body] ~ {
start, stop: INT _ 0;
start _ BeginBody[self];
IPMaster.SkipToEndOfBody[self.stream];
stop _ IO.GetIndex[self.stream];
RETURN[NEW[IPMaster.BodyRep _ [index: start, length: stop-start]]];
};

ExecuteInlineBody: PROC [self: Ref] ~ {
index: INT ~ BeginBody[self];
DO error: BOOL _ FALSE;
ExecuteToEndOfBody[self ! MarkRecovery => { error _ TRUE; CONTINUE }];
IF error THEN { -- do mark recovery
marker: Marker ~ PopToActiveMark[self];
IF marker=self.context.marker THEN {
IO.SetIndex[self.stream, self.context.token.index];
DO token: Token ~ IPMaster.GetToken[self.stream];
SELECT token.op FROM
endBody => ERROR MarkRecovery; -- end of body
beginBody => IPMaster.SkipToEndOfBody[self.stream]; -- skip body literal
unmark0 => { IO.SetIndex[self.stream, token.index]; EXIT }; -- found UNMARK0
ENDCASE;
IF token.type=seq THEN IPMaster.SkipBytes[self.stream, token.len];
ENDLOOP;
}
ELSE ERROR MarkRecovery; -- not this context's marker
}
ELSE EXIT; -- normal completion
ENDLOOP;
};


CallInlineBody: PUBLIC PROC [self: Ref, frame: Vector, env: Vector] ~ {
action: PROC ~ { ExecuteInlineBody[self] };
Call[self: self, action: action, frame: frame, env: env];
};

CallBody: PROC [self: Ref, body: Body, frame: Vector, env: Vector] ~ {
stream: STREAM ~ self.stream;
next: INT ~ IO.GetIndex[stream];
IO.SetIndex[stream, body.index];
CallInlineBody[self: self, frame: frame, env: env ! UNWIND => IO.SetIndex[stream, next]];
IO.SetIndex[stream, next];
};


DoWithMarkProtection: PUBLIC PROC [self: Ref, action: PROC] ~ {
error: BOOL _ FALSE;
inner: PROC ~ { Mark[self, 0]; action[]; Unmark[self, 0] };
inner[! MarkRecovery => { error _ TRUE; CONTINUE}];
IF error THEN { -- do mark recovery
marker: Marker ~ PopToActiveMark[self];
IF marker=self.context.marker THEN Unmark[self, 0]
ELSE ERROR MarkRecovery;
};
};


Do: PUBLIC PROC [self: Ref, op: Operator] ~ { op.class.do[op, self] };

composedClass: OperatorClass ~ NEW[OperatorClassRep _ [
type: $Composed, do: ComposedDo]];

ComposedData: TYPE ~ REF ComposedDataRep;
ComposedDataRep: TYPE ~ RECORD[
frame: Vector, -- initial frame
env: Vector, -- environment
body: Body -- body of the operator
];

ComposedDo: PROC [op: Operator, state: Ref] ~ {
data: ComposedData ~ NARROW[op.data];
CallBody[self: state, body: data.body, frame: data.frame, env: data.env];
};

MakeCO: PUBLIC PROC [frame: Vector, env: Vector, body: Body] RETURNS [Operator] ~ {
data: ComposedData ~ NEW[ComposedDataRep _ [frame: frame, env: env, body: body]];
RETURN[NEW[OperatorRep _ [class: composedClass, data: data]]];
};


CallPreamble: PROC [self: Ref, node: Node, frame: Vector, env: Vector] ~ {
WITH node SELECT FROM
node: REF NodeRep.body => {
preamble: PROC ~ {
Mark[self, 0];
ExecuteInlineBody[self];
IF Count[self]<1 THEN PushVector[self, Env[self]];
IF Count[self]<2 THEN PushVector[self, Frame[self]];
Unmark[self, 2];
};
IO.SetIndex[self.stream, node.body.index];
Call[self: self, action: preamble, frame: frame, env: env];
};
ENDCASE => ERROR;
};

CallNode: PROC [self: Ref, node: Node, frame: Vector, env: Vector] ~ {
WITH node SELECT FROM
node: REF NodeRep.body => {
body: Body ~ node.body;
IO.SetIndex[self.stream, body.index];
CallInlineBody[self: self, frame: frame, env: env];
};
ENDCASE => ERROR;
};

emptyVec: Vector ~ ZeroVec[0];
topFrame: Vector ~ ZeroVec[topFrameSize];
topEnv: Vector ~ emptyVec; -- empty vector, for now

OpenMaster: TYPE ~ Interpress.OpenMaster;
OpenMasterRep: TYPE ~ Interpress.OpenMasterRep;
OpenMasterImplRep: PUBLIC TYPE ~ IPInterpreter.Rep; -- exported to Interpress
LogProc: TYPE ~ Interpress.LogProc;

DoTopAction: PROC [master: OpenMaster, action: PROC] ~ {
self: Ref ~ master.impl;
protect: PROC ~ { DoWithMarkProtection[self, action] };
call: PROC ~ { Call[self, protect, emptyVec, emptyVec] };
save: PROC ~ { IF self.imager=NIL THEN call ELSE DoSaveAll[self, call] };
Interpress.AddMaster[master, save];
};

DoPreamble: PROC [master: OpenMaster] ~ {
self: Ref ~ master.impl;
block: Block ~ master.skeleton.topBlock;
action: PROC ~ {
CallPreamble[self: self, node: block.preamble, frame: topFrame, env: topEnv];
self.topFrame _ PopVector[self];
self.topEnv _ PopVector[self];
};
DoTopAction[master, action];
};

defaultMaxStackLength: Cardinal ~ 1000;

Open: PUBLIC PROC [fileName: ROPE, logProc: LogProc, logData: REF _ NIL] 
RETURNS [OpenMaster] ~ {
stream: STREAM ~ FS.StreamOpen[fileName];
RETURN [FromStream[stream, logProc, logData]];
};

FromStream: PUBLIC PROC [stream: STREAM, logProc: LogProc, logData: REF _ NIL] 
RETURNS [OpenMaster] ~ {
restOfHeader: ROPE ~ IPMaster.GetHeader[stream, "Interpress/Xerox/"];
skeleton: IPMaster.Skeleton ~ IPMaster.GetSkeleton[stream];
self: Ref ~ NEW[Rep _ [stream: stream]];
master: OpenMaster ~ NEW[OpenMasterRep _ [
pages: skeleton.topBlock.size, skeleton: skeleton, 
logProc: logProc, logData: logData, impl: self]];
self.buffer _ NEW[TEXT[200]];
self.stackArray _ NEW[StackArrayRep _ ALL[[zero[]]]];
self.stackCountMax _ defaultMaxStackLength;
self.markArray _ NEW[MarkArrayRep[4] _ [size: 0, seq: ]];
DoPreamble[master];
RETURN[master];
};

DoPage: PUBLIC PROC [master: OpenMaster, page: INT, context: Imager.Context] ~ {
IF page IN[1..master.pages] THEN {
block: Block ~ master.skeleton.topBlock;
node: Node ~ block[page-1];
self: Ref ~ master.impl;
action: PROC ~ { CallNode[self: self, node: node, frame: self.topFrame, env: self.topEnv] };
self.imager _ context;
DoTopAction[master, action];
self.imager _ NIL;
};
};

END.

ήIPExecImpl.mesa
Copyright c 1984, 1985 by Xerox Corporation.  All rights reserved.
Michael Plass, June 7, 1985 3:32:30 pm PDT
Doug Wyatt, November 22, 1985 4:15:21 pm PST
node: REF NodeRep.block => {
MasterError[$unimplemented, "Preamble cannot be a block."];
ERROR Error;
};
node: REF NodeRep.block => {
block: Block ~ node.block;
pageFrame, pageEnv: Vector;
CallPreamble[self, block.preamble, frame, env];
pageFrame _ PopVector[self];
pageEnv _ PopVector[self];
FOR i: NAT IN[0..block.size) DO
CallNode[self, block[i], pageFrame, pageEnv];
ENDLOOP;
};
self.imager _ imager; -- dummy imager context

ObtainExternalInstructions: PROC [self: Ref] RETURNS [Vector] ~ {
RETURN[VectorFromAny[GetP[Env[self], $externalInstructions]]];
};

AddInstructionDefaults: PROC [self: Ref, computedInstructions, externalInstructions: Vector]
RETURNS [Vector] ~ {
RETURN[computedInstructions]
};

ExecuteInstructionsBody: PROC [self: Ref, externalInstructions: Vector] RETURNS [Vector] ~ {
body: Index ~ self.skeleton.preamble.instructions;
IF body=nullIndex THEN RETURN[externalInstructions]
ELSE {
reader: Reader ~ NARROW[self.reader];
PushVector[self, externalInstructions];
reader.SetIndex[body];
DoBody[self, NoPool[], initialTopFrame, $saveAll];
WHILE Count[self]>1 DO Apply[self, $mergeprop] ENDLOOP;
RETURN[PopVector[self]];
};
};

ComputePrintingInstructions: PROC [self: Ref] ~ {
externalInstructions: Vector ~ ObtainExternalInstructions[self];
instructions: Vector _ emptyVector;

Mark[self, 0];
instructions _ ExecuteInstructionsBody[self, externalInstructions ! Error => CONTINUE];
Unmark0[self];

instructions _ AddInstructionDefaults[self, instructions, externalInstructions];

self.media _ GetP[instructions, $media];
self.copySelect _ GetP[instructions, $copySelect];
self.pageSelect _ GetP[instructions, $pageSelect];
self.onSimplex _ GetP[instructions, $onSimplex];
self.mediaSelect _ GetP[instructions, $mediaSelect];
self.copyName _ GetP[instructions, $copyName];
self.instructions _ instructions;
};

Κ‘˜
codeš
œ™Kšœ
Οm
œ7™BK™*Kš
œ,™,—K˜š
Οk	˜	Kšžœ
˜Kšœžœ˜!Kšœžœ˜(Kšœžœ1˜AKšžœ
˜Kš
œ˜Kšœ	žœžœΓ
˜ν
Kšœžœ˜K˜	Kš
œ˜—K˜KšΠbl
œžœ
ž˜Kšžœ
žœžœR˜`Kšžœ˜!Kšœžœ
žœ˜%K˜Kšžœžœžœ
˜Kšžœžœžœ
žœ
˜K˜Kšœžœ˜Kšœžœ˜Kšœžœ˜Kšœžœ˜Kšœ	žœ˜!Kšžœžœžœ
˜K˜Kšœžœ
žœžœ
˜"Kšœžœ
žœžœ
˜K˜Kšœžœžœ
žœ˜$Kšœ	žœžœ
žœ˜K˜šΟnœžœžœ
žœ˜.K˜\Kš
œ+˜+K˜K˜—š œžœžœ
žœ˜2Kšœžœ˜Kšœžœžœ
˜šžœžœ
žœ	ž˜Kšœžœ˜šžœž˜Kšžœ
žœžœ
˜Kšžœžœžœžœ
˜*Kšžœžœ
˜—Kšžœ
˜—Kšžœžœžœ
˜K˜-Kšžœžœ7˜CK˜K˜—š 	œžœžœ
žœ˜/Kšœžœ˜šžœžœ˜Kšœžœ&˜.Kš
œ˜K˜
—šžœ˜Kšœžœ'˜0Kš
œ˜K˜—K˜K˜—š 
œžœžœ
žœ˜0Kšœžœ˜Kšœžœ	˜šžœ	žœ˜KšœžœA˜GKšœžœD˜JKšžœžœ
žœ
žœžœ
žœ
žœ&˜KKšžœžœžœ˜,K˜
—šžœ˜KšœžœB˜IKšœžœE˜LKš
œ˜K˜—Kšžœžœ"žœ0žœ˜yK˜K˜—š œžœžœ
žœ˜2Kš
œE˜EK˜K˜—š œžœžœ
žœžœžœ˜AKšœžœ%˜1Kšœžœ'˜3Kšžœ
˜K˜K˜—š œžœ
žœ
žœžœžœžœ˜LKšœ
žœ
˜Kšœžœžœ
˜Kšœžœžœžœžœžœ˜XKš
žœžœžœžœ
žœ˜GKš
œ˜K˜—Kšœ
žœ	˜Kšœžœžœ
žœžœ
žœ	˜0š œžœ
žœ
žœžœ
žœžœžœžœžœ˜mKšœžœ˜Kšœ
žœžœ
˜šžœžœ,žœ
žœ˜VK•StartOfExpansionw[name: 
ROPE, start: 
INT _ 0, len: 
INT _ 2147483647, bufSize: 
INT _ 512, buffers: 
NAT _ 4, raw: 
BOOL _ TRUE]šœ
žœ4žœ˜Hšžœžœ
žœžœžœ
ž˜2Kš
œ˜Kš
œD˜DKš
œ˜Kšžœ
˜—Kš
œ
˜
—šžœ˜Kšœžœžœ˜%šžœžœ
žœžœžœ
ž˜2Kš
œ˜šžœ
ž˜Kšœžœžœ˜,Kš
œ*˜*K˜
Kšžœ˜Jšžœ	žœžœ!˜MKš
œ˜Kš
œ˜Kš
œ"˜"Kš
œ˜Kšžœ
˜—Kšžœ
˜—Kšžœ˜Kš
œ˜—Kšžœžœ
žœ
˜$K˜K˜—K˜@K˜š œžœ!˜;Kšœ žœ'žœžœ˜\K˜K˜—š œžœ˜(Kšœžœ˜Kš
œ,˜,K˜!Kšœžœ˜Kšœžœ˜Kšœžœ
žœžœ
˜Kšœžœ
žœ˜Kšœžœ
žœžœ
˜&š 
œžœ˜+šžœž˜Kš
œ‘
˜‘
Kš
œ‚
˜‚
Kšžœ˜—šžœž˜K˜+Kšœ žœ˜&Kšžœ
˜—Kš
œ˜K˜—š œžœ
žœ˜&šžœž˜˜Kš
œ?˜?K˜K˜—˜	Kšœžœ
˜Kšœžœ˜Kšžœ"žœ(˜PKšœ
žœJ˜YKšžœžœ
žœ
žœ˜4K˜—˜	Kšœ
žœ
žœ˜!Kšœžœ	žœ!˜;Kšžœ
žœ
žœžœ˜GKš
œ˜K˜—K˜"Kšžœžœ
˜—Kš
œ˜Kš
œ'˜'K˜—š œžœ˜šžœž˜Kš
œ'˜'Kš
œ/˜/Kš
œ)˜)Kš
œ+˜+Kš
œ/˜/Kšœžœ
˜š
œ˜Kšœžœ7˜AKšœžœ˜#KšœZžœ˜`Kš
œ˜K˜—š
œ˜Kšœžœ7˜AKšœ*Οc)˜SKšœžœ˜#Kšœžœ˜0Kš	œžœžœžœžœ˜@Kš
œ˜Kš
œ˜Kš
œ˜—Kš
œr˜rKš
œn˜nKš
œU˜UKšžœ%žœ&žœžœ˜p—Kš
œ˜Kš
œ˜K˜—šžœ
‘˜Kšœ<žœ˜CKšžœžœžœ˜HK˜šžœžœ˜%Kšœžœžœ
˜šžœ
ž˜Kš
œ:˜:KšœGžœ˜MKšžœžœ
˜—Kšžœžœžœ˜*K˜—Kšžœžœ˜*Kšžœžœ
žœ
˜šžœž˜š
œ˜K˜&Kš
œ*˜*Kšžœžœžœ˜=K˜—Kš
œ'˜'Kš
œ?˜?Kšžœžœ
˜—Kšžœ
˜—K˜K˜—K˜š 	œžœ
žœžœ˜-K˜.K˜Kšžœ
žœžœ+˜IKšžœ˜K˜K˜—š œžœ
žœ˜+Kšœžœ˜K˜&K˜K˜—š 
œžœ
žœ
žœ˜9Kšœ
žœ˜Kš
œ˜Kš
œ&˜&Kšœžœ˜ Kšžœ
žœ9˜CK˜K˜—š œžœ˜'Kšœžœ˜šžœžœžœ
˜Kšœ4žœžœ˜Fšžœžœ‘˜#Kš
œ'˜'šžœžœ˜$Kšžœ1˜3šžœ/˜1šžœ
ž˜Kšœžœ‘˜-Kšœ4‘˜HKšœ
žœ%žœ‘˜LKšžœ
˜—Kšžœžœ,˜BKšžœ
˜—K˜
—Kšžœ
žœ‘˜5K˜
—Kšžœ
žœ‘˜Kšžœ
˜—K˜K˜—K˜š œžœ
žœ,˜GKšœžœ˜+Kš
œ9˜9K˜K˜—š œžœ8˜FKšœžœ˜Kšœžœžœ˜ Kšžœ˜ Kšœ4žœžœ˜YKšžœ˜K˜K˜—K˜š œžœ
žœžœ˜?Kšœžœžœ
˜Kšœžœ0˜;Kšœ"žœžœ˜3šžœžœ‘˜#Kš
œ'˜'Kšžœžœ˜2Kšžœ
žœ˜K˜—K˜K˜—K˜Kš œžœ
žœ7˜FK˜šœžœ˜7Kš
œ"˜"K˜—Kšœžœžœ˜)šœžœžœ
˜Kšœ‘˜Kšœ
‘˜Kšœ‘˜"K˜K˜—š 
œžœ˜/Kšœžœ
˜%Kš
œI˜IK˜K˜—š œžœ
žœ*žœ˜SKšœžœ9˜QKšžœ
žœ4˜>K˜K˜—K˜š œžœ8˜Jšžœžœ
ž˜šœžœ˜šœ
žœ˜K˜Kš
œ˜Kšžœžœ˜2Kšžœžœ˜4K˜Kš
œ˜—Kšžœ(˜*Kš
œ;˜;K˜—šœžœ™K™;Kšžœ™K™—Kšžœžœ
˜—Kš
œ˜K˜—š œžœ8˜Fšžœžœ
ž˜šœžœ˜K˜Kšžœ#˜%Kš
œ3˜3K˜—šœžœ™K™K™K™/K™K™šžœžœ
žœž™K™-Kšžœ
™—K™—Kšžœžœ
˜—Kš
œ˜K˜—Kš
œ˜K˜)Kšœ‘˜3K˜Kšœžœ˜)Kšœžœ˜/Kšœžœ
žœ‘˜MKšœ	žœ˜#K˜š œžœžœ˜8K˜Kšœ	žœ*˜7Kšœžœ/˜9Kšœžœžœ
žœ
žœžœ˜IKš
œ#˜#K˜K˜—š 
œžœ˜)K˜K˜(šœžœ˜Kš
œM˜MK˜ K˜K˜—Kš
œ˜K˜K˜—K˜'K˜š œžœ
žœžœžœžœžœ˜bKšœžœžœ˜)Kšžœ(˜.K˜K˜—š 
œžœ
žœ
žœžœžœžœ˜hKšœžœ3˜EKš
œ;˜;Kšœžœ˜(Kšœžœx˜
Kšœžœ
žœ˜Kšœžœžœ˜5Kš
œ+˜+Kšœžœ%˜9Kšœ‘™-Kš
œ˜Kšžœ	˜K˜K˜—š œžœ
žœžœ˜Pšžœžœžœ˜"K˜(K˜K˜KšœžœP˜\K˜Kš
œ˜Kšœžœ
˜K˜—K˜K˜—Kšžœ
˜K™š œžœ
žœ
™AKšžœ8™>K™K™—š œžœ@™\Kšžœ
™Kšžœ™K™K™—š œžœ+žœ
™\K™2Kšžœžœ
žœ™3šžœ™Kšœžœ™%Kš
œ'™'Kš
œ™K™2Kšžœžœžœ
™7Kšžœ™K™—K™K™—š œžœ™1Kš
œ@™@Kš
œ#™#K™K™KšœMžœ™WK™K™Kš
œP™PK™K™(K™2K™2K™0K™4K™.Kš
œ!™!K™K™—K˜—…—7ζRe