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 _ TRUE; 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) { 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, January 28, 1986 2:14:32 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δRa