DIRECTORY
SaffronTreeBucketDef,
SaffronTreeDeclsDef,
SaffronGenericDef,
SaffronATDef;

SaffronAG5Def: CEDAR DEFINITIONS = 
BEGIN
OPEN SaffronTreeBucketDef, SaffronTreeDeclsDef, SaffronGenericDef, SaffronATDef;


DecListoneProdData: TYPE = REF DecListoneProdDataBody;
DecListoneProdDataBody: TYPE = RECORD[
Declaration: DeclarationNode];

DecListoneProdProcs: DecListNodeProcs;

BuildDecListoneProdNode: PROC[position: INT, length: INT, Declaration: DeclarationNode]
RETURNS[DecListNode];

DecListoneProdfoo: fooProcType;
DecListoneProdPreprocessDecls: PreprocessDeclsProcType;
DecListoneProdProcessDecls: ProcessDeclsProcType;


DecListmanyProdData: TYPE = REF DecListmanyProdDataBody;
DecListmanyProdDataBody: TYPE = RECORD[
DecListhead: DecListNode, DecListtail: DecListNode];

DecListmanyProdProcs: DecListNodeProcs;

BuildDecListmanyProdNode: PROC[position: INT, length: INT, DecListhead: DecListNode, DecListtail: DecListNode]
RETURNS[DecListNode];

DecListmanyProdfoo: fooProcType;
DecListmanyProdPreprocessDecls: PreprocessDeclsProcType;
DecListmanyProdProcessDecls: ProcessDeclsProcType;


DeclarationvalueProdData: TYPE = REF DeclarationvalueProdDataBody;
DeclarationvalueProdDataBody: TYPE = RECORD[
IdentList: IdentListNode, Access: AccessNode, Entry: EntryNode, ReadOnly: ReadOnlyNode, TypeExp: TypeExpNode, Initialization: InitializationNode];

DeclarationvalueProdProcs: DeclarationNodeProcs;

BuildDeclarationvalueProdNode: PROC[position: INT, length: INT, IdentList: IdentListNode, Access: AccessNode, Entry: EntryNode, ReadOnly: ReadOnlyNode, TypeExp: TypeExpNode, Initialization: InitializationNode]
RETURNS[DeclarationNode];

DeclarationvalueProdfoo: fooProcType;
DeclarationvalueProdPreprocessDecls: PreprocessDeclsProcType;
DeclarationvalueProdProcessDecls: ProcessDeclsProcType;
DeclarationvalueProdProcessOneDecl: ProcessOneDeclProcType;


DeclarationtypeProdData: TYPE = REF DeclarationtypeProdDataBody;
DeclarationtypeProdDataBody: TYPE = RECORD[
IdentList: IdentListNode, Accessid: AccessNode, Accesstype: AccessNode, TypeExp: TypeExpNode, Default: DefaultNode];

DeclarationtypeProdProcs: DeclarationNodeProcs;

BuildDeclarationtypeProdNode: PROC[position: INT, length: INT, IdentList: IdentListNode, Accessid: AccessNode, Accesstype: AccessNode, TypeExp: TypeExpNode, Default: DefaultNode]
RETURNS[DeclarationNode];

DeclarationtypeProdfoo: fooProcType;
DeclarationtypeProdPreprocessDecls: PreprocessDeclsProcType;
DeclarationtypeProdProcessDecls: ProcessDeclsProcType;
DeclarationtypeProdProcessOneDecl: ProcessOneDeclProcType;


DeclarationopaquetypeProdData: TYPE = REF DeclarationopaquetypeProdDataBody;
DeclarationopaquetypeProdDataBody: TYPE = RECORD[
IdentList: IdentListNode, Access: AccessNode, OptSize: OptSizeNode];

DeclarationopaquetypeProdProcs: DeclarationNodeProcs;

BuildDeclarationopaquetypeProdNode: PROC[position: INT, length: INT, IdentList: IdentListNode, Access: AccessNode, OptSize: OptSizeNode]
RETURNS[DeclarationNode];

DeclarationopaquetypeProdfoo: fooProcType;
DeclarationopaquetypeProdPreprocessDecls: PreprocessDeclsProcType;
DeclarationopaquetypeProdProcessDecls: ProcessDeclsProcType;
DeclarationopaquetypeProdProcessOneDecl: ProcessOneDeclProcType;


OptSizeabsentProdData: TYPE = REF OptSizeabsentProdDataBody;
OptSizeabsentProdDataBody: TYPE = RECORD[
];

OptSizeabsentProdProcs: OptSizeNodeProcs;

BuildOptSizeabsentProdNode: PROC[position: INT, length: INT]
RETURNS[OptSizeNode];

OptSizeabsentProdfoo: fooProcType;


OptSizepresentProdData: TYPE = REF OptSizepresentProdDataBody;
OptSizepresentProdDataBody: TYPE = RECORD[
Exp: ExpNode];

OptSizepresentProdProcs: OptSizeNodeProcs;

BuildOptSizepresentProdNode: PROC[position: INT, length: INT, Exp: ExpNode]
RETURNS[OptSizeNode];

OptSizepresentProdfoo: fooProcType;


EntryentryProdData: TYPE = REF EntryentryProdDataBody;
EntryentryProdDataBody: TYPE = RECORD[
];

EntryentryProdProcs: EntryNodeProcs;

BuildEntryentryProdNode: PROC[position: INT, length: INT]
RETURNS[EntryNode];

EntryentryProdfoo: fooProcType;


EntryinternalProdData: TYPE = REF EntryinternalProdDataBody;
EntryinternalProdDataBody: TYPE = RECORD[
];

EntryinternalProdProcs: EntryNodeProcs;

BuildEntryinternalProdNode: PROC[position: INT, length: INT]
RETURNS[EntryNode];

EntryinternalProdfoo: fooProcType;


EntryemptyProdData: TYPE = REF EntryemptyProdDataBody;
EntryemptyProdDataBody: TYPE = RECORD[
];

EntryemptyProdProcs: EntryNodeProcs;

BuildEntryemptyProdNode: PROC[position: INT, length: INT]
RETURNS[EntryNode];

EntryemptyProdfoo: fooProcType;


ExitListemptyProdData: TYPE = REF ExitListemptyProdDataBody;
ExitListemptyProdDataBody: TYPE = RECORD[
];

ExitListemptyProdProcs: ExitListNodeProcs;

BuildExitListemptyProdNode: PROC[position: INT, length: INT]
RETURNS[ExitListNode];

ExitListemptyProdfoo: fooProcType;


ExitListmoreProdData: TYPE = REF ExitListmoreProdDataBody;
ExitListmoreProdDataBody: TYPE = RECORD[
ExitList: ExitListNode, ExitItem: ExitItemNode];

ExitListmoreProdProcs: ExitListNodeProcs;

BuildExitListmoreProdNode: PROC[position: INT, length: INT, ExitList: ExitListNode, ExitItem: ExitItemNode]
RETURNS[ExitListNode];

ExitListmoreProdfoo: fooProcType;


ExitItemProdData: TYPE = REF ExitItemProdDataBody;
ExitItemProdDataBody: TYPE = RECORD[
IdList: IdListNode, Statement: StatementNode];

ExitItemProdProcs: ExitItemNodeProcs;

BuildExitItemProdNode: PROC[position: INT, length: INT, IdList: IdListNode, Statement: StatementNode]
RETURNS[ExitItemNode];

ExitItemProdfoo: fooProcType;


BindListemptyProdData: TYPE = REF BindListemptyProdDataBody;
BindListemptyProdDataBody: TYPE = RECORD[
];

BindListemptyProdProcs: BindListNodeProcs;

BuildBindListemptyProdNode: PROC[position: INT, length: INT]
RETURNS[BindListNode];

BindListemptyProdfoo: fooProcType;


BindListmoreProdData: TYPE = REF BindListmoreProdDataBody;
BindListmoreProdDataBody: TYPE = RECORD[
BindList: BindListNode, BindItem: BindItemNode];

BindListmoreProdProcs: BindListNodeProcs;

BuildBindListmoreProdNode: PROC[position: INT, length: INT, BindList: BindListNode, BindItem: BindItemNode]
RETURNS[BindListNode];

BindListmoreProdfoo: fooProcType;


BindItemnamedProdData: TYPE = REF BindItemnamedProdDataBody;
BindItemnamedProdDataBody: TYPE = RECORD[
id: idNode, Exp: ExpNode];

BindItemnamedProdProcs: BindItemNodeProcs;

BuildBindItemnamedProdNode: PROC[position: INT, length: INT, id: idNode, Exp: ExpNode]
RETURNS[BindItemNode];

BindItemnamedProdfoo: fooProcType;


BindItemunnamedProdData: TYPE = REF BindItemunnamedProdDataBody;
BindItemunnamedProdDataBody: TYPE = RECORD[
Exp: ExpNode];

BindItemunnamedProdProcs: BindItemNodeProcs;

BuildBindItemunnamedProdNode: PROC[position: INT, length: INT, Exp: ExpNode]
RETURNS[BindItemNode];

BindItemunnamedProdfoo: fooProcType;


ForClauseassignationProdData: TYPE = REF ForClauseassignationProdDataBody;
ForClauseassignationProdDataBody: TYPE = RECORD[
ControlId: ControlIdNode, Expinitial: ExpNode, Expnext: ExpNode];

ForClauseassignationProdProcs: ForClauseNodeProcs;

BuildForClauseassignationProdNode: PROC[position: INT, length: INT, ControlId: ControlIdNode, Expinitial: ExpNode, Expnext: ExpNode]
RETURNS[ForClauseNode];

ForClauseassignationProdfoo: fooProcType;


ForClauseiterationProdData: TYPE = REF ForClauseiterationProdDataBody;
ForClauseiterationProdDataBody: TYPE = RECORD[
ControlId: ControlIdNode, Decreasing: DecreasingNode, Range: RangeNode];

ForClauseiterationProdProcs: ForClauseNodeProcs;

BuildForClauseiterationProdNode: PROC[position: INT, length: INT, ControlId: ControlIdNode, Decreasing: DecreasingNode, Range: RangeNode]
RETURNS[ForClauseNode];

ForClauseiterationProdfoo: fooProcType;


ForClauserepetitionProdData: TYPE = REF ForClauserepetitionProdDataBody;
ForClauserepetitionProdDataBody: TYPE = RECORD[
Range: RangeNode];

ForClauserepetitionProdProcs: ForClauseNodeProcs;

BuildForClauserepetitionProdNode: PROC[position: INT, length: INT, Range: RangeNode]
RETURNS[ForClauseNode];

ForClauserepetitionProdfoo: fooProcType;


ForClauseemptyProdData: TYPE = REF ForClauseemptyProdDataBody;
ForClauseemptyProdDataBody: TYPE = RECORD[
];

ForClauseemptyProdProcs: ForClauseNodeProcs;

BuildForClauseemptyProdNode: PROC[position: INT, length: INT]
RETURNS[ForClauseNode];

ForClauseemptyProdfoo: fooProcType;


ControlIdnewProdData: TYPE = REF ControlIdnewProdDataBody;
ControlIdnewProdDataBody: TYPE = RECORD[
Ident: IdentNode, TypeExp: TypeExpNode];

ControlIdnewProdProcs: ControlIdNodeProcs;

BuildControlIdnewProdNode: PROC[position: INT, length: INT, Ident: IdentNode, TypeExp: TypeExpNode]
RETURNS[ControlIdNode];

ControlIdnewProdfoo: fooProcType;


ControlIdoldProdData: TYPE = REF ControlIdoldProdDataBody;
ControlIdoldProdDataBody: TYPE = RECORD[
id: idNode];

ControlIdoldProdProcs: ControlIdNodeProcs;

BuildControlIdoldProdNode: PROC[position: INT, length: INT, id: idNode]
RETURNS[ControlIdNode];

ControlIdoldProdfoo: fooProcType;


DecreasingyesProdData: TYPE = REF DecreasingyesProdDataBody;
DecreasingyesProdDataBody: TYPE = RECORD[
];

DecreasingyesProdProcs: DecreasingNodeProcs;

BuildDecreasingyesProdNode: PROC[position: INT, length: INT]
RETURNS[DecreasingNode];

DecreasingyesProdfoo: fooProcType;


DecreasingnoProdData: TYPE = REF DecreasingnoProdDataBody;
DecreasingnoProdDataBody: TYPE = RECORD[
];

DecreasingnoProdProcs: DecreasingNodeProcs;

BuildDecreasingnoProdNode: PROC[position: INT, length: INT]
RETURNS[DecreasingNode];

DecreasingnoProdfoo: fooProcType;


DoTestuntilProdData: TYPE = REF DoTestuntilProdDataBody;
DoTestuntilProdDataBody: TYPE = RECORD[
Exp: ExpNode];

DoTestuntilProdProcs: DoTestNodeProcs;

BuildDoTestuntilProdNode: PROC[position: INT, length: INT, Exp: ExpNode]
RETURNS[DoTestNode];

DoTestuntilProdfoo: fooProcType;


DoTestwhileProdData: TYPE = REF DoTestwhileProdDataBody;
DoTestwhileProdDataBody: TYPE = RECORD[
Exp: ExpNode];

DoTestwhileProdProcs: DoTestNodeProcs;

BuildDoTestwhileProdNode: PROC[position: INT, length: INT, Exp: ExpNode]
RETURNS[DoTestNode];

DoTestwhileProdfoo: fooProcType;


DoTestemptyProdData: TYPE = REF DoTestemptyProdDataBody;
DoTestemptyProdDataBody: TYPE = RECORD[
];

DoTestemptyProdProcs: DoTestNodeProcs;

BuildDoTestemptyProdNode: PROC[position: INT, length: INT]
RETURNS[DoTestNode];

DoTestemptyProdfoo: fooProcType;


DoExitProdData: TYPE = REF DoExitProdDataBody;
DoExitProdDataBody: TYPE = RECORD[
ExitList: ExitListNode, OptStatement: OptStatementNode];

DoExitProdProcs: DoExitNodeProcs;

BuildDoExitProdNode: PROC[position: INT, length: INT, ExitList: ExitListNode, OptStatement: OptStatementNode]
RETURNS[DoExitNode];

DoExitProdfoo: fooProcType;


OptArgsexplistProdData: TYPE = REF OptArgsexplistProdDataBody;
OptArgsexplistProdDataBody: TYPE = RECORD[
ExpList: ExpListNode];

OptArgsexplistProdProcs: OptArgsNodeProcs;

BuildOptArgsexplistProdNode: PROC[position: INT, length: INT, ExpList: ExpListNode]
RETURNS[OptArgsNode];

OptArgsexplistProdfoo: fooProcType;


OptArgsexpProdData: TYPE = REF OptArgsexpProdDataBody;
OptArgsexpProdDataBody: TYPE = RECORD[
Exp: ExpNode];

OptArgsexpProdProcs: OptArgsNodeProcs;

BuildOptArgsexpProdNode: PROC[position: INT, length: INT, Exp: ExpNode]
RETURNS[OptArgsNode];

OptArgsexpProdfoo: fooProcType;


OptArgsemptyProdData: TYPE = REF OptArgsemptyProdDataBody;
OptArgsemptyProdDataBody: TYPE = RECORD[
];

OptArgsemptyProdProcs: OptArgsNodeProcs;

BuildOptArgsemptyProdNode: PROC[position: INT, length: INT]
RETURNS[OptArgsNode];

OptArgsemptyProdfoo: fooProcType;


TransfersignalProdData: TYPE = REF TransfersignalProdDataBody;
TransfersignalProdDataBody: TYPE = RECORD[
];

TransfersignalProdProcs: TransferNodeProcs;

BuildTransfersignalProdNode: PROC[position: INT, length: INT]
RETURNS[TransferNode];

TransfersignalProdfoo: fooProcType;


TransfererrorProdData: TYPE = REF TransfererrorProdDataBody;
TransfererrorProdDataBody: TYPE = RECORD[
];

TransfererrorProdProcs: TransferNodeProcs;

BuildTransfererrorProdNode: PROC[position: INT, length: INT]
RETURNS[TransferNode];

TransfererrorProdfoo: fooProcType;


TransferreturnwitherrorProdData: TYPE = REF TransferreturnwitherrorProdDataBody;
TransferreturnwitherrorProdDataBody: TYPE = RECORD[
];

TransferreturnwitherrorProdProcs: TransferNodeProcs;

BuildTransferreturnwitherrorProdNode: PROC[position: INT, length: INT]
RETURNS[TransferNode];

TransferreturnwitherrorProdfoo: fooProcType;


TransferstartProdData: TYPE = REF TransferstartProdDataBody;
TransferstartProdDataBody: TYPE = RECORD[
];

TransferstartProdProcs: TransferNodeProcs;

BuildTransferstartProdNode: PROC[position: INT, length: INT]
RETURNS[TransferNode];

TransferstartProdfoo: fooProcType;


TransferrestartProdData: TYPE = REF TransferrestartProdDataBody;
TransferrestartProdDataBody: TYPE = RECORD[
];

TransferrestartProdProcs: TransferNodeProcs;

BuildTransferrestartProdNode: PROC[position: INT, length: INT]
RETURNS[TransferNode];

TransferrestartProdfoo: fooProcType;


TransferjoinProdData: TYPE = REF TransferjoinProdDataBody;
TransferjoinProdDataBody: TYPE = RECORD[
];

TransferjoinProdProcs: TransferNodeProcs;

BuildTransferjoinProdNode: PROC[position: INT, length: INT]
RETURNS[TransferNode];

TransferjoinProdfoo: fooProcType;


TransfernotifyProdData: TYPE = REF TransfernotifyProdDataBody;
TransfernotifyProdDataBody: TYPE = RECORD[
];

TransfernotifyProdProcs: TransferNodeProcs;

BuildTransfernotifyProdNode: PROC[position: INT, length: INT]
RETURNS[TransferNode];

TransfernotifyProdfoo: fooProcType;


TransferbroadcastProdData: TYPE = REF TransferbroadcastProdDataBody;
TransferbroadcastProdDataBody: TYPE = RECORD[
];

TransferbroadcastProdProcs: TransferNodeProcs;

BuildTransferbroadcastProdNode: PROC[position: INT, length: INT]
RETURNS[TransferNode];

TransferbroadcastProdfoo: fooProcType;


TransfertransferwithProdData: TYPE = REF TransfertransferwithProdDataBody;
TransfertransferwithProdDataBody: TYPE = RECORD[
];

TransfertransferwithProdProcs: TransferNodeProcs;

BuildTransfertransferwithProdNode: PROC[position: INT, length: INT]
RETURNS[TransferNode];

TransfertransferwithProdfoo: fooProcType;


TransferreturnwithProdData: TYPE = REF TransferreturnwithProdDataBody;
TransferreturnwithProdDataBody: TYPE = RECORD[
];

TransferreturnwithProdProcs: TransferNodeProcs;

BuildTransferreturnwithProdNode: PROC[position: INT, length: INT]
RETURNS[TransferNode];

TransferreturnwithProdfoo: fooProcType;


FreeplainProdData: TYPE = REF FreeplainProdDataBody;
FreeplainProdDataBody: TYPE = RECORD[
];

FreeplainProdProcs: FreeNodeProcs;

BuildFreeplainProdNode: PROC[position: INT, length: INT]
RETURNS[FreeNode];

FreeplainProdfoo: fooProcType;


FreezonedProdData: TYPE = REF FreezonedProdDataBody;
FreezonedProdDataBody: TYPE = RECORD[
Exp: ExpNode];

FreezonedProdProcs: FreeNodeProcs;

BuildFreezonedProdNode: PROC[position: INT, length: INT, Exp: ExpNode]
RETURNS[FreeNode];

FreezonedProdfoo: fooProcType;
END..

úSaffronAG5Def.mesa
Copyright Ó 1987 by Xerox Corporation.  All rights reserved.
Generated by BJackson.pa at April 27, 1987 10:51:18 pm PDT
using ThreeCasabaFour [1.1] of April 14, 1987 6:34:07 pm PDT
DecListoneProd
DecListmanyProd
DeclarationvalueProd
DeclarationtypeProd
DeclarationopaquetypeProd
OptSizeabsentProd
OptSizepresentProd
EntryentryProd
EntryinternalProd
EntryemptyProd
ExitListemptyProd
ExitListmoreProd
ExitItemProd
BindListemptyProd
BindListmoreProd
BindItemnamedProd
BindItemunnamedProd
ForClauseassignationProd
ForClauseiterationProd
ForClauserepetitionProd
ForClauseemptyProd
ControlIdnewProd
ControlIdoldProd
DecreasingyesProd
DecreasingnoProd
DoTestuntilProd
DoTestwhileProd
DoTestemptyProd
DoExitProd
OptArgsexplistProd
OptArgsexpProd
OptArgsemptyProd
TransfersignalProd
TransfererrorProd
TransferreturnwitherrorProd
TransferstartProd
TransferrestartProd
TransferjoinProd
TransfernotifyProd
TransferbroadcastProd
TransfertransferwithProd
TransferreturnwithProd
FreeplainProd
FreezonedProd
�ÊN˜š
œ™Jš
œ<™<Jš
œ:™:Jš
œ<™<—J˜š
Ïk	˜	J˜J˜J˜J˜
—J˜JšÏn
œ�œ
�œ˜#Jš
�˜Jš�œL˜PJ˜Jš
œ™J˜Jšœ�œ�œ˜6Jšœ�œ�œ
˜&Jšžœ˜J˜Jšžœ˜&J˜š
žœ�œ�œ
�œžœ˜WJš�œ˜—J˜J˜Jšžœ˜7Jšžœ˜1J˜Jš
œ™J˜Jšœ�œ�œ˜8Jšœ�œ�œ
˜'Jšžœžœ˜4J˜Jšžœ˜'J˜šžœ�œ�œ
�œžœžœ˜nJš�œ˜—J˜J˜ Jšžœ˜8Jšžœ˜2J˜Jš
œ™J˜Jšœ�œ�œ˜BJšœ�œ�œ
˜,Jšž	œžœžœ
žœžœžœ˜’
J˜Jšžœ˜0J˜šžœ�œ�œ
�œž	œžœžœ
žœžœžœ˜Ñ
Jš�œ˜—J˜J˜%Jšž#œ˜=Jšž œ˜7Jšž"œ˜;J˜Jš
œ™J˜Jšœ�œ�œ˜@Jšœ�œ�œ
˜+Jš
ž	œžœž
œžœžœ˜tJ˜Jšžœ˜/J˜šžœ�œ�œ
�œž	œžœž
œžœžœ˜²
Jš�œ˜—J˜J˜$Jšž"œ˜<Jšžœ˜6Jšž!œ˜:J˜Jš
œ™J˜Jšœ�œ�œ#˜LJšœ#�œ�œ
˜1Jšž	œžœžœ˜DJ˜Jšžœ˜5J˜šž"œ�œ�œ
�œž	œžœžœ˜ˆ
Jš�œ˜—J˜J˜*Jšž(œ˜BJšž%œ˜<Jšž'œ˜@J˜Jš
œ™J˜Jšœ�œ�œ˜<Jšœ�œ�œ
˜)J˜J˜Jšžœ˜)J˜šžœ�œ�œ
�œ
˜<Jš�œ˜—J˜J˜"J˜Jš
œ™J˜Jšœ�œ�œ˜>Jšœ�œ�œ
˜*Jšžœ˜J˜Jšžœ˜*J˜š
žœ�œ�œ
�œžœ
˜KJš�œ˜—J˜J˜#J˜Jš
œ™J˜Jšœ�œ�œ˜6Jšœ�œ�œ
˜&J˜J˜Jšžœ˜$J˜šžœ�œ�œ
�œ
˜9Jš�œ˜—J˜J˜J˜Jš
œ™J˜Jšœ�œ�œ˜<Jšœ�œ�œ
˜)J˜J˜Jšžœ˜'J˜šžœ�œ�œ
�œ
˜<Jš�œ˜—J˜J˜"J˜Jš
œ™J˜Jšœ�œ�œ˜6Jšœ�œ�œ
˜&J˜J˜Jšžœ˜$J˜šžœ�œ�œ
�œ
˜9Jš�œ˜—J˜J˜J˜Jš
œ™J˜Jšœ�œ�œ˜<Jšœ�œ�œ
˜)J˜J˜Jšžœ˜*J˜šžœ�œ�œ
�œ
˜<Jš�œ˜—J˜J˜"J˜Jš
œ™J˜Jšœ�œ�œ˜:Jšœ�œ�œ
˜(Jšžœžœ˜0J˜Jšžœ˜)J˜šžœ�œ�œ
�œžœžœ˜kJš�œ˜—J˜J˜!J˜Jš
œ™J˜Jšœ�œ�œ˜2Jšœ�œ�œ
˜$Jšžœž	œ˜.J˜Jšžœ˜%J˜šžœ�œ�œ
�œžœž	œ˜eJš�œ˜—J˜J˜J˜Jš
œ™J˜Jšœ�œ�œ˜<Jšœ�œ�œ
˜)J˜J˜Jšžœ˜*J˜šžœ�œ�œ
�œ
˜<Jš�œ˜—J˜J˜"J˜Jš
œ™J˜Jšœ�œ�œ˜:Jšœ�œ�œ
˜(Jšžœžœ˜0J˜Jšžœ˜)J˜šžœ�œ�œ
�œžœžœ˜kJš�œ˜—J˜J˜!J˜Jš
œ™J˜Jšœ�œ�œ˜<Jšœ�œ�œ
˜)Jšœžœ˜J˜Jšžœ˜*J˜š
žœ�œ�œ
�œžœ
˜VJš�œ˜—J˜J˜"J˜Jš
œ™J˜Jšœ�œ�œ˜@Jšœ�œ�œ
˜+Jšžœ˜J˜Jšžœ˜,J˜š
žœ�œ�œ
�œžœ
˜LJš�œ˜—J˜J˜$J˜Jš
œ™J˜Jšœ�œ�œ"˜JJšœ"�œ�œ
˜0Jšž	œž
œžœ˜AJ˜Jšžœ˜2J˜šž!œ�œ�œ
�œž	œž
œžœ
˜„
Jš�œ˜—J˜J˜)J˜Jš
œ™J˜Jšœ�œ�œ ˜FJšœ �œ�œ
˜.Jšž	œž
œžœ
˜HJ˜Jšžœ˜0J˜šžœ�œ�œ
�œž	œž
œžœ˜‰
Jš�œ˜—J˜J˜'J˜Jš
œ™J˜Jšœ�œ�œ!˜HJšœ!�œ�œ
˜/Jšžœ
˜J˜Jšžœ˜1J˜š
ž œ�œ�œ
�œžœ˜TJš�œ˜—J˜J˜(J˜Jš
œ™J˜Jšœ�œ�œ˜>Jšœ�œ�œ
˜*J˜J˜Jšžœ˜,J˜šžœ�œ�œ
�œ
˜=Jš�œ˜—J˜J˜#J˜Jš
œ™J˜Jšœ�œ�œ˜:Jšœ�œ�œ
˜(Jšžœ
žœ˜(J˜Jšžœ˜*J˜šžœ�œ�œ
�œžœ
žœ˜cJš�œ˜—J˜J˜!J˜Jš
œ™J˜Jšœ�œ�œ˜:Jšœ�œ�œ
˜(J˜J˜Jšžœ˜*J˜šžœ�œ�œ
�œ
˜GJš�œ˜—J˜J˜!J˜Jš
œ™J˜Jšœ�œ�œ˜<Jšœ�œ�œ
˜)J˜J˜Jšžœ˜,J˜šžœ�œ�œ
�œ
˜<Jš�œ˜—J˜J˜"J˜Jš
œ™J˜Jšœ�œ�œ˜:Jšœ�œ�œ
˜(J˜J˜Jšžœ˜+J˜šžœ�œ�œ
�œ
˜;Jš�œ˜—J˜J˜!J˜Jš
œ™J˜Jšœ�œ�œ˜8Jšœ�œ�œ
˜'Jšžœ˜J˜Jšžœ˜&J˜š
žœ�œ�œ
�œžœ
˜HJš�œ
˜—J˜J˜ J˜Jš
œ™J˜Jšœ�œ�œ˜8Jšœ�œ�œ
˜'Jšžœ˜J˜Jšžœ˜&J˜š
žœ�œ�œ
�œžœ
˜HJš�œ
˜—J˜J˜ J˜Jš
œ™J˜Jšœ�œ�œ˜8Jšœ�œ�œ
˜'J˜J˜Jšžœ˜&J˜šžœ�œ�œ
�œ
˜:Jš�œ
˜—J˜J˜ J˜Jš
œ
™
J˜Jšœ�œ�œ˜.Jšœ�œ�œ
˜"Jšžœžœ˜8J˜Jšžœ˜!J˜šžœ�œ�œ
�œžœžœ˜mJš�œ
˜—J˜J˜J˜Jš
œ™J˜Jšœ�œ�œ˜>Jšœ�œ�œ
˜*Jšžœ˜J˜Jšžœ˜*J˜š
žœ�œ�œ
�œžœ˜SJš�œ˜—J˜J˜#J˜Jš
œ™J˜Jšœ�œ�œ˜6Jšœ�œ�œ
˜&Jšžœ˜J˜Jšžœ˜&J˜š
žœ�œ�œ
�œžœ
˜GJš�œ˜—J˜J˜J˜Jš
œ™J˜Jšœ�œ�œ˜:Jšœ�œ�œ
˜(J˜J˜Jšžœ˜(J˜šžœ�œ�œ
�œ
˜;Jš�œ˜—J˜J˜!J˜Jš
œ™J˜Jšœ�œ�œ˜>Jšœ�œ�œ
˜*J˜J˜Jšžœ˜+J˜šžœ�œ�œ
�œ
˜=Jš�œ˜—J˜J˜#J˜Jš
œ™J˜Jšœ�œ�œ˜<Jšœ�œ�œ
˜)J˜J˜Jšžœ˜*J˜šžœ�œ�œ
�œ
˜<Jš�œ˜—J˜J˜"J˜Jš
œ™J˜Jšœ!�œ�œ%˜PJšœ%�œ�œ
˜3J˜J˜Jšž œ˜4J˜šž$œ�œ�œ
�œ
˜FJš�œ˜—J˜J˜,J˜Jš
œ™J˜Jšœ�œ�œ˜<Jšœ�œ�œ
˜)J˜J˜Jšžœ˜*J˜šžœ�œ�œ
�œ
˜<Jš�œ˜—J˜J˜"J˜Jš
œ™J˜Jšœ�œ�œ˜@Jšœ�œ�œ
˜+J˜J˜Jšžœ˜,J˜šžœ�œ�œ
�œ
˜>Jš�œ˜—J˜J˜$J˜Jš
œ™J˜Jšœ�œ�œ˜:Jšœ�œ�œ
˜(J˜J˜Jšžœ˜)J˜šžœ�œ�œ
�œ
˜;Jš�œ˜—J˜J˜!J˜Jš
œ™J˜Jšœ�œ�œ˜>Jšœ�œ�œ
˜*J˜J˜Jšžœ˜+J˜šžœ�œ�œ
�œ
˜=Jš�œ˜—J˜J˜#J˜Jš
œ™J˜Jšœ�œ�œ˜DJšœ�œ�œ
˜-J˜J˜Jšžœ˜.J˜šžœ�œ�œ
�œ
˜@Jš�œ˜—J˜J˜&J˜Jš
œ™J˜Jšœ�œ�œ"˜JJšœ"�œ�œ
˜0J˜J˜Jšžœ˜1J˜šž!œ�œ�œ
�œ
˜CJš�œ˜—J˜J˜)J˜Jš
œ™J˜Jšœ�œ�œ ˜FJšœ �œ�œ
˜.J˜J˜Jšžœ˜/J˜šžœ�œ�œ
�œ
˜AJš�œ˜—J˜J˜'J˜Jš
œ
™
J˜Jšœ�œ�œ˜4Jšœ�œ�œ
˜%J˜J˜Jšžœ˜"J˜šžœ�œ�œ
�œ
˜8Jš�œ˜—J˜J˜J˜Jš
œ
™
J˜Jšœ�œ�œ˜4Jšœ�œ�œ
˜%Jšžœ˜J˜Jšžœ˜"J˜š
žœ�œ�œ
�œžœ
˜FJš�œ˜—J˜J˜Jš�œ˜J˜—…—:VQž