DIRECTORY
Alloc,
Code,
CodeDefs,
ComData,
FOpCodes,
IntCodeDefs,
Log,
P5,
P5S,
P5U,
PrincOps,
SourceMap,
SymbolOps,
Symbols,
Tree,
TreeOps;

Statement: PROGRAM
IMPORTS MPtr: ComData, CPtr: Code, CodeDefs, Log, P5U, P5, P5S, SymbolOps, TreeOps 
EXPORTS CodeDefs, P5 = BEGIN OPEN FOpCodes, IntCodeDefs, CodeDefs;


SEIndex: TYPE = Symbols.SEIndex;
ISEIndex: TYPE = Symbols.ISEIndex;
ISENull: ISEIndex = Symbols.ISENull;
CSEIndex: TYPE = Symbols.CSEIndex;
CSENull: CSEIndex = Symbols.CSENull;
RecordSEIndex: TYPE = Symbols.RecordSEIndex;
RecordSENull: RecordSEIndex = Symbols.RecordSENull;
BTIndex: TYPE = Symbols.BTIndex;
BTNull: BTIndex = Symbols.BTNull;
BitAddress: TYPE = Symbols.BitAddress;
BitCount: TYPE = Symbols.BitCount;


tb: Tree.Base;		-- tree base (local copy)
seb: Symbols.Base;		-- semantic entry base (local copy)
ctxb: Symbols.Base;		-- context entry base (local copy)
bb: Symbols.Base;		-- body base (local copy)
cb: CodeDefs.Base;		-- code base (local copy)

StatementNotify: PUBLIC Alloc.Notifier =
BEGIN  -- called by allocator whenever table area is repacked
seb _ base[Symbols.seType];
ctxb _ base[Symbols.ctxType];
bb _ base[Symbols.bodyType];
tb _ base[Tree.treeType];
cb _ base[codeType];
END;

catchEndLabel: Label _ NIL;

recentStmt: PUBLIC Tree.Link; -- for debugging

DeclList: PUBLIC PROC [cl: CodeList, t: Tree.Link] = { -- maybe some statements, too
OneDecl: Tree.Scan = {
IF t = Tree.Null THEN RETURN;
SELECT TreeOps.OpName[t] FROM 
decl => DeclItem[cl, TreeOps.GetNode[t]];
typedecl => NULL;
ENDCASE => P5U.MoreCode[cl, StatementTree[t]]};
TreeOps.ScanList[t, OneDecl]};

StatementList: PUBLIC PROC [cl: CodeList, t: Tree.Link] = {
OneStmt: Tree.Scan = {P5U.MoreCode[cl, StatementTree[t]]};
TreeOps.ScanList[t, OneStmt]};

StatementTree: PUBLIC PROC [t: Tree.Link] RETURNS [l: Node] =
BEGIN -- generates code for Mesa statements
node: Tree.Index;
saveIndex: SourceMap.Loc = MPtr.textIndex;
recentStmt _ t;
IF t = Tree.Null THEN RETURN [NIL];
BEGIN
ENABLE 
BEGIN
CPtr.CodeNotImplemented => IF ~MPtr.switches['d] THEN
GO TO unimplementedConstruct;
END;
WITH t SELECT FROM
subtree =>
BEGIN
fIndex: SourceMap.Loc _ CPtr.inlineFileLoc;
node _ index;
IF fIndex = SourceMap.nullLoc THEN fIndex _ tb[node].info;
IF fIndex # SourceMap.nullLoc THEN
SELECT tb[node].name FROM
list, block, null => NULL; -- info is not a valid file index
ENDCASE => 
{CPtr.fileLoc _ MPtr.textIndex _ fIndex; 
};
SELECT tb[node].name FROM
list => l _ Compound[t];
block => l _ Block[node];
start => l _ P5S.Start[node];
restart => l _ P5S.Restart[node];
stop => l _ P5S.Stop[node];
call, portcall => l _ P5S.Call[node];
signal, error => l _ P5S.SigErr[node];
syserror => l _ P5.SysError[];
label => l _ P5S.LabelStmt[node];
assign => l _ P5S.Assign[node];
extract => l _ P5S.Extract[node];
if => l _ IfStmt[node];
case => l_ P5.CaseStmtExp[node, FALSE];
bind => l _ P5.BindStmtExp[node, FALSE];
do => l _ DoStmt[node];
exit => l _ P5S.Exit[];
loop => l _ P5S.Loop[];
retry => l _ P5S.Retry[];
continue => l _ P5S.Continue[];
goto => l _ P5S.GoTo[node];
catchmark => l _ P5S.CatchMark[node];
return => l _ P5S.Return[node];
resume => l _ P5S.Resume[node];
reject => l _ Reject[];
result => l _ P5S.Result[node];
open => l _ Open[node];
enable => l _ Enable[node];
checked => l _ StatementTree[tb[node].son[1]];
procinit => l _ P5S.ProcInit[node];
wait => l _ P5S.Wait[node];
notify => l _ Notify[node];
broadcast => l _ Broadcast[node];
join => l _ P5S.Join[node];
unlock => l _ P5S.Unlock[node];
lock => l _ P5S.Lock[node];
subst => l _ P5S.Subst[node];
free => l _ P5S.Free[node];
xerror => l _ P5S.RetWithError[node];
null => NULL;
ENDCASE => GO TO unimplementedConstruct;
END;
ENDCASE;
EXITS
unimplementedConstruct => Log.Error[unimplemented];
END;
MPtr.textIndex _ saveIndex;
RETURN
END;

DeclItem: PROC [cl: CodeList, node: Tree.Index] = {
initVal: Node _ IF tb[node].son[3] = Tree.Null THEN NIL ELSE P5.Exp[tb[node].son[3]]; 
first: BOOL _ TRUE;
OneId: Tree.Scan = {
sei: ISEIndex _ TreeOps.GetSe[t];
IF NOT seb[sei].constant THEN {
var: Var _ P5.VarForSei[sei];
P5U.Declare[cl: cl, var: var, init: initVal];
IF first THEN {
first _ FALSE; 
IF initVal # NIL AND initVal.kind # const THEN initVal _ var};
};
};
TreeOps.ScanList[tb[node].son[1], OneId];
};

Open: PROC [node: Tree.Index] RETURNS [Node] =
BEGIN

RETURN[StatementTree[tb[node].son[2]]];
END;




Compound: PROC [t: Tree.Link] RETURNS [Node] =
BEGIN
cl: CodeList _ P5U.NewCodeList[];
StatementList[cl, t];
RETURN[P5U.MakeBlock[cl]];
END;

Block: PROC [node: Tree.Index] RETURNS [Node] =
BEGIN
cl: CodeList _ P5U.NewCodeList[];
bti: BTIndex = tb[node].info;

EnterBlock[cl, bti];
DeclList[cl, tb[node].son[1]];
StatementList[cl, tb[node].son[2]];
RETURN[P5U.MakeBlock[cl]];
END;

IfStmt: PROC [node: Tree.Index] RETURNS [l: Node] =
BEGIN -- generates code for an IF statement
test: Node = P5.Exp[tb[node].son[1]];
s1: Node = StatementTree[tb[node].son[2]];
s2: Node = StatementTree[tb[node].son[3]];
else: CaseList = P5U.MakeCaseList[NIL, s2];
then: CaseList = P5U.MakeCaseList[P5U.MakeNodeList[test], s1, else];
l _ z.NEW[cond NodeRep _ [details: cond[then]]];
END;

DoStmt: PROC [rootNode: Tree.Index] RETURNS [l: Node] =
BEGIN --  generates code for all the loop statments
stepLoop, tempIndex, tempEnd, upLoop, forSeqLoop, bigForSeq: BOOL _ FALSE;
signed: BOOL _ FALSE;
sSon, eSon: Tree.Link;
node, subNode: Tree.Index;
bti: BTIndex _ BTNull;
intType: Tree.NodeName;
deltaOp: Node;
indexVar: Var;
endVal: Node;
topLabel: Label = P5U.AllocLabel[];
startLabel: Label = P5U.AllocLabel[];
finLabel: Label = P5U.AllocLabel[];
endLabel, loopLabel: Label;
labelMark: LabelInfoIndex = P5.GetLabelMark[];
cl: CodeList _ P5U.NewCodeList[];
cvBound: Node;
ati: ArithTypeIndex;

UpdateCV: PROC =
BEGIN
delta: Node _ P5U.ApplyOp[oper: deltaOp, args: P5U.MakeNodeList2[indexVar, CPtr.nC1], bits: WordSize];
IF cvBound # NIL THEN 
delta _ P5U.BoundsCheck[delta, cvBound];
P5U.DoAssign[cl, indexVar, delta];
END;


[exit: endLabel, loop: loopLabel] _ P5.MakeExitLabel[];
TreeOps.ScanList[tb[rootNode].son[5], P5.LabelCreate];


IF tb[rootNode].son[1] = Tree.Null THEN P5U.InsertLabel[cl, topLabel]
ELSE
BEGIN
node _ TreeOps.GetNode[tb[rootNode].son[1]];
bti _ tb[node].info;
IF bti # BTNull THEN EnterBlock[cl, bti];
SELECT tb[node].name FROM
forseq =>
BEGIN
t1: Tree.Link = tb[node].son[1];
e2: Node = P5.Exp[tb[node].son[2]];
indexVar _ P5.VarForSei[TreeOps.GetSe[t1]];
IF bti # BTNull THEN -- or some better test of locally declared cv
P5U.Declare[cl, indexVar, e2]
ELSE P5U.DoAssign[cl, indexVar, e2];
P5U.InsertLabel[cl, topLabel];
END;
upthru, downthru =>
BEGIN
knownNonEmpty: BOOL = tb[node].attr1;
cvBound _ P5.Exp[tb[node].son[3]];
stepLoop _ TRUE;
upLoop _ tb[node].name = upthru;
subNode _ TreeOps.GetNode[tb[node].son[2]];
intType _ tb[subNode].name;
IF tb[subNode].attr1 THEN SIGNAL CPtr.CodeNotImplemented; -- REAL
ati _ P5U.ArithTypeForTree[subNode];
WITH tb[node].son[1] SELECT FROM
subtree => -- son1 is empty
{indexVar _ P5U.CreateTemp[WordSize].var; tempIndex _ TRUE};
symbol => indexVar _ P5.VarForSei[index];
ENDCASE;
IF upLoop THEN {
deltaOp _ P5U.ArithOp[add, ati];
sSon _ tb[subNode].son[1]; 
eSon _ tb[subNode].son[2]}
ELSE
BEGIN
deltaOp _ P5U.ArithOp[sub, ati];
SELECT intType FROM
intCO => intType _ intOC;
intOC => intType _ intCO;
ENDCASE;
sSon _ tb[subNode].son[2];  eSon _ tb[subNode].son[1];
END;
WITH e: eSon SELECT FROM
literal =>  endVal _ P5.Exp[eSon];
symbol =>
IF seb[e.index].immutable THEN endVal _ P5.Exp[eSon]
ELSE
BEGIN
tv: Var _ P5U.CreateTemp[WordSize].var;
P5U.Declare[cl, tv, P5.Exp[eSon]];
endVal _ tv;
tempEnd _ TRUE;
END;
ENDCASE =>
BEGIN
endVal _ P5U.MakeTemp[cl: cl, bits: WordSize, init: P5.Exp[eSon]].var;
tempEnd _ TRUE;
END;
IF tempIndex OR bti # BTNull THEN -- or some better test of locally declared cv
P5U.Declare[cl, indexVar, P5.Exp[sSon]]
ELSE P5U.DoAssign[cl, indexVar, P5.Exp[sSon]];
IF (intType = intCC OR intType = intOO) AND ~knownNonEmpty THEN
BEGIN -- earlier passes check for empty intervals

topTest: ARRAY BOOL OF ARRAY BOOL OF Comparator = [
[lt,le],	-- down, closed/open
[gt,ge]];	-- up, closed/open
P5U.CJump[
cl: cl, test: topTest[upLoop][intType = intOO], ati: ati,
op1: indexVar, op2: endVal, target: finLabel];
END;
P5U.Jump[cl, startLabel];
P5U.InsertLabel[cl, topLabel];
SELECT intType FROM
intCC => {UpdateCV[]; P5U.InsertLabel[cl, startLabel]};
intOC => UpdateCV[];
intCO, intOO => NULL;
ENDCASE;
END;
ENDCASE;
END;

IF tb[rootNode].son[2] # Tree.Null THEN {
goto: Node = z.NEW[goto NodeRep _ [details: goto[finLabel]]];
case: CaseList _ P5U.MakeCaseList[P5U.MakeNodeList[P5.Exp[tb[rootNode].son[2]]], NIL, P5U.MakeCaseList[NIL, goto]];
cond: Node _ z.NEW[NodeRep.cond _ [details: cond[case]]];
P5U.MoreCode[cl, cond]};


P5U.MoreCode[cl, StatementTree[tb[rootNode].son[4]]];


P5U.InsertLabel[cl, loopLabel];
IF stepLoop THEN
BEGIN
SELECT intType FROM
intCC => NULL;
intCO => {UpdateCV[]; P5U.InsertLabel[cl, startLabel]};
intOC => P5U.InsertLabel[cl, startLabel];
intOO => {P5U.InsertLabel[cl, startLabel]; UpdateCV[]};
ENDCASE;
P5U.CJump[cl: cl, test: IF upLoop THEN lt ELSE gt, op1: indexVar, op2: endVal, ati: ati, target: topLabel];
P5U.Jump[cl, finLabel];
END
ELSE
BEGIN
IF forSeqLoop THEN P5U.DoAssign[cl, indexVar, P5.Exp[tb[node].son[3]]];
P5U.Jump[cl, topLabel];
END;


P5.LabelList[cl, tb[rootNode].son[5], endLabel, labelMark];


P5U.InsertLabel[cl, finLabel];
P5U.MoreCode[cl, StatementTree[tb[rootNode].son[6]]];
P5U.InsertLabel[cl, endLabel];
RETURN[P5U.MakeBlock[cl]];
END;


Enable: PROC [node: Tree.Index] RETURNS [l: Node] =
BEGIN -- generate code for an ENABLE
handler: Node _ SCatchPhrase[tb[node].son[1]];
cl: CodeList _ P5U.NewCodeList[];
range: NodeList;
StatementList[cl, tb[node].son[2]];
range _ P5U.ExtractList[cl];
l _ z.NEW[enable NodeRep _ [details: enable[handle: handler, scope: range]]];
END;

SCatchPhrase: PUBLIC PROC [t: Tree.Link] RETURNS [l: Node] =
BEGIN -- main subr for catchphrases and ENABLEs
node: Tree.Index = TreeOps.GetNode[t];
saveCaseCV: Node = CPtr.caseCV;
regsPtr, except, rtnPtr, argPtr: Var; -- formal parameters
cl: CodeList _ P5U.NewCodeList[];
catchLabel: Label _ P5U.AllocLabel[]; -- use [bti] when catch phrases have them
armHead, armTail: CaseList _ NIL;
enclosingContext: Label _ P5.visibleContext[CPtr.curctxlvl];
lambda: LambdaNode;

CatchArm: PROC [t: Tree.Link] =
BEGIN
node: Tree.Index _ TreeOps.GetNode[t]; -- t is an item
tests: NodeList _ P5.ExpList[tb[node].son[1]].head;
body: Node _ CatchItem[node: node, argPtr: argPtr];
arm: CaseList _ z.NEW[CaseListRep _ [tests: tests, body: body, rest: NIL]];
IF armTail = NIL THEN armHead _ arm ELSE armTail.rest _ arm;
armTail _ arm
END;

regsPtr _ P5U.FormalVar[PtrSize];
except _ P5U.FormalVar[SignalSize];
rtnPtr _ P5U.FormalVar[PtrSize];
argPtr _ P5U.FormalVar[PtrSize];
lambda _ z.NEW[lambda NodeRep _ [details: lambda[parent: enclosingContext, formalArgs: P5U.MakeVarList[regsPtr, P5U.MakeVarList[except, P5U.MakeVarList2[rtnPtr, argPtr]]], body: NIL]]]; -- will fill in body field soon

catchEndLabel _ P5U.AllocLabel[];
CPtr.curctxlvl _ CPtr.curctxlvl + 1;
P5.visibleContext[CPtr.curctxlvl] _ catchLabel;

CPtr.caseCV _ except;
TreeOps.ScanList[tb[node].son[1], CatchArm];
IF tb[node].son[2] # Tree.Null THEN {
ec: Node _ CatchItem[node:TreeOps.GetNode[tb[node].son[2]], argPtr: argPtr];
other: CaseList _ z.NEW[CaseListRep _ [tests: NIL, body: ec, rest: NIL]];
IF armHead = NIL THEN armHead _ other ELSE armTail.rest _ other};
P5U.InsertLabel[cl, catchEndLabel];
lambda.body _ P5U.MakeNodeList[z.NEW[NodeRep.cond _ [details: cond[armHead]]]];
catchLabel.node _ lambda;
l _ z.NEW[NodeRep.label _ [details: label[catchLabel]]];
CPtr.curctxlvl _ CPtr.curctxlvl-1;
CPtr.caseCV _ saveCaseCV;
END;

CatchItem: PROC [node: Tree.Index, argPtr: Node] RETURNS [Node] =
BEGIN -- generate code for a CATCH item
saveCatchOutRecord: RecordSEIndex = CPtr.catchoutrecord;
inRecord: RecordSEIndex;
body: Node;
bodyStmts: NodeList;
cl: CodeList _ P5U.NewCodeList[];
tSei: CSEIndex = SymbolOps.UnderType[tb[node].info];
IF tSei = Symbols.CSENull THEN inRecord _ CPtr.catchoutrecord _ RecordSENull
ELSE
BEGIN
[inRecord, CPtr.catchoutrecord] _ SymbolOps.TransferTypes[tSei];
END;
GetSignalParams[cl, argPtr, inRecord];
body _ StatementTree[tb[node].son[2]];
WITH b: body SELECT FROM
block => bodyStmts _ b.nodes;
ENDCASE => bodyStmts _ P5U.MakeNodeList[body];
IF cl.tail = NIL THEN cl.head _ bodyStmts ELSE cl.tail.rest _ bodyStmts;
CPtr.catchoutrecord _ saveCatchOutRecord;
RETURN[P5U.MakeBlock[cl]];
END;


Bits: PROC [ba: BitAddress] RETURNS [INT] = {RETURN[LONG[LOOPHOLE[ba, CARDINAL]]]};

GetSignalParams: PROC [cl: CodeList, argPtr: Node, irecord: RecordSEIndex] =
BEGIN
totalBits: BitCount _ P5U.BitsForType[irecord];
sei: ISEIndex;
np: CARDINAL _ 0;
offset: BitAddress;
size: BitCount;
nParms: CARDINAL;
args: Node;

IF irecord = CSENull THEN RETURN;
nParms _ P5U.WordsForSei[irecord];
IF nParms = 0 THEN RETURN;
args _ P5U.Deref[n: argPtr, bits: totalBits];
sei _ P5U.NextVar[ctxb[seb[irecord].fieldCtx].seList];
UNTIL sei = ISENull DO
[offset, size] _ SymbolOps.FnField[sei];
P5U.Declare[cl: cl, var: P5.VarForSei[sei], init: P5U.TakeField[n: args, vl: [disp: Bits[offset], size: size]]];
sei _ P5U.NextVar[SymbolOps.NextSe[sei]];
ENDLOOP;
END;

EnterBlock: PUBLIC PROC [cl: CodeList, bti: BTIndex]  = {
};

Reject: PROC RETURNS [l: Node] = 
BEGIN
l _ z.NEW[goto NodeRep _ [details: goto[catchEndLabel]]];
END;

Notify: PROC [node: Tree.Index] RETURNS [l: Node] =
BEGIN
cv: Node _ P5.Exp[tb[node].son[1]];
l _ P5U.ApplyOp[oper: P5U.MesaOpNode[notify], args: P5U.MakeNodeList[cv], bits: 0];
END;

Broadcast: PROC [node: Tree.Index] RETURNS [l: Node] =
BEGIN
cv: Node _ P5.Exp[tb[node].son[1]];
l _ P5U.ApplyOp[oper: P5U.MesaOpNode[broadcast], args: P5U.MakeNodeList[cv], bits: 0];
END;

END.

	Statement.mesa
Copyright c 1985 by Xerox Corporation.  All rights reserved.
Sweet, June 2, 1986 11:55:50 am PDT
Satterthwaite, December 30, 1985 11:51:18 am PST
Donahue, 10-Dec-81  9:39:18
Russ Atkinson (RRA) March 6, 1985 11:27:09 pm PST
imported definitions
P5U.OutSource[cl, fIndex];
dst => l _ DumpState[node];
lst =>  GO TO unimplementedConstruct;	-- added in Trinity
lste => l _ LoadState[node];
lstf => l _ LoadStateFree[node];
syscall => l _ SysCallStmt[node];
SysCallStmt: PROC [node: Tree.Index] =
BEGIN
TreeOps.ScanList[tb[node].son[2], P5.PushRhs];
P5.SysCall[P5U.TreeLiteralValue[tb[node].son[1]]];
END;


OpenItem: PROC [t: Tree.Link] RETURNS [Tree.Link] =
BEGIN
MarkShared[t, FALSE];
RETURN [FreeTree[t]]
END;

tb[node].son[1] _ ReverseUpdateList[tb[node].son[1], OpenItem];
DumpState: PROC [node: Tree.Index] = INLINE
BEGIN -- generates dumpstate
DLState[node, qDST];
END;

LoadState: PROC [node: Tree.Index] = INLINE
BEGIN -- generates loadstate
DLState[node, qLST];
P5.CallCatch[Tree.Null];
END;

LoadStateFree: PROC [node: Tree.Index] = INLINE
BEGIN -- generates loadstateandfree
DLState[node, qLSTF];
P5U.OutJump[JumpRet, LabelCCNull];
END;

DLState: PROC [node: Tree.Index, opc: Byte] =
BEGIN -- does state move after checking for small currentcontext address
lowBound: CARDINAL = PrincOps.localbase+2;
var: VarComponent = P5L.MakeComponent[P5L.VarForLex[P5.Exp[tb[node].son[1]]]];
WITH var SELECT FROM
frame => 
BEGIN
IF level # CPtr.curctxlvl THEN {Log.Error[stateVector]; RETURN};
IF wd NOT IN [lowBound..Byte.LAST] THEN Log.Error[stateVector];
P5U.Out1[opc, wd];
END;
ENDCASE => Log.Error[stateVector];
END;
ExitBlock[bti];
long: BOOL _ FALSE;
set up for EXIT clause
handle initialization node
now the pre-body test
ignore the opens (tb[rootNode].son3)
now the body
now (update and) test the control variable
now the labelled EXITs
finally the FINISHED clause
IF bti # BTNull THEN ExitBlock[bti];
saveEndLabel: LabelCCIndex = catchEndLabel;
catchEndLabel _ saveEndLabel;
functionality replace by leaving decls in in Pass4s.
ctx: Symbols.CTXIndex = bb[bti].localCtx;
sei: ISEIndex;
IF ctx = Symbols.CTXNull THEN RETURN;
sei _ P5U.NextVar[ctxb[ctx].seList];
UNTIL sei = ISENull DO
P5U.Declare[cl: cl, var: P5.VarForSei[sei]];
sei _ P5U.NextVar[SymbolOps.NextSe[sei]];
ENDLOOP;
Κ˜
codeš
œ™Kšœ
Οm
œ1™<Kš
œ#™#Kš
œ0™0Kš
œ™K™1—K˜š
Οk	˜	Kš
œ˜Kš
œ˜Kš
œ	˜	Kš
œ˜Kš
œ	˜	K˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ	˜	K˜
Kš
œ
˜
Kš
œ˜Kš
œ˜š
œ˜K˜——šœž˜KšžœL˜SKšžœžœ!˜BK˜Kš
œ™K˜Kšœ	žœ˜ Kšœ
žœ˜"K˜$Kšœ
žœ˜"Kš
œ$˜$Kšœžœ˜,K˜3Kšœ	žœ˜ K˜!Kšœžœ˜&Kšœ
žœ˜"K˜K˜KšœΟc˜)KšœŸ#˜7KšœŸ"˜7KšœŸ˜,KšœŸ˜-K˜šœžœ˜(KšžœŸ6˜=K˜K˜K˜K˜K˜Kšžœ
˜K˜—Kšœžœ
˜K˜KšœžœŸ˜.K˜šΟnœžœ
žœ"Ÿ˜T˜Kšžœžœ
žœ
˜šžœžœ
˜Kšœžœ"˜)Kšœžœ
˜Kšžœ(˜/——K˜K˜—š 
œžœ!˜;K˜:K˜—K˜š 
œžœ
žœžœ˜=Kšžœ
Ÿ%˜+K˜Kš
œ*˜*K˜Kšžœžœ
žœžœ˜#Kš
ž˜šžœ
˜Kš
ž˜šœžœž˜5Kšžœ
žœ˜—Kšžœ
˜—šžœžœ
ž˜˜
Kš
ž˜Kš
œ+˜+K˜
Kšžœžœ˜:šžœž˜"šžœž˜KšœžœŸ!˜<šžœ˜K˜)Kš
œ™K˜———šžœž˜K˜K˜K˜K˜!K˜K™Kšœžœ
žœŸ™9K™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˜K˜!K˜K˜K˜K˜K˜K˜%Kšœžœ
˜
Kšžœžœ
žœ˜(—Kšžœ
˜—Kšžœ
˜—š
ž˜K˜3—Kšžœ
˜K˜Kš
ž˜Kšžœ
˜K˜—š œžœ%˜3Kš	œžœžœ
žœ
žœ˜VKšœžœžœ
˜˜K˜!šžœ
žœžœ˜K˜K˜-šžœžœ˜Kšœžœ˜Kšžœžœ
žœžœ˜>—Kš
œ˜—K˜—K˜)K˜K˜—š œžœ™&Kš
ž™K™.K™2Kšžœ
™K™K™—š œžœžœ	˜.Kš
ž˜K˜š œžœžœ™3Kš
ž™Kšœžœ™Kšžœ™Kšžœ
™K™—Kšžœ!˜'K™?Kšžœ
˜K˜K˜—š 	œžœž™+Kšžœ
Ÿ™K™Kšžœ
™K™—š 	œžœž™+Kšžœ
Ÿ™K™K™Kšžœ
™K™—š 
œžœž™/Kšžœ
Ÿ™#K™K™"Kšžœ
™K™—š œžœ ™-Kšžœ
ŸB™HKšœ
žœ™*K™Nšžœžœ
ž™™	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˜—š œžœžœ˜3Kšžœ
Ÿ%˜+K˜%K˜*K˜*Kšœ"žœ˜+K˜DKšœžœ'˜0Kšžœ
˜K˜—š œžœžœ˜7Kšžœ
Ÿ-˜3Kšœ=žœžœ
˜JKšœžœžœ
˜Kšœžœžœ
™K˜K˜K˜K˜K˜K˜K˜
Kš
œ#˜#Kš
œ%˜%Kš
œ#˜#K˜K˜.K˜!K˜Kš
œ˜K˜š œžœ˜Kš
ž˜Kš
œf˜fšžœžœ
žœ
˜K˜(—K˜"Kšžœ
˜K˜—Kš
œ™K˜K˜7K˜6K˜Kš
œ™K˜Kšžœ!žœ˜Eš
ž˜Kš
ž˜K˜,K˜Kšžœžœ˜)šžœž˜˜	Kš
ž˜K˜ K˜#K˜+šžœžœ
Ÿ-˜BK˜—Kšžœ ˜$K˜Kšžœ
˜—˜Kš
ž˜Kšœžœ˜%K˜"Kšœžœ
˜K˜ K˜+K˜Kšžœžœ
žœ!˜AK˜$šžœžœ
ž˜ šœŸ˜Kšœ6žœ˜<—K˜)Kšžœ
˜—šžœžœ˜K˜ Kš
œ˜Kš
œ˜—š
ž˜Kš
ž˜K˜ šžœ	ž˜K˜K˜Kšžœ
˜—K˜6Kšžœ
˜—šžœ	žœ
ž˜K˜"˜	Kšžœžœ˜4š
ž˜Kš
ž˜K˜'K˜"K˜Kšœ
žœ
˜Kšžœ
˜——šžœ˜
Kš
ž˜Kš
œF˜FKšœ
žœ
˜Kšžœ
˜——šžœžœžœ
Ÿ-˜OK˜'—Kšžœ*˜.šžœžœžœž˜?Kšžœ
Ÿ+˜1K˜š
œ	žœ
žœ
žœ
žœ
žœ
žœ˜3Kšœ	Ÿ˜Kšœ
Ÿ˜—š
œ
˜
Kš
œ9˜9Kš
œ.˜.—Kšžœ
˜—K˜K˜šžœ	ž˜Kš
œ7˜7Kš
œ˜Kšœžœ
˜Kšžœ
˜—Kšžœ
˜—Kšžœ
˜—Kšžœ
˜K˜—Kš
œ™šžœ!žœ˜)Kšœžœ+˜=KšœQžœžœ	˜sKšœžœ'˜9K˜—Kš
œ$™$K˜Kš
œ™K˜K˜5K˜Kš
œ*™*K˜K˜šžœ
ž˜Kš
ž˜šžœ	ž˜Kšœ	žœ
˜Kš
œ7˜7Kš
œ)˜)Kš
œ7˜7Kšžœ
˜—K˜kK˜Kš
ž˜—š
ž˜Kš
ž˜Kšžœžœ4˜GK˜Kšžœ
˜—K˜Kš
œ™K˜K˜;K˜Kš
œ™K˜K˜K˜5Kšžœžœ™$K˜Kšžœ˜Kšžœ
˜K˜K˜—š œžœžœ˜3Kšžœ
Ÿ˜$K˜.K˜!K˜K˜#K˜KšœžœD˜MKšžœ
˜K˜—š œžœ
žœžœ˜<Kšžœ
Ÿ)˜/Kš
œ&˜&K˜K™+Kšœ&Ÿ˜:K˜!Kšœ&Ÿ)˜OKšœžœ
˜!K˜<K˜K˜š œžœ˜Kš
ž˜Kšœ'Ÿ˜6K˜3Kš
œ3˜3Kšœžœ0žœ˜KKšžœžœ
žœžœ˜<K˜
Kšžœ
˜K˜—K˜!Kš
œ#˜#Kš
œ ˜ Kš
œ ˜ Kšœžœ€
žœŸ˜Ω
K˜Kš
œ!˜!K˜$K˜/K˜Kš
œ˜Kš
œ,˜,šžœžœ˜%Kš
œL˜LKšœžœžœžœ˜IKšžœžœ
žœžœ˜A—K˜#Kšœ!žœ+˜OK˜Kšœžœ/˜8K˜"K˜K™Kšžœ
˜K˜—š 	œžœ"žœ	˜AKšžœ
Ÿ!˜'K˜8K˜K˜K˜K˜!K˜4Kšžœžœ.˜Lš
ž˜Kš
ž˜K˜@Kšžœ
˜—K˜&K˜&šžœ	žœ
ž˜Kš
œ˜Kšžœ'˜.—Kšžœžœ
žœžœ˜HK˜)Kšžœ˜Kšžœ
˜K˜K˜—Kš œžœžœžœžœ
žœ
žœžœ˜SK˜š œžœ7˜LKš
ž˜Kš
œ/˜/K˜Kšœžœ˜K˜K˜Kšœžœ
˜K˜K˜Kšžœžœ
žœ
˜!K˜"Kšžœžœ
žœ
˜Kš
œ-˜-K˜6šžœž˜K˜(K˜pK˜)Kšžœ
˜—Kšžœ
˜K˜—š 
œžœ
žœ"˜9Kš
œ4™4Kš
œ)™)K™Kšžœžœ
žœ
™%K™$šžœž™K™,K™)Kšžœ
™—K˜K˜—š œžœ
žœ
˜!Kš
ž˜Kšœžœ0˜9Kšžœ
˜K˜—š œžœžœ˜3Kš
ž˜K˜#Kš
œS˜SKšžœ
˜K˜—š 	œžœžœ˜6Kš
ž˜K˜#Kš
œV˜VKšžœ
˜K˜—Kšžœ
˜K˜——…—6O