DIRECTORY
IP USING [Any, AnyFromInt, AnyFromReal, CheckInteger, Color, ColorFromAny, Element, ElementRep, GetMarker, Identifier, IdentifierFromAny, Integer, IntegerFromAny, IntegerFromInt, IntegerFromReal, Marker, MarkItem, MarkItemRep, MasterError, maxInteger, Operator, OperatorFromAny, Outline, OutlineFromAny, Pair, PixelArray, PixelArrayFromAny, RealFromAny, RealFromInt, State, Trajectory, TrajectoryFromAny, Transformation, TransformationFromAny, Type, TypeCode, Vector, VectorFromAny],
IPBase USING [];

IPStackImpl: CEDAR PROGRAM
IMPORTS IP
EXPORTS IP, IPBase
= BEGIN OPEN IP;

NewElement: PROC RETURNS[Element] ~ {
RETURN[NEW[ElementRep _ []]];
};

InitializeStack: PUBLIC PROC[self: State, maxLength: Integer] ~ {
self.stack _ NewElement[]; -- dummy element at base of stack, so self.stack.above always works
self.count _ 0;
self.maxCount _ CheckInteger[maxLength];
self.mark _ NIL;
};


StackUnderflow: PROC[self: State] ~ {
MasterError[$stackUnderflow, "Stack underflow."];
};


PushElement: PROC[self: State] RETURNS[Element] ~ {
old: Element ~ self.stack; new: Element _ old.above; count: Integer ~ self.count;
IF NOT count<self.maxCount THEN
MasterError[$stackOverflow, "Tried to push too many elements onto the stack."];
IF new=NIL THEN { new _ NewElement[]; old.above _ new; new.below _ old };
IF new.ref#NIL THEN ERROR;
self.count _ count+1; RETURN[self.stack _ new];
};

PopElement: PROC[self: State] RETURNS[Element] ~ {
old: Element ~ self.stack; count: Integer ~ self.count;
IF NOT count>0 THEN
MasterError[$stackUnderflow, "Tried to pop an element from an empty stack."];
self.count _ count-1; self.stack _ old.below; RETURN[old];
};


Push: PUBLIC PROC[self: State, x: Any] ~ {
new: Element ~ PushElement[self];
new.type _ $ref; new.ref _ x;
};

PushInteger: PUBLIC PROC[self: State, i: Integer] ~ {
new: Element ~ PushElement[self];
new.type _ $int; new.int _ CheckInteger[i];
};

PushInt: PUBLIC PROC[self: State, i: INT] ~ {
new: Element ~ PushElement[self];
new.type _ $int; new.int _ i;
};

PushReal: PUBLIC PROC[self: State, r: REAL] ~ {
new: Element ~ PushElement[self];
new.type _ $real; new.real _ r;
};

PushPair: PUBLIC PROC[self: State, p: Pair] ~ {
PushReal[self, p.x]; PushReal[self, p.y];
};

PushIdentifier: PUBLIC PROC[self: State, x: Identifier] ~ {
IF x=NIL THEN MasterError[$nilFault, "Identifier must not be NIL."]
ELSE { new: Element ~ PushElement[self]; new.type _ $ref; new.ref _ x };
};

PushVector: PUBLIC PROC[self: State, x: Vector] ~ {
IF x=NIL THEN MasterError[$nilFault, "Vector must not be NIL."]
ELSE { new: Element ~ PushElement[self]; new.type _ $ref; new.ref _ x };
};

PushOperator: PUBLIC PROC[self: State, x: Operator] ~ {
IF x=NIL THEN MasterError[$nilFault, "Operator must not be NIL."]
ELSE { new: Element ~ PushElement[self]; new.type _ $ref; new.ref _ x };
};

PushTransformation: PUBLIC PROC[self: State, x: Transformation] ~ {
IF x=NIL THEN MasterError[$nilFault, "Transformation must not be NIL."]
ELSE { new: Element ~ PushElement[self]; new.type _ $ref; new.ref _ x };
};

PushPixelArray: PUBLIC PROC[self: State, x: PixelArray] ~ {
IF x=NIL THEN MasterError[$nilFault, "PixelArray must not be NIL."]
ELSE { new: Element ~ PushElement[self]; new.type _ $ref; new.ref _ x };
};

PushColor: PUBLIC PROC[self: State, x: Color] ~ {
IF x=NIL THEN MasterError[$nilFault, "Color must not be NIL."]
ELSE { new: Element ~ PushElement[self]; new.type _ $ref; new.ref _ x };
};

PushTrajectory: PUBLIC PROC[self: State, x: Trajectory] ~ {
IF x=NIL THEN MasterError[$nilFault, "Trajectory must not be NIL."]
ELSE { new: Element ~ PushElement[self]; new.type _ $ref; new.ref _ x };
};

PushOutline: PUBLIC PROC[self: State, x: Outline] ~ {
IF x=NIL THEN MasterError[$nilFault, "Outline must not be NIL."]
ELSE { new: Element ~ PushElement[self]; new.type _ $ref; new.ref _ x };
};


Pop: PUBLIC PROC[self: State] RETURNS[Any] ~ {
old: Element ~ PopElement[self];
SELECT old.type FROM
$ref => { x: REF ~ old.ref; old.ref _ NIL; RETURN[x] };
$int => RETURN[AnyFromInt[old.int]];
$real => RETURN[AnyFromReal[old.real]];
ENDCASE => ERROR;
};

PopInteger: PUBLIC PROC[self: State] RETURNS[Integer] ~ {
old: Element ~ PopElement[self];
SELECT old.type FROM
$ref => { x: REF ~ old.ref; old.ref _ NIL; RETURN[IntegerFromAny[x]] };
$int => RETURN[IF old.int IN[0..maxInteger] THEN old.int ELSE IntegerFromInt[old.int]];
$real => RETURN[IntegerFromReal[old.real]];
ENDCASE => ERROR;
};

PopReal: PUBLIC PROC[self: State] RETURNS[REAL] ~ {
old: Element ~ PopElement[self];
SELECT old.type FROM
$ref => { x: REF ~ old.ref; old.ref _ NIL; RETURN[RealFromAny[x]] };
$int => RETURN[RealFromInt[old.int]];
$real => RETURN[old.real];
ENDCASE => ERROR;
};

PopPair: PUBLIC PROC[self: State] RETURNS[p: Pair] ~ {
p.y _ PopReal[self]; p.x _ PopReal[self];
};

PopIdentifier: PUBLIC PROC[self: State] RETURNS[Identifier] ~ {
old: Element ~ PopElement[self]; x: REF _ NIL;
IF old.type=$ref THEN { x _ old.ref; old.ref _ NIL };
WITH x SELECT FROM x: Identifier => RETURN[x]; ENDCASE;
RETURN[IdentifierFromAny[x]];
};

PopVector: PUBLIC PROC[self: State] RETURNS[Vector] ~ {
old: Element ~ PopElement[self]; x: REF _ NIL;
IF old.type=$ref THEN { x _ old.ref; old.ref _ NIL };
WITH x SELECT FROM x: Vector => RETURN[x]; ENDCASE;
RETURN[VectorFromAny[x]];
};

PopOperator: PUBLIC PROC[self: State] RETURNS[Operator] ~ {
old: Element ~ PopElement[self]; x: REF _ NIL;
IF old.type=$ref THEN { x _ old.ref; old.ref _ NIL };
WITH x SELECT FROM x: Operator => RETURN[x]; ENDCASE;
RETURN[OperatorFromAny[x]];
};

PopTransformation: PUBLIC PROC[self: State] RETURNS[Transformation] ~ {
old: Element ~ PopElement[self]; x: REF _ NIL;
IF old.type=$ref THEN { x _ old.ref; old.ref _ NIL };
WITH x SELECT FROM x: Transformation => RETURN[x]; ENDCASE;
RETURN[TransformationFromAny[x]];
};

PopPixelArray: PUBLIC PROC[self: State] RETURNS[PixelArray] ~ {
old: Element ~ PopElement[self]; x: REF _ NIL;
IF old.type=$ref THEN { x _ old.ref; old.ref _ NIL };
WITH x SELECT FROM x: PixelArray => RETURN[x]; ENDCASE;
RETURN[PixelArrayFromAny[x]];
};

PopColor: PUBLIC PROC[self: State] RETURNS[Color] ~ {
old: Element ~ PopElement[self]; x: REF _ NIL;
IF old.type=$ref THEN { x _ old.ref; old.ref _ NIL };
WITH x SELECT FROM x: Color => RETURN[x]; ENDCASE;
RETURN[ColorFromAny[x]];
};

PopTrajectory: PUBLIC PROC[self: State] RETURNS[Trajectory] ~ {
old: Element ~ PopElement[self]; x: REF _ NIL;
IF old.type=$ref THEN { x _ old.ref; old.ref _ NIL };
WITH x SELECT FROM x: Trajectory => RETURN[x]; ENDCASE;
RETURN[TrajectoryFromAny[x]];
};

PopOutline: PUBLIC PROC[self: State] RETURNS[Outline] ~ {
old: Element ~ PopElement[self]; x: REF _ NIL;
IF old.type=$ref THEN { x _ old.ref; old.ref _ NIL };
WITH x SELECT FROM x: Outline => RETURN[x]; ENDCASE;
RETURN[OutlineFromAny[x]];
};


TopType: PUBLIC PROC[self: State] RETURNS[TypeCode] ~ {
top: Element ~ self.stack; count: Integer ~ self.count;
IF NOT count>0 THEN
MasterError[$stackUnderflow, "Tried to pop an element from an empty stack."];
SELECT top.type FROM
$ref => RETURN[Type[top.ref]];
$int, $real => RETURN[$Number];
ENDCASE => ERROR;
};

Discard: PUBLIC PROC[self: State] ~ {
old: Element ~ PopElement[self];
SELECT old.type FROM
$ref => old.ref _ NIL;
$int, $real => NULL;
ENDCASE => ERROR;
};

Copy: PUBLIC PROC[self: State, depth: Integer] ~ {
IF CheckInteger[depth]=0 THEN NULL
ELSE IF self.count<depth THEN
MasterError[$stackUnderflow, "Too few elements on stack to COPY."]
ELSE {
this: Element _ self.stack;
THROUGH [0..depth) DO this _ this.below ENDLOOP;
THROUGH [0..depth) DO
new: Element ~ PushElement[self];
this _ this.above;
SELECT (new.type _ this.type) FROM
$int => new.int _ this.int;
$real => new.real _ this.real;
$ref => new.ref _ this.ref;
ENDCASE => ERROR;
ENDLOOP;
};
};

Roll: PUBLIC PROC[self: State, depth, moveFirst: Integer] ~ {
IF CheckInteger[moveFirst]>CheckInteger[depth] THEN
MasterError[$invalidArgs, "ROLL: moveFirst exceeds depth."]
ELSE IF self.count<depth THEN
MasterError[$stackUnderflow, "Too few elements on stack to ROLL."]
ELSE IF depth=0 OR moveFirst=0 OR moveFirst=depth THEN NULL
ELSE {
k: INT ~ depth-moveFirst;
old: Element ~ self.stack; -- the old top of stack
above: Element ~ old.above; -- free element above top of stack, if any
new, kth, nth: Element _ NIL;
bot: Element _ old; -- will become the element below the top depth elements
THROUGH [0..k) DO kth _ bot; bot _ bot.below ENDLOOP;
new _ bot; -- this will be the new top of stack
THROUGH [k..depth) DO nth _ bot; bot _ bot.below ENDLOOP;
new.above _ above; IF above#NIL THEN above.below _ new;
nth.below _ old; old.above _ nth;
kth.below _ bot; bot.above _ kth;
self.stack _ new;
};
};


Mark: PUBLIC PROC[self: State, n: Integer] ~ {
marker: Marker ~ GetMarker[self];
IF self.count<CheckInteger[n] THEN
MasterError[$stackUnderflow, "Too few elements on the stack to MARK."]
ELSE {
mark: MarkItem ~ NEW[MarkItemRep _ [marker: marker, under: self.count-n]];
self.count _ self.count-mark.under;
self.maxCount _ self.maxCount-mark.under;
mark.below _ self.mark; self.mark _ mark;
};
};

RemoveMark: PUBLIC PROC[self: State, marker: Marker] ~ {
mark: MarkItem ~ self.mark;
IF mark.marker#marker THEN ERROR;
self.count _ self.count+mark.under;
self.maxCount _ self.maxCount+mark.under;
self.mark _ mark.below;
};

MarkMismatch: PROC ~ {
MasterError[$markMismatch, "The top mark on the stack does not match the current context."]
};

Unmark: PUBLIC PROC[self: State, n: Integer] ~ {
marker: Marker ~ GetMarker[self];
mark: MarkItem ~ self.mark;
IF mark.marker#marker THEN MarkMismatch[];
IF self.count<CheckInteger[n] THEN
MasterError[$stackUnderflow, "Too few elements on the stack to UNMARK."]
ELSE IF self.count=n THEN RemoveMark[self, marker]
ELSE MasterError[$unmarkFailed, "UNMARK found too many elements above the top mark."];
};

Unmark0: PUBLIC PROC[self: State] ~ {
marker: Marker ~ GetMarker[self];
mark: MarkItem ~ self.mark;
IF mark.marker#marker THEN MarkMismatch[];
IF self.count>0 THEN {
MasterError[$unmarkFailed, "UNMARK0 found one or more elements above the top mark.",
FALSE]; -- don't raise Error
WHILE self.count>0 DO Discard[self] ENDLOOP; -- do mark recovery
};
RemoveMark[self, marker];
};

Count: PUBLIC PROC[self: State] RETURNS[Integer] ~ {
marker: Marker ~ GetMarker[self];
mark: MarkItem ~ self.mark;
IF mark.marker#marker THEN MarkMismatch[];
RETURN[CheckInteger[self.count]];
};

PopToMark: PUBLIC PROC[self: State] RETURNS[Marker] ~ {
mark: MarkItem ~ self.mark;
WHILE self.count>0 DO Discard[self] ENDLOOP;
RETURN[mark.marker];
};


ApplyPOP: PUBLIC PROC[self: State] ~ {
Discard[self];
};
ApplyCOPY: PUBLIC PROC[self: State] ~ {
n: Integer ~ PopInteger[self];
Copy[self: self, depth: n];
};
ApplyDUP: PUBLIC PROC[self: State] ~ {
Copy[self: self, depth: 1];
};
ApplyROLL: PUBLIC PROC[self: State] ~ {
moveFirst: Integer ~ PopInteger[self];
depth: Integer ~ PopInteger[self];
Roll[self: self, depth: depth, moveFirst: moveFirst];
};
ApplyEXCH: PUBLIC PROC[self: State] ~ {
Roll[self: self, depth: 2, moveFirst: 1];
};
ApplyMARK: PUBLIC PROC[self: State] ~ {
n: Integer ~ PopInteger[self];
Mark[self, n];
};
ApplyUNMARK: PUBLIC PROC[self: State] ~ {
n: Integer ~ PopInteger[self];
Unmark[self, n];
};
ApplyUNMARK0: PUBLIC PROC[self: State] ~ {
Unmark0[self];
};
ApplyCOUNT: PUBLIC PROC[self: State] ~ {
n: Integer ~ Count[self];
PushInteger[self, n];
};
ApplyNOP: PUBLIC PROC[self: State] ~ {
};


END.
$IPStackImpl.mesa

Last edited by:
Doug Wyatt, March 3, 1984 3:58:25 pm PST
Return the type of the top element.
Equivalent to [] _ Pop[self], but avoids useless NEW.
Since there is a dummy element at the base of the stack, bot cannot be NIL.

ReserveChars: PROC [to: String, nChars: NAT] RETURNS [String] = {
newMinLength: NAT = to.length + nChars; -- may raise PointerFault or BoundsFault
IF newMinLength <= to.maxLength THEN RETURN [to];
{ expandBy: NAT = MAX[16, to.maxLength, nChars];
newLength: NAT =
IF expandBy > NAT.LAST-to.maxLength THEN NAT.LAST ELSE expandBy+to.maxLength;
newString: String = NEW[StringRep[newLength]];
FOR i: NAT IN [0..to.length) DO newText[i] _ to[i] ENDLOOP;
newText.length _ to.length;
RETURN [newText];
}
};

AppendChar: PROC[to: String, from: CARDINAL] RETURNS[String] ~ {
IF to.length>=to.maxLength THEN to _ ReserveChars[to, 1];
to[to.length] _ from;
to.length _ to.length+1;
RETURN[to];
};

InlineAppendChar: PROC[to: String, from: CARDINAL] RETURNS[String] ~ INLINE {
IF to.length>=to.maxLength THEN RETURN[AppendChar[to, from]];
to[to.length] _ from;
to.length _ to.length+1;
RETURN[to];
};

PushString: PUBLIC PROC[self: State, text: REF TEXT] ~ {
offset: CARDINAL _ 0;
state: {run, escape, escape2, extended, extended2} _ run;
FOR i: NAT IN[0..text.length) DO
b: BYTE ~ LOOPHOLE[text[i]];
SELECT state FROM
run => IF b#255 THEN Append[offset+b] ELSE state _ escape;
escape => IF b#255 THEN { offset _ b*256; state _ run } ELSE state _ escape2;
escape2 => IF b=0 THEN state _ extended ELSE ERROR;
extended => IF b#255 THEN { offset _ b*256; state _ extended2 } ELSE state _ escape;
extended2 => { Append[offset+b]; state _ extended };
ENDCASE;
ENDLOOP;
IF NOT(state=run OR state=extended) THEN ERROR;
};

PopString: PUBLIC PROC[self: State, buffer: String] RETURNS[String] ~ {
};

�ʘJš
œ™J™š
œ™Jš
œ(™(—J˜š
Ïk	˜	Jš�œ
�œÛ˜ãJšœ�œ˜J˜—Jšœ
�œ
�˜Jš�œ
�˜
Jš�œ
�œ˜Jšœ�œ
�œ
�œ
˜J˜šÏn
œ�œ
�œ
˜%Jš�œ
�œ˜J˜J˜—šžœ�œ
�œ%˜AJšœÏcC˜^J˜J˜(Jšœ�œ
˜J˜J˜—J˜šžœ�œ˜%Jš
œ1˜1J˜J˜—J˜šžœ�œ�œ
˜3Jš
œQ˜Qš�œ
�œ�˜Jš
œO˜O—Jš�œ�œ
�œ:˜IJš�œ	�œ
�œ
�œ
˜Jšœ�œ˜/J˜J˜—šž
œ�œ�œ
˜2Jš
œ7˜7š�œ
�œ	�˜Jš
œM˜M—Jšœ.�œ˜:J˜J˜—J˜šžœ�œ
�œ˜*J˜!J˜J˜J˜—šžœ�œ
�œ˜5J˜!J˜+J˜J˜—šžœ�œ
�œ�œ˜-J˜!J˜J˜J˜—šžœ�œ
�œ�œ˜/J˜!J˜J˜J˜—šžœ�œ
�œ˜/J˜)J˜J˜—šžœ�œ
�œ ˜;Jš�œ�œ
�œ6˜CJš�œD˜HJ˜J˜—šž
œ�œ
�œ˜3Jš�œ�œ
�œ2˜?Jš�œD˜HJ˜J˜—šžœ�œ
�œ˜7Jš�œ�œ
�œ4˜AJš�œD˜HJ˜J˜—šžœ�œ
�œ$˜CJš�œ�œ
�œ:˜GJš�œD˜HJ˜J˜—šžœ�œ
�œ ˜;Jš�œ�œ
�œ6˜CJš�œD˜HJ˜J˜—šž	œ�œ
�œ˜1Jš�œ�œ
�œ1˜>Jš�œD˜HJ˜J˜—šžœ�œ
�œ ˜;Jš�œ�œ
�œ6˜CJš�œD˜HJ˜J˜—šžœ�œ
�œ˜5Jš�œ�œ
�œ3˜@Jš�œD˜HJ˜J˜—J˜šžœ�œ
�œ�œ	˜.Jš
œ ˜ š�œ
�˜Jšœ
�œ�œ�œ˜7Jšœ�œ˜$Jšœ	�œ˜'Jš�œ�œ
˜—J˜J˜—šž
œ�œ
�œ�œ
˜9J˜ š�œ
�˜Jšœ
�œ�œ�œ˜GJšœ�œ
�œ	�œ�œ	�œ˜WJšœ	�œ˜+Jš�œ�œ
˜—J˜J˜—š
žœ�œ
�œ�œ
�œ˜3J˜ š�œ
�˜Jšœ
�œ�œ�œ˜DJšœ�œ˜%Jšœ	�œ˜Jš�œ�œ
˜—J˜J˜—šžœ�œ
�œ�œ
˜6J˜)J˜J˜—šž
œ�œ
�œ�œ˜?Jšœ$�œ�œ
˜.Jš�œ�œ�œ˜5Jš
�œ�œ
�œ�œ�œ
˜7Jš�œ˜J˜J˜—šž	œ�œ
�œ�œ˜7Jšœ$�œ�œ
˜.Jš�œ�œ�œ˜5Jš
�œ�œ
�œ�œ�œ
˜3Jš�œ˜J˜J˜—šžœ�œ
�œ�œ˜;Jšœ$�œ�œ
˜.Jš�œ�œ�œ˜5Jš
�œ�œ
�œ�œ�œ
˜5Jš�œ˜J˜J˜—šžœ�œ
�œ�œ˜GJšœ$�œ�œ
˜.Jš�œ�œ�œ˜5Jš
�œ�œ
�œ�œ�œ
˜;Jš�œ˜!J˜J˜—šž
œ�œ
�œ�œ˜?Jšœ$�œ�œ
˜.Jš�œ�œ�œ˜5Jš
�œ�œ
�œ�œ�œ
˜7Jš�œ˜J˜J˜—šžœ�œ
�œ�œ˜5Jšœ$�œ�œ
˜.Jš�œ�œ�œ˜5Jš
�œ�œ
�œ
�œ�œ
˜2Jš�œ˜J˜J˜—šž
œ�œ
�œ�œ˜?Jšœ$�œ�œ
˜.Jš�œ�œ�œ˜5Jš
�œ�œ
�œ�œ�œ
˜7Jš�œ˜J˜J˜—šž
œ�œ
�œ�œ
˜9Jšœ$�œ�œ
˜.Jš�œ�œ�œ˜5Jš
�œ�œ
�œ�œ�œ
˜4Jš�œ˜J˜J˜—J˜šžœ�œ
�œ�œ˜7J™#Jš
œ7˜7š�œ
�œ	�˜Jš
œM˜M—š�œ
�˜Jšœ�œ˜Jšœ�œ
˜Jš�œ�œ
˜—J˜J˜—šžœ�œ
�œ˜%Jšœ1�œ
™5J˜ š�œ
�˜Jšœ�œ
˜Jšœ�œ
˜Jš�œ�œ
˜—J˜J˜—šžœ�œ
�œ!˜2Jš�œ�œ
�˜"š�œ
�œ�˜Jš
œB˜B—š�œ˜Jš
œ˜Jš�œ�œ�œ
˜0š�œ�˜Jš
œ!˜!J˜š�œ�˜"J˜J˜J˜Jš�œ�œ
˜—Jš�œ
˜—J˜—J˜J˜—šžœ�œ
�œ,˜=š�œ-�˜3Jš
œ;˜;—š�œ
�œ�˜Jš
œB˜B—Jš�œ
�œ	�œ
�œ�œ
�˜;š�œ˜Jšœ�œ˜JšœŸ˜2JšœŸ*˜FJšœ�œ
˜JšœŸ)œŸ	˜KJš�œ�œ�œ
˜5JšœŸ$˜/š�œ�œ�œ
˜9JšœG�œ
™K—Jšœ�œ�œ
�œ˜7J˜!Jš
œ!˜!J˜J˜—J˜J˜—J˜šžœ�œ
�œ˜.Jš
œ!˜!š�œ�˜"J˜F—š�œ˜Jšœ�œ6˜JJš
œ#˜#Jš
œ)˜)Jš
œ)˜)Jš
œ˜—J˜J˜—šž
œ�œ
�œ!˜8Jš
œ˜Jš�œ�œ
�œ
˜!Jš
œ#˜#Jš
œ)˜)Jš
œ˜Jš
œ˜J˜—šžœ�œ˜Jš
œ[˜[J˜J˜—šžœ�œ
�œ˜0Jš
œ!˜!Jš
œ˜Jš�œ�œ˜*š�œ�˜"J˜H—Jš�œ
�œ�œ˜2Jš�œR˜VJ˜J˜—šžœ�œ
�œ˜%Jš
œ!˜!Jš
œ˜Jš�œ�œ˜*š�œ�œ˜š
œT˜TJš�œŸ˜—Jš�œ�œ�œŸ˜@J˜—J˜J˜J˜—šžœ�œ
�œ�œ
˜4Jš
œ!˜!Jš
œ˜Jš�œ�œ˜*Jš�œ˜!Jš
œ˜J˜—šž	œ�œ
�œ�œ˜7Jš
œ˜Jš�œ�œ�œ
˜,Jš�œ˜Jš
œ˜J˜—J™šžœ�œ�œ�œ
™AJšœ�œŸ(™PJš�œ�œ
�œ™1šœ�œ�œ™0šœ�œ™Jš�œ�œ
�œ�œ
�œ
�œ
�œ™M—Jšœ�œ™.Jš
�œ�œ
�œ�œ�œ
™;J™Jš�œ™J™
—J™J™—šž
œ�œ�œ�œ™@Jš�œ�œ™9J™J™Jš�œ™J™J™—š
žœ�œ�œ�œ�œ™MJš�œ�œ
�œ™=J™J™Jš�œ™J™J™—š
ž
œ�œ
�œ�œ
�œ™8Jšœ�œ™Jš
œ9™9š�œ�œ
�œ�™ Jšœ�œ�œ
™š�œ�™Jšœ�œ�œ�œ™:Jšœ
�œ�œ!�œ™MJš	œ�œ�œ�œ
�œ
™3Jšœ�œ�œ'�œ™TJš
œ4™4Jš�œ
™—Jš�œ
™—Jš
�œ
�œ�œ�œ
�œ
™/J™J™—šž	œ�œ
�œ�œ™GJ™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š
œ˜J˜—šžœ�œ
�œ˜&J˜J˜—J˜Jš�œ
˜—…—,œCÆ