DIRECTORY
Alloc USING [Handle, Notifier, AddNotify, DropNotify, FreeChunk, GetChunk],
HashTypes USING [HTIndex],
Symbols USING [HTIndex, ISEIndex],
Tree USING [AttrId, Base, Finger, Id, Index, Info, Link, Map, Node, NodeName, Scan, Test, maxNSons, null, nullIndex, treeType],
TreeOps USING [];

TreePack: PROGRAM IMPORTS Alloc EXPORTS TreeOps = {

LitIndex: TYPE = HashTypes.HTIndex;

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

initialized: BOOL _ FALSE;

table: Alloc.Handle;

LinkSeq: TYPE = RECORD[SEQUENCE length: CARDINAL OF Tree.Link];
LinkStack: TYPE = REF LinkSeq;

stack: LinkStack;
sI: CARDINAL;

tb: Tree.Base;		-- tree base

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


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

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

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


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


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

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


InsertTree: PUBLIC 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: PUBLIC 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: PUBLIC PROC[name: Tree.NodeName, count: INTEGER] RETURNS[Tree.Link] = {
PushNode[name, count];  RETURN[PopTree[]]};

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


PushNode: PUBLIC 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].attrs _ ALL[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: PUBLIC 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].attrs _ ALL[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: PUBLIC 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].attrs _ ALL[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: PUBLIC PROC[hti: Symbols.HTIndex] = {PushTree[[hash[index: hti]]]};

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

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


SetInfo: PUBLIC 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: PUBLIC PROC[attr: Tree.AttrId, value: BOOL] = {
WITH stack[sI-1] SELECT FROM
v: Tree.Link.subtree =>
IF v = Tree.null THEN ERROR
ELSE tb[v.index].attrs[attr] _ value;
ENDCASE => ERROR};


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

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



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

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

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

NthSon: PUBLIC 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: PUBLIC 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: PUBLIC PROC[t: Tree.Link, attr: Tree.AttrId] RETURNS[BOOL] = {
RETURN[IF t # Tree.null
THEN tb[NARROW[t, Tree.Link.subtree].index].attrs[attr]
ELSE ERROR]};

PutAttr: PUBLIC PROC[t: Tree.Link, attr: Tree.AttrId, value: BOOL] = {
IF t = Tree.null THEN ERROR;
tb[NARROW[t, Tree.Link.subtree].index].attrs[attr] _ value};

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

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

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

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

SonCount: 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: PUBLIC 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: PUBLIC 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: PUBLIC 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: PUBLIC 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: PUBLIC 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: PUBLIC 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: PUBLIC 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: PUBLIC 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: PUBLIC 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: PUBLIC 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: PUBLIC 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].attrs _ root.baseP^[sNode].attrs;
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: PUBLIC Tree.Map = {
RETURN[IF ISTYPE[t, Tree.Link.subtree] AND ~Shared[t]
THEN CopyTree[[baseP:@tb, link:t], IdentityMap]
ELSE t]};


NodeSize: PUBLIC 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};

}.


nProtoTreePack.mesa
Copyright c 1985 by Xerox Corporation.  All rights reserved.
Satterthwaite, April 17, 1986 1:16:48 pm PST
Paul Rovner, September 9, 1983 8:53 am
Russ Atkinson (RRA) March 7, 1985 0:54:06 am PST
procedures for tree testing
procedures for tree traversal
procedures for list testing
procedures for list traversal
cross-table tree manipulation
Κœ˜
codeš
œ™Kšœ
Οm
œ1™<Kš
œ,™,Kš
œ&™&K™0—K˜š
Οk	˜	Kšœžœ@˜KKšœ
žœ˜Kšœžœ˜"Kšœžœu˜Kšœžœ˜K˜—Kšœ
žœžœ
ž
œ
˜3˜Kšœ
žœ˜#˜Kšœ"žœ
˜'K˜0K˜Kšœ
žœžœ
˜K˜Kš
œ˜K˜Kšœ	žœžœ
žœ	žœ
žœ˜?Kšœžœžœ	˜K˜Kš
œ˜Kšœžœ
˜
K˜KšœΟc˜K˜—Kš
œ8˜8K˜K˜šΟn
œžœ
žœ˜3Kšžœ
žœ˜Kšœžœ˜#K˜K˜Kšžœžœ
žœŸ˜<Kšœžœ˜K˜—š œžœ
žœ˜šžœ
žœžœ˜,Kšœžœ˜K˜——š œžœ
žœ˜Kšœ&žœ
˜*Kšœžœ
˜Kšœžœ˜K˜K˜—š œžœ˜Kšœžœ˜7Kš
žœžœ
žœžœžœ
˜IKš
œ˜K˜K˜—š œžœ
žœ˜'Kšžœžœ˜)K˜K˜—Kš
 œžœ
žœ
žœžœ˜CK˜K˜š 
œžœ
žœžœ˜6Kšœžœ
˜Kšžœžœ˜)K˜Kšžœ
žœ žœ
˜;K˜K˜—š
 œžœ
žœžœžœ˜?Kšœžœ
˜K˜
Kšžœ
žœ žœ
˜;K˜Kšžœ˜K˜K˜—š
 œžœ
žœžœžœ˜QKšœžœ
˜+K˜—š
 œžœ
žœžœžœ˜;Kšœžœ
˜$K˜K˜—š œžœ
žœžœ˜>Kšœžœ	žœ
˜Kšœ,žœžœ˜VKšœžœ
˜K˜.Kšœ&žœ
˜,Kšœžœ
žœ˜šžœž˜Kšžœžœžœ"ž˜K—š
ž˜Kšžœžœžœ"žœ
˜L—Kšžœžœ˜)K˜0K˜—š œžœ
žœžœ˜(Kšœžœžœ
˜K˜Kšœžœ
˜šžœž˜Kšœžœ
˜
K˜šžœ˜šžœžœž˜#Kšœ žœžœ˜I—šžœ˜Kšœ žœžœ˜NK˜!—K˜Kšœ&žœ
˜,Kšœžœ
žœ˜Kš	œžœžœžœžœ˜Bšžœ
ž˜Kšžœžœžœ"ž˜K—š
ž˜Kšžœžœžœ"žœ
˜L—Kšžœžœ˜)K˜1K˜———š œžœ
žœžœ˜.šžœžœ	žœ˜Kšœ,žœžœ˜PK˜Kšœ&žœ
˜,Kšœžœ
žœ˜Kšœžœ
˜Kšœžœ
žœ	žœ˜:K˜!—Kšžœ˜K˜K˜—Kš œžœ
žœ8˜MK˜Kš œžœ
žœ;˜NK˜Kš œžœ
žœ4˜HK˜K˜š œžœ
žœ˜)šžœ
žœ
ž˜Kšœžœžœ˜FKšžœ˜	K˜——š œžœ
žœžœ˜8šžœ
žœ
ž˜˜Kšžœžœ
ž˜Kšžœ!˜%—Kšžœžœ˜K˜K˜——š œžœ
žœ˜+šžœžœžœ˜4Kšœžœ
˜K˜
Kšœžœ˜šžœžœž˜&šžœžœž˜K˜Kšžœžœ
žœžœ
˜6Kš
ž˜——šžœ˜K˜šžœžœž˜5Kšžœžœ
žœžœ
˜6K˜Kšžœ˜	——Kšœ žœ
žœ˜HK˜——š œžœ
žœžœ˜:Kšžœžœ
žœžœ
˜9Kšžœ
˜K˜K˜——š
œ™K˜š œžœ
žœžœ˜?Kšžœ
žœ˜)K˜—š œžœ
žœžœ˜:Kšžœ
žœ˜,K˜—š œžœ
žœžœ˜>Kšžœ
žœ˜+K˜—š
 œžœ
žœžœžœ˜Ešžœ
žœ˜Kšžœ
ž˜
Kšžœžœ'˜5K˜——š œžœ
žœžœ˜<šžœ
žœ˜Kšžœ˜
Kš
žœ
žœžœ
žœžœ˜EK˜——š
 œžœ
žœ"žœ
žœ˜Gšžœ
žœ˜Kšžœžœ)˜7Kšžœ
žœ˜
K˜——š œžœ
žœ)žœ˜FKšžœžœ
žœ
˜Kšœžœ3˜<K˜—š œžœ
žœžœ˜9šžœ
žœ˜Kšžœžœ"˜0Kšžœ
žœ˜
K˜——š œžœ
žœ$˜8Kšžœžœ
žœ
˜Kšœžœ,˜5K˜—š
 œžœ
žœžœ
žœ˜3šžœ
žœžœ
ž˜Kš	œžœžœ
žœ
žœ˜=Kšžœžœ˜K˜——š 
œžœ
žœžœ˜7šžœžœ
ž˜Kšœžœžœ˜;Kšžœ˜	K˜——š
 œžœžœ
žœžœ˜=šžœ
žœž˜K˜šžœžœžœ˜:Kšžœ#˜'Kšžœ˜K˜K˜————š
œ™K˜š œžœ
žœ(˜=šžœž˜šžœžœ
ž˜˜K˜šžœžœ
žœž˜+Kšœžœ˜!——Kšžœ
˜——Kšžœ˜K˜—š œžœ
žœ!žœ˜SKšžœžœ˜&š
ž˜šžœžœ
ž˜˜K˜šžœžœ
žœž˜+K˜'Kšžœ
˜—K˜
—Kšžœ˜——Kšžœ˜K˜K˜——š
œ™K˜š
 
œžœ
žœžœ
žœ˜;Kšžœžœ
žœ˜ šžœžœ
ž˜˜K˜Kšœžœ
˜Kšžœžœ
žœ˜(K˜Kšžœžœ
žœ˜Kš
žœžœ
žœžœ	žœ
˜LKšžœ˜—Kšžœžœ˜K˜——š œžœ
žœžœ˜:Kšžœžœ
žœ˜(šžœžœ
ž˜˜K˜šžœ
žœ
žœ
ž˜K˜K˜/Kšžœ˜——Kšžœžœ˜K˜——š œžœ
žœžœ˜:Kšžœžœ
žœ˜(šžœžœ
ž˜˜K˜šžœ
žœ
žœ
ž˜K˜K˜;Kšžœ˜——Kšžœžœ˜K˜K˜———š
œ™K˜š œžœ
žœ(˜=šžœž˜šžœžœ
ž˜˜K˜Kšœžœ
˜K˜
Kšžœžœ
˜*šžœ
žœž˜%Kšžœžœžœž˜>—š
ž˜Kšžœžœžœžœ˜I——Kšžœ˜K˜———š œžœ
žœ(˜Dšžœž˜šžœžœ
ž˜˜K˜Kšžœžœ
˜*š
ž˜š	žœžœ
ž
œ
žœž˜8Kšœžœ˜!———Kšžœ˜K˜———š 
œžœ
žœ&˜=šžœž˜šžœžœ
ž˜˜K˜Kšœžœ
˜K˜
Kšžœžœ˜-šžœ
žœž˜%Kš
žœžœžœ
žœžœ
žœ
ž˜I—š
ž˜šžœžœž˜5Kšžœ	žœ
žœ
žœ˜———Kšžœ˜K˜———š 
œžœ
žœ!žœ˜NKšžœžœ
žœ˜+šžœžœ
ž˜˜K˜Kšœžœ
˜K˜
Kšžœžœ
žœ˜0šžœž˜ Kšžœžœžœ(ž˜M—š
ž˜šžœžœž˜5Kšœžœ
˜!——Kšžœ˜—Kšžœžœ
˜K˜——š œžœ
žœ!žœ˜UKšžœžœ
žœ˜+šžœžœ
ž˜˜K˜Kšžœžœ
žœ˜0š	žœžœ
ž
œ
žœž˜6Kšœ'žœ
˜/—Kšžœ˜—Kšžœžœ
˜K˜K˜———Kš
œ™˜š œžœ
žœžœ˜Mšžœžœ
ž˜˜K˜Kšžœžœ˜,šžœ˜Kšœžœ˜-K˜8K˜
K˜)Kšœžœ
˜K˜+K˜)K˜+š	žœžœ
žœžœž˜.šœžœ(˜=Kšžœ˜Kšžœ˜—Kšžœ
˜—K˜——Kšžœ˜—Kšžœ˜K˜—šœ
žœ
˜ šžœ
žœ
žœžœ˜5Kšžœ+˜/Kšžœ˜	K˜K˜——š
 œžœ
žœ'žœžœ˜WKšžœžœ	˜&šžœ
žœžœž˜@Kšœžœ ž˜9—šžœ˜Kšœžœ
žœ
˜'šžœžœ
žœž˜?Kšœžœ
žœ˜&——Kšžœ˜K˜—K˜K˜——…—.θAς