
DIRECTORY
Basics USING [Comparison, CompareCard],
IntCodeDefs USING [ApplyNode, AssignNode, BlockNode, CaseList, CommentNode, CompositeLocation, CondNode, ConstNode, DeclNode, DerefLocation, EnableNode, EscapeLocation, FieldLocation, GotoNode, IndexedLocation, Label, LabelNode, LambdaNode, Location, LocationRep, LogicalId, MesaOper, Node, NodeList, NodeRep, nullVariableFlags, nullVariableId, Offset, Oper, OperNode, OperRep, ReturnNode, SourceNode, Var, VariableFlags, VarList, VarRep],
IntCodeGen USING [CodeGenerator],
IntCodeStuff USING [],
IntCodeTarget USING [bitsPerLink, bitsPerLocal, logMinBitsPerArgument, maxBitsReturnRecord, minBitsPerArgument, ToBits, ToUnits],
IntCodeTwig USING [LambdaModel, OrFlag, OrVarFlags],
IntCodeUtils USING [IdTab, IntToWord, MapNode, NodeListCons, Visitor, zone],
Rope USING [ROPE],
Target: TYPE MachineParms USING [AlignmentIndex, Alignments];
IntCodeStuffImpl: CEDAR PROGRAM
IMPORTS Basics, IntCodeTarget, IntCodeTwig, IntCodeUtils
EXPORTS IntCodeGen, IntCodeStuff
= BEGIN OPEN IntCodeDefs, IntCodeTarget, IntCodeTwig, IntCodeUtils, Rope;

IdTab: TYPE = IntCodeUtils.IdTab;
phoney: Basics.Comparison = Basics.CompareCard[1, 2]; -- This is just to introduce a dependency so that IntCode.config can be the same for both worlds. 

z: ZONE Ź IntCodeUtils.zone;

CantHappen: PUBLIC SIGNAL = CODE;

NotYetImplemented: PUBLIC SIGNAL = CODE;

constInit: BOOL Ź FALSE;

dummyLoc: PUBLIC Location = z.NEW[LocationRep Ź [dummy[]]];

globalLinkInit: PUBLIC Node = GenOperNode[[mesa[globalFrame, 0]], bitsPerLink];
allocOperNode: PUBLIC Node = GenOperNode[[mesa[alloc, 0]]];
freeOperNode: PUBLIC Node = GenOperNode[[mesa[free, 0]]];
addrOperNode: PUBLIC Node = GenOperNode[[mesa[addr, 0]]];
subOperNode: PUBLIC Node = GenOperNode[[arith[class: [address, FALSE, bitsPerLink], select: sub]]];
emptyReturn: PUBLIC Node = z.NEW[NodeRep.return Ź [0, return[NIL]]];
constant0: PUBLIC ConstNode = GenConst[0, bitsPerLocal];
constant1: PUBLIC ConstNode = GenConst[1, bitsPerLocal];
constant2: PUBLIC ConstNode = GenConst[2, bitsPerLocal];
defaultNIL: PUBLIC ConstNode =
IF bitsPerLocal = bitsPerLink THEN constant0 ELSE GenConst[0, bitsPerLink];

worst: NAT = Target.Alignments[Target.AlignmentIndex.LAST];

usedFlags: VariableFlags = OrFlag[used];
assignedFlags: VariableFlags = OrFlag[used, OrFlag[assigned]];
addressedFlags: VariableFlags = OrFlag[addressed, OrFlag[notRegister]];


codeGenProc: IntCodeGen.CodeGenerator Ź NIL;
codeGenData: REF Ź NIL;
RegisterCodeGenerator: PUBLIC PROC [cg: IntCodeGen.CodeGenerator, data: REF] = {
codeGenProc Ź cg;
codeGenData Ź data;
};
GetCodeGenerator: PUBLIC PROC RETURNS [cg: IntCodeGen.CodeGenerator, data: REF] = {
cg Ź codeGenProc;
data Ź codeGenData;
};
BitsForArgList: PUBLIC PROC [args: NodeList] RETURNS [bits: INT Ź 0] = {
FOR each: NodeList Ź args, each.rest WHILE each # NIL DO
arg: Node Ź each.first;
IF arg # NIL THEN {
units: INT Ź ToUnits[arg.bits, minBitsPerArgument, logMinBitsPerArgument];
bits Ź bits + ToBits[units, logMinBitsPerArgument];
};
ENDLOOP;
};

BitsForFormalArgList: PUBLIC PROC [vars: VarList] RETURNS [bits: INT Ź 0] = {
FOR each: VarList Ź vars, each.rest WHILE each # NIL DO
arg: Var Ź each.first;
IF arg # NIL THEN {
units: INT Ź ToUnits[arg.bits, minBitsPerArgument, logMinBitsPerArgument];
bits Ź bits + ToBits[units, logMinBitsPerArgument];
};
ENDLOOP;
};

CopyVar: PUBLIC PROC [old: Var] RETURNS [Var] = {
IF old # NIL THEN
RETURN [z.NEW[VarRep Ź [bits: old.bits, details:
var[flags: old.flags, id: old.id, location: old.location]]]];
RETURN [NIL];
};

GenAddr: PUBLIC PROC [var: Var] RETURNS [Node] = {
node: ApplyNode Ź GenApply[addrOperNode, NodeListCons[var]];
MarkAddressed[var];
RETURN [node];
};

GenAnonVar: PUBLIC PROC [bits: INT, loc: Location Ź NIL] RETURNS [Var] = {
RETURN [z.NEW[VarRep Ź [bits: bits, details:
var[flags: nullVariableFlags, id: nullVariableId, location: loc]]]];
};

GenApply: PUBLIC PROC [proc: Node, args: NodeList, bits: INT Ź -1] RETURNS [ApplyNode] = {
RETURN [z.NEW[NodeRep.apply Ź [
IF bits = -1 THEN bitsPerLink ELSE bits,
apply[proc: proc, args: args]]]];
};

GenAssign: PUBLIC PROC [lhs: Var, rhs: Node, bits: INT Ź 0] RETURNS [AssignNode] = {
IF rhs = NIL OR rhs.bits = 0 OR lhs = NIL OR lhs.bits # rhs.bits THEN
SIGNAL CantHappen;
IF bits # 0 AND bits # lhs.bits THEN SIGNAL CantHappen;
RETURN [z.NEW[NodeRep.assign Ź [bits, assign[lhs: lhs, rhs: rhs]]]];
};

GenBlock: PUBLIC PROC [nodes: NodeList, bits: INT Ź 0] RETURNS [BlockNode] = {
RETURN [z.NEW[NodeRep.block Ź [bits, block[nodes]]]];
};

GenComment: PUBLIC PROC [msg: ROPE] RETURNS [CommentNode] = {
RETURN [z.NEW[NodeRep.comment Ź [0, comment[msg]]]];
};

GenComposite: PUBLIC PROC [nodes: NodeList, bits: INT] RETURNS [Var] = {
IF nodes = NIL THEN RETURN [NIL];
IF nodes.rest = NIL THEN
WITH nodes.first SELECT FROM
var: Var => RETURN [var];
ENDCASE;
RETURN [GenAnonVar[bits, z.NEW[LocationRep.composite Ź [composite[nodes]]]]];
};

GenConst: PUBLIC PROC [int: INT, bits: INT Ź bitsPerLocal] RETURNS [ConstNode] = {
IF constInit AND bits = bitsPerLocal THEN SELECT int FROM
0 => RETURN [constant0];
1 => RETURN [constant1];
2 => RETURN [constant2];
ENDCASE;
RETURN [z.NEW[NodeRep.const.word Ź [bits, const[word[IntCodeUtils.IntToWord[int]]]]]];
};

GenDecl: PUBLIC PROC [var: Var, init: Node] RETURNS [DeclNode] = {
RETURN [z.NEW[NodeRep.decl Ź [0, decl[var: var, init: init]]]];
};

GenDeref: PUBLIC PROC [node: Node, bits: INT, align: NAT] RETURNS [Var] = {
loc: Location Ź z.NEW[LocationRep.deref Ź [deref[node, align]]];
WITH node SELECT FROM
var: Var => var.flags[used] Ź TRUE;
ENDCASE;
RETURN [GenAnonVar[bits, loc]];
};

GenDummy: PUBLIC PROC [bits: INT] RETURNS [Var] = {
RETURN [GenAnonVar[bits, dummyLoc]];
};

GenField: PUBLIC PROC [base: Node, offset: INT, bits: INT] RETURNS [Var] = {
RETURN [GenAnonVar[bits, GenFieldLoc[base, offset]]];
};

GenXField: PUBLIC PROC [base: Node, offset: INT, bits: INT] RETURNS [Var] = { 
RETURN [GenAnonVar[bits, GenXFieldLoc[base, offset]]];
};

GenFieldLoc: PUBLIC PROC [base: Node, offset: INT] RETURNS [Location] = {
WITH base SELECT FROM
var: Var => RETURN [GenFieldLocOfVar[var, offset]];
ENDCASE;
IF base = NIL OR base.bits < offset THEN SIGNAL CantHappen;
RETURN [z.NEW[LocationRep.field Ź [field[base, offset, FALSE]]]];
};

GenXFieldLoc: PUBLIC PROC [base: Node, offset: INT] RETURNS [Location] = { 
WITH base SELECT FROM
var: Var => RETURN [GenXFieldLocOfVar[var, offset]];
ENDCASE;
IF base = NIL OR base.bits < offset THEN SIGNAL CantHappen;
RETURN [z.NEW[LocationRep.field _ [field[base, offset, TRUE]]]];
};

GenFieldLocOfVar: PUBLIC PROC [var: Var, offset: INT] RETURNS [Location] = {
base: Node Ź var;
var.flags[used] Ź TRUE;
WITH var.location SELECT FROM
field: FieldLocation => {
IF field.cross THEN ERROR; -- dont know how to handle LAI
base Ź field.base;
offset Ź offset + field.start;
};
ENDCASE;
RETURN [z.NEW[LocationRep.field Ź [field[base, offset, FALSE]]]];
};

GenXFieldLocOfVar: PUBLIC PROC [var: Var, offset: INT] RETURNS [Location] = { 
base: Node _ var;
var.flags[used] _ TRUE;
WITH var.location SELECT FROM
field: FieldLocation => {
IF ~field.cross THEN ERROR; -- dont know how to handle LAI
base Ź field.base;
offset Ź offset + field.start;
};
ENDCASE;
RETURN [z.NEW[LocationRep.field _ [field[base, offset, TRUE]]]];
};

GenFieldOfDeref: PUBLIC PROC [ptr: Var, offset: Offset, bits: INT] RETURNS [Var] = {
var: Var Ź GenDeref[ptr, offset+bits, worst];
IF offset # 0 THEN var Ź GenAnonVar[bits, GenFieldLocOfVar[var, offset]];
RETURN [var];
};

GenFree: PUBLIC PROC [var: Var] RETURNS [Node] = {
RETURN [GenAssign[var, GenApply[freeOperNode, NodeListCons[var], bitsPerLink]]];
};

GenGoTo: PUBLIC PROC [label: Label] RETURNS [GotoNode] = {
label.jumpedTo Ź label.used Ź TRUE;
RETURN [z.NEW[NodeRep.goto Ź [0, goto[label, FALSE]]]];
};

GenLabelAddress: PUBLIC PROC [label: Label, direct: BOOL] RETURNS [Node] = {
oper: Oper Ź z.NEW[OperRep.code Ź [code[label: label, offset: 0, direct: direct]]];
operNode: Node Ź z.NEW[NodeRep.oper Ź [bits: bitsPerLink, details: oper[oper: oper]]];
RETURN [operNode];
};

GenLargeReturn: PUBLIC PROC [rets: NodeList, rtnVar: Var] RETURNS [Node] = {
head: NodeList Ź NIL;
tail: NodeList Ź NIL;
offset: INT Ź 0;
FOR each: NodeList Ź rets, each.rest WHILE each # NIL DO
this: Node Ź each.first;
tBits: INT Ź this.bits;
new: NodeList Ź NodeListCons[GenAssign[GenField[rtnVar, offset, tBits], this]];
IF this.bits MOD bitsPerLocal # 0 THEN ERROR;
IF tail = NIL THEN head Ź new ELSE tail.rest Ź new;
tail Ź new;
offset Ź offset + tBits;
ENDLOOP;
IF head = NIL THEN RETURN [emptyReturn];
tail.rest Ź NodeListCons[emptyReturn];
RETURN [GenBlock[head]];
};

GenOperNode: PUBLIC PROC [operRep: OperRep, bits: INT Ź 0] RETURNS [OperNode] = {
RETURN [z.NEW[NodeRep.oper Ź [bits, oper[z.NEW[OperRep Ź operRep]]]]];
};

GenReturn: PUBLIC PROC [rets: NodeList Ź NIL] RETURNS [Node] = {
RETURN [z.NEW[NodeRep.return Ź [bits: 0, details: return [rets]]]];
};

GenUpLevel: PUBLIC PROC [link: Var, reg: Var, format: LogicalId Ź 0] RETURNS [Var] = {
loc: Location Ź z.NEW[LocationRep.upLevel Ź [upLevel[link, reg, format]]];
reg.flags[used] Ź TRUE;
RETURN [GenAnonVar[reg.bits, loc]];
};

HasLongReturnVar: PUBLIC PROC [model: LambdaModel, bits: INT] RETURNS [BOOL] = {
IF model.forceLong OR bits > maxBitsReturnRecord THEN {
rtnVar: Var Ź model.returnVar;
IF bits = 0 THEN bits Ź bitsPerLink;
IF rtnVar = NIL THEN {
rtnPtr: Var Ź GenAnonVar[bitsPerLink];
rtnVar Ź GenDeref[rtnPtr, bits, worst];
model.returnVar Ź rtnVar;
};
IF rtnVar.bits # bits THEN SIGNAL CantHappen;
RETURN [TRUE];
};
RETURN [FALSE];
};

IsError: PUBLIC PROC [node: Node] RETURNS [BOOL] = {
WITH node SELECT FROM
apply: ApplyNode => IF apply.handler = NIL THEN
WITH apply.proc SELECT FROM
oper: OperNode =>
WITH oper.oper SELECT FROM
mesa: MesaOper => IF mesa.mesa = error THEN RETURN [TRUE];
ENDCASE;
ENDCASE;
ENDCASE;
RETURN [FALSE];
};

IsLive: PUBLIC PROC [node: Node, initialLive: BOOL Ź TRUE] RETURNS [BOOL] = {
innerArgs: PROC [list: NodeList] = {
oldLive: BOOL Ź live;
newLive: BOOL Ź live;
FOR each: NodeList Ź list, each.rest WHILE each # NIL DO
live Ź oldLive;
[] Ź inner[each.first];
newLive Ź newLive AND live;
ENDLOOP;
live Ź newLive;
};
inner: IntCodeUtils.Visitor = {
n: Node Ź node;
list: NodeList Ź NIL;
DO
WITH n SELECT FROM
var: Var => {
WITH var.location SELECT FROM
field: FieldLocation => {n Ź field.base; LOOP};
deref: DerefLocation => {n Ź deref.addr; LOOP};
escape: EscapeLocation => {n Ź escape.base; LOOP};
indexed: IndexedLocation => {
oldLive: BOOL Ź live;
newLive: BOOL Ź oldLive;
[] Ź inner[indexed.base];
newLive Ź live;
live Ź oldLive;
[] Ź inner[indexed.index];
live Ź newLive AND live;
};
comp: CompositeLocation => innerArgs[comp.parts];
ENDCASE;
};
labelNode: LabelNode => {
label: Label = labelNode.label;
IF label.used THEN live Ź TRUE;
n Ź label.node;
LOOP;
};
lambda: LambdaNode => {list Ź lambda.body; EXIT};
block: BlockNode => {list Ź block.nodes; EXIT};
source: SourceNode => {list Ź source.nodes; EXIT};
enable: EnableNode => {list Ź enable.scope; EXIT};
rtn: ReturnNode => {innerArgs[rtn.rets]; live Ź FALSE};
goto: GotoNode => live Ź FALSE;
cond: CondNode => {
oldLive: BOOL Ź live;
newLive: BOOL Ź FALSE;
nCases: INT Ź 0;
lastTestList: NodeList Ź NIL;
lastBody: Node Ź NIL;
nextTestLive: BOOL Ź oldLive;
FOR each: CaseList Ź cond.cases, each.rest WHILE each # NIL DO
live Ź nextTestLive;
lastTestList Ź each.tests;
FOR tests: NodeList Ź lastTestList, tests.rest WHILE tests # NIL DO
[] Ź inner[tests.first];
nextTestLive Ź nextTestLive OR live;
ENDLOOP;
[] Ź inner[lastBody Ź each.body];
newLive Ź live OR newLive;
nCases Ź nCases + 1;
ENDLOOP;
SELECT TRUE FROM
lastTestList # NIL => newLive Ź newLive OR nextTestLive;
ENDCASE;
live Ź newLive;
};
apply: ApplyNode => {
oldLive: BOOL Ź live;
newLive: BOOL Ź oldLive;
[] Ź inner[apply.proc];
newLive Ź live;
live Ź oldLive;
innerArgs[apply.args];
live Ź live AND newLive;
IF IsError[apply] THEN live Ź FALSE;
};
ENDCASE => IF n # NIL THEN IntCodeUtils.MapNode[n, inner];
EXIT;
ENDLOOP;
WHILE list # NIL DO [] Ź inner[list.first]; list Ź list.rest; ENDLOOP;
RETURN [node];
};
live: BOOL Ź initialLive;
[] Ź inner[node];
RETURN [live];
};

MarkAddressed: PUBLIC PROC [node: Node] = {
DO
WITH node SELECT FROM
var: Var => IF NOT var.flags[addressed] THEN {
OrVarFlags[var, addressedFlags];
WITH var.location SELECT FROM
indexed: REF LocationRep.indexed => {node Ź indexed.base; LOOP};
field: REF LocationRep.field => {node Ź field.base; LOOP};
ENDCASE;
};
ENDCASE;
RETURN;
ENDLOOP;
};

MarkAssigned: PUBLIC PROC [node: Node] = {
DO
WITH node SELECT FROM
var: Var => IF NOT var.flags[assigned] THEN {
var.flags[assigned] Ź TRUE;
WITH var.location SELECT FROM
indexed: REF LocationRep.indexed => {node Ź indexed.base; LOOP};
field: REF LocationRep.field => {node Ź field.base; LOOP};
composite: REF LocationRep.composite =>
FOR each: NodeList Ź composite.parts, each.rest WHILE each # NIL DO
MarkAssigned[each.first];
ENDLOOP;
ENDCASE;
};
ENDCASE;
RETURN;
ENDLOOP;
};

MarkUsed: PUBLIC PROC [node: Node] = {
DO
WITH node SELECT FROM
var: Var => IF NOT var.flags[used] THEN {
var.flags[used] Ź TRUE;
WITH var.location SELECT FROM
indexed: REF LocationRep.indexed => {
MarkUsed[indexed.base];
node Ź indexed.index;
LOOP;
};
deref: REF LocationRep.deref => {node Ź deref.addr; LOOP};
field: REF LocationRep.field => {node Ź field.base; LOOP};
composite: REF LocationRep.composite =>
FOR each: NodeList Ź composite.parts, each.rest WHILE each # NIL DO
MarkUsed[each.first];
ENDLOOP;
ENDCASE;
};
ENDCASE;
RETURN;
ENDLOOP;
};

NodeContains: PUBLIC PROC [node: Node, object: Node] RETURNS [BOOL] = {
inner: IntCodeUtils.Visitor = {
SELECT TRUE FROM
node = object => found Ź TRUE;
NOT found => IntCodeUtils.MapNode[node, inner];
ENDCASE;
RETURN [node];
};
found: BOOL Ź object = node;
IF NOT found THEN [] Ź inner[node];
RETURN [found];
};

NodeListCons2: PUBLIC PROC [node1, node2: Node] RETURNS [NodeList] = {
RETURN [NodeListCons[node1, NodeListCons[node2]]];
};

NodeListCons3: PUBLIC PROC [node1, node2, node3: Node] RETURNS [NodeList] = {
RETURN [NodeListCons[node1, NodeListCons[node2, NodeListCons[node3]]]];
};

NodeListCons4: PUBLIC PROC [node1, node2, node3, node4: Node] RETURNS [NodeList] = {
RETURN [NodeListCons[node1, NodeListCons[node2,
NodeListCons[node3, NodeListCons[node4]]]]];
};

NodeListCons5: PUBLIC PROC [node1, node2, node3, node4, node5: Node]
RETURNS [NodeList] = {
RETURN [NodeListCons[node1, NodeListCons[node2,
NodeListCons[node3, NodeListCons[node4, NodeListCons[node5]]]]]];
};

PadComposite: PUBLIC PROC [argsRets: NodeList, logMinBits: NAT] RETURNS [Node] = {
newList: NodeList Ź NIL;
tail: NodeList Ź NIL;
totalBits: INT Ź 0;
minBits: INT Ź ToBits[1, logMinBits];
FOR each: NodeList Ź argsRets, each.rest WHILE each # NIL DO
argsRet: Node Ź each.first;
IF argsRet # NIL THEN {
bits: INT Ź argsRet.bits;
units: INT Ź ToUnits[bits, minBits, logMinBits];
round: INT Ź ToBits[units, logMinBits];
new: NodeList Ź NodeListCons[argsRet];
IF bits # round THEN {
pad: NodeList Ź NodeListCons[GenDummy[round-bits]];
IF tail = NIL THEN newList Ź pad ELSE tail.rest Ź pad;
tail Ź pad;
};
IF tail = NIL THEN newList Ź new ELSE tail.rest Ź new;
tail Ź new;
totalBits Ź totalBits + round;
};
ENDLOOP;
SELECT TRUE FROM
newList = NIL => RETURN [NIL];
newList.rest = NIL => RETURN [newList.first];
ENDCASE => {
comp: Var Ź GenComposite[newList, totalBits];
comp.flags[used] Ź TRUE;
RETURN [comp];
};
};

StripNilCheck: PUBLIC PROC [node: Node] RETURNS [Node] = {
WITH node SELECT FROM
apply: ApplyNode => IF apply.handler = NIL THEN
WITH apply.proc SELECT FROM
oper: OperNode =>
WITH oper.oper SELECT FROM
mesa: MesaOper => IF mesa.mesa = nilck THEN RETURN [apply.args.first];
ENDCASE;
ENDCASE;
ENDCASE;
RETURN [node];
};

constInit Ź TRUE;

END.


     
IntCodeStuffImpl.mesa
Copyright Ó 1986, 1987, 1988, 1991, 1993 by Xerox Corporation.  All rights reserved.
Russ Atkinson (RRA) June 30, 1989 2:50:01 pm PDT
JKF July 27, 1988 12:47:53 pm PDT
Christian Jacobi, May 4, 1993 8:33 pm PDT
The global zone
Signals & Errors
Signalled when something is simply not possible (according to our intentions, at least)
Signalled when something is not yet supported.
Constant pieces
Constant locations
Constant nodes
Local stuff
Constant flags
IntCodeGen routines

Registers the given code generator for callback when the front end has something to generate code for.  cg = NIL removes the registration.  New registrations simply overwrite the old.

Returns the current registration.

Little Utilities
--Little endian only. ChJ, May 4, 1993
--Little endian only. ChJ, May 4, 1993
LS? LAI
--ChJ, May 4, 1993
--ChJ, May 4, 1993
Must only be used for fields based on worst-case (largest) alignment
A large return record
Time to have a new large variable
Determines whether control flow might exit the node, given that the node has an initial reachability given by initialLive.  If NOT initialLive, then the exit liveness is determined by the existence of labels in the node that might be reached from outside of the node.  This routine assumes that the used flag on labels has been properly initialized.
Since the args can be evaluated in any order, the initial value of live is always oldLive.  However, since all of the arguments must be evaluated, we take liveness to be the AND of all the livenesses.  The handler does not affect the liveness.
[node: IntCodeDefs.Node] RETURNS [IntCodeDefs.Node]
Special handling for variables (both because they are common and because they are a lot like application).
The liveness of a cond is the OR of all the livenesses of the arms.
Evaluate the tests sequentially
There is an implicit ENDCASE or ELSE preserving liveness
Returns TRUE iff the given object is found as a component (at any depth) of the given node.
[node: IntCodeDefs.Node] RETURNS [IntCodeDefs.Node]
We need some padding inserted
 Ę  NewlineDelimiter
(cedarcode) style headIcode
ĎeITL0L!L) Ďk		L'LŚˇL!LLnL#4L:LLL=L18L L=IL L!L6ĎcbL LL head22.5 in tabStops!LWWL (L..L 2.5 in tabStopsL L
;L L9OL&;L%9L%9L,cL
DL'8L'8L'8L	jL L2.5 in tabStops+;L L((L>>GGL L L(,L Ďn&PLmGˇLLLL 
 &SL!!LLLL  	H"8LL@JL33LLLL  	M!7LL@JL33LLLL  
1LanLLL  2L<<LLLL 
 

J,LDDLL  $ZL
(jLL  	TELL
7L7DLL  NL(5LL  
=L'4LL  
HL
	!LLL/MLL 
 R	9LLLLLIVLL  BL2?LL 
 	
KL+@L#LLLL  
3L$LL 
 
LL/5LL  	NL&L06LL 
 IL!3LL
;L*ALL 
 KL&LL"4LL
;L*Đbk@LL  LLLLL9LLLLL*ALL 
 NLLLL:LLLLL*Ą@LL  "
TLDL--L7ILLL  2LJPLL  :L#L 7LL  LLASL@VLLL  LLLL"8LLLOOL-L3LLLL(L&&LLL  QLFLL  	@L6CLL  
.
VL5JLL#LL 
 P7LLL
$
L!!L&&L''LLL-LLLLL  4/L	:LLLLLL  MLÝÝ$LŽBóL	L	"8LLLLLLL3LLLjL)/L)/L,2L	L	LLLLLLL11LLLLLLLL+1L)/L,2L,2L07LL#CL	L	LLLL(>LL,	CLLL$LL!!L	LL8L8LLLL	L	LLLLL	L$LL :LLL+FLLLLLLL  +.L  L	.@L*:LLLLLLL  *-LL	-@L*:'-CLLLLLLLLL  &)L	%LLLLL*:L*:'-CLLLLLLLLL  GLO[L3LL,/LLLLL#L	LL  FL,2LL  MLAGLL  $TLV\LL  +[LkqLL  "RLLLL	%&<LLL&0L'L&&LL33L6LLL6LLLLL
L-L--LLLLL  :/LFLLLLLL L LL L L      =Ř  [˙  