DIRECTORY CedarProcess, Commander, Core, CoreOps, CoreProperties, GList, HashTable, IO, ProcessProps, Rope, RopeList;

CoreOpsImpl: CEDAR PROGRAM
IMPORTS CedarProcess, CoreProperties, GList, HashTable, IO, ProcessProps, Rope, RopeList
EXPORTS CoreOps = 
BEGIN OPEN Core, CoreOps;
nameProp: PUBLIC ATOM _ CoreProperties.RegisterProperty[$CoreName, CoreProperties.Props[[CoreProperties.propPrint, CoreProperties.PropDontPrint]]];
printClassProcProp: ATOM _ CoreProperties.RegisterProperty[$CorePrintClassProc];

SetClassPrintProc: PUBLIC PROC [class: CellClass, proc: PrintClassProc] RETURNS [sameClass: CellClass] = {
CoreProperties.PutCellClassProp[on: class, prop: printClassProcProp, value: NEW[PrintClassProc _ proc]];
sameClass _ class;
};

CreateCellType: PUBLIC PROC [class: CellClass, public: WireSeq, data: REF ANY _ NIL, name: ROPE _ NIL, props: Properties _ NIL]  RETURNS [cellType: CellType] = {
cellType _ NEW [CellTypeRec _ [class: class, public: public, data: data, properties: props]];
IF name#NIL THEN cellType _ SetCellTypeName[cellType, name];
};

SetCellTypeName: PUBLIC PROC [cellType: CellType, name: ROPE] RETURNS [sameCellType: CellType] = {
CoreProperties.PutCellTypeProp[cellType, nameProp, name];
sameCellType _ cellType;
};

GetCellTypeName: PUBLIC PROC [cellType: CellType] RETURNS [name: ROPE _ NIL] = {
name _ NARROW [CoreProperties.GetCellTypeProp[cellType, nameProp]];
};

InheritCellTypeName: PUBLIC PROC [cellType: CellType] RETURNS [name: ROPE _ NIL] = {
DO
name _ NARROW [CoreProperties.GetCellTypeProp[cellType, nameProp]];
IF name#NIL OR NOT cellType.class.layersProps THEN EXIT;
cellType _ Recast[cellType];
ENDLOOP;
};

recastCacheProp: ATOM _ CoreProperties.RegisterProperty[$CoreRecastCache];

Recast: PUBLIC PROC [me: CellType, fillCacheIfEmpty: BOOL _ TRUE] RETURNS [new: CellType] = {
new _ NARROW[CoreProperties.GetCellTypeProp[me, recastCacheProp]];
IF new=NIL THEN {
IF me.class.recast=NIL THEN ERROR;  -- Caller error.  No recast proc on this class.  Trap it here so that this comment is obvious to a user instead of getting an error window with a control fault in it.
new _ me.class.recast[me];
IF new#me AND fillCacheIfEmpty THEN CoreProperties.PutCellTypeProp[me, recastCacheProp, new];
};
};

RecastBindingTable: PUBLIC PROC [cellType: CellType] RETURNS [table: HashTable.Table] = {
table _ NARROW [CoreProperties.GetCellTypeProp[cellType, $CoreRecastBindingTableCache]];
IF table=NIL THEN {
recasted: CellType _ Recast[cellType];
IF recasted#cellType THEN {
table _ CreateBindingTable[cellType.public, recasted.public]; 
CoreProperties.PutCellTypeProp[cellType, $CoreRecastBindingTableCache, table];
};
};
};

ToBasic: PUBLIC PROC [cellType: Core.CellType] RETURNS [basic: Core.CellType] = {
FOR basic _ cellType, Recast[basic] UNTIL basic.class.recast = NIL DO NULL ENDLOOP;
};

PrintCellType: PUBLIC PROC [cellType: CellType, out: STREAM _ NIL, indent: NAT _ 0, level: NAT _ 2] = {
classProc: REF PrintClassProc;
IF out=NIL THEN out _ NARROW [ProcessProps.GetProp[$CommanderHandle], Commander.Handle].out;
IO.PutF[out,
"\n\n%g: %g Cell Type",
[rope[GetCellTypeName[cellType]]],
[rope[cellType.class.name]]
];
IO.PutRope[out, "\nPublic wire:"];
PrintWire[cellType.public, out, indent+1, level];
IF (classProc _ NARROW [CoreProperties.GetProp[from: cellType.class.properties, prop: printClassProcProp]]) # NIL THEN classProc[cellType.data, out, indent, level];
CoreProperties.PrintProperties[props: cellType.properties, out: out, indent: indent, level: level];
};

PrintIndent: PUBLIC PROC [indent: NAT, out: STREAM, cr: BOOL _ TRUE] = {
IF cr
THEN {
IO.PutChar[out, IO.CR];
FOR i: NAT IN [0..indent) DO IO.PutRope[out, "  "] ENDLOOP
}
ELSE IO.PutRope[out, ", "]
};
CreateWire: PUBLIC PROC [elements: Wires _ NIL, name: ROPE _ NIL, props: Properties _ NIL] RETURNS [wire: Wire] = {
size: NAT _ GList.Length[elements];
wire _ CreateWires[size, name, props];
size _ 0;
FOR c: Wires _ elements, c.rest UNTIL c=NIL DO
wire[size] _ c.first;
size _ size + 1;
ENDLOOP;
};

CreateWires: PUBLIC PROC [size: NAT, name: ROPE _ NIL, props: Properties _ NIL] RETURNS [wire: Wire] = {
wire _ NEW [WireRec[size]];
wire.properties _ props;
IF name#NIL THEN CoreProperties.PutWireProp[wire, nameProp, name];
};

SubrangeWire: PUBLIC PROC [wire: Wire, start, size: NAT, name: ROPE _ NIL, props: Properties _ NIL] RETURNS [sub: Wire] = {
sub _ CreateWires[size, name, props];
FOR i: NAT IN [0 .. size) DO
sub[i] _ wire[start+i];
ENDLOOP;
};

CopyWire: PUBLIC PROC [wire: Wire] RETURNS [new: Wire] = {

Copy: PROC [wire: Wire] RETURNS [new: Wire] = {
IF (new _ NARROW[HashTable.Fetch[table: visitTab, key: wire].value])=NIL THEN {
new _ CreateWires[size: wire.size, name: GetShortWireName[wire]];
IF NOT HashTable.Insert[table: visitTab, key: wire, value: new] THEN ERROR;
FOR i: NAT IN [0 .. wire.size) DO
new[i] _ Copy[wire[i]];
ENDLOOP;
};
};

visitTab: HashTable.Table _ HashTable.Create[];  -- Wire to Wire
new _ IF wire=NIL THEN NIL ELSE Copy[wire];
};

UnionWire: PUBLIC PROC [wire1, wire2: Wire, name: ROPE _ NIL, props: Properties _ NIL] RETURNS [union: Wire] = {
union _ CreateWires[size: wire1.size+wire2.size, name: name, props: props];
FOR i: NAT IN [0 .. wire1.size) DO union[i] _ wire1[i] ENDLOOP;
FOR i: NAT IN [0 .. wire2.size) DO union[wire1.size+i] _ wire2[i] ENDLOOP;
};

VisitWire: PUBLIC PROC [wire: Wire, eachWire: EachWireProc] RETURNS [quit: BOOL] = {
subWires: BOOL;
[subWires, quit] _ eachWire[wire];
IF quit OR NOT subWires THEN RETURN;
FOR i: NAT IN [0 .. wire.size) DO
IF VisitWire[wire[i], eachWire] THEN RETURN [TRUE];
ENDLOOP;
quit _ FALSE;
};

VisitWireSeq: PUBLIC PROC [seq: WireSeq, eachWire: EachWireProc] RETURNS [quit: BOOL] = {
FOR i: NAT IN [0 .. seq.size) DO
IF VisitWire[seq[i], eachWire] THEN RETURN [TRUE];
ENDLOOP;
quit _ FALSE;
};

VisitRootAtomics: PUBLIC PROC [root: WireSeq, eachWire: PROC [Wire]] = {
VisitAtomicWires: PROC [wire: Wire] = {
IF wire.size=0 
THEN eachWire[wire] 
ELSE FOR i: NAT IN [0 .. wire.size) DO VisitAtomicWires[wire[i]] ENDLOOP;
};
FOR i: NAT IN [0 .. root.size) DO VisitAtomicWires[root[i]] ENDLOOP;
};

VisitBinding: PUBLIC PROC [actual, public: Wire, eachWirePair: EachWirePairProc] RETURNS [quit: BOOL] = {
subWires: BOOL;
IF actual.size#public.size THEN RETURN [TRUE]; -- wires do not conform
[subWires, quit] _ eachWirePair[actual, public];
IF quit OR NOT subWires THEN RETURN;
FOR i: NAT IN [0 .. actual.size) DO
IF VisitBinding[actual[i], public[i], eachWirePair] THEN RETURN [TRUE];
ENDLOOP;
quit _ FALSE;
};

VisitBindingSeq: PUBLIC PROC [actual, public: WireSeq, eachWirePair: EachWirePairProc] RETURNS [quit: BOOL] = {
IF actual.size#public.size THEN RETURN [TRUE]; -- wires do not conform
FOR i: NAT IN [0 .. actual.size) DO
IF VisitBinding[actual[i], public[i], eachWirePair] THEN RETURN [TRUE];
ENDLOOP;
quit _ FALSE;
};

Conform: PUBLIC PROC [actual, public: Wire] RETURNS [BOOL] = {
EachWirePair: EachWirePairProc = {};
RETURN [NOT VisitBinding[actual, public, EachWirePair]];
};

CorrectConform: PUBLIC PROC [actual, public: WireSeq] RETURNS [BOOL] = {
p2a: HashTable.Table = HashTable.Create[];
EachWirePair: PROC [actualWire, publicWire: Wire] RETURNS [subWires: BOOL _ TRUE, quit: BOOL _ FALSE] --EachWirePairProc-- = {
found: BOOL;
ra: REF ANY;
[found, ra] _ HashTable.Fetch[p2a, publicWire];
subWires _ NOT found;
IF NOT found THEN {
IF NOT HashTable.Insert[p2a, publicWire, actualWire] THEN ERROR;
}
ELSE IF ra # actualWire THEN quit _ TRUE;
};
RETURN [NOT VisitBindingSeq[actual, public, EachWirePair]];
};

WireBits: PUBLIC PROC [wire: Wire] RETURNS [bits: NAT] = {
visitTab: HashTable.Table _ HashTable.Create[];  -- Wire to ATOM
CountBits: PROC [wire: Wire] RETURNS [bits: NAT _ 0] = {
IF NOT HashTable.Fetch[table: visitTab, key: wire].found THEN {
IF wire.size=0 THEN bits _ 1
ELSE FOR sub: NAT IN [0..wire.size) DO
bits _ bits + CountBits[wire[sub]];
ENDLOOP;
IF NOT HashTable.Insert[table: visitTab, key: wire, value: $Counted] THEN ERROR;
};
};
bits _ CountBits[wire];
};

CreateBindingTable: PUBLIC PROC [wire1, wire2: Wire] RETURNS [table: HashTable.Table] = {
AddInTable: EachWirePairProc = {[] _ HashTable.Store[table, actualWire, publicWire]};
table _ HashTable.Create[wire1.size];
[] _ VisitBinding[wire1, wire2, AddInTable];
};
GetShortWireName: PUBLIC PROC [wire: Wire] RETURNS [name: ROPE _ NIL] = {
name _ NARROW [CoreProperties.GetWireProp[wire, nameProp]];
};

SetShortWireName: PUBLIC PROC [wire: Wire, name: ROPE] RETURNS [sameWire: Wire] = {
CoreProperties.PutWireProp[wire, nameProp, name];
sameWire _ wire;
};

GetWireIndex: PUBLIC PROC [wire: Wire, name: ROPE] RETURNS [n: INT _ -1] ~ {
FOR i: NAT IN [0..wire.size) DO
IF Rope.Equal[name, GetShortWireName[wire[i]]] THEN RETURN [i];
ENDLOOP;
};

wireToNamesCacheProp: ATOM _ CoreProperties.RegisterProperty[$CoreWireToNamesCache, CoreProperties.Props[[CoreProperties.propPrint, CoreProperties.PropDontPrint]]];

nameToWireCacheProp: ATOM _ CoreProperties.RegisterProperty[$CoreNameToWireCache, CoreProperties.Props[[CoreProperties.propPrint, CoreProperties.PropDontPrint]]];

FullWireNames: PRIVATE PROC [root: Wire] RETURNS [wireToNames, nameToWire: HashTable.Table] = {
SetName: PUBLIC PROC [wire: Wire, name: ROPE] = {
names: LIST OF ROPE _ NARROW [HashTable.Fetch[wireToNames, wire].value];
previousWire: Wire _ NARROW [HashTable.Fetch[nameToWire, name].value];
IF name#NIL AND NOT RopeList.Memb[names, name] THEN {
names _ CONS [name, names]; 
[] _ HashTable.Store[wireToNames, wire, names];
};
IF name#NIL AND ~HashTable.Insert[nameToWire, name, wire] AND previousWire#wire THEN ERROR; -- two different wires have the same name relative to this root
FOR i: NAT IN [0 .. wire.size) DO
short: ROPE _ GetShortWireName[wire[i]];
SetName[wire[i], SELECT TRUE FROM
short=NIL 		=> Index[name, i],
name=NIL 		=> short,
ENDCASE 		=> Rope.Cat[name, ".", short]];
ENDLOOP;
};
wireToNames _ NARROW [CoreProperties.GetWireProp[root, wireToNamesCacheProp]];
nameToWire _ NARROW [CoreProperties.GetWireProp[root, nameToWireCacheProp]];
IF wireToNames#NIL AND nameToWire#NIL THEN RETURN;
wireToNames _ HashTable.Create[WireBits[root]];
nameToWire _ HashTable.Create[WireBits[root], HashTable.RopeEqual, HashTable.HashRope];
SetName[root, GetShortWireName[root]];
CoreProperties.PutWireProp[root, wireToNamesCacheProp, wireToNames];
CoreProperties.PutWireProp[root, nameToWireCacheProp, nameToWire];
};

GetFullWireNames: PUBLIC PROC [root: WireSeq, wire: Wire] RETURNS [names: LIST OF ROPE ] = {
names _ NARROW [HashTable.Fetch[FullWireNames[root].wireToNames, wire].value];
};

GetFullWireName: PUBLIC PROC [root: WireSeq, wire: Wire] RETURNS [name: ROPE _ NIL] = {
names: LIST OF ROPE _ GetFullWireNames[root, wire];
WHILE names#NIL DO 
IF name=NIL OR (Rope.Fetch[name]='[ AND Rope.Fetch[names.first]#'[) OR Rope.Length[names.first]<Rope.Length[name] OR (Rope.Length[names.first]=Rope.Length[name] AND Rope.Compare[names.first, name]=less) THEN name _ names.first;
names _ names.rest;
ENDLOOP;
};

IsFullWireName: PUBLIC PROC [root: WireSeq, wire: Wire, name: ROPE] RETURNS [BOOL] = {
RETURN [RopeList.Memb[GetFullWireNames[root, wire], name]]
};

FindWire: PUBLIC PROC [root: WireSeq, name: ROPE] RETURNS [wire: Wire _ NIL] = {
wire _ NARROW [HashTable.Fetch[FullWireNames[root].nameToWire, name].value];
};

ParseWireName: PUBLIC PROC [name: ROPE] RETURNS [base: ROPE, components: LIST OF ROPE _ NIL] = {
endBase: INT _ MIN [Rope.Index[name, 0, "."], Rope.Index[name, 0, "["]];
base _ Rope.Substr[name, 0, endBase];
name _ Rope.Substr[name, endBase];
WHILE Rope.Length[name]#0 DO
SELECT Rope.Fetch[name] FROM
'[		=> {
endBracket: INT _ Rope.Find[name, "]"];
IF endBracket=-1 THEN ERROR; -- malformed name
components _ CONS [Rope.Substr[name, 1, endBracket-1], components];
name _ Rope.Substr[name, endBracket+1];
};
'.		=> {
endField: INT _ MIN [Rope.Index[name, 1, "."], Rope.Index[name, 1, "["]];
components _ CONS [Rope.Substr[name, 1, endField-1], components];
name _ Rope.Substr[name, endField];
};
ENDCASE	=> ERROR; -- malformed name
ENDLOOP;
components _ RopeList.Reverse[components];
};


AllSimpleAtomics: PROC [wire: Wire] RETURNS [BOOL _ TRUE] = {
FOR i: NAT IN [0 .. wire.size) DO
IF wire[i].size#0 OR CoreProperties.HasPrintableProp[wire[i].properties] OR GetShortWireName[wire[i]]#NIL THEN RETURN [FALSE];
ENDLOOP;
};
PrintWire: PUBLIC PROC [wire: Wire, out: STREAM _ NIL, indent: NAT _ 0, level: NAT _ 2] = {
name: ROPE _ GetShortWireName[wire];
PrintAWire: PROC [wire: Wire, indent: NAT, level: NAT, name: ROPE, cr, firstWire: BOOL, recur: NAT] = {
CedarProcess.CheckAbort[];
PrintIndent[indent, out, cr OR firstWire];
IO.PutRope[out, name];
IF recur=1 AND Rope.Match["[*]", name] THEN out.PutF["(%g^)", IO.int[LOOPHOLE[wire]]];
IF wire.size#0 THEN IO.PutF[out, ", %g elements", IO.int[wire.size]];
CoreProperties.PrintProperties[props: wire.properties, out: out, indent: indent+1, cr: cr, level: level];
IF wire.size#0 AND (level=0 OR (recur#0 AND AllSimpleAtomics[wire]))
THEN IO.PutRope[out, " [...] "] 
ELSE FOR i: NAT IN [0 .. wire.size) DO
subName: ROPE _ GetShortWireName[wire[i]];
IF subName=NIL THEN subName _ IO.PutFR["[%g]", IO.int[i]];
PrintAWire[wire[i], indent+1, level-1, subName, cr AND wire.size<=32, cr AND i=0, recur+1];
ENDLOOP;
};

IF out=NIL THEN out _ NARROW[ProcessProps.GetProp[$CommanderHandle], Commander.Handle].out;
PrintAWire[wire, indent, level, IF name#NIL THEN name ELSE "<no name>", TRUE, TRUE, 0];
};

FlushNameCaches: PUBLIC PROC [root: WireSeq] = {
CoreProperties.PutWireProp[root, wireToNamesCacheProp, NIL];
CoreProperties.PutWireProp[root, nameToWireCacheProp, NIL];
};
Reverse: PUBLIC PROC [wires: Wires] RETURNS [revWires: Wires _ NIL] = {
revWires _ NARROW [GList.Reverse[wires]];
};

Delete: PUBLIC PROC [wires: Wires, wire: Wire] RETURNS [newWires: Wires _ NIL] = {
WHILE wires#NIL DO
IF wires.first#wire THEN newWires _ CONS [wires.first, newWires];
wires _ wires.rest;
ENDLOOP;
};

Member: PUBLIC PROC [wires: Wires, wire: Wire] RETURNS [BOOL] = {
RETURN [GList.Member[wire, wires]];
};

ParentWires: PUBLIC PROC [root, candidate: Wire] RETURNS [parents: LIST OF Wire _ NIL] = {
FindActual: EachWireProc = {
FOR i: NAT IN [0 .. wire.size) DO 
IF wire[i]=candidate AND NOT Member[parents, wire] THEN parents _ CONS [wire, parents];
ENDLOOP;
};
[] _ VisitWire[root, FindActual];
};

RecursiveMember: PUBLIC PROC [wire, candidate: Wire] RETURNS [BOOL] = {
FindActual: EachWireProc = {quit _ wire=candidate};
RETURN [VisitWire[wire, FindActual]];
};
brackets: ARRAY [0 .. 32) OF ROPE = [
"[0]", "[1]", "[2]", "[3]", "[4]", "[5]", "[6]", "[7]", "[8]", "[9]", 
"[10]", "[11]", "[12]", "[13]", "[14]", "[15]", "[16]", "[17]", "[18]", "[19]", 
"[20]", "[21]", "[22]", "[23]", "[24]", "[25]", "[26]", "[27]", "[28]", "[29]", 
"[30]", "[31]"]; 
Index: PUBLIC PROC [rope: ROPE, index: NAT] RETURNS [indexed: ROPE] = {
RETURN [IF index<32 
THEN Rope.Concat[rope, brackets[index]] 	-- speed up hack!
ELSE Rope.Cat[rope, "[", IO.PutR1[IO.int[index]], "]"]
];
};

FixStupidRef: PUBLIC PROC [ref: REF ANY] RETURNS [rope: ROPE] = {
IF ref=NIL THEN RETURN [NIL];
rope _ WITH ref SELECT FROM
r: REF TEXT 	=> Rope.FromRefText[r],
r: ROPE		=> r,
ENDCASE 		=> ERROR;
};

Print: PUBLIC PROC [ref: REF, out: STREAM _ NIL, indent: NAT _ 0, level: NAT _ 2] = {
WITH ref SELECT FROM
wire: Wire		=> PrintWire[wire, out, indent, level];
wires: Wires		=> WHILE wires#NIL DO
PrintWire[wires.first, out, indent, level];
wires _ wires.rest;
ENDLOOP;
cellType: CellType	=> PrintCellType[cellType, out, indent, level];
ENDCASE		=> {
IF out=NIL THEN out _ NARROW [ProcessProps.GetProp[$CommanderHandle], Commander.Handle].out;
IO.PutRope[out, IF ref=NIL THEN "NIL\n" ELSE "*** CoreOps.Print Does not know how to print argument\n"];
};
};

END.

ξCoreOpsImpl.mesa
Copyright c 1985 by Xerox Corporation.  All rights reserved.
Barth, December 4, 1986 5:04:52 pm PST
Spreitzer, April 8, 1986 4:34:16 pm PST
Bertrand Serlet March 16, 1987 11:34:18 pm PST
Louis Monier May 1, 1986 4:44:41 pm PDT
Pradeep Sindhu February 24, 1986 6:48:20 pm PST
Mike Spreitzer November 18, 1986 2:30:07 pm PST
Last Edited by: Louis Monier January 16, 1987 1:16:31 pm PST

Property
Cell Classes
Cell Types
Wire Creation
Wire Enumeration
Wire Naming
Association wire -> list of full names
Association full name -> wire
SetName has GetShortWireName[wire] instead of NIL to make full names also work for wires in their own context, as in Sisyph.
Wires Operations
Miscellaneous
Speed up hack for making new wire names

Κ–

"cedar" style˜
codeš
œ™Kšœ
Οm
œ1™<K™&K™'K™.K™'K™/K™/K™<K™—KšΟk	œKžœ˜uK˜•StartOfExpansion[]šΟnœžœ
ž˜Kšžœ1žœ˜XKšžœ˜Kšžœ
žœ˜—
headš
œ™Kšœ
žœ
žœ~˜“
—™šœžœ8˜PK˜—šŸœžœ
žœ*žœ˜jKšœLžœ˜hKš
œ˜K˜K˜——™
šŸœžœ
žœ+žœ
žœžœžœžœžœžœ˜‘
KšœžœO˜]Kšžœžœ
žœ,˜<K˜K˜—š
Ÿœžœ
žœžœžœ˜bKš
œ9˜9Kš
œ˜K˜K˜—šŸœžœ
žœžœžœžœ˜PKšœžœ6˜CK˜K˜—šŸœžœ
žœžœžœžœ˜Tš
ž˜Kšœžœ6˜CKšžœžœ
žœ
žœžœ
žœ
˜8Kš
œ˜Jšžœ
˜—K˜K˜—šœžœ5˜JK˜—šŸœžœ
žœ"žœžœžœ˜]Kšœžœ6˜Bšžœžœ
žœ˜Kš	žœžœ
žœ
žœΟc¦
˜Κ
Kš
œ˜Kšžœžœžœ:˜]K˜—K˜K˜—šŸœžœ
žœžœ˜YKšœžœJ˜Xšžœžœ
žœ˜K˜&šžœžœ˜Kš
œ>˜>Kš
œN˜NK˜—K˜—K˜K˜—šŸœžœ
žœžœ˜QKšžœ!žœžœ
žœ
žœ
žœ
˜SKš
œ˜—K˜šΠbn
œžœ
žœžœžœ
žœ
žœ	˜gKšœžœ˜Kšžœžœ
žœžœ?˜\šžœ
˜K˜Kš
œ"˜"Kš
œ˜K˜—Kšžœ ˜"Kš
œ1˜1KšžœžœWžœ
žœ.˜€
Kš
œc˜cJ˜—K˜šŸœžœ
žœ
žœžœžœžœ˜Hšžœ˜šžœ˜Kšžœžœ
žœ˜Kšžœžœ
žœ
žœ
žœž˜:K˜
—Kšžœ
žœ˜—K˜——™
šŸ
œžœ
žœžœžœžœžœžœ˜sKšœžœ˜#Kš
œ&˜&Kš
œ	˜	šžœžœžœ
ž˜.Kš
œ˜Kš
œ˜Kšžœ
˜—K˜K˜—šŸœžœ
žœžœžœžœžœžœ˜hKšœžœ˜Kš
œ˜Kšžœžœ
žœ2˜BK˜K˜—šŸœžœ
žœžœžœžœžœžœ˜{Kš
œ%˜%šžœžœ
žœ
ž˜Kš
œ˜Kšžœ
˜—Kš
œ˜K˜—šŸœžœ
žœžœ˜:K˜šŸœžœžœ˜/šžœžœ5žœ
žœ˜OJš
œA˜AKšžœ
žœ:žœ
žœ
˜Kšžœžœ
žœž˜!Jš
œ˜Jšžœ
˜—J˜—J˜J˜—Kšœ1 ˜@Kšœžœžœ
žœ
žœ
žœ˜+Kš
œ˜—K˜šŸ	œžœ
žœžœžœžœžœ˜pKš
œK˜KKš
žœžœ
žœžœžœ
˜?Kš
žœžœ
žœžœ žœ
˜JK˜K˜——™š
Ÿ	œžœ
žœ&žœžœ˜TJšœ
žœ
˜Jš
œ"˜"Jš
žœžœ
žœ
žœ
žœ
˜$šžœžœ
žœž˜!Jšžœžœ
žœžœ˜3Jšžœ
˜—Jšœžœ
˜
Jš
œ˜J˜—š
Ÿœžœ
žœ(žœžœ˜Yšžœžœ
žœž˜ Jšžœžœ
žœžœ˜2Jšžœ
˜—Jšœžœ
˜
K˜K˜—šŸœžœžœ˜HšŸœžœ˜'šžœ
˜Jšžœ˜Kšžœ
žœžœ
žœžœžœ
˜I—Jš
œ˜—Jš
žœžœ
žœžœžœ
˜DJš
œ˜J˜—š
‘œžœ
žœ8žœžœ˜iJšœ
žœ
˜Jš	žœžœ
žœžœ ˜FJš
œ0˜0Jš
žœžœ
žœ
žœ
žœ
˜$šžœžœ
žœž˜#Jšžœ2žœ
žœžœ˜GJšžœ
˜—Jšœžœ
˜
Jš
œ˜J˜—š
Ÿœžœ
žœ;žœžœ˜oKš	žœžœ
žœžœ ˜Fšžœžœ
žœž˜#Jšžœ2žœ
žœžœ˜GJšžœ
˜—Jšœžœ
˜
K˜K˜—š
Ÿœžœ
žœžœžœ˜>Kš‘œ˜$Kšžœžœ-˜8K˜K˜—š
Ÿœžœ
žœžœžœ˜HK˜*š‘œžœ žœžœžœžœžœ œ˜~Kšœžœ
˜Kšœžœ
žœ
˜K˜/Kšœžœ˜šžœ
žœžœ˜Kšžœ
žœ/žœ
žœ
˜@K˜
—Kšžœ
žœžœžœ
˜)Kš
œ˜—Kšžœžœ0˜;K˜K˜—š
Ÿœžœ
žœžœžœ˜:Kšœ1 ˜@šŸ	œžœžœžœ	˜8šžœ
žœ3žœ˜?Kšžœ
žœ	˜š	žœ
žœžœ
žœž˜&Kš
œ#˜#Kšžœ
˜—Kšžœ
žœ?žœ
žœ
˜PK˜—K˜—K˜K˜K˜—šŸœžœ
žœžœ˜YKšŸ
œK˜UKš
œ%˜%Kš
œ,˜,K˜——™šŸœžœ
žœžœžœžœ˜IKšœžœ.˜;K˜K˜—š
Ÿœžœ
žœžœžœ˜SKš
œ1˜1Kš
œ˜K˜K˜—šŸœžœ
žœžœžœžœ
˜Lšžœžœ
žœž˜Kšžœ-žœ
žœ˜?Kšžœ
˜—K˜K˜—šœžœŠ
˜€
K™&K˜—šœžœ‰
˜’
K™K˜—šŸ
œžœ
žœžœ/˜_šŸœžœ
žœžœ˜1Kš	œžœ
žœ
žœžœ,˜HKšœžœ+˜Fš
žœžœ
žœ
žœžœ˜5Kšœžœ˜Kš
œ/˜/Kš
œ˜—Jš
žœžœ
žœ+žœžœ
žœ ?˜›
šžœžœ
žœž˜!Kšœžœ˜(šœžœ
žœ
ž˜!Kšœžœ˜Kšœžœ˜Kšžœ"˜)—Jšžœ
˜—K˜—Kšœžœ:˜NKšœ
žœ9˜LKšžœ
žœ
žœžœ
žœ
žœ
˜2Kš
œ/˜/Kš
œW˜WKš
œ|™|Kš
œ&˜&Jš
œD˜DJš
œB˜BK˜—K˜šŸœžœ
žœžœ	žœ
žœ
žœ˜\Kšœžœ@˜NK˜K˜—šŸœžœ
žœžœžœžœ˜WKšœžœ
žœ
žœ ˜3šžœžœ
žœ
˜Kšžœžœ
žœžœžœ,žœ-žœ'žœ˜γ
Kš
œ˜Kšžœ
˜—K˜K˜—šŸœžœ
žœ#žœžœžœ˜VKšžœ4˜:K˜K˜—šŸœžœ
žœžœžœžœ˜PKšœžœ?˜LK˜K˜—šŸ
œžœ
žœžœžœžœžœ
žœ
žœžœ˜`Jšœ	žœžœ6˜HJš
œ%˜%Jš
œ"˜"šžœž˜šžœž˜˜Jšœžœ˜'Jšžœžœ
žœ ˜.Jšœ
žœ2˜CJš
œ'˜'J˜—˜Jšœ
žœžœ6˜IJšœ
žœ0˜AJš
œ#˜#J˜—Jšžœžœ ˜#—Jšžœ
˜—J˜*J˜J˜—K˜šŸœžœžœ
žœ˜=šžœžœ
žœž˜!Jšžœžœ5žœžœ
žœ
žœžœ˜~Jšžœ
˜—Jš
œ˜—šŸ	œžœ
žœžœžœ
žœ
žœ	˜[Kšœžœ˜$šŸ
œžœžœ	žœžœžœ	žœ˜gKš
œ˜Kšœžœ˜*Kšžœ˜Kš
žœ	žœžœžœžœ	˜VKšžœ
žœ
žœžœ˜EKš
œi˜išžœ
žœ
žœ
žœ˜DKšžœ
žœ˜ š	žœ
žœžœ
žœž˜&Kšœ	žœ˜*Kš
žœ	žœ
žœžœžœ	˜:Kšœ3žœžœ˜[Kšžœ
˜——K˜K˜—Kšžœžœ
žœžœ?˜[Kš
œžœžœ
žœžœžœžœ˜WK˜K˜—šŸœžœ
žœ˜0Jšœ7žœ˜<Jšœ6žœ˜;K˜——š
œ™š
Ÿœžœ
žœžœžœ˜GKšœžœ˜)Jš
œ˜J˜—š
Ÿœžœ
žœžœžœ˜Ršžœžœ
ž˜Jšžœžœžœ˜AJš
œ˜Jšžœ
˜—Jš
œ˜J˜—š
Ÿœžœ
žœžœžœ˜AJšžœ˜#Jš
œ˜J˜—šŸœžœ
žœžœžœ
žœžœ˜ZšŸ
œ˜šžœžœ
žœžœ
˜"Kš
žœžœ
žœžœžœ˜WKšžœ
˜—Kš
œ˜—Kš
œ!˜!Jš
œ˜J˜—š
Ÿœžœ
žœžœžœ˜GKšŸ
œ)˜3Kšžœ˜%Jš
œ˜——š
œ
™
šœ
žœžœ
žœ˜%Kš
œF˜FKš
œP˜PKš
œP˜PKš
œ˜K™'K™—šŸœžœ
žœžœ	žœžœžœ˜Gšžœžœ
˜Kšžœ% ˜:Kšžœžœžœ˜6Kš
œ˜—K˜K˜—šŸœžœ
žœžœ
žœžœžœ˜AKš
žœžœ
žœ
žœžœ˜šœžœžœ
ž˜Kšœžœ
žœ˜$Kšœžœ˜Kšžœžœ
˜—Kš
œ˜K˜—šŸœžœ
žœžœžœžœ
žœ
žœ	˜Ušžœžœ
ž˜Kš
œ3˜3šœžœžœ
ž˜#Kš
œ+˜+Kš
œ˜Kšžœ
˜—Kš
œB˜Bšžœ˜
Kšžœžœ
žœžœ@˜\Kš
žœžœžœ
žœ	žœ<˜hK˜——K˜——K˜Kšžœ
˜K˜—…—= T₯