DIRECTORY
Rope,
IO,
Basics,
Atom,
Convert,
RealFns,
AlgebraClasses,
MathConstructors,
Bools,
Ints,
BigRats,
Reals;

RealsImpl: CEDAR PROGRAM
IMPORTS IO, Convert, RealFns, AlgebraClasses, MathConstructors, Ints, BigRats
EXPORTS Reals

= BEGIN OPEN Reals, Convert, AC: AlgebraClasses;
RealsError: PUBLIC SIGNAL [reason: ATOM _ $Unspecified] = CODE;
bitsPerWord: CARDINAL = Basics.bitsPerWord;
CARD: TYPE = LONG CARDINAL;
ROPE: TYPE = Rope.ROPE;
STREAM: TYPE = IO.STREAM;
Object: TYPE = AC.Object;
Method: TYPE = AC.Method;
PrintName: PUBLIC AC.ToRopeOp = {
RETURN["Reals"];
};
ShortPrintName: PUBLIC AC.ToRopeOp = {
RETURN["R"];
};
Characteristic: PUBLIC AC.StructureRankOp = {
RETURN[ 0 ]
}; 
Recast: PUBLIC AC.BinaryOp = {
IF AC.StructureEqual[firstArg.class, Reals] THEN RETURN[firstArg];
IF BigRats.CanRecast[firstArg, BigRats.BigRats] THEN
RETURN[ FromREAL[BigRats.ToReal[BigRats.Recast[firstArg, BigRats.BigRats] ] ] ];
RETURN[NIL];
}; 

CanRecast: PUBLIC AC.BinaryPredicate = {
firstArgStructure: Object _ IF firstArg.flavor = StructureElement THEN firstArg.class ELSE IF firstArg.flavor = Structure THEN firstArg ELSE ERROR;
SELECT TRUE FROM
AC.StructureEqual[firstArgStructure, Reals] => RETURN[TRUE];
BigRats.CanRecast[firstArg, BigRats.BigRats] => RETURN[TRUE];
ENDCASE;
RETURN[FALSE];
}; 
LegalFirstChar: PUBLIC AC.LegalFirstCharOp = {
SELECT char FROM
= '., IN ['0..'9] => RETURN[TRUE];
ENDCASE;
RETURN[BigRats.LegalFirstChar[char, structure] ];
};
Read: PUBLIC AC.ReadOp ~ {
rat: Object _ BigRats.Read[in, structure ! IO.Error => GO TO TryReal ];
RETURN[Recast[rat, Reals] ];
EXITS
TryReal => {
in.SetIndex[0];
RETURN[FromREAL[IO.GetReal[in] ] ] };
};
FromRope: PUBLIC AC.FromRopeOp = {
stream: IO.STREAM _ IO.RIS[in];
RETURN[ Read[stream, structure] ];
};

ToRope: PUBLIC AC.ToRopeOp = {
data: RealData _ NARROW[in.data];
RETURN[ Convert.RopeFromReal[data^] ];
};

Write: PUBLIC AC.WriteOp = {
IO.PutRope[ stream, ToRope[in] ]
}; 

ToExpr: PUBLIC AC.ToExprOp = {
data: RealData _ NARROW[in.data];
RETURN[MathConstructors.MakeReal[ data^] ];
}; 

FromREAL: PUBLIC PROC [real: REAL] RETURNS [Real] = {
RETURN[NEW[AC.ObjectRec _ [
class: Reals,
flavor: StructureElement,
data: NEW[REAL  _ real]
] ] ];
};

ToREAL: PUBLIC PROC [real: Real] RETURNS [REAL] = {
data: RealData _ NARROW[real.data];
RETURN[data^];
};
Zero: PUBLIC AC.NullaryOp = {
RETURN[ RealZero ]
}; 
One: PUBLIC AC.NullaryOp = {
RETURN[ RealOne ]
}; 
Add: PUBLIC AC.BinaryOp ~ {
firstData: RealData _ NARROW[firstArg.data];
secondData: RealData _ NARROW[secondArg.data];
RETURN[NEW[AC.ObjectRec _ [
class: Reals,
flavor: StructureElement,
data: NEW[REAL  _ firstData^ + secondData^ ]
] ] ];
};

Negate: PUBLIC AC.UnaryOp ~ {
data: RealData _ NARROW[arg.data];
RETURN[NEW[AC.ObjectRec _ [
class: Reals,
flavor: StructureElement,
data: NEW[REAL  _ - data^  ]
] ] ];
};

Subtract: PUBLIC AC.BinaryOp ~ {
firstData: RealData _ NARROW[firstArg.data];
secondData: RealData _ NARROW[secondArg.data];
RETURN[NEW[AC.ObjectRec _ [
class: Reals,
flavor: StructureElement,
data: NEW[REAL  _ firstData^ - secondData^  ]
] ] ];
};

Multiply: PUBLIC AC.BinaryOp ~ {
firstData: RealData _ NARROW[firstArg.data];
secondData: RealData _ NARROW[secondArg.data];
RETURN[NEW[AC.ObjectRec _ [
class: Reals,
flavor: StructureElement,
data: NEW[REAL  _ firstData^ * secondData^  ]
] ] ];
};

ObjectAndIntDesired: PUBLIC AC.UnaryToListOp ~ {
RETURN[ LIST[arg, Ints.Ints] ]; -- arg assumed to be a Structure
};

Power: PUBLIC AC.BinaryOp ~ { -- this simple algorithm is Structure independent
power: INT _ Ints.ToINT[secondArg];
structure: Object _ firstArg.class;
one: Object _ AC.ApplyLkpNoRecastObject[$one, structure, LIST[structure] ];
productMethod: Method _ AC.LookupMethodInStructure[$product, structure];
IF power < 0 THEN {
invertMethod: Method _ AC.LookupMethodInStructure[$invert, structure];
temp: Object;
IF invertMethod = NIL THEN ERROR;
temp _ Power[firstArg, Ints.FromINT[ABS[power] ] ];
RETURN[AC.ApplyNoLkpNoRecastObject[invertMethod, LIST[temp] ] ];
};
IF power = 0 THEN RETURN[one];
result _ firstArg;
FOR i:INT IN [2..power] DO
result _ AC.ApplyNoLkpNoRecastObject[productMethod, LIST[firstArg, result] ];
ENDLOOP;
};

Invert: PUBLIC AC.UnaryOp ~ {
data: RealData _ NARROW[arg.data];
RETURN[NEW[AC.ObjectRec _ [
class: Reals,
flavor: StructureElement,
data: NEW[REAL  _ 1.0 /  data^  ]
] ] ];
};

Divide: PUBLIC AC.BinaryOp ~ {
firstData: RealData _ NARROW[firstArg.data];
secondData: RealData _ NARROW[secondArg.data];
RETURN[NEW[AC.ObjectRec _ [
class: Reals,
flavor: StructureElement,
data: NEW[REAL  _ firstData^ / secondData^  ]
] ] ];
};

Exp: PUBLIC AC.UnaryOp ~ {
firstData: RealData _ NARROW[arg.data];
RETURN[FromREAL[RealFns.Exp[ToREAL[arg] ] ] ];
};

Ln: PUBLIC AC.UnaryOp ~ {
firstData: RealData _ NARROW[arg.data];
RETURN[FromREAL[RealFns.Ln[ToREAL[arg] ] ] ];
};

SqRt: PUBLIC AC.UnaryOp ~ {
firstData: RealData _ NARROW[arg.data];
RETURN[FromREAL[RealFns.SqRt[ToREAL[arg] ] ] ];
};

Sin: PUBLIC AC.UnaryOp ~ {
firstData: RealData _ NARROW[arg.data];
RETURN[FromREAL[RealFns.Sin[ToREAL[arg] ] ] ];
};

Cos: PUBLIC AC.UnaryOp ~ {
firstData: RealData _ NARROW[arg.data];
RETURN[FromREAL[RealFns.Cos[ToREAL[arg] ] ] ];
};

Tan: PUBLIC AC.UnaryOp ~ {
firstData: RealData _ NARROW[arg.data];
RETURN[FromREAL[RealFns.Tan[ToREAL[arg] ] ] ];
};

Sign:  PUBLIC AC.CompareToZeroOp = {
data: RealData _ NARROW[arg.data];
SELECT data^ FROM
< 0.0 => RETURN[less];
= 0.0 => RETURN[equal];
ENDCASE => RETURN[greater];
};
Abs: PUBLIC AC.UnaryOp ~ {
data: RealData _ NARROW[arg.data];
RETURN[NEW[AC.ObjectRec _ [
class: Reals,
flavor: StructureElement,
data: NEW[REAL  _ ABS[data^] ]
] ] ];
};

Compare: PUBLIC AC.BinaryCompareOp ~ {
firstData: RealData _ NARROW[firstArg.data];
secondData: RealData _ NARROW[secondArg.data];
SELECT firstData^ FROM
< secondData^ => RETURN[less];
= secondData^ => RETURN[equal];
ENDCASE => RETURN[greater];
};

Equal: PUBLIC AC.BinaryPredicate ~ {
firstData: RealData _ NARROW[firstArg.data];
secondData: RealData _ NARROW[secondArg.data];
RETURN[ firstData^ = secondData^]
};
RealsDesired: PUBLIC AC.UnaryToListOp ~ {
RETURN[ LIST[Reals] ];
};


RealClass: Object _ AC.MakeClass["RealClass", NIL, NIL];
Reals: PUBLIC Object _ AC.MakeStructure["Reals", RealClass, NIL];

RealOne: Real _ FromREAL[1.0]; -- do after Reals set
RealZero: Real _ FromREAL[0.0];

categoryMethod: Method _ AC.MakeMethod[Value, FALSE, NEW[AC.Category _ field], NIL, "category"];
groundStructureMethod: Method _ AC.MakeMethod[Value, FALSE, NIL, NIL, "groundStructure"];
shortPrintNameMethod: Method _ AC.MakeMethod[ToRopeOp, FALSE, NEW[AC.ToRopeOp _ ShortPrintName], NIL, "shortPrintName"];
recastMethod: Method _ AC.MakeMethod[BinaryOp, TRUE, NEW[AC.BinaryOp _ Recast], NIL, "recast"];
canRecastMethod: Method _ AC.MakeMethod[BinaryPredicate, TRUE, NEW[AC.BinaryPredicate _ CanRecast], NIL, "canRecast"];
legalFirstCharMethod: Method _ AC.MakeMethod[LegalFirstCharOp, FALSE, NEW[AC.LegalFirstCharOp _ LegalFirstChar], NIL, "legalFirstChar"];
readMethod: Method _ AC.MakeMethod[ReadOp, FALSE, NEW[AC.ReadOp _ Read], NIL, "read"];
fromRopeMethod: Method _ AC.MakeMethod[FromRopeOp, TRUE, NEW[AC.FromRopeOp _ FromRope], NIL, "fromRope"];
toRopeMethod: Method _ AC.MakeMethod[ToRopeOp, FALSE, NEW[AC.ToRopeOp _ ToRope], NIL, "toRope"];
toExprMethod: Method _ AC.MakeMethod[ToExprOp, FALSE, NEW[AC.ToExprOp _ ToExpr], NEW[AC.UnaryToListOp _ RealsDesired], "toExpr"];
realMethod: Method _ AC.MakeMethod[FromRopeOp, FALSE, NEW[AC.FromRopeOp _ FromRope], NIL, "real"];
parenMethod: Method _ AC.MakeMethod[UnaryOp, FALSE, NEW[AC.UnaryOp _ AC.Copy], NIL, "paren"];
zeroMethod: Method _ AC.MakeMethod[NullaryOp, FALSE, NEW[AC.NullaryOp _ Zero], NIL, "zero"];
oneMethod: Method _ AC.MakeMethod[NullaryOp, FALSE, NEW[AC.NullaryOp _ One], NIL, "one"];
sumMethod: Method _ AC.MakeMethod[BinaryOp, TRUE, NEW[AC.BinaryOp _ Add], NEW[AC.UnaryToListOp _ RealsDesired], "sum"];
negationMethod: Method _ AC.MakeMethod[UnaryOp, TRUE, NEW[AC.UnaryOp _ Negate], NEW[AC.UnaryToListOp _ RealsDesired], "negation"];
differenceMethod: Method _ AC.MakeMethod[BinaryOp, TRUE, NEW[AC.BinaryOp _ Subtract], NEW[AC.UnaryToListOp _ RealsDesired], "difference"];
productMethod: Method _ AC.MakeMethod[BinaryOp, TRUE, NEW[AC.BinaryOp _ Multiply], NEW[AC.UnaryToListOp _ RealsDesired], "product"];
commutativeMethod: Method _ AC.MakeMethod[Value, FALSE, NIL, NIL, "commutative"];
powerMethod: Method _ AC.MakeMethod[BinaryOp, TRUE, NEW[AC.BinaryOp _ Power], NEW[AC.UnaryToListOp _ ObjectAndIntDesired], "power"];
invertMethod: Method _ AC.MakeMethod[UnaryOp, TRUE, NEW[AC.UnaryOp _ Invert], NEW[AC.UnaryToListOp _ RealsDesired], "invert"];
fractionMethod: Method _ AC.MakeMethod[BinaryOp, TRUE, NEW[AC.BinaryOp _ Divide], NEW[AC.UnaryToListOp _ RealsDesired], "fraction"];
expMethod: Method _ AC.MakeMethod[UnaryOp, TRUE, NEW[AC.UnaryOp _ Exp], NEW[AC.UnaryToListOp _ RealsDesired], "exp"];
lnMethod: Method _ AC.MakeMethod[UnaryOp, TRUE, NEW[AC.UnaryOp _ Ln], NEW[AC.UnaryToListOp _ RealsDesired], "ln"];
sqRtMethod: Method _ AC.MakeMethod[UnaryOp, TRUE, NEW[AC.UnaryOp _ SqRt], NEW[AC.UnaryToListOp _ RealsDesired], "sqRt"];
sinMethod: Method _ AC.MakeMethod[UnaryOp, TRUE, NEW[AC.UnaryOp _ Sin], NEW[AC.UnaryToListOp _ RealsDesired], "sin"];
cosMethod: Method _ AC.MakeMethod[UnaryOp, TRUE, NEW[AC.UnaryOp _ Cos], NEW[AC.UnaryToListOp _ RealsDesired], "cos"];
tanMethod: Method _ AC.MakeMethod[UnaryOp, TRUE, NEW[AC.UnaryOp _ Tan], NEW[AC.UnaryToListOp _ RealsDesired], "tan"];
equalMethod: Method _ AC.MakeMethod[BinaryPredicate, TRUE, NEW[AC.BinaryPredicate _ Equal], NEW[AC.UnaryToListOp _ RealsDesired], "equals"];
orderedMethod: Method _ AC.MakeMethod[Value, FALSE, NIL, NIL, "ordered"];
signMethod: Method _ AC.MakeMethod[CompareToZeroOp, TRUE, NEW[AC.CompareToZeroOp _ Sign], NEW[AC.UnaryToListOp _ RealsDesired], "sign"];
absMethod: Method _ AC.MakeMethod[UnaryOp, TRUE, NEW[AC.UnaryOp _ Abs], NEW[AC.UnaryToListOp _ RealsDesired], "abs"];
compareMethod: Method _ AC.MakeMethod[BinaryCompareOp, TRUE, NEW[AC.BinaryCompareOp _ Compare], NEW[AC.UnaryToListOp _ RealsDesired], "compare"];

AC.AddMethodToClass[$category, categoryMethod, RealClass];
AC.AddMethodToClass[$groundStructure, categoryMethod, RealClass];
AC.AddMethodToClass[$shortPrintName, shortPrintNameMethod, RealClass];
AC.AddMethodToClass[$recast, recastMethod, RealClass];
AC.AddMethodToClass[$canRecast, canRecastMethod, RealClass];
AC.AddMethodToClass[$legalFirstChar, legalFirstCharMethod, RealClass];
AC.AddMethodToClass[$read, readMethod, RealClass];
AC.AddMethodToClass[$fromRope, fromRopeMethod, RealClass];
AC.AddMethodToClass[$toRope, toRopeMethod, RealClass];
AC.AddMethodToClass[$toExpr, toExprMethod, RealClass];
AC.AddMethodToClass[$real, realMethod, RealClass];
AC.AddMethodToClass[$zero, zeroMethod, RealClass];
AC.AddMethodToClass[$one, oneMethod, RealClass];
AC.AddMethodToClass[$paren, parenMethod, RealClass];
AC.AddMethodToClass[$sum, sumMethod, RealClass];
AC.AddMethodToClass[$negation, negationMethod, RealClass];
AC.AddMethodToClass[$difference, differenceMethod, RealClass];
AC.AddMethodToClass[$product, productMethod, RealClass];
AC.AddMethodToClass[$invert, invertMethod, RealClass];
AC.AddMethodToClass[$pow, powerMethod, RealClass];
AC.AddMethodToClass[$commutative, commutativeMethod, RealClass];
AC.AddMethodToClass[$fraction, fractionMethod, RealClass];
AC.AddMethodToClass[$exp, expMethod, RealClass];
AC.AddMethodToClass[$ln, lnMethod, RealClass];
AC.AddMethodToClass[$radical, sqRtMethod, RealClass];
AC.AddMethodToClass[$sin, sinMethod, RealClass];
AC.AddMethodToClass[$cos, cosMethod, RealClass];
AC.AddMethodToClass[$tan, tanMethod, RealClass];
AC.AddMethodToClass[$eqFormula, equalMethod, RealClass];
AC.AddMethodToClass[$ordered, orderedMethod, RealClass];
AC.AddMethodToClass[$sign, signMethod, RealClass];
AC.AddMethodToClass[$abs, absMethod, RealClass];
AC.AddMethodToClass[$compare, compareMethod, RealClass];

AC.InstallStructure[Reals];
AC.SetSuperClass[BigRats.BigRats, Reals];




END.

RealsImpl.mesa
Last Edited by: Arnon, July 19, 1985 2:54:46 pm PDT

Types
Structure Operations
I/O and Conversion
args are a StructureElement and a Structure
Read: PUBLIC AC.ReadOp ~ {
real: REAL _ IO.GetReal[in ! IO.EndOfStream, IO.Error => GO TO TryRat ];
RETURN[FromREAL[real] ];
EXITS
TryRat => {
in.SetIndex[0];
RETURN[Recast[ BigRats.Read[in, BigRats.BigRats], Reals] ] };
};
Arithmetic
RealFns - Exponent and logarithm functions
RealFns - Trigonometric functions
Comparison

Standard Desired Arg Structures
Name Reals explicitly, instead of using AC.DefaultDesiredArgStructures, so that if a Reals method found by lookup from a subclasss, then will recast its args correctly (i.e. to Reals)
Start Code
RealClass: AC.StructureClass _ NEW[AC.StructureClassRec _ [
category: field,
printName: ClassPrintName,
shortPrintName: ClassShortPrintName,
structureEqual: AC.defaultStructureEqualityTest,
characteristic: ClassCharacteristic,

isElementOf: AC.defaultElementOfProc,

legalFirstChar: ClassLegalFirstChar,
read: Read,
fromRope: FromRope,
toRope: ToRope,
write: Write,
toExpr: ClassToExpr,

add: Add,
negate: Negate,
subtract: Subtract,
zero: ClassZero,

multiply: Multiply,
commutative: TRUE,
invert: Invert,
divide: Divide,
one: ClassOne,

equal: Equal,

ordered: TRUE,
sign: Sign,
abs: Abs,
compare: Compare,

completeField: TRUE,
realField: TRUE,
realClosedField: TRUE,
algebraicallyClosedField: FALSE,

propList: NIL
] ];

Reals: PUBLIC AC.Structure _ NEW[AC.StructureRec _ [
class: RealClass,
instanceData: NIL
] ];

สš˜Jš
œ™J™3J™š
ฯk	˜	Jš
œ˜Icodešœ
˜K˜K˜K˜Kš
œ˜J˜J˜J˜J˜J˜Jš
œ˜—J˜
head2šœœ
˜Jšœ
œC˜MJšœ˜
J˜—Jšœœ
œœ˜0
headš
ฯn™Jš	œœ
œ
œœ
˜?Kšœ
œ˜+Kšœœœ
œ
˜Kšœœœ
˜Kšœœœ
œ
˜Kšœœœ˜Kšœœœ˜—š
ž™šž	œ	œ
˜!Jšœ
˜J˜—šžœ	œ
˜&Jšœ˜J˜—šžœ	œ˜-Jšœ˜Jš
œ˜——š
œ™šžœœ
œ
˜Jš
œ+™+Jšœ
œ'œ
œ˜Bšœ.˜4JšœJ˜P—Jšœ
œ˜Jš
œ˜J˜—šž	œ	œ˜(Jšœœ$œœ
œœ
œ
œ
˜“
šœ
œ
˜Kšœ-œ
œ˜<Kšœ0œ
œ˜=Kšœ
˜—Kšœ
œ˜Jš
œ˜—šžœœ
œ˜.šœ˜Kšœ
œ
œ˜"Kšœ
˜—Kšœ+˜1J˜—šžœœ
œ™Jš
œœœœœ
œ
œ
™HKšœ™š
™š
œ™Kš
œ™Kšœ7™=——K™—šžœœ
œ˜Jšœ+œ
œ
œ˜GKšœ˜š
˜š
œ˜Kš
œ˜Kšœ
œ˜%——K˜—šžœœ
œ˜"Kš	œœ
œœ
œ˜Kšœ˜"K˜K˜—šžœœ
œ
˜Kšœœ
˜!Kšœ ˜&K˜K˜—šžœœ
œ˜Jšœ˜ Jš
œ˜J˜—šžœ	œ
˜Kšœœ
˜!Jšœ%˜+Jš
œ˜J˜—š
žœœ
œœœ˜5šœ
œ
œ˜Kš
œ
˜
K˜Kšœœ
œ	˜Kš
œ˜—K˜K˜—šžœœœœ˜3Kšœœ˜#Kšœ˜K˜——š
ž
™
šžœ	œ˜Jšœ˜Jš
œ˜—šžœ	œ˜Jšœ˜Jš
œ˜—šžœœ
œ
˜Kšœœ˜,Kšœœ˜.šœ
œ
œ˜Kš
œ
˜
K˜Kšœœ
œ
œ˜,Kš
œ˜—K˜K˜—šžœœ
œ˜Kšœœ˜"šœ
œ
œ˜Kš
œ
˜
K˜Kšœœ
œ
œ	˜Kš
œ˜—K˜J˜—šžœœ
œ
˜ Kšœœ˜,Kšœœ˜.šœ
œ
œ˜Kš
œ
˜
K˜Kšœœ
œ
œ˜-Kš
œ˜—K˜J˜—šžœœ
œ
˜ Kšœœ˜,Kšœœ˜.šœ
œ
œ˜Kš
œ
˜
K˜Kšœœ
œ
œ˜-Kš
œ˜—K˜J˜—šžœœ
œ˜0Jšœœฯc ˜@J˜J˜—šžœœ
œŸ1˜OKšœœ˜#K˜#Kšœœ)œ˜KKšœœ.˜Hšœœ˜Kšœœ-˜FKš
œ
˜
Kšœœ
œ
œ
˜!Kšœ$œ˜3Kšœ
œ(œ˜@K˜—Kšœœ
œ˜Kš
œ˜šœœ
œ˜Kšœ	œ)œ˜MKšœ
˜—K˜J˜—šžœœ
œ˜Kšœœ˜"šœ
œ
œ˜Kš
œ
˜
K˜Kšœœ
œ˜!Kš
œ˜—K˜J˜—šžœœ
œ
˜Kšœœ˜,Kšœœ˜.šœ
œ
œ˜Kš
œ
˜
K˜Kšœœ
œ
œ˜-Kš
œ˜—K˜J˜——š
œ*™*šžœœ
œ˜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šœœ
˜—Jš
œ˜J™—šžœœ
œ˜Kšœœ˜"šœ
œ
œ˜Kš
œ
˜
Kš
œ˜Kšœœ
œ˜Kš
œ˜—J˜J˜—šžœœ
œ˜&Kšœœ˜,Kšœœ˜.šœ˜Kšœœ˜Kšœœ˜Kšœœ
˜—J˜J˜—šžœœ
œ˜$Kšœœ˜,Kšœœ˜.Jšœ˜!J˜——™šžœœ
œ˜)Jšœ(œ
™ท
Jšœœ
˜J˜J˜——™
šž	œœœ
œ™;J™J™J™$Kšœœ™0Jš
œ$™$J™Kšœ
œ™%J™Jš
œ$™$Jš
œ™Jš
œ™Jš
œ™Jš
œ
™
Jš
œ™J™Kš
œ	™	Kš
œ™Kš
œ™K™K™Kš
œ™Kšœ
œ
™Kš
œ™Kš
œ™K™K™K™
K™Kšœ	œ
™Kš
œ™Kš
œ	™	Kš
œ™K™Kšœœ
™Kšœœ
™Kšœœ
™Kšœœ
™ K™Jšœ
™
K™K™—š
žœœ
œ
œ
œ™4Jš
œ™Jšœ™K™K™—K˜Jš
ž	œœž	œœœ˜8Jšžœœ
œžœž	œœ˜AJ˜KšžœŸ˜4Kšžœ˜J˜Jšœœœœ
œœ˜`Jš	œ œœœœ˜YJšœœœœ
œœ˜xJšœœœœ
œœ˜_Jšœœœœ
œœ˜vJšœœœœ
œ%œ˜ˆ
Jšœœœœ
œœ
˜VJšœœœœ
œœ˜iJšœœœœ
œœ˜`Jš
œœœœ
œœ
œ*˜
Jšœœœœ
œœ
˜bJš
œœœœ
œœœ˜]Jšœœœœ
œœ
˜\Jšœœœœ
œœ	˜YJš
œœœœ
œœ
œ'˜wJš
œœœœ
œœ
œ,˜‚
Jš
œœœœ
œœ
œ.˜Š
Jš
œœœœ
œœ
œ+˜„
Jš	œœœœœ˜QJš
œœœœ
œœ
œ0˜„
Jš
œœœœ
œœ
œ*˜~Jš
œœœœ
œœ
œ,˜„
Jš
œœœœ
œœ
œ'˜uJšœœœœ
œžœœ
œ&˜rJšœœœœ
œžœœ
œ(˜xJšœœœœ
œžœœ
œ'˜uJšœœœœ
œžœœ
œ'˜uJšœœœœ
œžœœ
œ'˜uJš
œœœœ
œœ
œ*˜Œ
Jš	œœœœœ
˜IJš
œœœœ
œœ
œ(˜ˆ
Jš
œœœœ
œœ
œ'˜uJš
œœœœ
œœ
œ+˜‘
J˜Jšœ8˜:Jšœ?˜AJšœD˜FJšœ4˜6Jšœ:˜<JšœD˜FJšœ0˜2Jšœ8˜:Jšœ4˜6Jšœ4˜6Jšœ0˜2Jšœ0˜2Jšœ.˜0Jšœ2˜4Jšœ.˜0Jšœ8˜:Jšœ<˜>Jšœ6˜8Jšœ4˜6Jšœ0˜2Jšœ>˜@Jšœ8˜:Jšœ.˜0Jšœ,˜.Jšœ3˜5Jšœ.˜0Jšœ.˜0Jšœ.˜0Jšœ6˜8Jšœ6˜8Jšœ0˜2Jšœ.˜0Jšœ6˜8J˜Jšœ˜Jšœ'˜)J˜J˜—˜J˜—Jšœ
˜J˜—…—/Fฎ