DIRECTORY
Basics USING [Comparison],
BigCardinals USING [BigAdd, BigCARD, BigCompare, BigDivMod, BigFromBinaryRope, BigFromDecimalRope, BigFromSmall, BigMultiply, BigSubtract, BigToDecimalRope, BigZero, FirstOneBit, Zero],
IO USING [bool, int, PutFR, PutR, rope],
Rope USING [ActionType, Cat, Fetch, ROPE, Substr],
SaffronBaseDef USING [LocalContextNode, ProgramGraphNode],
SaffronContextPrivateTypes USING [BaseTypeTGNBody, TypeGraphNodeListNodeBody, TypeGraphNodeNodeBody],
SaffronErrorHandling USING [Error, InternalError, Message],
SaffronInstance,
SaffronTargetArchitecture USING [TargetArchitecture];
SaffronInstanceImpl: CEDAR PROGRAM
IMPORTS BigCardinals, IO, Rope, SaffronErrorHandling
EXPORTS SaffronBaseDef, SaffronInstance
 ~ BEGIN
ROPE: TYPE ~ Rope.ROPE;

LocalContextNode: TYPE ~ SaffronBaseDef.LocalContextNode;
ProgramGraphNode: TYPE ~ SaffronBaseDef.ProgramGraphNode;

TypeGraphNodeNode: TYPE ~ REF TypeGraphNodeNodeBody; 
TypeGraphNodeNodeBody: PUBLIC TYPE ~ SaffronContextPrivateTypes.TypeGraphNodeNodeBody;

TypeGraphNodeListNode: TYPE ~ REF TypeGraphNodeListNodeBody;
TypeGraphNodeListNodeBody: PUBLIC TYPE ~ SaffronContextPrivateTypes.TypeGraphNodeListNodeBody;

TargetArchitecture: TYPE ~ SaffronTargetArchitecture.TargetArchitecture;
InstanceNode: TYPE ~ REF InstanceNodeBody;
InstanceNodeBody: PUBLIC TYPE ~ RECORD [
type: TypeGraphNodeNode,
code: ProgramGraphNode,
value: SELECT instanceKind: * FROM
static	=> [concreteRepresentation: REF ANY],
runtime	=> [],
trash	=> [],
ENDCASE
];

Static: PUBLIC PROC [i: InstanceNode] RETURNS [BOOLEAN] ~ BEGIN
RETURN [i.instanceKind = static];
END;

RuntimeValue: PUBLIC PROC [i: InstanceNode] RETURNS [BOOLEAN] ~ BEGIN
RETURN [i.instanceKind = runtime];
END;

Trash: PUBLIC PROC [i: InstanceNode] RETURNS [BOOLEAN] ~ BEGIN
RETURN [i.instanceKind = trash];
END;

Type: PUBLIC PROC [i: InstanceNode] RETURNS [TypeGraphNodeNode] ~ BEGIN
RETURN [i.type];
END;
ChangeType: PUBLIC PROC [i: InstanceNode, newType: TypeGraphNodeNode] RETURNS [InstanceNode] ~ BEGIN
IF newType = NIL THEN ERROR SaffronErrorHandling.InternalError["Tried to change type to NIL"];
RETURN [NEW[InstanceNodeBody _
WITH i SELECT FROM
ii: REF static InstanceNodeBody => [newType, i.code, static[ii.concreteRepresentation]],
ii: REF runtime InstanceNodeBody	=> [newType, i.code, runtime[]],
ii: REF trash InstanceNodeBody	=> [newType, i.code, trash[]],
ENDCASE	=> ERROR
]];
END;
Code: PUBLIC PROC [i: InstanceNode] RETURNS [ProgramGraphNode] ~ BEGIN
RETURN[i.code];
END;
GetConcreteRepresentation: PROC [i: InstanceNode] RETURNS [REF ANY] ~ BEGIN
WITH i SELECT FROM
ii: REF static InstanceNodeBody => 
RETURN[ii.concreteRepresentation];
ii: REF runtime InstanceNodeBody => 
ERROR SaffronErrorHandling.InternalError[ "SaffronInstanceImpl.GetConcreteRepresentation called with runtime instance."];
ii: REF trash InstanceNodeBody => 
ERROR SaffronErrorHandling.InternalError[ "SaffronInstanceImpl.GetConcreteRepresentation called with trash instance."];
ENDCASE;
RETURN[NIL]; -- to make the compiler happy
END;

RopeFromInstance: PUBLIC PROC [i: InstanceNode] RETURNS [ROPE] ~ BEGIN
RETURN [WITH i SELECT FROM
ii: REF static InstanceNodeBody	=> RopeFromStaticInstance[ii],
ii: REF runtime InstanceNodeBody	=> "[RUNTIME VALUE]",
ii: REF trash InstanceNodeBody	=> "TRASH"
ENDCASE			=> ERROR
];
END;

RopeFromStaticInstance: PROC [i: REF static InstanceNodeBody] RETURNS [ROPE] ~ BEGIN
concreteRep: REF ANY = i.concreteRepresentation;
r: ROPE _ WITH concreteRep SELECT FROM
v: IntegerValue	=> UnparseIntegerValue[v, 10],
v: REF BOOLEAN	=> IO.PutR[IO.bool[v^]],
ENDCASE		=> "can't print it";
RETURN[Rope.Cat["STATIC[", r, "]"]];
END;
MakeDummy: PUBLIC PROC [msg: ROPE] RETURNS [InstanceNode] ~ BEGIN
SIGNAL SaffronErrorHandling.Message[IO.PutFR["Creating dummy (%g) instance.", IO.rope[msg]]];
RETURN [NEW[InstanceNodeBody _ [NIL, NIL, trash[]]]];
END;
MakeTrash: PUBLIC PROC [type: TypeGraphNodeNode] RETURNS [InstanceNode] ~ BEGIN
RETURN [NEW[InstanceNodeBody _ [type, NIL, trash[]]]];
END;

MakeRuntime: PUBLIC PROC [type: TypeGraphNodeNode, code: ProgramGraphNode] RETURNS [InstanceNode] ~ BEGIN
RETURN [NEW[InstanceNodeBody _ [type, code, runtime[]]]];
END;
Sign: TYPE = SaffronInstance.Sign;
IntegerValue: TYPE = REF IntegerValueBody;
IntegerValueBody: PUBLIC TYPE = RECORD [
sign: Sign,
absoluteValue: BigCardinals.BigCARD
];


MakeIntegerValue: PUBLIC PROC [j: INT] RETURNS [intValue: IntegerValue] ~ BEGIN
RETURN[NEW[IntegerValueBody _ [
sign: IF j >= 0 THEN plus ELSE minus,
absoluteValue: BigCardinals.BigFromSmall[ABS[j]]
]]];
END;

ParseIntegerLiteral: PUBLIC PROC [text: ROPE, base: [2..36] _ 10] RETURNS [IntegerValue] ~ BEGIN
sign: Sign _ plus;
absoluteValue: BigCardinals.BigCARD;
SELECT text.Fetch[0] FROM
'+			=> {text _ text.Substr[1]};
'-			=> {text _ text.Substr[1]; sign _ minus};
ENDCASE	=> NULL;
SELECT base FROM
2			=> {absoluteValue _ BigCardinals.BigFromBinaryRope[text]};
10			=> {absoluteValue _ BigCardinals.BigFromDecimalRope[text]};
ENDCASE	=> {
ERROR SaffronErrorHandling.InternalError[IO.PutFR["Can't parse base %g", IO.int[base]]] };
RETURN[NEW[IntegerValueBody _ [sign, absoluteValue]]];
END;


UnparseIntegerValue: PUBLIC PROC [value: IntegerValue, base: [2..36] _ 10] RETURNS [ROPE] ~ BEGIN
RETURN[Rope.Cat[
IF value.sign = minus THEN "-" ELSE "",
SELECT base FROM
10			=> BigCardinals.BigToDecimalRope[value.absoluteValue],
ENDCASE	=> 
ERROR SaffronErrorHandling.InternalError[IO.PutFR["Can't parse base %g", IO.int[base]]]
]];
END;

CastIntegerValue: PUBLIC PROC [value: IntegerValue, types: TypeGraphNodeListNode] RETURNS [InstanceNode] ~ BEGIN
typeList: LIST OF TypeGraphNodeNode _ types^;
WHILE (typeList # NIL) DO
IF CanCastIntegerValue[value, typeList.first]
THEN {
SIGNAL SaffronErrorHandling.Message[IO.PutFR["Casting an integer value of %g", IO.rope[UnparseIntegerValue[value]]]];
RETURN [NEW[InstanceNodeBody _ [
type: typeList.first,
code: NIL,
value: static[value]
]]];
};
ENDLOOP;
SIGNAL SaffronErrorHandling.Error[0, IO.PutFR["Integer value %g exceeds the capacity of all integer types.", IO.rope[UnparseIntegerValue[value]]]];
RETURN [NEW[InstanceNodeBody _ [
type: types^.first,
code: NIL,
value: static[MakeIntegerValue[0]]
]]];
END;

CanCastIntegerValue: PUBLIC PROC [value: IntegerValue, type: TypeGraphNodeNode] RETURNS [BOOLEAN] ~ BEGIN
IntegerBaseType: TYPE = REF integer SaffronContextPrivateTypes.BaseTypeTGNBody;
baseType: IntegerBaseType _ IF ISTYPE[type.body, IntegerBaseType] 
THEN NARROW[type.body]
ELSE ERROR SaffronErrorHandling.InternalError["Tried to cast an integer value into a non integer base type."];
IF baseType.signed
THEN {
nValueBits: INT _ BigCardinals.FirstOneBit[BigCardinals.BigSubtract[
value.absoluteValue, BigCardinals.BigFromSmall[IF value.sign = minus THEN 1 ELSE 0]]] + 1;
IF (nValueBits + 1) > baseType.nBits THEN RETURN[FALSE];
}
ELSE {
nValueBits: INT _ BigCardinals.FirstOneBit[value.absoluteValue] + 1;
IF value.sign = minus THEN RETURN[FALSE];
IF nValueBits > baseType.nBits THEN RETURN[FALSE];
};
RETURN[TRUE];
END;


RetrieveIntegerValue: PUBLIC PROC [i: InstanceNode] RETURNS [IntegerValue] ~ BEGIN
RETURN [NARROW[GetConcreteRepresentation[i]]];
END;

AddIntegers: PUBLIC PROC [i1, i2: IntegerValue] RETURNS [IntegerValue] ~ BEGIN
abs1: BigCardinals.BigCARD = i1.absoluteValue;
abs2: BigCardinals.BigCARD = i2.absoluteValue;
RETURN[NEW[IntegerValueBody _
IF i1.sign = i2.sign 
THEN [i1.sign, BigCardinals.BigAdd[abs1, abs2]]
ELSE SELECT BigCardinals.BigCompare[abs1, abs2] FROM
less		=> [i2.sign, BigCardinals.BigSubtract[abs2, abs1]],
equal		=> [plus, BigCardinals.Zero],
greater	=> [i1.sign, BigCardinals.BigSubtract[abs1, abs2]]
ENDCASE	=> ERROR
]];
END;

SubtractIntegers: PUBLIC PROC [i1, i2: IntegerValue] RETURNS [IntegerValue] ~ BEGIN
abs1: BigCardinals.BigCARD = i1.absoluteValue;
abs2: BigCardinals.BigCARD = i2.absoluteValue;
RETURN[NEW[IntegerValueBody _
IF i1.sign # i2.sign 
THEN [i1.sign, BigCardinals.BigAdd[abs1, abs2]]
ELSE SELECT BigCardinals.BigCompare[abs1, abs2] FROM
less		=> [FlipSign[i1.sign], BigCardinals.BigSubtract[abs2, abs1]],
equal		=> [plus, BigCardinals.Zero],
greater	=> [i1.sign, BigCardinals.BigSubtract[abs1, abs2]]
ENDCASE	=> ERROR
]];
END;

MultiplyIntegers: PUBLIC PROC [i1, i2: IntegerValue] RETURNS [IntegerValue] ~ BEGIN
RETURN[NEW[IntegerValueBody _ [
sign: IF i1.sign = i2.sign THEN plus ELSE minus,
absoluteValue: BigCardinals.BigMultiply[i1.absoluteValue, i2.absoluteValue]
]]];
END;

DivideIntegers: PUBLIC PROC [i1, i2: IntegerValue] RETURNS [IntegerValue] ~ BEGIN
RETURN[NEW[IntegerValueBody _ [
sign: IF i1.sign = i2.sign THEN plus ELSE minus,
absoluteValue: BigCardinals.BigDivMod[i1.absoluteValue, i2.absoluteValue].quo
]]];
END;

ModIntegers: PUBLIC PROC [i1, i2: IntegerValue] RETURNS [IntegerValue] ~ BEGIN
RETURN[NEW[IntegerValueBody _ [
sign: IF i1.sign = i2.sign THEN plus ELSE minus,
absoluteValue: BigCardinals.BigDivMod[i1.absoluteValue, i2.absoluteValue].rem
]]];
END;

NegateInteger: PUBLIC PROC [i: IntegerValue] RETURNS [IntegerValue] ~ BEGIN
RETURN[IF BigCardinals.BigZero[i.absoluteValue] 
THEN i
ELSE NEW[IntegerValueBody _ [
sign: FlipSign[i.sign],
absoluteValue: i.absoluteValue
]]];
END;

FlipSign: PROC [sign: Sign] RETURNS [Sign] = INLINE {
RETURN[IF sign = plus THEN minus ELSE plus]; };

MultiplySigns: PROC [sign1, sign2: Sign] RETURNS[Sign] = INLINE {
RETURN[IF sign1 = sign2 THEN plus ELSE minus]; };

RealValue: TYPE = REF RealValueBody;
RealValueBody: PUBLIC TYPE = RECORD [
sign: Sign,
mantissa: Mantissa,
exponent: Exponent
];

Mantissa: TYPE = REF MantissaBody;
MantissaBody: TYPE = RECORD [
mantissa: SEQUENCE nMantissaBytes: CARDINAL OF BYTE
];

Exponent: TYPE = REF ExponentBody;
ExponentBody: TYPE = RECORD [
exponent: SEQUENCE nExponentBytes: CARDINAL OF BYTE
];

InstanceAdd: PUBLIC PROC [i1, i2: InstanceNode, targetType: TypeGraphNodeNode] RETURNS [InstanceNode] ~ BEGIN
RETURN [MakeDummy["add"]];
END;

InstanceSubtract: PUBLIC PROC [i1, i2: InstanceNode, targetType: TypeGraphNodeNode] RETURNS [InstanceNode] ~ BEGIN
RETURN [MakeDummy["subtract"]];
END;

InstanceMultiply: PUBLIC PROC [i1, i2: InstanceNode, targetType: TypeGraphNodeNode] RETURNS [InstanceNode] ~ BEGIN
RETURN [MakeDummy["multiply"]];
END;

InstanceDivide: PUBLIC PROC [i1, i2: InstanceNode, targetType: TypeGraphNodeNode] RETURNS [InstanceNode] ~ BEGIN
RETURN [MakeDummy["divide"]];
END;

MakeStaticBoolean: PUBLIC PROC [value: BOOLEAN, type: TypeGraphNodeNode] RETURNS [InstanceNode] ~ BEGIN
SIGNAL SaffronErrorHandling.Message[IO.PutFR["Creating a static boolean value of %g", IO.bool[value]]];
RETURN[NEW[InstanceNodeBody _ [type, NIL, static[NEW[BOOLEAN _ value]]]]];
END;
BooleanValue: PUBLIC PROC [i: InstanceNode] RETURNS [BOOLEAN] ~ BEGIN
IF Static[i] AND TRUE 
THEN RETURN[NARROW[GetConcreteRepresentation[i], REF BOOLEAN]^]
ELSE ERROR SaffronErrorHandling.InternalError["not a boolean instance"];
END;



END.
 
ͺSaffronInstanceImpl.Mesa
Copyright Σ 1988 by Xerox Corporation.  All rights reserved.
James Rauen, June 20, 1988 4:34:50 pm PDT
Last edited by: James Rauen July 12, 1988 11:26:47 am PDT

This file implements the Instance abstraction, which Saffron uses to represent an arbitrary Cedar object.  The abstraction is implemented with an opaque type.  The constructors enforce the various invariants of the representation; they also raise numerous type-checking errors.


Nicknames
Representation
Generic Operations



Dummies Until Everything's Implemented
Trash
Runtime Values
Numeric Types
Generic Definitions
Integers
DigitFromChar: PROC [literal: CHARACTER, base: [2..36]] RETURNS [digit: INT] ~ BEGIN
SELECT literal FROM
IN ['0..'9]		=> digit _ literal - '0;
IN ['a..'z]		=> digit _ literal - 'a + 10;
IN ['A..'Z]	=> digit _ literal - 'A + 10;
ENDCASE	=> ERROR SaffronErrorHandling.InternalError[IO.PutFR["Bad argument (%g) to DigitFromChar", IO.char[literal]]];
IF digit >= base THEN ERROR SaffronErrorHandling.InternalError[IO.PutFR["Argument (%g) to DigitFromChar too large for base %g", IO.char[literal], IO.int[base]]];
RETURN[digit];
END;


do a divide by zero check!
do a divide by zero check!
Reals
ParseLiteralReal: PROC [text: ROPE, architecture: TargetArchitecture, rootContext: LocalContextNode] RETURNS [InstanceNode];

IsReal: PROC [i: InstanceNode] RETURNS [BOOLEAN];
Return TRUE if i is a real instance, FALSE otherwise.

AddReals: PROC [i1, i2: InstanceNode] RETURNS [InstanceNode];

SubtractReals: PROC [i1, i2: InstanceNode] RETURNS [InstanceNode];

MultiplyReals: PROC [i1, i2: InstanceNode] RETURNS [InstanceNode];

DivideReals: PROC [i1, i2: InstanceNode] RETURNS [InstanceNode];

Generic Operations
IsNumeric: PROC [i: InstanceNode] RETURNS [BOOLEAN];
Return TRUE if i is an integer or real instance, FALSE otherwise.

CoerceIntegerToReal: PROC [i: InstanceNode] RETURNS [InstanceNode];
Foo.
Operations on Numeric Instances
Operations
Other Basic Types
Atom
MakeStaticAtom: PROC [value: ATOM, rootContext: LocalContextNode] RETURNS [InstanceNode];

MakeUnknownAtom: PROC [code: ProgramGraphNode, rootContext: LocalContextNode] RETURNS [InstanceNode];

IsAtom: PROC [i: InstanceNode] RETURNS [BOOLEAN];
Return TRUE if i is an atom instance, FALSE otherwise.

AtomValue: PROC [i: InstanceNode] RETURNS [ATOM];
i must be a static atom instance.  Return its value.

Boolean
needs code!

MakeUnknownBoolean: PROC [code: ProgramGraphNode, rootContext: LocalContextNode] RETURNS [InstanceNode];

also test to see if its type is boolean
Character
MakeStaticChar: PROC [value: CHARACTER, rootContext: LocalContextNode] RETURNS [InstanceNode];

MakeUnknownChar: PROC [code: ProgramGraphNode, rootContext: LocalContextNode] RETURNS [InstanceNode];

IsCharacter: PROC [i: InstanceNode] RETURNS [BOOLEAN];
Return TRUE if i is a character instance, FALSE otherwise.

CharacterValue: PROC [i: InstanceNode] RETURNS [CHARACTER];
i must be a static character instance.  Return its value.

Rope
MakeStaticRope: PROC [value: ROPE, rootContext: LocalContextNode] RETURNS [InstanceNode];

MakeUnknownRope: PROC [code: ProgramGraphNode, rootContext: LocalContextNode] RETURNS [InstanceNode];

IsRope: PROC [i: InstanceNode] RETURNS [BOOLEAN];
Return TRUE if i is a rope instance, FALSE otherwise.

RopeValue: PROC [i: InstanceNode] RETURNS [ROPE];
i must be a static rope instance.  Return its value.
Constructed Types
MakeSubRange: PUBLIC PROC [low, high: InstanceNode, subRangeType: TypeGraphNodeNode] RETURNS [i: InstanceNode] ~ BEGIN
i _ NEW[InstanceNodeBody _ [TRUE, subRangeType, elements]];

MakeList: PUBLIC PROC [elements: LIST OF InstanceNode, listType: TypeGraphNodeNode] RETURNS [i: InstanceNode] ~ BEGIN
-- i _ NEW[InstanceNodeBody _ [listType, NIL, elements]];
-- FOR e: LIST OF InstanceNode _ elements, e.rest WHILE (e.first # NIL) DO
-- IF e.first.Static = FALSE THEN i.Static _ FALSE;
-- IF Incompatible[element.type, listType.elementType] THEN error...
-- ENDLOOP;
-- if this winds up being a not-compile-time-constant, then we need to return consing code.
RETURN [NEW[InstanceNodeBody _ [NIL, NIL, trash[]]]];
END;



Procedure Frame
MakeList: PROC [elements: LIST OF InstanceNode, listType: TypeGraphNodeNode] RETURNS [i: InstanceNode];
Κψ˜™Icodeš
œ<™<Kšœ&Οk™)Kš
œ9™9K™—Ibodyš
œ•™•L™š
	˜	Jšœœ˜Jšœ
œ§
˜Ή
Jšœ
œ ˜(Jšœœœ
˜2Jšœœ&˜:JšœœE˜eJšœœ!˜;Jš
œ˜Jšœœ˜5—K™šΟnœœ
˜"Kšœœ˜4Kšœ ˜'Kšœ˜—
headš
œ	™	Kšœœœ
˜K˜Kšœœ#˜9Kšœœ#˜9K˜Kšœœœ˜5Kšœœ
œ4˜VK˜Kšœœœ˜<Kšœœ
œ8˜^K˜Kšœœ0˜H—š
œ™Kšœœœ˜*šœœ
œœ˜(Kš
œ˜K˜šœœ˜"Kšœ#œ
œ˜,K˜K˜Kš
˜—˜K˜———š
œ™šžœœ
œœœ˜?Kšœ˜!Kšœ
˜K˜—šžœœ
œœœ˜EKšœ˜"Kšœ
˜K˜—šžœœ
œœœ˜>Kšœ˜ Kšœ
˜K˜—š	žœœ
œœ˜GKšœ
˜Kšœ
˜K™—š	ž
œœ
œ/œ˜dKšœœ
œ
œC˜^šœœ˜šœœ
˜KšœœQ˜XKšœœ:˜AKšœœ6˜=Kšœ˜—K˜—Kšœ
˜K™—š	žœœ
œœ˜FKšœ	˜Kšœ
˜K™—šžœœœœ
œ˜Kšœœ
˜šœœ˜#Kšœ˜"—šœœ˜$Kšœt˜y—šœœ˜"Kšœr˜w—Kšœ
˜—Kšœ
œΟc˜*Kšœ
˜K˜—šžœœ
œœœ˜Fšœœœ
˜Kšœœ7˜>Kšœœ/˜6Kšœœ"˜)Kšœ˜K˜—Kšœ
˜K˜—šžœœœœœ˜TKšœ
œ
œ˜0šœœœ
œ
˜&K˜.Kš	œœ
œœœ˜'Kšœ˜—Kšœ˜$Kšœ
˜——š
œ&™&šž	œœ
œœœ˜AKšœœ(œ
˜]Kšœœœœ
˜5Kšœ
˜——š
œ™š	ž	œœ
œœ˜OKšœœœ
˜6Kšœ
˜K˜——š
Οz™š	žœœ
œ3œ˜iKšœœ.˜9Kšœ
˜——š
œ
™
š
œ™Jšœœ˜"—š
œ™Jšœœœ˜*šœœ
œœ˜(J˜J˜#Jš
œ˜J˜—J˜šžœœ
œœœ˜Ošœ
œ˜Jšœœœœ˜%Jšœ)œ˜0J˜—Jšœ
˜J˜—šžœœ
œœœ˜`J˜J˜$šœ˜Jš
œ ˜ Jš
œ.˜.Jšœœ
˜—šœ˜Jš
œ>˜>Jš
œ@˜@šœ˜Jšœ$œœ˜Z——Jšœ
œ,˜6Jšœ
˜J˜J˜—šžœœ
œ+œœ˜ašœ
˜Jšœœœ˜'šœ˜Jš
œ;˜;šœ˜Jšœ$œœ˜W——J˜—Jšœ
˜J˜—šž
œœ	œœ	œ™Tšœ	™Jšœ#™%Jšœ(™*Jšœ'™)Jšœœ$œ-œ™v—Jšœœ
œ$œ?œœ
™‘
Jšœ™Jšœ
™J™J™—š	žœœ
œ5œ˜pJšœ
œ
œ˜-šœ
œ˜šœ+˜-šœ˜Jšœœ)œ$˜ušœœ˜ Jš
œ˜Jšœœ
˜
J˜J˜—J˜——Jšœ
˜—JšœœFœ$˜“
šœœ˜ Jš
œ˜Jšœœ
˜
J˜"J˜—šœ
˜J˜——š	žœœ0œœ˜iJšœœœ4˜Ošœœ
œ˜BJšœ˜Jšœ
œd˜n—šœ˜šœ˜šœœ5˜DJšœ/œœœ
˜Z—Jšœ#œ
œ
œ˜8J˜
—šœ˜Jšœœ5˜DJšœœ
œ
œ˜)Jšœœ
œ
œ˜2J˜——Jšœ
œ˜
Jšœ
˜J˜J˜—š	žœœ
œœ˜RJšœœ ˜.Jšœ
˜J˜—š	žœœ
œœ˜NJš
œ.˜.Jš
œ.˜.šœ
œ˜šœ˜Jšœ+˜/šœ
œ%˜4Jš
œ9˜9J˜$Jš
œ:˜:Jšœ˜——J˜—Jšœ
˜J˜—š	žœœ
œœ˜SJš
œ.˜.Jš
œ.˜.šœ
œ˜šœ˜Jšœ+˜/šœ
œ%˜4Jš
œC˜CJ˜$Jš
œ:˜:Jšœ˜——J˜—Jšœ
˜J˜—š	žœœ
œœ˜Sšœ
œ˜Jšœœœœ˜0Jš
œK˜KJ˜—Jšœ
˜J˜—š	žœœ
œœ˜QJ™šœ
œ˜Jšœœœœ˜0Jš
œM˜MJ˜—Jšœ
˜J˜—š	žœœ
œœ˜NJ™šœ
œ˜Jšœœœœ˜0Jš
œM˜MJ˜—Jšœ
˜J˜—š	ž
œœ
œœ˜Kšœ
œ'˜0Jšœ˜šœ
œ˜J˜J˜J˜——Jšœ
˜J˜—šžœœœ
œ˜5Jšœ
œ
œœ
˜/J˜—šž
œœœ	œ˜AJšœ
œœœ˜1J˜——š
œ™Jšœœœ˜$šœœ
œœ˜%J˜Jš
œ˜Jš
œ˜J˜J˜—Jšœ
œœ˜"šœœœ˜Jšœ
œœ
œ
˜3J˜J˜—Jšœ
œœ˜"šœœœ˜Jšœ
œœ
œ
˜3J˜J˜—šžœœœCœ™|J™—šžœœœœ™1Jšœœœ™5J™—šžœœœ™=J™—šž
œœœ™BJ™—šž
œœœ™BJ™—šžœœœ™@J™——š
œ™šž	œœœœ™4Jšœœ&œ™AJ™—šžœœœ™CJ™———š
œ™š
œ
™
š	žœœ
œ7œ˜mKšœ˜Kšœ
˜K˜—š	žœœ
œ7œ˜rKšœ˜Kšœ
˜K˜—š	žœœ
œ7œ˜rKšœ˜Kšœ
˜K˜—š	žœœ
œ7œ˜pKšœ˜Kšœ
˜K˜———š
œ™š
œ™šžœœ	œ!œ™YK™—šžœœ9œ™eK™—šžœœœœ™1Jšœœœ™6J™—šž	œœœœ™1Jš
œ4™4J™——š
œ™š	žœœ	œœ˜gJšœœ0œ˜gKš
œ
œœ	œ
œ˜JKšœ
˜K™K™—šžœœ9œ™hK™—šžœœ
œœœ˜Ešœœ
œ
˜Kš
œ
œ
œœ
œ˜?K™'Kš
œ>˜H—Kšœ
˜J˜——š
œ	™	šžœœ		œ!œ™^K™—šžœœ9œ™eK™—šžœœœœ™6Jšœœœ™:J™—šžœœœ	œ™;Jš
œ9™9J™——š
œ™šžœœ	œ!œ™YK™—šžœœ9œ™eK™—šžœœœœ™1Jšœœœ™5J™—šž	œœœœ™1Jš
œ4™4———š
œ™š	žœœ
œ<œ™vKšœœœ™;K™—š
žœœ
œœ
œ,œ™uKš
Ÿ9™9š
ŸJ™JKš
Ÿ3™3Kš
ŸD™DJš
Ÿ™—Jš
Ÿ[™[Kšœœœœ
™5šœ
™K™K™—K™——š
œ™š
žœœœ
œ,œ™gK˜K˜—Kšœ
˜—Kš
œ
˜
—…—* MB