DIRECTORY
Rope,
Basics,
IO,
Ascii,
Convert,
AlgebraClasses,
Variables,
Ints,
Sequences,
VariableSequences,
DistribPolys;

DistribPolysImpl: CEDAR PROGRAM
IMPORTS Rope, IO, Ascii, Convert, AlgebraClasses, Variables, Ints, Sequences
EXPORTS DistribPolys =
BEGIN OPEN AC: AlgebraClasses, VARS: Variables, SEQ: Sequences, VARSEQ: VariableSequences, DistribPolys;
ROPE: TYPE = Rope.ROPE;
STREAM: TYPE = IO.STREAM;
Object: TYPE = AC.Object;
Method: TYPE = AC.Method;
DollarProc: PUBLIC TermCharProc =  { RETURN[char='$] };

RightBracketProc: PUBLIC TermCharProc =  { RETURN[char='] OR char=')] };

BasicPolyTerminators: PUBLIC TermCharProc = {
SELECT char FROM
', , '$ ,  '] , ')   => RETURN[TRUE];
ENDCASE;
RETURN[FALSE] };

DollarRope: PUBLIC Rope.ROPE _ " $";
ReadDPoly: PUBLIC PROC [in: IO.STREAM, V: VARSEQ.VariableSequence, coeffRing: AC.Object, termCharProc: TermCharProc _ BasicPolyTerminators] RETURNS [poly: DPolynomial, termChar: CHAR _ 000C] = {
char: CHAR;
firstTerm: BOOL _ TRUE;
legalTermStartSeen: BOOL;
coeff: AC.Object;
sign: INTEGER;
exponent: CARDINAL;
degreeVec: DegreeVector;
variable: Object;
varIndexInt: Ints.Int;
varIndex: CARDINAL;
ReadDPFail: PUBLIC ERROR [subclass: ATOM _ $Unspecified] = CODE;
ok: BOOL;
zero: AC.Object _ AC.ApplyLkpNoRecastObject[$zero, coeffRing, LIST[coeffRing] ];
one: AC.Object _ AC.ApplyLkpNoRecastObject[$one, coeffRing, LIST[coeffRing] ];
legalFirstCharMethod: Method _ AC.LookupMethodInStructure[$legalFirstChar, coeffRing];
readMethod: Method _ AC.LookupMethodInStructure[$read, coeffRing];
equalMethod: Method _ AC.LookupMethodInStructure[$eqFormula, coeffRing];
negateMethod: Method _ AC.LookupMethodInStructure[$negation, coeffRing];
poly _ NIL;
[]_ in.SkipWhitespace[];

IF in.PeekChar[] = '0 THEN {
[] _ in.GetChar[];  -- toss it (assumes that we can strip a leading zero)
[]_ in.SkipWhitespace[];
IF in.EndOf[] THEN RETURN[ZeroDPoly];
char _ in.PeekChar[];
IF char = '$ THEN RETURN[ZeroDPoly, in.GetChar[] ];
IF termCharProc[char] THEN RETURN[ZeroDPoly, char];
};

DO

legalTermStartSeen _ FALSE;
sign _ 1;
coeff _ one;  -- default term is +1 
degreeVec _ NIL;

[]_ in.SkipWhitespace[];
IF in.PeekChar[] = '- THEN {
sign _ -1;
[] _ in.GetChar[];  -- toss it
[]_ in.SkipWhitespace[];
}
ELSE IF in.PeekChar[] = '+ THEN {
[] _ in.GetChar[];  -- toss it
[]_ in.SkipWhitespace[];
}
ELSE IF NOT firstTerm THEN ERROR;
firstTerm _ FALSE;

IF AC.ApplyLegalFirstCharMethod[legalFirstCharMethod, in.PeekChar[], coeffRing] THEN {
legalTermStartSeen _ TRUE;
coeff _ AC.ApplyReadMethod[readMethod, in, coeffRing];
[]_ in.SkipWhitespace[];
IF AC.ApplyPredNoLkpNoRecast[equalMethod, LIST[coeff, zero] ] THEN ERROR ReadDPFail[$ZeroCoefficient]; -- zero coeff not allowed
};
IF sign < 1 THEN coeff _ AC.ApplyNoLkpNoRecastObject[negateMethod, LIST[coeff] ];  -- if sign < 1, then negate either coeff read or default coeff of 1

WHILE NOT in.EndOf[] AND (Ascii.Letter[in.PeekChar[]] OR in.PeekChar[]='*) DO
legalTermStartSeen _ TRUE;
exponent _ 1;
IF in.PeekChar[] = '* THEN {
[] _ in.GetChar[]; -- toss * multiplication
[]_ in.SkipWhitespace[];
};
variable _ VARS.FromRope[in.GetID[] ];
varIndexInt _ SEQ.Find[V, variable];
IF varIndexInt = NIL THEN ERROR ReadDPFail[$UnknownVariable];
varIndex _ Ints.ToINT[varIndexInt];
[]_ in.SkipWhitespace[];
IF NOT in.EndOf[] THEN IF in.PeekChar[] = '* OR in.PeekChar[] = '^ THEN  {
char _ in.GetChar[]; -- toss (could be either * multiplication, first char of ** exponentiation, or ^ exponentiation, here)
[]_ in.SkipWhitespace[];
}
ELSE char _ 'X; -- anything
IF NOT in.EndOf[] THEN IF (char = '* AND in.PeekChar[] = '*) OR char = '^ THEN {  -- allow ** or ^ exponentiation
IF in.PeekChar[] = '* THEN [] _ in.GetChar[]; -- toss
[]_ in.SkipWhitespace[];
SELECT in.PeekChar[] FROM
IN ['0..'9] => {
exponent _ in.GetCard;
[]_ in.SkipWhitespace[];
IF exponent = 0 THEN ERROR ReadDPFail[$ZeroExponent];
};
ENDCASE=> ERROR ReadDPFail[$NonNumericExponent];
};
[ok, degreeVec] _ DVInsertVariablePower[varIndex, exponent, degreeVec];
IF NOT ok THEN ERROR ReadDPFail[$RepeatedVariable];
ENDLOOP;

IF legalTermStartSeen THEN {
[ok, poly] _ DPInsertTerm[coeff, degreeVec, poly];
IF NOT ok THEN ERROR ReadDPFail[$RepeatedMonomial];
}
ELSE ERROR ReadDPFail[$UnexpectedCharacter];
IF in.EndOf[] THEN RETURN[poly];
char _ in.PeekChar[];
IF char = '$ THEN RETURN[poly, in.GetChar[] ];
IF termCharProc[char] THEN RETURN[poly, char ]; 
ENDLOOP;
};


DPolyFromRope: PUBLIC PROC [in: Rope.ROPE, V: VARSEQ.VariableSequence, coeffRing: AC.Object, termCharProc: TermCharProc _ BasicPolyTerminators] RETURNS [out: DPolynomial] = {
stream: IO.STREAM _ IO.RIS[in];
termChar: CHAR;
[out, termChar ] _ ReadDPoly[stream, V, coeffRing, termCharProc];
};

DPolyToRope: PUBLIC PROC [in: DPolynomial, V: VARSEQ.VariableSequence, coeffRing: AC.Object, termRope: Rope.ROPE _ NIL] RETURNS [out: Rope.ROPE]={
firstTerm: BOOL _ TRUE;
trivialMonomial: BOOL;
coeff, coeffAbs: AC.Object;
degreeVec: DegreeVector;
coeffSign: Basics.Comparison;
exponent, index:  CARDINAL;
one: AC.Object _ AC.ApplyLkpNoRecastObject[$one, coeffRing, LIST[coeffRing] ];
equalMethod: Method _ AC.LookupMethodInStructure[$eqFormula, coeffRing];
toRopeMethod: Method _ AC.LookupMethodInStructure[$toRope, coeffRing];
isOrdered: BOOL _ AC.HasProperty[coeffRing, $ordered];
signMethod, absMethod: Method;
IF in = ZeroDPoly THEN RETURN[Rope.Concat["0", termRope]];
out _ "";
IF isOrdered THEN {
signMethod _ AC.LookupMethodInStructure[$sign, coeffRing];
absMethod _ AC.LookupMethodInStructure[$abs, coeffRing];
};
WHILE in#NIL DO
[coeff, degreeVec] _ in.first;  in _ in.rest;
IF isOrdered THEN { 
coeffSign _ AC.ApplyCompareToZeroMethod[signMethod, coeff];
coeffAbs _ AC.ApplyNoLkpNoRecastObject[absMethod, LIST[coeff] ]
}
ELSE { -- for unordered coeffRing, act as though coeff is positive
coeffSign _ greater;
coeffAbs _ coeff;
};
IF coeffSign = less THEN out _ Rope.Concat[out,"- "] ELSE IF NOT firstTerm THEN out _ Rope.Concat[out,"+ "];
firstTerm _ FALSE;
IF NOT AC.ApplyPredNoLkpNoRecast[equalMethod, LIST[coeffAbs, one] ] THEN
out _ Rope.Cat[out, NARROW[AC.ApplyNoLkpNoRecastRef[toRopeMethod, LIST[coeffAbs] ] ], " "];
trivialMonomial _ TRUE;
degreeVec _ DVReverse[degreeVec];
WHILE degreeVec#NIL DO
trivialMonomial _ FALSE;
exponent _ degreeVec.first;  degreeVec _ degreeVec.rest;
index _ degreeVec.first;  degreeVec _ degreeVec.rest;
out _ Rope.Concat[out, VARS.ToRope[SEQ.Select[V, Ints.FromINT[index] ] ] ];
IF exponent>1 THEN out _ Rope.Cat[out, "**", Convert.RopeFromCard[exponent]]; -- temp change 5/21/87 for Bridging to SAC-2
out _ Rope.Concat[out," "];
ENDLOOP;
IF trivialMonomial AND AC.ApplyPredNoLkpNoRecast[equalMethod, LIST[coeffAbs, one] ] THEN
out _ Rope.Cat[out, NARROW[AC.ApplyNoLkpNoRecastRef[toRopeMethod, LIST[one] ] ], " "];
ENDLOOP;
out _ Rope.Concat[out, termRope];
};

WriteDPoly: PUBLIC PROC [in: DPolynomial, V: VARSEQ.VariableSequence, coeffRing: AC.Object, out: IO.STREAM, termRope: Rope.ROPE _ NIL] = {
polyRope: Rope.ROPE _ DPolyToRope[in, V, coeffRing];
out.PutF["\n %g \n", IO.rope[polyRope] ];
};
DPInsertTerm: PROC [coefficient: AC.Object, degreeVec: DegreeVector, inPoly: DPolynomial] RETURNS [ok: BOOL, outPoly: DPolynomial] ~ {
nextCoeff: AC.Object;
nextDegreeVec: DegreeVector;
poly: DPolynomial _ inPoly;
degreeVecComparison: [-1..1];
ok _ TRUE;
IF inPoly=NIL THEN {
outPoly_CONS[ [coefficient, degreeVec], NIL ];
RETURN
};
outPoly _ inPoly;
[nextCoeff, nextDegreeVec] _ poly.first;  poly _ poly.rest;
degreeVecComparison _ DVCompare[degreeVec, nextDegreeVec];
SELECT degreeVecComparison FROM
0 => { ok _ FALSE;  RETURN };
1  => {
outPoly_CONS[ [coefficient, degreeVec], inPoly ];
RETURN
};
ENDCASE; 
outPoly _ CONS[ [nextCoeff, nextDegreeVec], NIL];
WHILE poly# NIL DO
[nextCoeff, nextDegreeVec] _ poly.first;  poly _ poly.rest;
degreeVecComparison _ DVCompare[degreeVec, nextDegreeVec];
SELECT degreeVecComparison FROM
0 => { outPoly _ inPoly; ok _ FALSE;  RETURN };
1 =>  {
outPoly _ CONS[ [nextCoeff, nextDegreeVec], CONS[ [coefficient, degreeVec], outPoly] ];
outPoly _ DPReverse[outPoly];
outPoly _ DPNconc[outPoly, poly];
RETURN
};
ENDCASE; 
outPoly _ CONS[ [nextCoeff, nextDegreeVec], outPoly];
ENDLOOP;
outPoly _ CONS[ [coefficient, degreeVec], outPoly];
outPoly _ DPReverse[outPoly];
};

DPNconc: PROC [l1, l2: DPolynomial] RETURNS [DPolynomial] ~ {
z: DPolynomial _ l1;
IF z = NIL THEN RETURN[l2];
UNTIL z.rest = NIL DO
z _ z.rest;
ENDLOOP;
z.rest _ l2;
RETURN[l1];
};

DPReverse: PUBLIC PROC [list: DPolynomial] RETURNS[val: DPolynomial] = {
val _ NIL;
UNTIL list = NIL DO
val _ CONS[list.first, val];
list _ list.rest;
ENDLOOP;
RETURN[val];
}; -- of Reverse
DVInsertVariablePower: PUBLIC PROC [varIndex, exponent: CARDINAL, inDegreeVec: DegreeVector] RETURNS [ok: BOOL, outDegreeVec: DegreeVector] ~ {
nextIndex, nextExponent: CARDINAL;
degreeVec: DegreeVector _ inDegreeVec;
outDegreeVec _ inDegreeVec;
ok _ TRUE;
IF inDegreeVec=NIL THEN {
IF exponent=0 THEN RETURN ELSE {
outDegreeVec_CONS[varIndex, CONS[ exponent, NIL] ];
RETURN
}
};
nextIndex _ degreeVec.first;  degreeVec _ degreeVec.rest;
nextExponent _ degreeVec.first;  degreeVec _ degreeVec.rest;
SELECT varIndex FROM
= nextIndex => { ok _ FALSE;  RETURN };
> nextIndex => IF exponent=0 THEN RETURN ELSE {
outDegreeVec_CONS[varIndex, CONS[exponent, inDegreeVec] ]; 
RETURN
};
ENDCASE; 
outDegreeVec _ CONS[nextExponent, CONS[nextIndex, NIL]];
WHILE degreeVec# NIL DO
nextIndex _ degreeVec.first;  degreeVec _ degreeVec.rest;
nextExponent _ degreeVec.first;  degreeVec _ degreeVec.rest;
SELECT varIndex FROM
= nextIndex => { outDegreeVec _ inDegreeVec;ok _ FALSE;  RETURN };
> nextIndex => IF exponent=0 THEN
{ outDegreeVec _ inDegreeVec; RETURN }
ELSE {
outDegreeVec_DVCons4[nextExponent, nextIndex, exponent, varIndex, outDegreeVec]; 
outDegreeVec _ DVReverse[outDegreeVec];
outDegreeVec _ DVNconc[outDegreeVec, degreeVec];
RETURN
};
ENDCASE; 
outDegreeVec _ CONS[nextExponent, CONS[nextIndex, outDegreeVec]];
ENDLOOP;
outDegreeVec _ CONS[exponent, CONS[varIndex, outDegreeVec]];
outDegreeVec _ DVReverse[outDegreeVec];
};

DVCompare: PUBLIC PROC [dv1, dv2: DegreeVector] RETURNS [ [-1..1] ] ~ {
index1, index2, exponent1, exponent2: CARDINAL;
WHILE dv1#NIL AND dv2#NIL DO
index1 _ dv1.first;  dv1 _ dv1.rest;
exponent1 _ dv1.first;  dv1 _ dv1.rest;
index2 _ dv2.first;  dv2 _ dv2.rest;
exponent2 _ dv2.first;  dv2 _ dv2.rest;
IF index1 > index2 THEN RETURN[1];
IF index1 < index2 THEN RETURN[-1];
IF exponent1 > exponent2 THEN RETURN[1];
IF exponent1 < exponent2 THEN RETURN[-1];
ENDLOOP;
IF dv1#NIL THEN RETURN[1];
IF dv2#NIL THEN RETURN[-1];
RETURN[0];
};

DVDegree: PUBLIC PROC [degreeVec: DegreeVector, numVars: CARDINAL] RETURNS [degree: CARDINAL] ~ {
IF degreeVec = NIL THEN RETURN[0];
IF degreeVec.first = numVars THEN RETURN[degreeVec.rest.first] ELSE RETURN[0];
};

DVRemoveMainVariablePower: PUBLIC PROC [in: DegreeVector, numVars: CARDINAL] RETURNS [out: DegreeVector] ~ {
IF in = NIL THEN RETURN[NIL];
IF in.first = numVars THEN RETURN [in.rest.rest] ELSE RETURN[in];
};

DVAddMainVariablePower: PUBLIC PROC [in: DegreeVector, varIndex, exponent: CARDINAL] RETURNS [out: DegreeVector] ~ {
IF exponent>0 THEN RETURN[ CONS[varIndex, CONS[ exponent, in] ] ] ELSE RETURN[in];
};

DVCons4: PUBLIC PROC [x1, x2, x3, x4: CARDINAL, degreeVec: DegreeVector] RETURNS [DegreeVector] ~ {
RETURN[ CONS[x1, CONS[x2, CONS[x3, CONS[x4, degreeVec]]]] ];
};

DVNconc: PUBLIC PROC [l1, l2: DegreeVector] RETURNS [DegreeVector] ~ {
z: DegreeVector _ l1;
IF z = NIL THEN RETURN[l2];
UNTIL z.rest = NIL DO
z _ z.rest;
ENDLOOP;
z.rest _ l2;
RETURN[l1];
};

DVReverse: PUBLIC PROC [list: DegreeVector] RETURNS[val: DegreeVector] = {
val _ NIL;
UNTIL list = NIL DO
val _ CONS[list.first, val];
list _ list.rest;
ENDLOOP;
RETURN[val];
}; -- of Reverse


END.
®DistribPolysImpl.mesa
Last Edited by: Arnon, June 10, 1985 4:19:22 pm PDT
Types from Imported Interfaces
Types

Distributed Polynomial IO

Check for zero polynomial
Parse the terms of a nonzero polynomial
Initialization
Look for (optional) sign preceding first term, or (mandatory) sign separating two terms
Look for (optional) coefficient [Cannot be at EndOf[in] here] 
Look for (optional) monomial [Can be at EndOf[in] here]
Check that we saw some kind of legal term
IF exponent>1 THEN out _ Rope.Cat[out, "^", Convert.RopeFromCard[exponent]];

The term (coefficient, degreeVec) is inserted in the distributed polynoimal inPoly.  NOT ok if degreeVec already occurs (and inPoly unchanged). If degreeVec doesn't yet occur, then ok, and outPoly  is inPoly with (coefficient, degreeVec) inserted.
DPInsertTerm is an insertion sort.
Degree Vectors
Variable varIndex raised to the exponent power is recorded in inDegreeVec.  NOT ok if the variable already occurs (and inDegreeVec unchanged). If the variable doesn't yet occur, then ok; if exponent = 0, inDegreeVec unchanged, otherwise outDegreeVec  is inDegreeVec with (varIndex, exponent) inserted.
DVInsertVariablePower is an insertion sort.
�Ê+˜Jš
œ™J™3J˜š
Ïk	˜	Jš
œ˜J˜Jš�œ
˜J˜J˜Jš
œ˜Jš
œ
˜
Jš
œ˜Jš
œ
˜
Jš
œ˜Jš
œ
˜
—J˜
head2šœ�œ
�˜Jš�œE˜LJš�œ˜—Jš�œ
�œ
�œ�œ
�œ	�œ"˜h
headš
Ïn™Icodeš�œ�œ�œ
˜Mš�œ�œ�œ
�œ
˜Mšœ�œ�œ˜Mšœ�œ�œ˜—š
ž™šž
œ�œ�œ˜7J˜—šžœ�œ�œ	�œ˜HJ˜—šžœ�œ˜-š�œ�˜Mšœ�œ
�œ˜%Mš�œ
˜—Mš�œ
�œ˜J˜—šœ�œ�œ˜$M™——šœž™J™šž	œ�œ
�œ�œ
�œž
œ�œ�œ<�œ�œ˜Â
Jšœ�œ
˜Jšœ�œ�œ
˜Jšœ�œ
˜Jšœ�œ˜Jšœ�œ
˜Jšœ
�œ
˜Jš
œ˜Jš
œ˜Jš
œ˜Jšœ
�œ
˜Jš
ž
œ�œ
�œ�œ�œ
˜@Jšœ�œ
˜	Jšœ�œ
�œ*�œ˜PJšœ�œ
�œ)�œ˜NMšœ�œ5˜VMšœ�œ+˜BMšœ�œ0˜HMšœ�œ/˜HJšœ�œ
˜Jš
œ˜J˜Jš
œ™š�œ�œ˜JšœÏc5˜IJš
œ˜Jš�œ�œ
�œ˜%Jš
œ˜Jš�œ�œ
�œ˜3Jš�œ�œ
�œ˜3J˜J˜—Jš
œ'™'š
�˜J˜Jš
œ™Jšœ�œ
˜Jš
œ	˜	JšœŸ˜$Jšœ�œ
˜J˜Jš
œW™WJš
œ˜š�œ�œ˜J˜
JšœŸ
˜Jš
œ˜J˜
—š�œ
�œ�œ˜!JšœŸ
˜Jš
œ˜J˜
—Jš
�œ
�œ
�œ�œ
�œ
˜!Jšœ�œ
˜J˜Jš
œ>™>š�œ
�œK�œ˜VMšœ�œ
˜Mšœ�œ,˜6Jš
œ˜Mš�œ
�œ%�œ�œ
�œŸ˜€
M˜—Mš	�œ
�œ	�œ(�œŸC˜–
M˜Mš
œ7™7š	�œ
�œ�œ�œ�˜MMšœ�œ
˜Mš
œ
˜
š�œ�œ˜JšœŸ˜+Jš
œ˜J˜—Mšœ�œ˜&Mšœ�œ˜$Mš�œ�œ
�œ
�œ˜=Mš
œ#˜#Jš
œ˜š�œ
�œ�œ
�œ�œ�œ˜JJšœŸf˜{Jš
œ˜J˜
Jš�œŸ˜—š�œ
�œ�œ
�œ�œ�œ�œŸ˜qJš�œ�œŸ˜5Jš
œ˜š�œ�˜š�œ˜Mš
œ˜Jš
œ˜Mš�œ�œ
�œ˜5M˜—Mš�œ�œ!˜0—M˜—Mš
œG˜GMš�œ
�œ�œ
�œ˜3Jš�œ
˜—J˜Jš
œ)™)š�œ�œ˜Mš
œ2˜2Mš�œ
�œ�œ
�œ˜3J˜
—Jš�œ
�œ"˜,Jš�œ�œ
�œ˜ Jš
œ˜Jš�œ�œ
�œ˜.Jš�œ�œ
�œ˜0Jš�œ
˜—J˜J˜J˜—šž
œ�œ
�œ�œž
œ�œ�œ<�œ˜®
Mš	œ�œ
�œ�œ
�œ˜Mšœ
�œ
˜Mš
œA˜AM˜M˜—šžœ�œ
�œž
œ�œ�œ�œ�œ�œ�œ˜’
Jšœ�œ�œ
˜Jšœ�œ
˜Jšœ�œ˜Jš
œ˜Jš
œ˜Jšœ�œ
˜Jšœ�œ
�œ)�œ˜NMšœ�œ0˜HMšœ�œ-˜FJšœ�œ�œ"˜6Mš
œ˜Jš�œ�œ
�œ˜:J˜	š�œ�œ˜Mšœ
�œ+˜:Mšœ�œ*˜8J˜—š�œ�œ
�˜Jš
œ-˜-š�œ�œ˜Jšœ�œ-˜;Jšœ�œ%�œ	˜?J˜
—š�œŸ;˜BJš
œ˜Jš
œ˜J˜—Jš�œ�œ�œ
�œ
�œ�œ˜lJšœ�œ
˜š�œ
�œ%�œ�˜HMšœ�œ
�œ%�œ˜[—Jšœ�œ
˜Jš
œ!˜!š�œ�œ
�˜Jšœ�œ
˜Jš
œ8˜8Jš
œ5˜5Jšœ�œ�œ%˜KJš�œ�œ:™LJš�œ�œ<Ÿ,˜zJš
œ˜Jš�œ
˜—š	�œ�œ
�œ%�œ�˜XMšœ�œ
�œ%�œ˜V—Jš�œ
˜—Jš
œ!˜!J˜J˜—šž
œ�œ
�œž
œ�œ�œ�œ
�œ�œ�œ˜Š
Jšœ�œ!˜4Jšœ�œ˜)J˜M™—š
žœ�œ�œ7�œ�œ˜†
Mš
œ÷
™÷
Mš
œ"™"Mšœ�œ˜Mš
œ˜Mš
œ˜M˜Mšœ�œ
˜
š�œ�œ
�œ˜Mšœ�œ�œ˜.Mš
�˜M˜—Mš
œ˜Mš
œ;˜;Mš
œ:˜:š�œ�˜Mšœ�œ�œ˜š
œ˜Mšœ�œ%˜1Mš
�˜Mš
œ˜—Mš�œ˜	—Mšœ
�œ�œ˜1š�œ�œ
�˜Mš
œ;˜;Mš
œ:˜:š�œ�˜Mšœ�œ�œ˜/š
œ˜Mšœ
�œ�œ'˜WMš
œ˜Mš
œ!˜!Mš
�˜Mš
œ˜—Mš�œ˜	—Mšœ
�œ'˜5Mš�œ
˜—Mšœ
�œ%˜3Mš
œ˜M˜M˜—šžœ�œ�œ˜=Mš
œ˜Mš�œ�œ
�œ
�œ˜š�œ
�œ
�˜Mš
œ˜Mš�œ
˜—M˜Mš�œ˜Mš
œ˜M˜—šž	œ�œ
�œ�œ˜HMšœ�œ
˜
š�œ�œ
�˜Mšœ�œ˜M˜Mš�œ
˜—Mš�œ˜MšœŸ
˜——™šžœ�œ
�œ�œ�œ�œ!˜�
Mš
œ­™­Mš
œ+™+Mšœ�œ
˜"Mš
œ&˜&Mš
œ˜Mšœ�œ
˜
š�œ
�œ
�œ˜š�œ�œ
�œ
�œ˜ Mšœ
�œ�œ�œ˜3Mš
�˜M˜
—M˜—Mš
œ9˜9Mš
œ<˜<š�œ
�˜Mšœ�œ�œ˜'š	œ�œ�œ
�œ
�œ˜/Mšœ
�œ�œ˜;Mš
�˜Mš
œ˜—Mš�œ˜	—Mšœ�œ�œ�œ˜8š�œ�œ
�˜Mš
œ9˜9Mš
œ<˜<š�œ
�˜Mšœ1�œ�œ˜Bšœ�œ�˜!Mšœ�œ˜&Mš�œ˜Mš
œQ˜QMš
œ'˜'Mš
œ0˜0Mš
�˜Mš
œ˜—Mš�œ˜	—Mšœ�œ�œ˜AMš�œ
˜—Mšœ�œ�œ˜<Mš
œ'˜'M˜M˜—šž	œ�œ
�œ�œ˜GMšœ&�œ
˜/š	�œ�œ
�œ�œ
�˜Mš
œ$˜$Mš
œ'˜'Mš
œ$˜$Mš
œ'˜'Mš�œ�œ
�œ˜"Mš�œ�œ
�œ˜#Mš�œ�œ
�œ˜(Mš�œ�œ
�œ˜)Mš�œ
˜—Mš�œ�œ
�œ
�œ˜Mš�œ�œ
�œ
�œ˜Mš�œ˜
M˜M˜—šžœ�œ
�œ$�œ�œ
�œ˜aMš�œ
�œ
�œ
�œ˜"Mš
�œ�œ
�œ�œ
�œ˜NM˜M˜—š
žœ�œ
�œ�œ�œ˜lMš
�œ�œ
�œ
�œ
�œ˜Mš
�œ�œ
�œ�œ
�œ˜AM˜M˜—š
žœ�œ
�œ(�œ�œ˜tMš�œ�œ
�œ�œ�œ�œ
�œ˜RM˜M˜—š
žœ�œ
�œ�œ�œ˜cMš
�œ�œ�œ�œ�œ˜<M˜M˜—šžœ�œ
�œ�œ˜FMš
œ˜Mš�œ�œ
�œ
�œ˜š�œ
�œ
�˜Mš
œ˜Mš�œ
˜—M˜Mš�œ˜Mš
œ˜M˜—šž	œ�œ
�œ�œ˜JMšœ�œ
˜
š�œ�œ
�˜Mšœ�œ˜M˜Mš�œ
˜—Mš�œ˜MšœŸ
˜M˜——J˜Jš�œ
˜—…—.BÝ