Include [ SaffronBaseDecls, SaffronTreeDecls, SaffronAG, SaffronProgramGraphDecls ];

SaffronBlockCompile: Module = Begin

for Block: AbstractProduction [Scope, ExitList]
let CompileFrameBlock[tree, transferType, parentTree, pg, cs] _ <newTree, code, pg1>
where newTree _ AddSubContextTree[parentTree, childTree]
where <childTree, code, pg1> _ InternalCompileBlock[tree, lc1, fl, pg, cs]
where fl _ CreateEmptyFieldList[] -- add transfer bindings to field list!!
where lc1 _ CreateEmptyContext[Rib[parentTree], True[]]
let Compile[tree, parentTree, pg, cs] _ <newTree, code, pg1>
where newTree _ AddSubContextTree[parentTree, childTree]
where <childTree, code, pg1> _ InternalCompileBlock[tree, lc1, fl, pg, cs]
where fl _ CreateEmptyFieldList[] 
where lc1 _ CreateEmptyContext[Rib[parentTree], False[]]
let InternalCompileBlock[tree, localContext, fl, pg, cs] _
CompileScope[Scope, lc1, fl, pg, cs]
where lc1 _ FakeDamageContext[localContext] -- add exit list to lc!!
;

for Scope: AbstractProduction [BindList, Catch, OptDecList, StatementList]
let CompileScope[tree, localContext, fl, pg, cs] _ <contextTree3, pf3, pg2>
where pf3 _ ConcatProgramFragments[pf1, pf2]
where <contextTree3, pf2, pg2> _ Compile[StatementList, contextTree2, pg1, cs]
where <contextTree2, pf1, pg1> _ Compile[OptDecList, contextTree1, pg, cs]
where contextTree1 _ EmptyContextTree[rib]
where rib _ FreezeLocalContext[localContext3, blockTGN]
where <localContext3, blockTGN> _ 
CreateBlockTGN[localContext2, FreezeFieldList[fieldList4]]
where <fieldList4, localContext2> _ 
AnalyzeDependencies[dependencyGraph, fieldList3, localContext1, cs]
where dependencyGraph _ BuildDependencyGraph[fieldList3, localContext1]
where fieldList3 _ DiscernSpecianatedTGNs[fieldList2, localContext1]
where fieldList2 _ LookupIdentifierTGNs[fieldList1, localContext1]
where <fieldList1, localContext1> _ 
AddDeclarationsToFieldList[OptDecList, fl, localContext, cs]
;

for DefBody:	AbstractProduction [ BindList, DecList ]
let MakeContextTree[tree, contextRib, paintRecords, cs] _ contextTree2
where <contextTree2, pf1, pg1> _ Compile[DecList, contextTree1, pg, cs]
where pg _ CreateEmptyProgramGraph[]
where contextTree1 _ EmptyContextTree[rib]
where rib _ FreezeLocalContext[localContext3, interfaceTGN]
where <localContext3, interfaceTGN> _ 
CreateInterfaceContentsTGN[localContext2, FreezeFieldList[fieldList4]]
where <fieldList4, localContext2> _ 
AnalyzeDependencies[dependencyGraph, fieldList3, localContext1, cs]
where dependencyGraph _ BuildDependencyGraph[fieldList3, localContext1]
where fieldList3 _ DiscernSpecianatedTGNs[fieldList2, localContext1]
where fieldList2 _ LookupIdentifierTGNs[fieldList1, localContext1]
where <fieldList1, localContext1> _ 
AddDeclarationsToFieldList[DecList, CreateEmptyFieldList[], localContext, cs]
where localContext _ CreateEmptyContext[contextRib, True[]]
;

End;

SaffronDeclarationCompile: Module = Begin

for OptDecList.absent: AbstractProduction []
let Compile[tree, contextTree, pg, cs] _ <
FakeDamageContextTree[contextTree], 
MakePGNoOp[],
FakeDamageProgramGraph[pg] >
;

for OptDecList.present: AbstractProduction [DecList]
let Compile[tree, contextTree, pg, cs] _ Compile[DecList, contextTree, pg, cs]
;

for DecList.one: AbstractProduction [Declaration]
let Compile[tree, contextTree, pg, cs] _ Compile[Declaration, contextTree, pg, cs]
;

for DecList.many: AbstractProduction [DecList.head, DecList.tail]
let Compile[tree, contextTree, pg, cs] _ <contextTree2, pf3, pg2> 
where pf3 _ ConcatProgramFragments[pf1, pf2]
where <contextTree2, pf2, pg2> _ Compile[DecList.tail, contextTree1, pg1, cs]
where <contextTree1, pf1, pg1> _ Compile[DecList.head, contextTree, pg, cs]
;

for Declaration.opaquetype: AbstractProduction [ IdentList, Access, OptSize ]
let Compile[tree, contextTree, pg, cs] _ <
FakeDamageContextTree[contextTree], 
MakePGNoOp[],
FakeDamageProgramGraph[pg] >
;

for Declaration.type:	AbstractProduction [ IdentList, Access.id, Access.type, TypeExp, Default ]
let Compile[tree, contextTree, pg, cs] _ <
FakeDamageContextTree[contextTree], 
MakePGNoOp[],
FakeDamageProgramGraph[pg] >
;

for Declaration.value:	AbstractProduction [ IdentList, Access, Entry, ReadOnly, TypeExp, Initialization ]
let Compile[tree, contextTree, pg, cs] _ <contextTree1, pf, pg1>
where pf _ 
if IsTrash[initialValue]
then MakePGNoOp[]
else (ConcatProgramFragments[pushInitialValue, storeInitialValue]
where pushInitialValue _ Code[initialValue]
where storeInitialValue _ 
MakeCodeToStoreTOSInVariousLocalFrameSlots[IdentList, contextTree1]
)
where <contextTree1, initialValue, pg1> _ 
CompileInitialization[Initialization, contextTree, pg, cs, targetType]
where targetType _ FieldType[anyCorrespondingField]
where anyCorrespondingField _ FindAFieldCorrespondingToDeclaration[contextTree, DeclarationPTreeVal[tree]]
;

for Initialization.empty: AbstractProduction []
let CompileInitialization[tree, contextTree, pg, cs, targetType] _ <
FakeDamageContextTree[contextTree],
CompileDefaultInitialization[targetType],
FakeDamageProgramGraph[pg] >
;

for Initialization.binding: AbstractProduction [InitialValue]
let CompileInitialization[tree, contextTree, pg, cs, targetType] _
CompileInitialization[InitialValue, contextTree, pg, cs, targetType]
;

for Initialization.assignment: AbstractProduction [InitialValue]
let CompileInitialization[tree, contextTree, pg, cs, targetType] _
CompileInitialization[InitialValue, contextTree, pg, cs, targetType]
;

for InitialValue.trash: AbstractProduction []
let CompileInitialization[tree, contextTree, pg, cs, targetType] _ <
FakeDamageContextTree[contextTree], 
MakeTrash[targetType],
FakeDamageProgramGraph[pg] >
;

for InitialValue.code: AbstractProduction []
let CompileInitialization[tree, contextTree, pg, cs, targetType] _ <
FakeDamageContextTree[contextTree], 
MakeTrash[targetType],
FakeDamageProgramGraph[pg] >
where err _ Error["CompileInitialization for InitialValue.code not yet implemented."]
;

for InitialValue.exp: AbstractProduction [Exp]
let CompileInitialization[tree, contextTree, pg, cs, targetType] _ <contextTree1, value, pg1> 
where <value, contextTree1> _ CompileExpression[Exp, contextTree, cs, targetType]
where pg1 _ FakeDamageProgramGraph[pg]
;

for InitialValue.block: AbstractProduction [Checked, Inline, Block]
let CompileInitialization[tree, contextTree, pg, cs, targetType] _ <contextTree1, value, pg2>
where pg2 _ AddSubroutineProcedureGraphToProgramGraph[procedureGraph, pg1]
where value _ MakeTransferValue[targetType, procedureGraph]
where procedureGraph _ MakeProcedureGraph[blockCode]
where <contextTree1, blockCode, pg1> _ CompileFrameBlock[Block, targetType, contextTree, pg, cs]
;

for InitialValue.machinecode: AbstractProduction [Checked, CodeList]
let CompileInitialization[tree, contextTree, pg, cs, targetType] _ <
FakeDamageContextTree[contextTree], 
MakeTrash[targetType],
FakeDamageProgramGraph[pg] >
where err _ Error["CompileInitialization for InitialValue.machinecode not yet implemented."]
;

for IdentList.one: AbstractProduction [Ident]
let MakeCodeToStoreTOSInVariousLocalFrameSlots[tree, contextTree] _
MakeCodeToStoreTOSInVariousLocalFrameSlots[Ident, contextTree]
;

for IdentList.many: AbstractProduction [IdentList.head, IdentList.tail]
let MakeCodeToStoreTOSInVariousLocalFrameSlots[tree, ct] _ pf4
where pf4 _ ConcatProgramFragments[ConcatProgramFragments[pf1, pf2], pf3]
where pf3 _ MakeCodeToStoreTOSInVariousLocalFrameSlots[IdentList.tail, ct]
where pf2 _ MakePGNoOp[] -- this should be MakePGDuplicate!!!
where pf1 _ MakeCodeToStoreTOSInVariousLocalFrameSlots[IdentList.head, ct]
;

for Ident.id: AbstractProduction [Id]
let MakeCodeToStoreTOSInVariousLocalFrameSlots[tree, contextTree] _ pf
where pf _  MakePGStoreLocal[pfd]
where <pfd, tgn> _ GetPathToName[contextTree, Id]
;

for Ident.idposition: AbstractProduction [Id, Position]
let MakeCodeToStoreTOSInVariousLocalFrameSlots[tree, contextTree] _ pf
where pf _  MakePGStoreLocal[pfd]
where <pfd, tgn> _ GetPathToName[contextTree, Id]
;



End;

SaffronStatementCompile: Module = Begin

for StatementList.empty:	AbstractProduction [ ]
let Compile[tree, contextTree, pg, cs] _ <
FakeDamageContextTree[contextTree], 
MakePGNoOp[],
FakeDamageProgramGraph[pg] >
;

for StatementList.more:  AbstractProduction [ StatementList, Statement ]
let Compile[tree, contextTree, pg, cs] _ <contextTree2, pf3, pg2> 
where pf3 _ ConcatProgramFragments[pf1, pf2]
where <contextTree2, pf2, pg2> _ Compile[Statement, contextTree1, pg1, cs]
where <contextTree1, pf1, pg1> _ Compile[StatementList, contextTree, pg, cs]
;


for Statement.ifthen:	AbstractProduction [ Exp, Statement ]
let Compile[tree, contextTree, pg, cs] _ <contextTree2, code, pg1>
where code _ MakePGTest[Code[testValue], ifTrueCode, ifFalseCode]
where ifFalseCode _ MakePGNoOp[]
where <contextTree2, ifTrueCode, pg1> _ Compile[Statement, contextTree1, pg, cs]
where <testValue, contextTree1> _ 
CompileAndTypeCheckExpression[Exp, contextTree, cs, booleanType]
where booleanType _ GetIntrinsicBooleanType[cs]
;

for Statement.ifthenelse:AbstractProduction [ Exp, Statement.thenpart, Statement.elsepart ]
let Compile[tree, contextTree, pg, cs] _ <contextTree3, code, pg2>
where code _ MakePGTest[testCode, ifTrueCode, ifFalseCode]
where <contextTree3, ifFalseCode, pg2> _ Compile[Statement.elsepart, contextTree2, pg1, cs]
where <contextTree2, ifTrueCode, pg1> _ Compile[Statement.thenpart, contextTree1, pg, cs]
where testCode _ Code[testValue]
where <testValue, contextTree1> _ 
CompileAndTypeCheckExpression[Exp, contextTree, cs, booleanType]
where booleanType _ GetIntrinsicBooleanType[cs]
;

for Statement.select:	AbstractProduction [ SelectHead, SelectStmtList, OptStatement ] 
let Compile[tree, contextTree, pg, cs] _ <
FakeDamageContextTree[contextTree], 
MakePGNoOp[],
FakeDamageProgramGraph[pg] >
where err _ Error["Compile for Statement.select not implemented yet."]
;

for Statement.exp:	AbstractProduction [ Exp ]
let Compile[tree, contextTree, pg, cs] _ <
FakeDamageContextTree[contextTree], 
MakePGNoOp[],
FakeDamageProgramGraph[pg] >
where err _ Error["Compile for Statement.exp not implemented yet."]
;

for Statement.assign:	AbstractProduction [ Exp.lhs, Exp.rhs ] 
let Compile[tree, contextTree, pg, cs] _ <contextTree1, code, FakeDamageProgramGraph[pg]>
where code _ ConcatProgramFragments[Code[rhsValue], storeTOS]
where storeTOS _ if PFDIsLocal[lvalue]
then MakePGStoreLocal[lvalue]
else MakePGStoreIndirect[lvalue]
where <rhsValue, contextTree1> _ 
CompileAndTypeCheckExpression[Exp.rhs, contextTree, cs, tgn]
where <lvalue, tgn> _ CompileLValue[Exp.lhs, contextTree, cs]
;

for Statement.multiassign:	AbstractProduction [ ExpList, Exp ]
let Compile[tree, contextTree, pg, cs] _ <
FakeDamageContextTree[contextTree], 
MakePGNoOp[],
FakeDamageProgramGraph[pg] >
where err _ Error["Compile for Statement.multiassign not implemented yet."]
;

for Statement.block:	AbstractProduction [ Checked, Block ]
let Compile[tree, contextTree, pg, cs] _ Compile[Block, contextTree, pg, cs]
;

for Statement.loopcontrol:	AbstractProduction [ ForClause, DoTest, Scope, DoExit ]
let Compile[tree, contextTree, pg, cs] _ <
FakeDamageContextTree[contextTree], 
MakePGNoOp[],
FakeDamageProgramGraph[pg] >
where err _ Error["Compile for Statement.loopcontrol not implemented yet."]
;

for Statement.exit:	AbstractProduction [ ]
let Compile[tree, contextTree, pg, cs] _ <
FakeDamageContextTree[contextTree], 
MakePGNoOp[],
FakeDamageProgramGraph[pg] >
where err _ Error["Compile for Statement.exit not implemented yet."]
;

for Statement.loop:	AbstractProduction [ ]
let Compile[tree, contextTree, pg, cs] _ <
FakeDamageContextTree[contextTree], 
MakePGNoOp[],
FakeDamageProgramGraph[pg] >
where err _ Error["Compile for Statement.loop not implemented yet."]
;

for Statement.goto:	AbstractProduction [ Id ]
let Compile[tree, contextTree, pg, cs] _ <
FakeDamageContextTree[contextTree], 
MakePGNoOp[],
FakeDamageProgramGraph[pg] >
where err _ Error["Compile for Statement.goto not implemented yet."]
;

for Statement.return:	AbstractProduction [ OptArgs ]
let Compile[tree, contextTree, pg, cs] _ <
FakeDamageContextTree[contextTree], 
MakePGNoOp[],
FakeDamageProgramGraph[pg] >
where err _ Error["Compile for Statement.return not implemented yet."]
;

for Statement.transfer:	AbstractProduction [ Transfer, Exp ]
let Compile[tree, contextTree, pg, cs] _ <
FakeDamageContextTree[contextTree], 
MakePGNoOp[],
FakeDamageProgramGraph[pg] >
where err _ Error["Compile for Statement.transfer not implemented yet."]
;

for Statement.free:	AbstractProduction [ Free, Exp, Catch ]
let Compile[tree, contextTree, pg, cs] _ <
FakeDamageContextTree[contextTree], 
MakePGNoOp[],
FakeDamageProgramGraph[pg] >
where err _ Error["Compile for Statement.free not implemented yet."]
;

for Statement.wait:	AbstractProduction [ Exp ]
let Compile[tree, contextTree, pg, cs] _ <
FakeDamageContextTree[contextTree], 
MakePGNoOp[],
FakeDamageProgramGraph[pg] >
where err _ Error["Compile for Statement.wait not implemented yet."]
;

for Statement.error:	AbstractProduction [ ]
let Compile[tree, contextTree, pg, cs] _ <
FakeDamageContextTree[contextTree], 
MakePGNoOp[],
FakeDamageProgramGraph[pg] >
where err _ Error["Compile for Statement.error not implemented yet."]
;

for Statement.stop:	AbstractProduction [ ]
let Compile[tree, contextTree, pg, cs] _ <
FakeDamageContextTree[contextTree], 
MakePGNoOp[],
FakeDamageProgramGraph[pg] >
where err _ Error["Compile for Statement.stop not implemented yet."]
;

for Statement.null:	AbstractProduction [ ]
let Compile[tree, contextTree, pg, cs] _ <
FakeDamageContextTree[contextTree], 
MakePGNoOp[],
FakeDamageProgramGraph[pg] >
;

for Statement.resume:	AbstractProduction [ OptArgs ]
let Compile[tree, contextTree, pg, cs] _ <
FakeDamageContextTree[contextTree], 
MakePGNoOp[],
FakeDamageProgramGraph[pg] >
where err _ Error["Compile for Statement.resume not implemented yet."]
;

for Statement.reject:	AbstractProduction [ ]
let Compile[tree, contextTree, pg, cs] _ <
FakeDamageContextTree[contextTree], 
MakePGNoOp[],
FakeDamageProgramGraph[pg] >
;

for Statement.continue:	AbstractProduction [ ]
let Compile[tree, contextTree, pg, cs] _ <
FakeDamageContextTree[contextTree], 
MakePGNoOp[],
FakeDamageProgramGraph[pg] >
where err _ Error["Compile for Statement.continue not implemented yet."]
;

for Statement.retry:	AbstractProduction [ ]
let Compile[tree, contextTree, pg, cs] _ <
FakeDamageContextTree[contextTree], 
MakePGNoOp[],
FakeDamageProgramGraph[pg] >
where err _ Error["Compile for Statement.retry not implemented yet."]
;

for Statement.getstate:	AbstractProduction [ Exp ]
let Compile[tree, contextTree, pg, cs] _ <
FakeDamageContextTree[contextTree], 
MakePGNoOp[],
FakeDamageProgramGraph[pg] >
where err _ Error["Compile for Statement.getstate not implemented yet."]
;

for Statement.setstate:	AbstractProduction [ Exp ]
let Compile[tree, contextTree, pg, cs] _ <
FakeDamageContextTree[contextTree], 
MakePGNoOp[],
FakeDamageProgramGraph[pg] >
where err _ Error["Compile for Statement.setstate not implemented yet."]
;


End.
ฎSaffronBlockCompileMethods.ThreeC4
James Rauen, August 10, 1988 7:02:59 am PDT
Last edited by: James Rauen August 25, 1988 1:54:12 pm PDT

maybe here we should gritch if there's any code.
important note for documentation: CompileExpression never adds anything to the program graph!!!
warning: we're doing nothing about Checked or Inline!!
note: there's a lot of stuff going on here.
Conditionals: IF...THEN and IF...THEN...ELSE
For conditionals, if the test is a static value, do we want to actually compile both arms of the conditional?  Right now I am, but it's trivial to change these methods to only compile an arm if it is needed.
why doesn't this work???
let Compile[tree, contextTree, pg, cs] _ <contextTree2, code>
where code _ if Static[testValue]
then if BooleanValue[testValue]
then ifTrueCode
else ifFalseCode
else MakePGTest[testCode, ifTrueCode, ifFalseCode]
where <contextTree3, ifFalseCode> _ Compile[Statement.elsepart, contextTree2, cs]
where <contextTree2, ifTrueCode> _ Compile[Statement.thenpart, contextTree1, cs]
where testCode _ Code[testValue]
where <testValue, contextTree1> _ 
CompileAndTypeCheckExpression[Exp, contextTree, cs, booleanType]
where booleanType _ GetIntrinsicBooleanType[cs]
Note: We have no notion of trusted/safe/unsafe program graphs yet.  (I wonder what we're going to do with MACHINE CODE...)  So the Checked argument is ignored.
where err _ Error["Compile for Statement.reject not implemented yet."]
ส˜™"J™+Icode™:J™—KšะizœM˜TK˜šฯnœœ˜#J˜šœ
žœœ˜/šœQ˜TJšœ3˜8JšœE˜JJšœ"ฯc(˜JJšœ2˜7—šœ9˜<Jšœ3˜8JšœE˜JJš
œ"˜"Jšœ3˜8—šœ7˜:J˜$Jšœ'Ÿ˜D—J˜
—J˜šœ
žœœ-˜JšœH˜KJšœ'˜,JšœI˜NJšœE˜JJšœ%˜*Jšœ2˜7š
œ"˜"Jš
œ:˜:—šœ˜$Jš
œC˜C—JšœB˜GJšœ?˜DJšœ=˜Bšœ˜$Jš
œ<˜<——J˜
J˜—
codetabšœ
ž	œ˜5š
œF˜FL™0JšœB˜GJ˜$Jšœ%˜*Jšœ6˜;š
œ&˜&Jš
œF˜F—šœ˜$Jš
œC˜C—JšœB˜GJšœ?˜DJšœ=˜Bšœ˜$Jš
œM˜M—Jš
œ;˜;L˜
—J˜—J˜J˜—šžœœ˜)J˜šœ
žœœ˜,šœ'˜*Jš
œ$˜$Jš
œ
˜
Jš
œ˜—J˜
J˜—šœ
žœœ
˜4JšœK˜NJ˜
—J˜šœ
žœœ˜1JšœO˜RJš
œ
˜
J˜—šœ
žœœ˜Ašœ?˜BJšœ'˜,JšœH˜MJšœF˜K—J˜
J˜—šœ
žœœ˜Mšœ'˜*Jš
œ$˜$Jš
œ
˜
Jš
œ˜—J˜
J˜—šœ
ะbnœœ8˜`šœ'˜*Jš
œ$˜$Jš
œ
˜
Jš
œ˜—J˜
J˜—šœ
 œœ@˜išœ=˜@šœ˜šœ˜Lšœ
˜šœ=˜ALšœ&˜+šœ˜Lš
œC˜C—L˜
———šœ%˜*Lš
œF˜F—Lšœ.˜3Lšœe˜j—J˜
J˜—šœ
žœœ˜/šœA˜DJš
œ#˜#Jš
œ)˜)J˜—Jš
œ
˜
J˜—šœ
žœœ˜=šœ?˜BJš
œD˜D—J˜
J˜—šœ
žœœ˜@šœ?˜BJš
œD˜D—J˜
J˜—šœ
žœœ˜-šœA˜DJš
œ$˜$Jš
œ˜Jš
œ˜—J˜
J˜—šœ
žœœ˜,šœA˜DJš
œ$˜$Jš
œ˜Jš
œ˜—JšœP˜UJ˜
J˜—šœ
žœœ˜.šœ[˜^JšœL˜QJšœ!˜&Jš
œ_™_—J˜
J˜—šœ
žœœ˜CšœZ˜]JšœE˜JJšœ6˜;Jšœ/˜4Jšœ[˜`—Jšžœ/™6J™+J˜
J˜—šœ
žœœ˜DšœA˜DJš
œ$˜$Jš
œ˜Jš
œ˜—JšœW˜\J˜
J˜—šœ
ž
œœ˜-šœ@˜CJš
œ>˜>—J˜
J˜—šœ
žœœ!˜Gšœ;˜>JšœD˜IJšœE˜JJšœŸ$˜=JšœE˜J—J˜
—J˜šœ
žœœ˜%šœC˜FJšœ˜!Jšœ,˜1—J˜
J˜—šœ
žœœ˜7šœC˜FJšœ˜!Jšœ,˜1—˜
J˜——J˜J˜Jšœ
˜J˜—šžœœ˜'J˜šœ
žœœ˜/šœ'˜*Jš
œ$˜$Jš
œ
˜
Jš
œ˜—J˜
J˜—šœ
žœœ˜Hšœ?˜BJšœ'˜,JšœE˜JJšœG˜L—J˜
J˜—Iheadš
ฯzะkzกขกขกขกข™,K˜šœ
žœœ˜;šœ?˜BJšœ<˜AJšœ˜ JšœK˜Pšœ˜"Jš
œ@˜@—Jšœ*˜/—J˜
JšœHฯbœ€
™ฯ
J˜—šœ
žœ
œ0˜[šœ?˜BJšœ5˜:JšœV˜[JšœT˜YJš
œ ˜ šœ˜"Jš
œ@˜@—Jšœ*˜/—J™šœ:™=šœœ™!šœ
œ™Jšœ™Jšœ™—Jšœ.™2—JšœL™QJšœK™PJš
œ ™ šœ™"Jš
œ@™@—Jšœ*™/—J˜
J˜—šœ
žœœ.˜Všœ'˜*Jš
œ$˜$Jš
œ
˜
Jš
œ˜—JšœA˜FJ˜
J˜—šœ
ž
œœ˜-šœ'˜*Jš
œ$˜$Jš
œ
˜
Jš
œ˜—Jšœ>˜CJ˜
J˜—šœ
žœœ˜>šœV˜YLšœ8˜=šœœ˜&Lšœ˜Lšœ˜ —šœ˜!Lš
œ<˜<—Lšœ8˜=—J˜
J˜—šœ
žœœ˜>šœ'˜*Jš
œ$˜$Jš
œ
˜
Jš
œ˜—JšœF˜KJ˜
J˜—šœ
žœœ˜:JšœI˜LJšœjฯkœ
คœ)™Ÿ
J˜
J˜—šœ
žœœ%˜Ršœ'˜*Jš
œ$˜$Jš
œ
˜
Jš
œ˜—JšœF˜KJ˜
J˜—šœ
žœœ˜*šœ'˜*Jš
œ$˜$Jš
œ
˜
Jš
œ˜—Jšœ?˜DJ˜
J˜—šœ
žœœ˜*šœ'˜*Jš
œ$˜$Jš
œ
˜
Jš
œ˜—Jšœ?˜DJ˜
J˜—šœ
žœœ˜-šœ'˜*Jš
œ$˜$Jš
œ
˜
Jš
œ˜—Jšœ?˜DJ˜
J˜—šœ
žœœ˜4šœ'˜*Jš
œ$˜$Jš
œ
˜
Jš
œ˜—JšœA˜FJ˜
J˜—šœ
žœœ˜<šœ'˜*Jš
œ$˜$Jš
œ
˜
Jš
œ˜—JšœC˜HJ˜
J˜—šœ
žœœ˜;šœ'˜*Jš
œ$˜$Jš
œ
˜
Jš
œ˜—Jšœ?˜DJ˜
J˜—šœ
žœœ˜.šœ'˜*Jš
œ$˜$Jš
œ
˜
Jš
œ˜—Jšœ?˜DJ˜
J˜—šœ
žœœ˜+šœ'˜*Jš
œ$˜$Jš
œ
˜
Jš
œ˜—Jšœ@˜EJ˜
J˜—šœ
žœœ˜*šœ'˜*Jš
œ$˜$Jš
œ
˜
Jš
œ˜—Jšœ?˜DJ˜
J˜—šœ
žœœ˜*šœ'˜*Jš
œ$˜$Jš
œ
˜
Jš
œ˜—J˜
J˜—šœ
žœœ˜4šœ'˜*Jš
œ$˜$Jš
œ
˜
Jš
œ˜—JšœA˜FJ˜
J˜—šœ
žœœ˜,šœ'˜*Jš
œ$˜$Jš
œ
˜
Jš
œ˜—JšœA™FJ˜
J˜—šœ
žœœ˜.šœ'˜*Jš
œ$˜$Jš
œ
˜
Jš
œ˜—JšœC˜HJ˜
J˜—šœ
žœœ˜+šœ'˜*Jš
œ$˜$Jš
œ
˜
Jš
œ˜—Jšœ@˜EJ˜
J˜—šœ
žœœ˜2šœ'˜*Jš
œ$˜$Jš
œ
˜
Jš
œ˜—JšœC˜HJ˜
J˜—šœ
žœœ˜2šœ'˜*Jš
œ$˜$Jš
œ
˜
Jš
œ˜—JšœC˜HJ˜
J˜—J˜Jšœ
˜——…—:๖Nต