DIRECTORY
Alloc: TYPE USING [
Handle, Notifier, AddNotify, DropNotify, FreeChunk, GetChunk],
Literals: TYPE USING [LitIndex],
Symbols: TYPE USING [HTIndex, ISEIndex],
Tree: TYPE USING [
AttrId, Base, Finger, Id, Info, Index, Link, Map, Node, NodeName, Scan, Test,
maxNSons, Null, NullIndex, treeType],
TreeOps: TYPE USING [];

TreePack: PROGRAM
IMPORTS Alloc 
EXPORTS TreeOps =
PUBLIC {

endIndex: Tree.Index = Tree.Index.LAST;
endMark: Tree.Link = [subtree[index: endIndex]];

initialized: PRIVATE BOOL _ FALSE;

table: PRIVATE Alloc.Handle;
zone: PRIVATE UNCOUNTED ZONE _ NIL;

LinkSeq: PRIVATE TYPE = RECORD [SEQUENCE length: CARDINAL OF Tree.Link];
LinkStack: PRIVATE TYPE = LONG POINTER TO LinkSeq;

stack: PRIVATE LinkStack;
sI: PRIVATE CARDINAL;

tb: PRIVATE Tree.Base;		-- tree base

UpdateBase: PRIVATE Alloc.Notifier = {tb _ base[Tree.treeType]};


Initialize: PROC [ownTable: Alloc.Handle, scratchZone: UNCOUNTED ZONE] = {
IF initialized THEN Finalize[];
zone _ scratchZone;
stack _ zone.NEW[LinkSeq[250]];  sI _ 0;
table _ ownTable;
table.AddNotify[UpdateBase];
IF MakeNode[$none,0] # Tree.Null THEN ERROR;	-- reserve null
initialized _ TRUE};

Reset: PROC = {
IF initialized AND stack.length > 250 THEN {
zone.FREE[@stack]; stack _ zone.NEW[LinkSeq[250]]}};

Finalize: PROC = {
table.DropNotify[UpdateBase]; table _ NIL;
zone.FREE[@stack]; zone _ NIL;
initialized _ FALSE};


ExpandStack: PRIVATE PROC = {
newStack: LinkStack = zone.NEW[LinkSeq[stack.length + 256]];
FOR i: CARDINAL IN [0 .. stack.length) DO newStack[i] _ stack[i] ENDLOOP;
zone.FREE[@stack];  stack _ newStack};


PushTree: PROC [v: Tree.Link] = {
IF sI >= stack.length THEN ExpandStack[];
stack[sI] _ v;  sI _ sI+1};

PopTree: PROC RETURNS [Tree.Link] = {RETURN [stack[sI_sI-1]]};


InsertTree: PROC [v: Tree.Link, n: CARDINAL] = {
i: CARDINAL;
IF sI >= stack.length THEN ExpandStack[];
i _ sI;  sI _ sI+1;
THROUGH [1 .. n) DO stack[i] _ stack[i-1]; i _ i-1 ENDLOOP;
stack[i] _ v};

ExtractTree: PROC [n: CARDINAL] RETURNS [v: Tree.Link] = {
i: CARDINAL _ sI - n;
v _ stack[i];
THROUGH [1 .. n) DO stack[i] _ stack[i+1]; i _ i+1 ENDLOOP;
sI _ sI - 1;
RETURN [v]};


MakeNode: PROC [name: Tree.NodeName, count: INTEGER] RETURNS [Tree.Link] = {
PushNode[name, count];  RETURN [PopTree[]]};

MakeList: PROC [size: INTEGER] RETURNS [Tree.Link] = {
PushList[size];  RETURN [PopTree[]]};


PushNode: PROC [name: Tree.NodeName, count: INTEGER] = {
nSons: CARDINAL = count.ABS;
node: Tree.Index = table.GetChunk[Tree.Node.SIZE+nSons*Tree.Link.SIZE, Tree.treeType];
i: CARDINAL;
tb[node].name _ name;  tb[node].nSons _ nSons;
tb[node].info _ 0;  tb[node].shared _ FALSE;
tb[node].attr1 _ tb[node].attr2 _ tb[node].attr3 _ FALSE;
IF count >= 0 THEN
FOR i _ nSons, i-1 WHILE i >= 1 DO tb[node].son[i] _ stack[sI_sI-1] ENDLOOP
ELSE
FOR i _ 1, i+1 WHILE i <= nSons DO tb[node].son[i] _ stack[sI_sI-1] ENDLOOP;
IF sI >= stack.length THEN ExpandStack[];
stack[sI] _ [subtree[index: node]];  sI _ sI+1};

PushList: PROC [size: INTEGER] = {
nSons: CARDINAL = size.ABS;
node: Tree.Index;
i: CARDINAL;
SELECT nSons FROM
1 => NULL;
0 => PushTree[Tree.Null];
ENDCASE => {
IF nSons IN (0..Tree.maxNSons] THEN
node _ table.GetChunk[Tree.Node.SIZE+nSons*Tree.Link.SIZE, Tree.treeType]
ELSE {
node _ table.GetChunk[Tree.Node.SIZE+(nSons+1)*Tree.Link.SIZE, Tree.treeType];
tb[node].son[nSons+1] _ endMark};
tb[node].name _ $list;
tb[node].info _ 0;  tb[node].shared _ FALSE;
tb[node].attr1 _ tb[node].attr2 _ tb[node].attr3 _ FALSE;
tb[node].nSons _ IF nSons IN (0..Tree.maxNSons] THEN nSons ELSE 0;
IF size > 0 THEN
FOR i _ nSons, i-1 WHILE i >= 1 DO tb[node].son[i] _ stack[sI_sI-1] ENDLOOP
ELSE
FOR i _ 1, i+1 WHILE i <= nSons DO tb[node].son[i] _ stack[sI_sI-1] ENDLOOP;
IF sI >= stack.length THEN ExpandStack[];
stack[sI] _ [subtree[index: node]];  sI _ sI+1}};

PushProperList: PROC [size: INTEGER] = {
IF size IN [-1..1] THEN {
node: Tree.Index = table.GetChunk[Tree.Node.SIZE+Tree.Link.SIZE, Tree.treeType];
tb[node].name _ $list;
tb[node].info _ 0;  tb[node].shared _ FALSE;
tb[node].attr1 _ tb[node].attr2 _ tb[node].attr3 _ FALSE;
tb[node].nSons _ size.ABS;
tb[node].son[1] _ IF size = 0 THEN endMark ELSE PopTree[];
PushTree[[subtree[index: node]]]}
ELSE PushList[size]};


PushHash: PROC [hti: Symbols.HTIndex] = {PushTree[[hash[index: hti]]]};

PushSe: PROC [sei: Symbols.ISEIndex] = {PushTree[[symbol[index: sei]]]};

PushLit: PROC [lti: Literals.LitIndex] = {PushTree[[literal[index: lti]]]};


SetInfo: PROC [info: Tree.Info] = {
WITH stack[sI-1] SELECT FROM
v: Tree.Link.subtree => IF v # Tree.Null THEN tb[v.index].info _ info;
ENDCASE};

SetAttr: PROC [attr: Tree.AttrId, value: BOOL] = {
WITH stack[sI-1] SELECT FROM
v: Tree.Link.subtree =>
IF v = Tree.Null THEN ERROR
ELSE
SELECT attr FROM
1 => tb[v.index].attr1 _ value;
2 => tb[v.index].attr2 _ value;
3 => tb[v.index].attr3 _ value;
ENDCASE;
ENDCASE => ERROR};


FreeNode: PROC [node: Tree.Index] = {
IF node # Tree.NullIndex AND ~tb[node].shared THEN {
i: CARDINAL;
n: CARDINAL _ tb[node].nSons;
IF tb[node].name # $list OR n # 0 THEN
FOR i _ 1, i+1 WHILE i <= n DO
WITH tb[node].son[i] SELECT FROM
t: Tree.Link.subtree => FreeNode[t.index];
ENDCASE;
ENDLOOP
ELSE {
n _ 1;
FOR i _ 1, i+1 UNTIL tb[node].son[i] = endMark DO
WITH tb[node].son[i] SELECT FROM
t: Tree.Link.subtree => FreeNode[t.index];
ENDCASE;
n _ n+1;
ENDLOOP};
table.FreeChunk[node, Tree.Node.SIZE+n*Tree.Link.SIZE, Tree.treeType]}};

FreeTree: PROC [t: Tree.Link] RETURNS [Tree.Link] = {
WITH t SELECT FROM subtree => FreeNode[index] ENDCASE;
RETURN [Tree.Null]};



GetHash: PROC [t: Tree.Link] RETURNS [Symbols.HTIndex] = {
RETURN [NARROW[t, Tree.Link.hash].index]};

GetNode: PROC [t: Tree.Link] RETURNS [Tree.Index] = {
RETURN [NARROW[t, Tree.Link.subtree].index]};

GetSe: PROC [t: Tree.Link] RETURNS [Symbols.ISEIndex] = {
RETURN [NARROW[t, Tree.Link.symbol].index]};

NthSon: PROC [t: Tree.Link, n: CARDINAL] RETURNS [Tree.Link] = {
RETURN [IF t = Tree.Null
THEN ERROR
ELSE tb[NARROW[t, Tree.Link.subtree].index].son[n]]};

OpName: PROC [t: Tree.Link] RETURNS [Tree.NodeName] = {
RETURN [IF t = Tree.Null
THEN $none
ELSE WITH t SELECT FROM subtree => tb[index].name ENDCASE => $none]};

GetAttr: PROC [t: Tree.Link, attr: Tree.AttrId] RETURNS [BOOL] = {
node: Tree.Index = NARROW[t, Tree.Link.subtree].index;
RETURN [IF t = Tree.Null
THEN ERROR
ELSE SELECT attr FROM
1 => tb[node].attr1,
2 => tb[node].attr2,
3 => tb[node].attr3,
ENDCASE => ERROR]};

PutAttr: PROC [t: Tree.Link, attr: Tree.AttrId, value: BOOL] = {
node: Tree.Index = NARROW[t, Tree.Link.subtree].index;
IF t = Tree.Null THEN ERROR;
SELECT attr FROM
1 => tb[node].attr1 _ value;
2 => tb[node].attr2 _ value;
3 => tb[node].attr3 _ value;
ENDCASE => ERROR};

GetInfo: PROC [t: Tree.Link] RETURNS [Tree.Info] = {
RETURN [IF t # Tree.Null
THEN tb[NARROW[t, Tree.Link.subtree].index].info
ELSE ERROR]};

PutInfo: PROC [t: Tree.Link, value: Tree.Info] = {
IF t = Tree.Null THEN ERROR;
tb[NARROW[t, Tree.Link.subtree].index].info _ value};

Shared: PROC [t: Tree.Link] RETURNS [BOOL] = {
RETURN [WITH t SELECT FROM
s: Tree.Link.subtree => IF s = Tree.Null THEN FALSE ELSE tb[s.index].shared,
ENDCASE => FALSE]};

MarkShared: PROC [t: Tree.Link, shared: BOOL] = {
WITH t SELECT FROM
s: Tree.Link.subtree => IF s # Tree.Null THEN tb[s.index].shared _ shared;
ENDCASE};

SonCount: PRIVATE PROC [node: Tree.Index] RETURNS [CARDINAL] = INLINE {
RETURN [SELECT node FROM
Tree.NullIndex, endIndex => 0,
ENDCASE => IF tb[node].name = $list AND tb[node].nSons = 0
THEN ListLength[[subtree[index: node]]]
ELSE tb[node].nSons]};



ScanSons: PROC [root: Tree.Link, action: Tree.Scan] = {
IF root # Tree.Null THEN
WITH root SELECT FROM
subtree => {
node: Tree.Index = index;
FOR i: CARDINAL IN [1 .. SonCount[node]] DO
action[tb[node].son[i]] ENDLOOP};
ENDCASE;
RETURN};

UpdateLeaves: PROC [root: Tree.Link, map: Tree.Map] RETURNS [v: Tree.Link] = {
IF root = Tree.Null THEN v _ Tree.Null
ELSE
WITH root SELECT FROM
subtree => {
node: Tree.Index = index;
FOR i: CARDINAL IN [1 .. SonCount[node]] DO
tb[node].son[i] _ map[tb[node].son[i]];
ENDLOOP;
v _ root};
ENDCASE => v _ map[root];
RETURN};



ListLength: PROC [t: Tree.Link] RETURNS [CARDINAL] = {
IF t = Tree.Null THEN RETURN [0];
WITH t SELECT FROM
subtree => {
node: Tree.Index = index;
n: CARDINAL;
IF tb[node].name # $list THEN RETURN [1];
n _ tb[node].nSons;
IF n # 0 THEN RETURN [n];
FOR i: CARDINAL _ 1, i+1 UNTIL tb[node].son[i] = endMark DO n _ n+1 ENDLOOP;
RETURN [n]};
ENDCASE => RETURN [1]};

ListHead: PROC [t: Tree.Link] RETURNS [Tree.Link] = {
IF t = Tree.Null THEN RETURN [Tree.Null];
WITH t SELECT FROM
subtree => {
node: Tree.Index = index;
RETURN [SELECT TRUE FROM
(tb[node].name # $list) => t,
(tb[node].son[1] # endMark) => tb[node].son[1],
ENDCASE => Tree.Null]};
ENDCASE => RETURN [t]};

ListTail: PROC [t: Tree.Link] RETURNS [Tree.Link] = {
IF t = Tree.Null THEN RETURN [Tree.Null];
WITH t SELECT FROM
subtree => {
node: Tree.Index = index;
RETURN [SELECT TRUE FROM
(tb[node].name # $list) => t,
(tb[node].son[1] # endMark) => tb[node].son[ListLength[t]],
ENDCASE => Tree.Null]};
ENDCASE => RETURN [t]};



ScanList: PROC [root: Tree.Link, action: Tree.Scan] = {
IF root # Tree.Null THEN
WITH root SELECT FROM
subtree => {
node: Tree.Index = index;
i, n: CARDINAL;
t: Tree.Link;
IF tb[node].name # $list THEN action[root]
ELSE IF (n _ tb[node].nSons) # 0 THEN
FOR i _ 1, i+1 WHILE i <= n DO action[tb[node].son[i]] ENDLOOP
ELSE
FOR i _ 1, i+1 UNTIL (t_tb[node].son[i]) = endMark DO action[t] ENDLOOP};
ENDCASE => action[root]};

ReverseScanList: PROC [root: Tree.Link, action: Tree.Scan] = {
IF root # Tree.Null THEN
WITH root SELECT FROM
subtree => {
node: Tree.Index = index;
IF tb[node].name # $list THEN action[root]
ELSE
FOR i: CARDINAL DECREASING IN [1 .. ListLength[root]] DO
action[tb[node].son[i]] ENDLOOP};
ENDCASE => action[root]};

SearchList: PROC [root: Tree.Link, test: Tree.Test] = {
IF root # Tree.Null THEN
WITH root SELECT FROM
subtree => {
node: Tree.Index = index;
i, n: CARDINAL;
t: Tree.Link;
IF tb[node].name # $list THEN [] _ test[root]
ELSE IF (n _ tb[node].nSons) # 0 THEN
FOR i _ 1, i+1 WHILE i <= n DO IF test[tb[node].son[i]] THEN EXIT ENDLOOP
ELSE
FOR i _ 1, i+1 UNTIL (t_tb[node].son[i]) = endMark DO
IF test[t] THEN EXIT ENDLOOP};
ENDCASE => [] _ test[root]};

UpdateList: PROC [root: Tree.Link, map: Tree.Map] RETURNS [Tree.Link] = {
IF root = Tree.Null THEN RETURN [Tree.Null];
WITH root SELECT FROM
subtree => {
node: Tree.Index = index;
i, n: CARDINAL;
t: Tree.Link;
IF tb[node].name # $list THEN RETURN [map[root]];
IF (n _ tb[node].nSons) # 0 THEN
FOR i _ 1, i+1 WHILE i <= n DO tb[node].son[i] _ map[tb[node].son[i]] ENDLOOP
ELSE
FOR i _ 1, i+1 UNTIL (t_tb[node].son[i]) = endMark DO
tb[node].son[i] _ map[t] ENDLOOP;
RETURN [root]};
ENDCASE => RETURN [map[root]]};

ReverseUpdateList: PROC [root: Tree.Link, map: Tree.Map] RETURNS [Tree.Link] = {
IF root = Tree.Null THEN RETURN [Tree.Null];
WITH root SELECT FROM
subtree => {
node: Tree.Index = index;
IF tb[node].name # $list THEN RETURN [map[root]];
FOR i: CARDINAL DECREASING IN [1..ListLength[root]] DO
tb[node].son[i] _ map[tb[node].son[i]] ENDLOOP;
RETURN [root]};
ENDCASE => RETURN [map[root]]};



CopyTree: PROC [root: Tree.Id, map: Tree.Map] RETURNS [v: Tree.Link] = {
WITH root.link SELECT FROM
subtree => {
sNode: Tree.Index = index;
IF sNode = Tree.NullIndex THEN v _ Tree.Null
ELSE {
size: CARDINAL = NodeSize[root.baseP, sNode];
dNode: Tree.Index = table.GetChunk[size, Tree.treeType];
t: Tree.Link;
tb[dNode].name _ root.baseP^[sNode].name;
tb[dNode].shared _ FALSE;
tb[dNode].nSons _ root.baseP^[sNode].nSons;
tb[dNode].info _ root.baseP^[sNode].info;
tb[dNode].attr1 _ root.baseP^[sNode].attr1;
tb[dNode].attr2 _ root.baseP^[sNode].attr2;
tb[dNode].attr3 _ root.baseP^[sNode].attr3;
FOR i: CARDINAL IN [1..size-Tree.Node.SIZE] DO
tb[dNode].son[i] _ IF (t_root.baseP^[sNode].son[i]) = endMark
THEN endMark
ELSE map[t];
ENDLOOP;
v _ [subtree[index: dNode]]}};
ENDCASE => v _ map[root.link];
RETURN};

IdentityMap: Tree.Map = {
RETURN [IF ISTYPE[t, Tree.Link.subtree] AND ~Shared[t]
THEN CopyTree[[baseP:@tb, link:t], IdentityMap]
ELSE t]};


NodeSize: PROC [baseP: Tree.Finger, node: Tree.Index] RETURNS [size: CARDINAL] = {
IF node = Tree.NullIndex THEN size _ 0
ELSE IF baseP^[node].name # $list OR baseP^[node].nSons # 0 THEN
size _ Tree.Node.SIZE + baseP^[node].nSons*Tree.Link.SIZE
ELSE {
size _ Tree.Node.SIZE + Tree.Link.SIZE;
FOR i: CARDINAL _ 1, i+1 UNTIL baseP^[node].son[i] = endMark DO
size _ size + Tree.Link.SIZE ENDLOOP};
RETURN};

}.

äfile TreePack.Mesa
last modified by Satterthwaite, January 10, 1983 9:37 am
procedures for tree testing
procedures for tree traversal
procedures for list testing
procedures for list traversal
cross-table tree manipulation
�ʯ˜Jš
œ™Jš
œ8™8J˜š
Ïk	˜	šœ�œ
�œ˜J˜>—Jšœ
�œ
�œ˜ Jšœ	�œ
�œ˜(šœ�œ
�œ˜J˜MJ˜%—Jšœ	�œ
�œ˜J˜—šœ
�˜Jš�œ˜Jš�œ
˜Jš�œ˜˜Jšœ"�œ
˜'J˜0J˜Jšœ
�œ
�œ�œ
˜"J˜Jšœ�œ˜Jš	œ�œ
�	œ
�œ�œ
˜#J˜Jš
œ	�œ
�œ�œ�œ	�œ
�œ˜HJšœ�œ
�œ�œ
�œ
�œ	˜2J˜Jšœ�œ˜Jšœ�œ
�œ
˜J˜Jšœ�œ
Ïc˜$J˜Jšœ�œ-˜@J˜J˜šÏn
œ�œ'�	œ
�œ˜JJš�œ
�œ˜J˜Jšœ
�œ˜(J˜J˜Jš�œ�œ
�œž˜<Jšœ�œ˜J˜—šŸœ�œ˜š�œ
�œ�œ˜,Jšœ�œ�œ˜4J˜——šŸœ�œ˜Jšœ&�œ
˜*Jšœ�œ�œ
˜Jšœ�œ˜J˜J˜—šŸœ�œ
�œ˜Jšœ�œ˜<Jš
�œ�œ
�œ�œ�œ
˜IJšœ�œ˜&J˜J˜—šŸœ�œ˜!Jš�œ�œ˜)J˜J˜—JšŸœ�œ
�œ�œ˜>J˜J˜šŸ
œ�œ�œ˜0Jšœ�œ
˜Jš�œ�œ˜)J˜Jš�œ
�œ �œ
˜;J˜J˜—šŸœ�œ�œ�œ˜:Jšœ�œ
˜J˜
Jš�œ
�œ �œ
˜;J˜Jš�œ˜J˜J˜—šŸœ�œ�œ�œ˜LJšœ�œ˜,J˜—šŸœ�œ�œ�œ˜6Jšœ�œ˜%J˜J˜—šŸœ�œ�œ˜8Jšœ�œ	�œ
˜Jšœ,�œ�œ˜VJšœ�œ
˜J˜.Jšœ&�œ
˜,Jšœ3�œ
˜9š�œ�˜Jš�œ�œ�œ"�˜K—š
�˜Jš�œ�œ�œ"�œ
˜L—Jš�œ�œ˜)J˜0J˜—šŸœ�œ�œ˜"Jšœ�œ�œ
˜J˜Jšœ�œ
˜š�œ�˜Jšœ�œ
˜
J˜š�œ˜š�œ�œ�˜#Jšœ �œ�œ˜I—š�œ˜Jšœ �œ�œ˜NJ˜!—J˜Jšœ&�œ
˜,Jšœ3�œ
˜9Jš	œ�œ�œ�œ�œ˜Bš�œ
�˜Jš�œ�œ�œ"�˜K—š
�˜Jš�œ�œ�œ"�œ
˜L—Jš�œ�œ˜)J˜1J˜———šŸœ�œ�œ˜(š�œ�œ	�œ˜Jšœ,�œ�œ˜PJ˜Jšœ&�œ
˜,Jšœ3�œ
˜9Jšœ�œ
˜Jšœ�œ
�œ	�œ˜:J˜!—Jš�œ˜J˜J˜—JšŸœ�œ9˜GJ˜JšŸœ�œ<˜HJ˜JšŸœ�œ>˜KJ˜J˜šŸœ�œ˜#š�œ
�œ
�˜Jšœ�œ�œ˜FJš�œ˜	J˜——šŸœ�œ�œ˜2š�œ
�œ
�˜˜Jš�œ�œ
�˜š
�˜š�œ�˜J˜J˜J˜Jš�œ
˜———Jš�œ�œ˜J˜J˜——šŸœ�œ˜%š�œ�œ�œ˜4Jšœ�œ
˜Jšœ�œ˜š�œ�œ�˜&š�œ�œ�˜š�œ�œ
�˜ J˜*Jš�œ
˜—Jš
�˜——š�œ˜J˜š�œ�œ�˜1š�œ�œ
�˜ J˜*Jš�œ
˜—J˜Jš�œ˜	——Jšœ �œ
�œ˜HJ˜——šŸœ�œ�œ˜5Jš�œ�œ
�œ�œ
˜6Jš�œ˜J˜J˜—Jš
œ™J˜šŸœ�œ�œ˜:Jš�œ�œ˜*J˜—šŸœ�œ�œ˜5Jš�œ�œ˜-J˜—šŸœ�œ�œ˜9Jš�œ�œ˜,J˜—šŸœ�œ�œ�œ˜@š�œ�œ˜Jš�œ
�˜
Jš�œ�œ'˜5J˜——šŸœ�œ�œ˜7š�œ�œ˜Jš�œ˜
Jš
�œ
�œ�œ
�œ�œ˜EJ˜——šŸœ�œ#�œ�œ˜BJšœ�œ˜6š�œ�œ˜Jš�œ
�˜
š�œ
�œ�˜J˜J˜J˜Jš�œ�œ˜J˜———šŸœ�œ*�œ˜@Jšœ�œ˜6Jš�œ�œ
�œ
˜š�œ�˜J˜J˜J˜Jš�œ�œ˜J˜——šŸœ�œ�œ˜4š�œ�œ˜Jš�œ�œ"˜0Jš�œ
�œ˜
J˜——šŸœ�œ%˜2Jš�œ�œ
�œ
˜Jšœ�œ,˜5J˜—šŸœ�œ�œ�œ˜.š�œ�œ�œ
�˜Jš	œ�œ�œ
�œ
�œ˜LJš�œ�œ˜J˜——šŸ
œ�œ�œ˜1š�œ�œ
�˜Jšœ�œ�œ˜JJš�œ˜	J˜——šŸœ�œ
�œ�œ�œ�œ˜Gš�œ�œ�˜J˜š�œ�œ�œ˜:Jš�œ#˜'Jš�œ˜J˜J˜———Jš
œ™J˜šŸœ�œ)˜7š�œ�˜š�œ�œ
�˜˜J˜š�œ�œ
�œ�˜+Jšœ�œ˜!——Jš�œ
˜——Jš�œ˜J˜—šŸœ�œ"�œ˜NJš�œ�œ˜&š
�˜š�œ�œ
�˜˜J˜š�œ�œ
�œ�˜+J˜'Jš�œ
˜—J˜
—Jš�œ˜——Jš�œ˜J˜J˜—Jš
œ™J˜šŸ
œ�œ�œ�œ˜6Jš�œ�œ
�œ˜!š�œ�œ
�˜˜J˜Jšœ�œ
˜Jš�œ�œ
�œ˜)J˜Jš�œ�œ
�œ˜Jš
�œ�œ
�œ�œ	�œ
˜LJš�œ˜—Jš�œ�œ˜J˜——šŸœ�œ�œ˜5Jš�œ�œ
�œ
˜)š�œ�œ
�˜˜J˜š�œ�œ
�œ
�˜J˜J˜/Jš�œ˜——Jš�œ�œ˜J˜——šŸœ�œ�œ˜5Jš�œ�œ
�œ
˜)š�œ�œ
�˜˜J˜š�œ�œ
�œ
�˜J˜J˜;Jš�œ˜——Jš�œ�œ˜J˜J˜——Jš
œ™J˜šŸœ�œ)˜7š�œ�˜š�œ�œ
�˜˜J˜Jšœ�œ
˜J˜
Jš�œ�œ
˜*š�œ
�œ�˜%Jš�œ�œ�œ�˜>—š
�˜Jš�œ�œ�œ�œ˜I——Jš�œ˜J˜———šŸœ�œ)˜>š�œ�˜š�œ�œ
�˜˜J˜Jš�œ�œ
˜*š
�˜š	�œ�œ
�
œ
�œ�˜8Jšœ�œ˜!———Jš�œ˜J˜———šŸ
œ�œ'˜7š�œ�˜š�œ�œ
�˜˜J˜Jšœ�œ
˜J˜
Jš�œ�œ˜-š�œ
�œ�˜%Jš
�œ�œ�œ
�œ�œ
�œ
�˜I—š
�˜š�œ�œ�˜5Jš�œ	�œ
�œ
�œ˜———Jš�œ˜J˜———šŸ
œ�œ"�œ˜IJš�œ�œ
�œ
˜,š�œ�œ
�˜˜J˜Jšœ�œ
˜J˜
Jš�œ�œ
�œ
˜1š�œ�˜ Jš�œ�œ�œ(�˜M—š
�˜š�œ�œ�˜5Jšœ�œ
˜!——Jš�œ	˜—Jš�œ�œ˜J˜——šŸœ�œ"�œ˜PJš�œ�œ
�œ
˜,š�œ�œ
�˜˜J˜Jš�œ�œ
�œ
˜1š	�œ�œ
�
œ
�œ�˜6Jšœ'�œ
˜/—Jš�œ	˜—Jš�œ�œ˜J˜J˜———Jš
œ™˜šŸœ�œ �œ˜Hš�œ�œ
�˜˜J˜Jš�œ�œ˜,š�œ˜Jšœ�œ˜-J˜8J˜
J˜)Jšœ�œ
˜J˜+J˜)J˜+J˜+J˜+š	�œ�œ
�œ�œ�˜.šœ�œ(˜=Jš�œ˜Jš�œ˜—Jš�œ
˜—J˜——Jš�œ˜—Jš�œ˜J˜—˜š�œ�œ
�œ�œ˜6Jš�œ+˜/Jš�œ˜	J˜J˜——šŸœ�œ(�œ�œ˜RJš�œ�œ	˜&š�œ
�œ�œ�˜@Jšœ�œ �˜9—š�œ˜Jšœ�œ
�œ
˜'š�œ�œ
�œ�˜?Jšœ�œ
�œ˜&——Jš�œ˜J˜—J˜J˜———…—14CÇ