DIRECTORY
Alloc: TYPE USING [Notifier],
ComData: TYPE USING [
interface, typeCARDINAL, typeINT, typeStringBody, zone],
LiteralOps: TYPE USING [FindDescriptor],
Log: TYPE USING [Error, ErrorTree, WarningTree],
P4: TYPE USING [
Attr, voidAttr, Prop, Repr, none, unsigned, both, other, RegCount, maxRegs,
WordSeq, ValueDescriptor,
BiasForType, BitsForType, CatchNest, CommonAttr, CommonProp, Exp,
FillMultiWord, ForceType, LiteralAttr, MakeArgRecord, MakeStructuredLiteral,
MakeTreeLiteral, OperandType, RegsForType, RelTest, RepForType,
Rhs, RValue, StructuredLiteral, TreeLiteral, TreeLiteralValue, TypeExp,
TypeForTree, VAttr, VPop, VProp, VPush, VRegs, VRep, WordsForType],
Symbols: TYPE USING [
Base, BitAddress, BitCount, ByteLength, WordLength,
ISEIndex, CSEIndex, ISENull, codeCHAR, codeINT, lZ,
ctxType, seType],
SymbolOps: TYPE USING [
ArgRecord, BitsPerElement, Cardinality, FirstCtxSe, NormalType, NextSe,
PackedSize, VariantField, UnderType],
SymLiteralOps: TYPE USING [TypeRef],
Tree: TYPE USING [Base, Index, Link, NodeName, Null, treeType],
TreeOps: TYPE USING [
FreeNode, FreeTree, GetNode, IdentityMap, MakeNode, OpName, PopTree,
PushLit, PushNode, PushSe, PushTree, SetAttr, SetInfo];

Pass4Xc: PROGRAM
IMPORTS
Log, LiteralOps, P4, SymbolOps, SymLiteralOps, TreeOps,
dataPtr: ComData
EXPORTS P4 = {
OPEN SymbolOps, TreeOps, P4;

CSEIndex: TYPE = Symbols.CSEIndex;
WordLength: CARDINAL = Symbols.WordLength;

tb: Tree.Base;	-- tree base address (local copy)
seb: Symbols.Base;	-- se table base address (local copy)
ctxb: Symbols.Base;	-- context table base address (local copy)

ExpCNotify: PUBLIC Alloc.Notifier = {
tb _ base[Tree.treeType];
seb _ base[Symbols.seType];  ctxb _ base[Symbols.ctxType]};



NormalizeRange: PUBLIC PROC [t: Tree.Link] RETURNS [val: Tree.Link] = {
next: Tree.Link;
FOR val _ t, next DO
WITH val SELECT FROM
symbol => {
lBound: INTEGER = BiasForType[UnderType[index]];
THROUGH [1..2] DO
PushTree[MakeTreeLiteral[ABS[lBound]]];
IF lBound < 0 THEN PushNode[uminus, 1];
ENDLOOP;
PushTree[MakeTreeLiteral[Cardinality[index] - 1]];
PushNode[plus, 2];  SetInfo[dataPtr.typeINT];
next _ MakeNode[intCC, 2]};
subtree => {
node: Tree.Index = index;
SELECT tb[node].name FROM
subrangeTC, cdot => {
next _ tb[node].son[2]; tb[node].son[2] _ Tree.Null; FreeNode[node]};
IN [intOO .. intCC] => EXIT;
ENDCASE => ERROR};
ENDCASE => ERROR;
ENDLOOP;
RETURN};

Interval: PUBLIC PROC [node: Tree.Index, bias: INTEGER, target: Repr]
RETURNS [const: BOOL] = {
OPEN tb[node];
attr: Attr;
nRegs: RegCount;
son[1] _ RValue[son[1], bias, target];
attr _ VAttr[]; nRegs _ VRegs[];
son[2] _ RValue[son[2], bias, target];
nRegs _ MAX[VRegs[], nRegs];  attr _ CommonAttr[attr, VAttr[]];
VPop[];  VPop[];  VPush[bias, attr, nRegs];
const _ StructuredLiteral[son[1]] AND StructuredLiteral[son[2]] AND ~attr1;
RETURN};

EmptyInterval: PUBLIC SIGNAL = CODE;

ConstantInterval: PUBLIC PROC [node: Tree.Index] RETURNS [origin, range: INTEGER] = {
OPEN tb[node];
uBound: INTEGER;
rep: Repr _ VRep[];
empty: BOOL _ FALSE;
origin _ TreeLiteralValue[son[1]];  uBound _ TreeLiteralValue[son[2]];
SELECT name FROM
intOO, intOC => {
IF RelTest[son[1], son[2], relGE, rep] THEN empty _ TRUE;
origin _ origin + 1;
son[1] _ FreeTree[son[1]];
name _ IF name = intOO THEN intCO ELSE intCC;
son[1] _ MakeTreeLiteral[origin]};
ENDCASE;
SELECT name FROM
intCC => IF RelTest[son[1], son[2], relG, rep] THEN empty _ TRUE;
intCO => {
IF RelTest[son[1], son[2], relGE, rep] THEN empty _ TRUE;
uBound _ uBound - 1;
son[2] _ FreeTree[son[2]];
name _ intCC;  son[2] _ MakeTreeLiteral[uBound]};
ENDCASE => ERROR;
IF ~empty THEN range _ uBound - origin ELSE {SIGNAL EmptyInterval; range _ 0};
RETURN};





TypeOp: PUBLIC PROC [node: Tree.Index] RETURNS [val: Tree.Link] = {
SELECT tb[node].name FROM

size => val _ Size[node];
first, last => val _ EndPoint[node];
typecode => val _ TypeCode[node];
ENDCASE => {
Log.Error[unimplemented]; VPush[0, voidAttr, 0]; val _ [subtree[node]]};

RETURN};


Size: PROC [node: Tree.Index] RETURNS [val: Tree.Link] = {
type: CSEIndex;

ApplyLit: PROC [op: Tree.NodeName, val: WORD] = {
PushTree[MakeTreeLiteral[val]];  PushNode[op, 2];
SetInfo[dataPtr.typeINT];  SetAttr[1, FALSE];  SetAttr[2, FALSE]};

IF OpName[tb[node].son[1]] = apply THEN {
subNode: Tree.Index = GetNode[tb[node].son[1]];
sei: Symbols.ISEIndex;
bitsPerItem: Symbols.BitCount;
TypeExp[tb[subNode].son[1]];  type _ UnderType[TypeForTree[tb[subNode].son[1]]];
SELECT TRUE FROM
(type = dataPtr.typeStringBody) => bitsPerItem _ Symbols.ByteLength;
((sei _ VariantField[type]) # Symbols.ISENull) => {
subType: CSEIndex = UnderType[seb[sei].idType];
bitsPerItem _ WITH t: seb[subType] SELECT FROM
sequence => BitsPerElement[t.componentType, t.packed],
ENDCASE => ERROR};
ENDCASE => ERROR;
PushTree[tb[subNode].son[2]];  tb[subNode].son[2] _ Tree.Null;
IF bitsPerItem < WordLength THEN {
itemsPerWord: CARDINAL = WordLength/CARDINAL[bitsPerItem];
ApplyLit[plus, itemsPerWord-1];  ApplyLit[div, itemsPerWord]}
ELSE ApplyLit[times, bitsPerItem/WordLength];
ApplyLit[plus, P4.WordsForType[type]];
IF tb[node].son[2] # Tree.Null THEN {
PushTree[tb[node].son[2]];  tb[node].son[2] _ Tree.Null;
PushNode[times, 2]; 
SetInfo[dataPtr.typeINT];  SetAttr[1, FALSE];  SetAttr[2, FALSE]}}
ELSE {
TypeExp[tb[node].son[1]];  type _ UnderType[TypeForTree[tb[node].son[1]]];
IF tb[node].son[2] = Tree.Null THEN PushTree[MakeTreeLiteral[P4.WordsForType[type]]]
ELSE {
nBits: CARDINAL = P4.BitsForType[type];
PushTree[tb[node].son[2]];  tb[node].son[2] _ Tree.Null;
IF nBits <= Symbols.ByteLength THEN {
n: CARDINAL = WordLength/PackedSize[nBits];
ApplyLit[plus, n-1];  ApplyLit[div, n]}
ELSE  ApplyLit[times, P4.WordsForType[type]]}};
val _ Rhs[PopTree[], dataPtr.typeCARDINAL];  FreeNode[node]};

EndPoint: PROC [node: Tree.Index] RETURNS [val: Tree.Link] = {
OPEN tb[node];
type, next: CSEIndex;
first: BOOL = (name=first);
MaxInteger: WORD = INTEGER.LAST;
MaxWord: WORD = CARDINAL.LAST;
v: WORD;
vv: ARRAY [0..2) OF WORD;
TypeExp[son[1]];
FOR type _ UnderType[TypeForTree[son[1]]], next DO
WITH seb[type] SELECT FROM
basic => {
v _ SELECT code FROM
Symbols.codeINT => IF first THEN MaxInteger+1 ELSE MaxInteger,
Symbols.codeCHAR => IF first THEN 0 ELSE CARDINAL[Cardinality[type]-1],
ENDCASE => IF first THEN 0 ELSE MaxWord;
GO TO short};
enumerated => {
v _ IF first THEN 0 ELSE CARDINAL[Cardinality[type]-1]; GO TO short};
relative => next _ UnderType[offsetType];
subrange => {v _ IF first THEN origin ELSE origin+range; GO TO short};
long => {
vv _ IF UnderType[rangeType] = dataPtr.typeINT
THEN IF first THEN [0, MaxInteger+1] ELSE [MaxWord, MaxInteger]
ELSE IF first THEN [0, 0] ELSE [MaxWord, MaxWord];
GO TO long};
ENDCASE => ERROR;
REPEAT
short => val _ MakeTreeLiteral[v];
long => {
PushLit[LiteralOps.FindDescriptor[DESCRIPTOR[vv]]];
PushNode[mwconst, 1];  SetInfo[type];  val _ PopTree[]};
ENDLOOP;
FreeNode[node];
VPush[0, LiteralAttr[RepForType[type]], RegsForType[type]]; RETURN};

TypeCode: PROC [node: Tree.Index] RETURNS [val: Tree.Link] = {
TypeExp[tb[node].son[1]];
IF dataPtr.interface THEN val _ [subtree[index: node]]
ELSE {
val _ SymLiteralOps.TypeRef[TypeForTree[tb[node].son[1]], FALSE];
FreeNode[node]};
VPush[0, LiteralAttr[both], 1];  RETURN};



MiscXfer: PUBLIC PROC [node: Tree.Index] RETURNS [Tree.Link] = {
type: CSEIndex;
attr: Attr;
SELECT tb[node].name FROM

create => {
tb[node].son[1] _ RValue[tb[node].son[1], 0, none];
attr _ [prop: VProp[], rep: unsigned];  VPop[]};

fork => {
OPEN tb[node];
son[1] _ Exp[son[1], none];
attr.prop _ VProp[]; VPop[];  type _ OperandType[son[1]];
WITH t: seb[type] SELECT FROM
transfer => {
son[2] _ MakeArgRecord[ArgRecord[t.typeIn], son[2]];
attr.prop _ CommonProp[attr.prop, VProp[]]; attr.rep _ other;  VPop[]};
ENDCASE => ERROR};

ENDCASE => {Log.Error[unimplemented]; attr _ voidAttr};

attr.prop.noXfer _ attr.prop.noFreeVar _ FALSE;  VPush[0, attr, maxRegs];
IF tb[node].nSons > 2 THEN CatchNest[tb[node].son[3]];
RETURN [[subtree[index: node]]]};



Nil: PUBLIC PROC [node: Tree.Index] RETURNS [Tree.Link] = {
type: CSEIndex = tb[node].info;
n: CARDINAL;
words: ValueDescriptor;
IF tb[node].son[1] # Tree.Null THEN TypeExp[tb[node].son[1]];
n _ P4.WordsForType[type];
words _ (dataPtr.zone).NEW[WordSeq[n]];
FOR i: CARDINAL IN [0..n) DO words[i] _ 0 ENDLOOP;
PushLit[LiteralOps.FindDescriptor[DESCRIPTOR[words]]];
IF n > 1 THEN {PushNode[mwconst, 1]; SetInfo[type]};
FreeNode[node];  (dataPtr.zone).FREE[@words];
VPush[BiasForType[type], LiteralAttr[RepForType[type]], RegsForType[type]];
RETURN [ForceType[PopTree[], type]]};



AddrOp: PUBLIC PROC [node: Tree.Index] RETURNS [val: Tree.Link] = {
attr: Attr;
nRegs: RegCount;
SELECT tb[node].name FROM

addr => val _ Addr[node];

base => {
tb[node].son[1] _ Exp[tb[node].son[1], none];
nRegs _ VRegs[]; attr _ [prop: VProp[], rep: unsigned];  VPop[];
VPush[0, attr, nRegs];  val _ [subtree[index: node]]};

length => {
type: CSEIndex;
tb[node].son[1] _ Exp[tb[node].son[1], none];
type _ OperandType[tb[node].son[1]];
WITH seb[type] SELECT FROM
array => {
val _ MakeTreeLiteral[Cardinality[indexType]];
FreeNode[node];  attr _ LiteralAttr[both];  nRegs _ 1};
ENDCASE => {
val _ [subtree[index: node]]; attr _ [prop: VProp[], rep: both]; nRegs _ VRegs[]};
VPop[];  VPush[0, attr, nRegs]};

arraydesc =>
val _ IF OpName[tb[node].son[1]] # list THEN Desc[node] ELSE DescList[node];

ENDCASE => {
Log.Error[unimplemented]; VPush[0, voidAttr, 0]; val _ [subtree[node]]};

RETURN};


Addr: PROC [node: Tree.Index] RETURNS [val: Tree.Link] = {
OPEN tb[node];
v: Tree.Link;
subNode: Tree.Index;
type, next: CSEIndex;
prop: Prop;
nRegs: RegCount;
son[1] _ Exp[son[1], none];
nRegs _ MAX[VRegs[], RegsForType[info]];  prop _ VProp[];
FOR t: Tree.Link _ son[1], v DO
WITH t SELECT FROM
symbol => {
sei: Symbols.ISEIndex = index;
IF ctxb[seb[sei].idCtx].level = Symbols.lZ AND
(LOOPHOLE[seb[sei].idValue, Symbols.BitAddress].bd # 0 OR
LOOPHOLE[seb[sei].idInfo, CARDINAL] MOD WordLength # 0) THEN GO TO fail;
GO TO pass};
subtree => {
subNode _ index;
SELECT tb[subNode].name FROM
dot, dollar =>  v _ tb[subNode].son[2];
index, dindex, seqindex =>
FOR  type _ NormalType[OperandType[tb[subNode].son[1]]], next DO
WITH t: seb[type] SELECT FROM
array => IF t.packed THEN GO TO fail ELSE GO TO pass;
sequence => IF t.packed THEN GO TO fail ELSE GO TO pass;
arraydesc => next _ UnderType[t.describedType];
ENDCASE => ERROR;
ENDLOOP;
apply => GO TO fail;
uparrow, reloc => GO TO pass;
cast, chop => v _ tb[subNode].son[1];
ENDCASE => ERROR};
ENDCASE => ERROR;
REPEAT
pass => NULL;
fail => Log.ErrorTree[nonAddressable, son[1]]; 
ENDLOOP;
val _ [subtree[index: node]];
IF OpName[son[1]] = dot THEN {
subNode _ GetNode[son[1]];
IF TreeLiteral[tb[subNode].son[1]] THEN {
val _ MakeStructuredLiteral[
TreeLiteralValue[tb[subNode].son[1]] + LOOPHOLE[
seb[NARROW[tb[subNode].son[2], Tree.Link.symbol].index].idValue,
Symbols.BitAddress].wd,
info];
FreeNode[node]}};
VPop[];
VPush[0, [prop: prop, rep: unsigned], nRegs];  RETURN};


Desc: PROC [node: Tree.Index] RETURNS [Tree.Link] = {
subNode: Tree.Index = GetNode[tb[node].son[1]];
long: BOOL = tb[subNode].attr2;
prop: Prop;
nRegs: RegCount;
subType: CSEIndex;
tb[subNode].son[1] _ Exp[tb[subNode].son[1], none];
nRegs _ VRegs[];  prop _ VProp[];  VPop[];
subType _ OperandType[tb[subNode].son[1]];
WITH t: seb[subType] SELECT FROM
array => {
n: CARDINAL = Cardinality[t.indexType];
IF n = 0 THEN Log.WarningTree[sizeClash, tb[subNode].son[1]];
IF t.packed AND (BitsForType[subType] MOD WordLength # 0) THEN
Log.ErrorTree[nonAddressable, tb[subNode].son[1]];
PushTree[[subtree[subNode]]];  PushTree[MakeTreeLiteral[n]]};
sequence => {
copy: Tree.Link = IdentityMap[tb[subNode].son[1]];
cNode: Tree.Index = NARROW[copy, Tree.Link.subtree].index;
PushTree[tb[subNode].son[1]];  PushTree[MakeTreeLiteral[0]];
PushNode[seqindex, 2];  SetInfo[UnderType[t.componentType]];
SetAttr[2, long];  SetAttr[3, FALSE];
tb[subNode].son[1] _ PopTree[];  PushTree[[subtree[subNode]]];
tb[cNode].son[2] _ FreeTree[tb[cNode].son[2]];
tb[cNode].son[2] _ [symbol[index: t.tagSei]];
tb[cNode].info _ dataPtr.typeCARDINAL;
PushTree[copy]};
record => {  -- StringBody only (compatibility glitch)
copy: Tree.Link = IdentityMap[tb[subNode].son[1]];
sei: Symbols.ISEIndex = NextSe[NextSe[FirstCtxSe[t.fieldCtx]]];
PushTree[tb[subNode].son[1]];  PushSe[sei];  PushNode[dollar, 2];
SetInfo[UnderType[seb[sei].idType]];  SetAttr[2, long];
tb[subNode].son[1] _ PopTree[];  PushTree[[subtree[subNode]]];
PushTree[copy];  PushSe[NextSe[FirstCtxSe[t.fieldCtx]]];  PushNode[dollar, 2];
SetInfo[dataPtr.typeCARDINAL]; SetAttr[2, long]};
ENDCASE => {
Log.ErrorTree[typeClash, tb[subNode].son[1]];
PushTree[[subtree[subNode]]];  PushTree[Tree.Null]};
PushTree[Tree.Null];  PushNode[list, 3];  tb[node].son[1] _ PopTree[];
VPush[0, [prop: prop, rep: other], MAX[RegsForType[tb[node].info], nRegs]];
RETURN [[subtree[index: node]]]};

DescList: PROC [node: Tree.Index] RETURNS [val: Tree.Link] = {
subNode: Tree.Index = GetNode[tb[node].son[1]];
type: CSEIndex = tb[node].info;
subType: CSEIndex;
prop: Prop;
nRegs: RegCount;
tb[subNode].son[1] _ RValue[tb[subNode].son[1], 0, unsigned];
nRegs _ VRegs[];  prop _ VProp[];  subType _ OperandType[tb[subNode].son[1]];
WITH seb[subType] SELECT FROM
ref =>
IF BitsForType[refType] MOD WordLength # 0 THEN
Log.ErrorTree[nonAddressable, tb[subNode].son[1]];
ENDCASE;
tb[subNode].son[2] _ RValue[tb[subNode].son[2], 0, none];
nRegs _ MAX[VRegs[], nRegs];  prop _ CommonProp[VProp[], prop];
IF tb[subNode].son[3] # Tree.Null THEN TypeExp[tb[subNode].son[3]];
VPop[]; VPop[];
IF StructuredLiteral[tb[subNode].son[1]] AND TreeLiteral[tb[subNode].son[2]] THEN {
n: CARDINAL = WordsForType[type];
words: ValueDescriptor _ (dataPtr.zone).NEW[WordSeq[n]];
FillMultiWord[words, 0, tb[subNode].son[1]];
words[n-1] _ TreeLiteralValue[tb[subNode].son[2]];
PushLit[LiteralOps.FindDescriptor[DESCRIPTOR[words]]];
PushNode[mwconst, 1];  SetInfo[type];
(dataPtr.zone).FREE[@words];
val _ PopTree[];  FreeNode[node]}
ELSE val _ [subtree[index: node]];
VPush[0, [prop: prop, rep: other], MAX[RegsForType[type], nRegs]];  RETURN};

}.


$file Pass4Xc.mesa
last written by Satterthwaite, June 3, 1983 9:53 am
Last Edited by: Maxwell, July 28, 1983 12:34 pm
called by allocator whenever table area is repacked
interval utilities
type utilities (move?)
operators on types
misc transfer operators
NIL
misc addressing operators
�Ê
V˜Jš
œ™Jš
œ3™3Jš
œ/™/J˜š
Ïk	˜	Jšœ�œ
�œ˜šœ	�œ
�œ˜J˜8—Jšœ�œ
�œ˜(Jšœ�œ
�œ!˜0šœ�œ
�œ˜J˜KJ˜J˜AJ˜LJ˜?J˜GJ˜C—šœ	�œ
�œ˜J˜3J˜3J˜—šœ�œ
�œ˜J˜GJ˜%—Jšœ�œ
�œ˜$Jšœ�œ
�œ/˜?šœ	�œ
�œ˜J˜DJ˜7J˜——šœ	�˜š
�˜J˜7J˜—Jš�œ˜Jš�œ˜J˜Jšœ
�œ˜"Jšœ�œ˜*J˜JšœÏc!˜0Jšœž%˜8Jšœž*˜>J˜šœ�œ˜%Jš
œ3™3J˜J˜;J˜J˜—Jš
œ™˜šÏnœ�œ
�œ�œ˜GJ˜š�œ�˜š�œ�œ
�˜˜Jšœ�œ!˜0š�œ�˜Jšœ�œ˜'Jš�œ�œ˜'Jš�œ
˜—J˜2J˜-J˜—˜J˜š�œ�˜˜J˜E—Jš�œ�œ
˜Jš�œ�œ˜——Jš�œ�œ
˜—Jš�œ
˜—Jš�œ˜J˜—šŸœ�œ
�œ�œ˜EJš�œ	�œ˜Jš�œ
˜J˜J˜J˜&J˜ J˜&Jšœ�œ4˜?J˜+Jšœ"�œ�œ˜KJš�œ˜J˜—Jšœ�œ
�œ�œ
˜$J˜š
Ÿœ�œ
�œ�œ�œ˜UJš�œ
˜Jšœ�œ
˜J˜Jšœ�œ�œ
˜J˜Fš�œ�˜˜Jš�œ%�œ	�œ
˜9J˜J˜Jšœ�œ�œ�œ˜-J˜"—Jš�œ
˜—š�œ�˜Jšœ	�œ$�œ	�œ
˜A˜
Jš�œ%�œ	�œ
˜9J˜J˜J˜1—Jš�œ�œ
˜—Jš�œ�œ�œ�œ˜NJš�œ˜J˜J˜——Jš
œ™J˜J˜Jš
œ™˜šŸœ�œ
�œ�œ˜CJš�œ�˜˜J˜J˜$J˜!š�œ˜J˜HJ˜——Jš�œ˜J˜J˜—šŸœ�œ�œ˜:J˜J˜šŸœ�œ�œ˜1J˜1Jšœ&�œ�œ˜BJ˜—š�œ!�œ˜)J˜/J˜J˜J˜Pš�œ
�œ
�˜J˜D˜3J˜/šœ�œ�œ
�˜.J˜6Jš�œ�œ˜——Jš�œ�œ
˜—J˜>š�œ�œ˜"Jšœ�œ�œ˜:J˜=—Jš�œ)˜-J˜&š�œ�œ˜%J˜8J˜Jšœ&�œ�œ˜B——š�œ˜J˜JJš�œ�œ1˜Tš�œ˜Jšœ�œ˜'J˜8š�œ�œ˜%Jšœ�œ ˜+J˜'—Jš�œ+˜/——J˜=J˜—šŸœ�œ�œ˜>Jš�œ
˜J˜Jšœ�œ˜Jšœ�œ�œ
�œ
˜ Jšœ	�œ�œ
�œ
˜Jšœ�œ
˜Jšœ�œ�œ
�œ
˜J˜š�œ-�˜2š�œ�œ
�˜˜
šœ�œ�˜Jšœ�œ�œ�œ˜>Jš	œ�œ�œ�œ
�œ˜GJš�œ�œ�œ�œ	˜(—Jš�œ
�œ˜
—˜Jš
œ�œ�œ�œ
�œ�œ
�œ˜E—J˜)Jšœ�œ�œ�œ�œ
�œ˜F˜	šœ�œ'˜.Jš�œ
�œ�œ�œ˜?Jš�œ
�œ�œ�œ˜2—Jš�œ
�œ˜—Jš�œ�œ
˜—š
�˜J˜"˜	Jšœ"�
œ˜3J˜8——Jš�œ
˜—J˜Jšœ<�œ˜DJ˜—šŸœ�œ�œ˜>J˜š�œ�œ˜6š�œ˜Jšœ:�œ˜AJ˜——Jšœ!�œ˜)J˜J˜——Jš
œ™˜šŸœ�œ
�œ�œ˜@J˜J˜Jš�œ�˜˜˜J˜3J˜0J˜—˜	Jš�œ
˜J˜J˜9š�œ�œ
�˜˜
J˜4J˜G—Jš�œ�œ˜J˜——Jš�œ0˜7J˜—Jšœ)�œ˜IJš�œ�œ˜6Jš�œ˜!J˜J˜——Jš
œ™˜šŸœ�œ
�œ�œ˜;J˜Jšœ�œ
˜J˜Jš�œ�œ˜=J˜Jšœ�œ
˜'Jš
�œ�œ
�œ�œ�œ
˜2Jšœ"�
œ
˜6Jš�œ�œ'˜4Jšœ �œ	˜-J˜KJš�œ˜%J˜J˜——Jš
œ™˜šŸœ�œ
�œ�œ˜CJ˜J˜Jš�œ�˜˜J˜J˜˜	J˜-J˜@J˜6J˜—˜J˜J˜-J˜$š�œ�œ
�˜˜
J˜.J˜7—š�œ˜J˜R——J˜ J˜—˜Jšœ�œ �œ�œ˜LJ˜—š�œ˜J˜HJ˜——Jš�œ˜J˜J˜—šŸœ�œ�œ˜:Jš�œ
˜J˜
J˜J˜J˜J˜J˜Jšœ�œ.˜9š�œ�˜š�œ�œ
�˜˜J˜š�œ)�˜.šœ
�œ.�˜9Jš�œ�œ�œ�œ
�œ
�œ˜H——Jš�œ
�œ˜—˜J˜š�œ�˜J˜'˜š�œ;�˜@š�œ�œ
�˜Jšœ	�œ
�œ
�œ
�œ�œ
�œ
�œ˜5Jšœ�œ
�œ
�œ
�œ�œ
�œ
�œ˜8J˜/Jš�œ�œ
˜—Jš�œ
˜——Jšœ	�œ
�œ˜Jšœ�œ
�œ˜J˜%Jš�œ�œ˜——Jš�œ�œ
˜—š
�˜Jšœ�œ
˜
J˜/—Jš�œ
˜—J˜š�œ�œ˜J˜š�œ!�œ˜)˜šœ'�œ
˜0Jšœ�œ6˜@J˜—J˜—J˜——J˜Jšœ/�œ˜7J˜J˜—šŸœ�œ�œ˜5J˜/Jšœ�œ˜J˜J˜J˜J˜3J˜*J˜*š�œ�œ
�˜ ˜
Jšœ�œ˜'Jš�œ�œ0˜=š�œ
�œ�œ�˜>J˜2—J˜=—˜
J˜2Jšœ�œ ˜:J˜<J˜<Jšœ�œ˜%J˜>J˜.J˜-J˜&J˜—šœ
ž)˜6J˜2J˜?J˜AJ˜7J˜>J˜NJ˜1—š�œ˜J˜-J˜4——J˜FJšœ#�œ%˜KJš�œ˜!J˜—šŸœ�œ�œ˜>J˜/J˜J˜J˜J˜J˜=J˜Mš�œ�œ
�˜˜š�œ�œ�˜/J˜2——Jš�œ
˜—J˜9Jšœ�œ4˜?Jš�œ �œ˜CJ˜š�œ'�œ!�œ˜SJšœ�œ˜!Jšœ(�œ
˜8J˜,J˜2Jšœ"�
œ
˜6J˜%Jšœ�œ	˜J˜!—Jš�œ˜"Jšœ#�œ�œ˜LJ˜—J˜J˜———…—7NEÈ