DIRECTORY
AMBridge USING [
IsRemote, SetTVFromLI, TVForATOM, TVForPointerReferent, TVToLI, WordSequence, WordSequenceRecord],
AMTypes USING [
Assign, Class, Error, GroundStar, IndexToTV, IndexToType, NComponents, New, Size, TVType, TypeClass, UnderType, Index, TV, TypedVariable, Type],
BrandXSymbolDefs USING [
ExtensionClass, InnerCallableBodyIndex, SymbolTableBase, TreeIndex, TreeLink],
BrandYSymbolDefs USING [
ExtensionClass, InnerCallableBodyIndex, SymbolTableBase, TreeIndex, TreeLink],
PrincOps USING [ControlLink, GFTIndex, GlobalFrameHandle, ProcDesc],
RTCommon USING [ShortenLongPointer],
RTSymbolDefs USING [
ExtensionClass, SymbolConstructorIndex, SymbolIdIndex, SymbolIndex, SymbolTableBase, TreeLink],
RTSymbolOps USING[
AcquireAtom, AcquireType, EnumerateCtxIseis, ISEExtended, ISEFindExtension, ISEInfo, ISEType, IsTypeSEI, SETagIDP, SETypeXferMode, SEUnderType, ISEConstant],
RTSymbols USING [GetTypeSymbols, ReleaseSTB],
RTTCache USING [FillRefEntry, GetRef, LookupRef, RefEntry],
RTTypesPrivate USING [RecordComponentISEI, TypedVariableRec],
RTTypesRemotePrivate USING [GetRemoteGFHeader];

RTTDefaultImpl: PROGRAM
IMPORTS
AMBridge, AMTypes, RTCommon, RTSymbolOps, RTSymbols, RTTCache, RTTypesPrivate, RTTypesRemotePrivate
EXPORTS AMTypes, RTTypesPrivate
= BEGIN OPEN AMBridge, AMTypes, bx: BrandXSymbolDefs, by: BrandYSymbolDefs, RTSymbolDefs, RTSymbolOps, RTSymbols, RTTypesRemotePrivate;

CARD: TYPE = LONG CARDINAL;

DefaultInitialValue: PUBLIC SAFE PROC
[type: Type] RETURNS[tv: TypedVariable] = TRUSTED {
uType: Type _ UnderType[type];
c: Class _ TypeClass[uType];
typeSTB: SymbolTableBase;
typeSEI: SymbolIndex;
entry: RTTCache.RefEntry;
valid: BOOL;

Nature: TYPE = {basic, constructed, nil};
n: Nature _ SELECT c FROM
record, structure => constructed,
unspecified, enumerated, subrange, ref, list, atom, rope,
pointer, longPointer, nil, cardinal, integer, character, longInteger,
longCardinal, real, countedZone, uncountedZone
=> IF TypeClass[type] = definition THEN basic ELSE nil,
ENDCASE => ERROR Error[reason: notImplemented, msg: "DefaultInitialValue for this type"];

IF n = nil THEN RETURN[NIL];
entry _ RTTCache.LookupRef[type, DefaultInitialValue];
[tv, valid] _ RTTCache.GetRef[entry];
IF valid THEN RETURN [tv];

[typeSTB, typeSEI] _ GetTypeSymbols[type];

{ENABLE UNWIND => ReleaseSTB[typeSTB];
tv _ New[uType];
SELECT n FROM
constructed => {
index: Index _ 0;
iTV, defTV: TypedVariable;
csei: SymbolConstructorIndex = SEUnderType[typeSTB, typeSEI];

EachIndex: PROC
[stb: SymbolTableBase, isei: SymbolIdIndex] RETURNS[stop: BOOL _ FALSE] = {
index _ index + 1;
iTV _ IndexToTV[tv, index];
IF ISEExtended[stb, isei]
THEN {
ttype: ExtensionClass;
tree: TreeLink;
[ttype, tree] _ ISEFindExtension[stb, isei];
IF (WITH ttype SELECT FROM
t: ExtensionClass.x => t.e = default,
t: ExtensionClass.y => t.e = default,
ENDCASE => ERROR)
THEN {
IF SetTVFromLink[iTV, stb, tree]
THEN RETURN
ELSE ERROR Error[
reason: notImplemented,
msg: "DefaultInitialValue for this type"]}};
defTV _ DefaultInitialValue[TypeFromISE[stb, isei]];
IF defTV = NIL THEN {
tv _ NIL;
RETURN[TRUE]};
Assign[iTV, defTV]};

WITH typeSTB SELECT FROM
t: SymbolTableBase.x =>
WITH ser: t.e.seb[NARROW[csei, SymbolConstructorIndex.x].e] SELECT FROM
record => [] _ EnumerateCtxIseis[typeSTB, [x[ser.fieldCtx]], EachIndex];
definition => ERROR Error[reason: notImplemented,
msg: "DefaultInitialValue for interface records"];
ENDCASE=> ERROR;
t: SymbolTableBase.y =>
WITH ser: t.e.seb[NARROW[csei, SymbolConstructorIndex.y].e] SELECT FROM
record => [] _ EnumerateCtxIseis[typeSTB, [y[ser.fieldCtx]], EachIndex];
definition => ERROR Error[reason: notImplemented,
msg: "DefaultInitialValue for interface records"];
ENDCASE=> ERROR;
ENDCASE => ERROR;
};  -- end constructed case

basic => {
isei: SymbolIdIndex _ LOOPHOLE[typeSEI, SymbolIdIndex];
ttype: ExtensionClass;
tree: TreeLink;
DO sei: SymbolIndex = ISEInfo[typeSTB, isei];
IF ISEExtended[typeSTB, isei] THEN EXIT; -- found default
IF NOT SETagIDP[typeSTB, sei] THEN GOTO noDefault;
isei _ LOOPHOLE[sei, SymbolIdIndex];
ENDLOOP;
[ttype, tree] _ ISEFindExtension[typeSTB, isei];
IF (WITH ttype SELECT FROM
t: ExtensionClass.x => t.e # default,
t: ExtensionClass.y => t.e # default,
ENDCASE => ERROR)
THEN GO TO noDefault;
IF ~SetTVFromLink[tv, typeSTB, tree]
THEN ERROR Error[reason: notImplemented, msg: "DefaultInitialValue in this case"];
EXITS noDefault => tv _ NIL};
ENDCASE => ERROR};  -- end basic case

ReleaseSTB[typeSTB];
[] _ RTTCache.FillRefEntry[entry, tv];
RETURN[tv]};  -- end DefaultInitialValue

IndexToDefaultInitialValue: PUBLIC SAFE PROC[type: Type, index: Index]
RETURNS [tv: TypedVariable _ NIL] = TRUSTED {
GetDefaultFieldValue: PROC[stb: SymbolTableBase, isei: SymbolIdIndex] = {
IF ISEExtended[stb, isei]
THEN {
ttype: ExtensionClass;
tree: TreeLink;
tv _ New[IndexToType[type, index]];
[ttype, tree] _ ISEFindExtension[stb, isei];
IF (WITH ttype SELECT FROM
t: ExtensionClass.x => t.e = default,
t: ExtensionClass.y => t.e = default,
ENDCASE => ERROR)
 AND NOT SetTVFromLink[tv, stb, tree]
THEN ERROR Error[reason: notImplemented,
                    msg: "IndexToDefaultInitialValue in this case"];
}  -- IF ISEExtended[stb, isei]
ELSE IF ISEConstant[stb, isei] THEN {
ENABLE Error => IF reason = notImplemented THEN GOTO nimp;
sei: SymbolIndex = ISEType[stb, isei];
cType: Type _ AcquireType[stb, sei];
tv _ NEW[RTTypesPrivate.TypedVariableRec _ [
				referentType: [cType],
				head: [constant[]],
				status: const,
				field: constant[value: GetIdConstantValue[NIL, stb, isei]]
				]];
EXITS nimp => NULL;
};  -- ELSE clause of IF ISEExtended[stb, isei]
};  -- end GetDefaultFieldValue

RTTypesPrivate.RecordComponentISEI[type, index, GetDefaultFieldValue]};

SetTVFromLink: PROC
[tv: TypedVariable, stb: SymbolTableBase, tree: TreeLink] RETURNS[BOOL] =  {
WITH stb SELECT FROM
t: SymbolTableBase.x =>
RETURN[SetTVFromLinkX[tv, t.e, NARROW[tree, TreeLink.x].e]];
t: SymbolTableBase.y =>
RETURN[SetTVFromLinkY[tv, t.e, NARROW[tree, TreeLink.y].e]];
ENDCASE => ERROR};

SetTVFromLinkX: PROC[tv: TypedVariable, stb: bx.SymbolTableBase, tree: bx.TreeLink]
RETURNS[success: BOOL _ TRUE] =  {
type: Type = TVType[tv];
ground: Type = GroundStar[type];
class: Class = TypeClass[ground];
vType: Type _ ground; -- type of value defaults to ground type of target
DO
WITH oak: tree SELECT FROM
literal => {
WITH wordLit: oak.index SELECT FROM
string => RETURN[FALSE]; -- Mesa can't do it
word => {
ptr: LONG POINTER _ NIL;
WITH val: stb.ltb[wordLit.lti] SELECT FROM
short => {
ptr _ @val.value;
SELECT TypeClass[UnderType[vType]] FROM
longInteger => vType _ CODE[INTEGER];
longCardinal => vType _ CODE[CARDINAL];
ENDCASE;
};
long => ptr _ @val.value;
ENDCASE => ERROR;
Assign[
lhs: tv,
rhs: TVForPointerReferent[ptr: ptr, type: vType, status: readOnly]];
RETURN[TRUE];
};
ENDCASE => ERROR};
symbol => {
OPEN node: stb.seb[oak.index];
IF ~node.constant THEN RETURN[FALSE];
vType _ AcquireType[[x[stb]], [x[node.idType]]];
IF node.extended THEN {
ttype: bx.ExtensionClass;
[ttype, tree] _ stb.FindExtension[oak.index];
IF ttype # value THEN ERROR; -- I (DCS) don't believe any of this.
LOOP};
Assign[
lhs: tv,
rhs: TVForPointerReferent[ptr: @node.idValue, type: vType, status: readOnly]];
RETURN[TRUE]};
subtree => {
OPEN node: stb.tb[oak.index];
SELECT node.name FROM
nil => {
Assign[tv, NIL];
RETURN[TRUE]};
void => RETURN[FALSE];
lengthen => {
IF node.attr1  -- ptr to lengthen. forget it.
THEN RETURN[FALSE];
tree _ node.son[1];
LOOP};
shorten, clit, mwconst => {
tree _ node.son[1];  -- the one son of an mwconst is guaranteed to be a literal
LOOP};
uminus => {
IF ~SetTVFromLinkX[tv: tv, stb: stb, tree: node.son[1]]
THEN RETURN[FALSE];
SetTVFromLI[tv, -TVToLI[tv]];
RETURN[TRUE]};
construct => {
uT: Type = UnderType[type];
index: bx.TreeIndex _ oak.index;

IF stb.tb[index].nSons # 2 THEN ERROR;

WITH link: stb.tb[index].son[2] SELECT FROM
subtree => index _ link.index;
ENDCASE => ERROR;

SELECT TypeClass[uT] FROM
record, structure => NULL;
ENDCASE => ERROR;

IF stb.tb[index].name # list OR NComponents[uT] # stb.tb[index].nSons
THEN ERROR;

FOR i: INTEGER IN [1..stb.tb[index].nSons]
DO stv: TypedVariable _ IndexToTV[tv, i];
IF NOT SetTVFromLinkX[stv, stb, stb.tb[index].son[i]] THEN
RETURN[FALSE];
ENDLOOP;
RETURN[TRUE]};
atom => {
atom: ATOM _ AcquireAtom[[x[stb]],
[x[NARROW[node.son[1], bx.TreeLink.hash].index]]];
Assign[tv, TVForATOM[atom]];
RETURN[TRUE]};
ENDCASE => RETURN[FALSE]};
ENDCASE => ERROR;
ENDLOOP;
};  -- end of SetTVFromLinkX

SetTVFromLinkY: PROC[tv: TypedVariable, stb: by.SymbolTableBase, tree: by.TreeLink]
RETURNS[success: BOOL _ TRUE] =  {
type: Type = TVType[tv];
ground: Type = GroundStar[type];
class: Class = TypeClass[ground];
vType: Type _ ground; -- type of value defaults to ground type of target
DO
WITH oak: tree SELECT FROM
literal => {
WITH wordLit: oak.index SELECT FROM
string => RETURN[FALSE]; -- Mesa can't do it
word => {
ptr: LONG POINTER _ NIL;
WITH val: stb.ltb[wordLit.lti] SELECT FROM
short => {
ptr _ @val.value;
SELECT TypeClass[UnderType[vType]] FROM
longInteger => vType _ CODE[INTEGER];
longCardinal => vType _ CODE[CARDINAL];
ENDCASE;
};
long => ptr _ @val.value;
ENDCASE => ERROR;
Assign[
lhs: tv,
rhs: TVForPointerReferent[ptr: ptr, type: vType, status: readOnly]];
RETURN[TRUE];
};
ENDCASE => ERROR};
symbol => {
OPEN node: stb.seb[oak.index];
IF ~node.constant THEN RETURN[FALSE];
vType _ AcquireType[[y[stb]], [y[node.idType]]];
IF node.extended THEN {
ttype: by.ExtensionClass;
[ttype, tree] _ stb.FindExtension[oak.index];
IF ttype # value THEN ERROR; -- I (DCS) don't believe any of this.
LOOP};
Assign[
lhs: tv,
rhs: TVForPointerReferent[ptr: @node.idValue, type: vType, status: readOnly]];
RETURN[TRUE]};
subtree => {
OPEN node: stb.tb[oak.index];
SELECT node.name FROM
nil => {
Assign[tv, NIL];
RETURN[TRUE]};
void => RETURN[FALSE];
lengthen, shorten => {
IF node.attr1  -- ptr to lengthen. forget it.
THEN RETURN[FALSE];
tree _ node.son[1];
LOOP};
shorten, clit, mwconst => {
tree _ node.son[1];  -- the one son of an mwconst is guaranteed to be a literal
LOOP};
uminus => {
IF ~SetTVFromLinkY[tv: tv, stb: stb, tree: node.son[1]] THEN RETURN[FALSE];
SetTVFromLI[tv, -TVToLI[tv]];
RETURN[TRUE]};
construct => {
uT: Type = UnderType[type];
index: by.TreeIndex _ oak.index;

IF stb.tb[index].nSons # 2 THEN ERROR;

WITH link: stb.tb[index].son[2] SELECT FROM
subtree => index _ link.index;
ENDCASE => ERROR;

SELECT TypeClass[uT] FROM
record, structure => NULL;
ENDCASE => ERROR;

IF stb.tb[index].name # list OR NComponents[uT] # stb.tb[index].nSons
THEN ERROR;

FOR i: INTEGER IN [1..stb.tb[index].nSons]
DO stv: TypedVariable _ IndexToTV[tv, i];
IF NOT SetTVFromLinkY[stv, stb, stb.tb[index].son[i]] THEN
RETURN[FALSE];
ENDLOOP;
RETURN[TRUE]};
atom => {
atom: ATOM _ AcquireAtom[[y[stb]],
[y[NARROW[node.son[1], by.TreeLink.hash].index]]];
Assign[tv, TVForATOM[atom]];
RETURN[TRUE]};
ENDCASE => RETURN[FALSE]};
ENDCASE => ERROR;
ENDLOOP;
};  -- end of SetTVFromLinkY

TypeFromISE: PROC [stb: SymbolTableBase, isei: SymbolIdIndex] RETURNS [Type] = {
RETURN [RTSymbolOps.AcquireType[stb, RTSymbolOps.ISEType[stb, isei]]];
};

GetIdConstantValue: PUBLIC PROC[tv: TypedVariable, stb: SymbolTableBase, isei: SymbolIdIndex]
RETURNS[ws: WordSequence] = {
IF IsTypeSEI[ISEType[stb, isei]]
THEN {
ws _ NEW[WordSequenceRecord[1]];
ws[0] _ LOOPHOLE[AcquireType[stb, LOOPHOLE[isei, SymbolIndex]], WORD];
RETURN};
SELECT SETypeXferMode[stb, ISEType[stb, isei]] FROM
none => {
IF ISEExtended[stb, isei]
THEN {
newTV: TV;
tree: TreeLink;
type: Type = AcquireType[stb, ISEType[stb, isei]];
ws _ NEW[WordSequenceRecord[Size[type]]];
newTV _ TVForPointerReferent[ptr: @ws[0], type: type];
[, tree] _ ISEFindExtension[stb, isei];
IF NOT SetTVFromLink[newTV, stb, tree]
THEN ERROR Error[reason: notImplemented, msg: "extended constants"]}
ELSE {
ws _ NEW[WordSequenceRecord[1]];
ws[0] _ LOOPHOLE[(WITH stb SELECT FROM
t: SymbolTableBase.x =>
t.e.seb[NARROW[isei,
SymbolIdIndex.x].e].idValue,
t: SymbolTableBase.y =>
t.e.seb[NARROW[isei,
SymbolIdIndex.y].e].idValue,
ENDCASE => ERROR),
WORD];
};
RETURN};
signalOrError, proc => {
popd: PrincOps.ProcDesc;
pd: PrincOps.ProcDesc;
gfiBase: PrincOps.GFTIndex;

IF tv = NIL THEN RETURN;
IF ISEExtended[stb, isei]
THEN ERROR Error[reason: notImplemented, msg: "extended transfer constants"];
IF IsRemote[tv]
THEN {
ws _ NEW[WordSequenceRecord[1]];
WITH tv SELECT FROM
tvr: REF RTTypesPrivate.TypedVariableRec => {
WITH h: tvr.head SELECT FROM
remoteGFH =>
gfiBase _ GetRemoteGFHeader[h.remoteGlobalFrameHandle].gfi;
remoteFH =>  -- nested proc
WITH stb SELECT FROM
t: SymbolTableBase.x => {
bti: bx.InnerCallableBodyIndex
= LOOPHOLE[t.e.seb
[NARROW[isei,
SymbolIdIndex.x].e].idInfo,
bx.InnerCallableBodyIndex];
ws[0] _ LOOPHOLE[
h.remoteFrameHandle.fh+t.e.bb[bti].frameOffset,
WORD];
RETURN};
t: SymbolTableBase.y => {
bti: by.InnerCallableBodyIndex
= LOOPHOLE[
t.e.seb[NARROW[isei, SymbolIdIndex.y].e].idInfo,
by.InnerCallableBodyIndex];
ws[0] _ LOOPHOLE[
h.remoteFrameHandle.fh+t.e.bb[bti].frameOffset,
WORD];
RETURN};
ENDCASE => ERROR;
ENDCASE => ERROR Error[reason: typeFault, type: TVType[tv]];
};
ENDCASE => ERROR Error[reason: typeFault, type: TVType[tv]];
}
ELSE {
ws _ NEW[WordSequenceRecord[1]];
WITH tv SELECT FROM
tvr: REF RTTypesPrivate.TypedVariableRec => {
WITH h: tvr.head SELECT FROM
gfh => gfiBase _ h.gfh.gfi;
fh => WITH stb SELECT FROM
t: SymbolTableBase.x => {
bti: bx.InnerCallableBodyIndex
= LOOPHOLE[
t.e.seb[NARROW[isei,SymbolIdIndex.x].e].idInfo,
bx.InnerCallableBodyIndex];
ws[0] _ LOOPHOLE[h.fh+t.e.bb[bti].frameOffset, WORD];
RETURN};
t: SymbolTableBase.y => {
bti: by.InnerCallableBodyIndex
= LOOPHOLE[
t.e.seb[NARROW[isei,SymbolIdIndex.y].e].idInfo,
by.InnerCallableBodyIndex];
ws[0] _ LOOPHOLE[h.fh+t.e.bb[bti].frameOffset, WORD];
RETURN};
ENDCASE => ERROR;
pointer => gfiBase _ LOOPHOLE [
RTCommon.ShortenLongPointer[h.ptr],
PrincOps.GlobalFrameHandle].gfi;
ENDCASE => ERROR Error[reason: typeFault, type: TVType[tv]];
};
ENDCASE => ERROR Error[reason: typeFault, type: TVType[tv]];
};
popd _ LOOPHOLE
[(WITH stb SELECT FROM
t: SymbolTableBase.x => t.e.seb[NARROW[isei,
SymbolIdIndex.x].e].idValue,
t: SymbolTableBase.y => t.e.seb[NARROW[isei,
SymbolIdIndex.y].e].idValue,
ENDCASE => ERROR),
PrincOps.ProcDesc];
pd _ PrincOps.ControlLink[procedure[gfi: 0, ep: 0, tag: TRUE]];
pd.ep _ popd.ep;
pd.gfi _ popd.gfi - 1--Groan-- + gfiBase;
ws[0] _ LOOPHOLE[pd, WORD];
RETURN
};
ENDCASE => ERROR Error [
reason: notImplemented,
msg: "other than PROC, SIGNAL and ERROR transfer mode constants"]};

END.



RTTDefaultImpl.mesa
Paul Rovner, June 29, 1983 5:13 pm
Russ Atkinson, April 28, 1983 5:14 pm
C O N S T A N T S
Raise notImplemented if can't hack it. Return NIL if there is no DefaultInitialValue
If no default is explicitly given for this field, perhaps its type has a default value.
stop enumeration, return NIL
start constructed case here
basic attribute guarantees that type is definition
Raise notImplemented if can't hack it. Return NIL if there is no DefaultInitialValue
(does not inherit from the type)
START IndexToDefaultInitialValue HERE
this guy returns FALSE if it can't figure out the value of the tree,
otherwise gets the value and assigns it to tv.
tv arg is for signal, error and proc constants, to determine the gfi or fh bias
raises notImplemented, typeFault
local case
�Ê!˜J˜Jš
œ™Jš
œ"™"J™%J˜š
Ïk	˜	šœ	�œ
˜Jš
œb˜b—šœ�œ
˜Jšœw�œ˜�
—šœ�œ
˜Jš
œN˜N—šœ�œ
˜Jš
œN˜N—Jšœ	�œ5˜DJšœ	�œ˜$šœ
�œ
˜Jš
œ_˜_—šœ�œ
˜Jš
œ�
˜�
—Jšœ
�œ˜-Jšœ	�œ,˜;Jšœ�œ(˜=Jšœ�œ˜/J˜—šœ�˜š
�˜Jš
œc˜c—Jš�œ˜Jšœ�œ
�œ{˜‡
J˜—š
œ™Jš�œ�œ�œ
�œ
˜—J˜šÏnœ�œ
�œ
�˜%Jšœ
�œ�œ˜3Jš
œT™TJš
œ˜J˜J˜J˜J˜Jšœ�œ
˜J˜Jšœ�œ˜)šœ�œ�˜J˜!J˜9J˜E˜.Jšœ�œ�œ�œ˜7—š�œ�œI˜YJ˜——Jš�œ	�œ
�œ
�œ˜J˜6J˜%Jš�œ�œ
�œ˜J˜J˜*J˜šœ
�œ
�œ˜&J˜š�œ�˜
˜J˜J˜J˜=J˜šž	œ�˜Jšœ+�œ�œ�œ˜KJš
œ˜J˜š�œ˜š�œ˜Jš
œ˜J˜J˜,š�œ�œ�œ
�˜J˜%J˜%Jš�œ�œ
˜š�œ˜š�œ˜ Jš�œ
�˜š�œ
�œ˜Jš
œ˜J˜,——————Jš
œW™WJš
œ4˜4š�œ	�œ
�œ˜Jš
œ™Jšœ�œ
˜	Jš�œ
�œ˜—˜J˜——Jš
œ™š�œ	�œ
�˜˜š�œ�œ$�œ
�˜GJ˜Hšœ�œ˜1J˜2—Jš�œ�œ
˜——˜š�œ�œ$�œ
�˜GJ˜Hšœ�œ˜1J˜2—Jš�œ�œ
˜——Jš�œ�œ
˜—JšœÏc˜J˜—š
œ
˜
Jšœ�œ˜7Jš
œ2™2J˜J˜š�œ+˜-Jš�œ�œ
�œŸ˜9Jš�œ
�œ�œ
�œ˜2Jšœ�œ˜$Jš�œ
˜—J˜0š�œ�œ�œ
�˜J˜%J˜%Jš�œ�œ
˜Jš�œ
�œ
�œ˜—š�œ"˜$Jš�œ
�œH˜R—Jš�œ�œ˜——Jš�œ�œŸ˜%J˜—J˜J˜&Jš�œŸ˜(J˜—šžœ�œ
�œ
�œ˜FJš�œ�œ�œ˜-Jš
œT™TJš
œ ™ šžœ�œ/˜IJš�œ˜š�œ˜Jš
œ˜J˜J˜#J˜,š�œ�œ�œ
�˜J˜%J˜%Jš�œ�œ
˜—Jš�œ
�œ˜%š�œ
�œ˜(J˜D—JšœŸ˜—š�œ
�œ�œ˜%Jš�œ
�œ�œ
�œ˜:Jš
œ&˜&Jš
œ$˜$šœ�œ$˜,Jš
œ˜J˜J˜Jšœ.�œ
˜>J˜—Jš�œ	�˜JšœŸ+˜/—šœŸ˜J˜——Jš
œ%™%J˜GJ˜šž
œ�˜Jšœ9�œ
�œ˜LJš
œD™DJš
œ.™.š�œ�œ
�˜˜Jš�œ�œ˜<—˜Jš�œ�œ˜<—Jš�œ�œ˜——J˜šžœ�œ?˜SJš�œ
�œ�œ˜"J˜J˜ J˜!JšœŸ2˜Hš
�˜š�œ�œ
�˜š
œ˜š�œ�œ
�˜#Jšœ
�œ
�œŸ˜,˜	Jšœ�œ
�œ�œ
˜š�œ�œ
�˜*š
œ
˜
Jš
œ˜š�œ�˜'Jšœ�œ
�œ˜%Jšœ�œ
�œ˜'Jš�œ
˜—J˜—Jš
œ˜Jš�œ�œ
˜—˜J˜Jš
œD˜D—Jš�œ
�œ˜
J˜—Jš�œ�œ˜——š
œ˜Jš�œ˜Jš�œ�œ
�œ
�œ˜%Jš
œ0˜0š�œ�œ˜Jš
œ˜J˜-Jš�œ�œ
�œŸ%˜BJš�œ˜—˜J˜Jš
œN˜N—Jš�œ
�œ˜—š
œ˜Jš�œ˜š�œ�˜š
œ˜Jšœ�œ˜Jš�œ
�œ˜—Jšœ�œ
�œ˜š
œ
˜
š�œ
Ÿ˜-Jš�œ
�œ
�œ˜—Jš
œ˜Jš�œ˜—š
œ˜JšœŸ:˜OJš�œ˜—š
œ˜š�œ5˜7Jš�œ
�œ
�œ˜—J˜Jš�œ
�œ˜—˜J˜J˜ J˜Jš�œ�œ
�œ
˜&J˜š�œ�œ
�˜+J˜Jš�œ�œ
˜J˜—š�œ�˜Jšœ�œ
˜Jš�œ�œ
˜J˜—š�œ�œ&˜EJš�œ
�œ
˜J˜—š�œ�œ
�œ˜*š�œ'˜)š�œ
�œ0�˜:Jš�œ
�œ˜——Jš�œ
˜—Jš�œ
�œ˜—š
œ	˜	šœ�œ˜"Jšœ�œ)˜2—J˜Jš�œ
�œ˜—Jš�œ�œ
�œ˜—Jš�œ�œ
˜——Jš
�˜—JšœŸ˜J˜—šžœ�œ?˜SJš�œ
�œ�œ˜"J˜J˜ J˜!JšœŸ2˜Hš
�˜š�œ�œ
�˜š
œ˜š�œ�œ
�˜#Jšœ
�œ
�œŸ˜,˜	Jšœ�œ
�œ�œ
˜š�œ�œ
�˜*š
œ
˜
Jš
œ˜š�œ�˜'Jšœ�œ
�œ˜%Jšœ�œ
�œ˜'Jš�œ
˜—J˜—Jš
œ˜Jš�œ�œ
˜—˜J˜Jš
œD˜D—Jš�œ
�œ˜
J˜—Jš�œ�œ˜——š
œ˜Jš�œ˜Jš�œ�œ
�œ
�œ˜%Jš
œ0˜0š�œ�œ˜Jš
œ˜J˜-Jš�œ�œ
�œŸ%˜BJš�œ˜—˜J˜Jš
œN˜N—Jš�œ
�œ˜—š
œ˜Jš�œ˜š�œ�˜š
œ˜Jšœ�œ˜Jš�œ
�œ˜—Jšœ�œ
�œ˜š
œ˜š�œ
Ÿ˜-Jš�œ
�œ
�œ˜—Jš
œ˜Jš�œ˜—š
œ˜JšœŸ:˜OJš�œ˜—š
œ˜Jš�œ6�œ
�œ
�œ˜KJ˜Jš�œ
�œ˜—˜J˜J˜ J˜Jš�œ�œ
�œ
˜&J˜š�œ�œ
�˜+J˜Jš�œ�œ
˜J˜—š�œ�˜Jšœ�œ
˜Jš�œ�œ
˜J˜—š�œ�œ&˜EJš�œ
�œ
˜J˜—š�œ�œ
�œ˜*š�œ'˜)š�œ
�œ0�˜:Jš�œ
�œ˜——Jš�œ
˜—Jš�œ
�œ˜—š
œ	˜	šœ�œ˜"Jšœ�œ)˜2—J˜Jš�œ
�œ˜—Jš�œ�œ
�œ˜—Jš�œ�œ
˜——Jš
�˜—šœŸ˜J˜———šžœ�œ-�œ˜PJš�œ@˜FJ˜J˜—šžœ�œ
�œ>˜]Jš�œ˜Jš
œO™OJš
œ ™ š�œ˜ š�œ˜Jšœ�œ˜ Jšœ�œ�œ�œ˜FJš�œ˜——š�œ)�˜3š
œ	˜	š�œ˜š�œ˜Jšœ�œ
˜
J˜J˜2Jšœ�œ!˜)J˜6J˜'š�œ
�œ ˜&Jš�œ
�œ:˜D——š�œ˜Jšœ�œ˜ šœ�œ�œ�œ
�˜&˜šœ�œ˜J˜——˜šœ�œ˜J˜——Jš�œ�œ˜Jš�œ˜—J˜—Jš�œ˜——˜J˜J˜J˜J˜Jš�œ�œ
�œ
�œ
˜š�œ˜Jš�œ
�œC˜M—š�œ
˜š�œ˜Jšœ�œ˜ š�œ�œ
�˜šœ�œ%˜-š�œ
�œ
�˜˜J˜;—šœ
Ÿ˜š�œ�œ
�˜˜˜šœ�œ˜šœ
�œ˜
J˜—J˜——šœ�	œ
˜Jš
œ/˜/Jš�œ˜—Jš�œ˜—˜˜šœ�œ
˜Jšœ�œ"˜0J˜——šœ�	œ
˜Jš
œ/˜/Jš�œ˜—Jš�œ˜—Jš�œ�œ
˜——Jš�œ�œ,˜<—J˜—Jš�œ�œ,˜<—J˜
—š�œ˜Jš
œ
™
Jšœ�œ˜ š�œ�œ
�˜šœ�œ%˜-š�œ
�œ
�˜J˜šœ�œ�œ
�˜˜˜šœ�œ
˜Jšœ�œ!˜/J˜——Jšœ�œ�œ˜5Jš�œ˜—˜˜šœ�œ
˜Jšœ�œ!˜/J˜——Jšœ�œ�œ˜5Jš�œ˜—Jš�œ�œ
˜—šœ�œ˜Jš
œ#˜#J˜ —Jš�œ�œ,˜<—J˜—Jš�œ�œ,˜<—J˜——šœ�˜šœ�œ�œ
�˜šœ �œ˜,J˜—šœ �œ˜,J˜—Jš�œ�œ˜J˜——Jšœ8�œ˜?J˜JšœŸ	œ˜)Jšœ�œ�œ˜Jš
�˜J˜—š�œ�œ˜Jš
œ˜J˜CJ˜———Jš�œ
˜J˜J˜J˜—…—9NM