DIRECTORY LichenSetTheory, RefTab, Rope, RopeHash;

LichenSetTheoryImpl: CEDAR PROGRAM
IMPORTS LichenSetTheory, RefTab, Rope, RopeHash
EXPORTS LichenSetTheory =

BEGIN OPEN LichenSetTheory;

NotMutable: PUBLIC ERROR = CODE;
Escape: ERROR ~ CODE;

CreateSingleton: PUBLIC PROC [elt: REF ANY] RETURNS [set: Set] = {
set _ NEW [SetPrivate _ [singletonClass, FALSE, elt]];
};

singletonClass: SetClass = NEW [SetClassPrivate _ [
TestSingletonMembership,
DontUnionSingleton,
DontUnionSet,
DontRemoveElt,
EnumerateSingleton,
DontErase,
SingletonSize]];

TestSingletonMembership: PROC [set: Set, elt: REF ANY] RETURNS [in: BOOL] = {
in _ elt = set.data};

DontUnionSingleton: PUBLIC PROC [set: Set, elt: REF ANY] RETURNS [new: BOOL] = {ERROR};
DontUnionSet: PUBLIC PROC [self, other: Set] = {ERROR};
DontRemoveElt: PUBLIC PROC [set: Set, elt: REF ANY] RETURNS [had: BOOL] = {ERROR};
DontEnumerate: PUBLIC PROC [set: Set, Consumer: PROC [ra: REF ANY]] ~ {ERROR};
DontErase: PUBLIC PROC [set: Set] = {ERROR};
DontAskSetSize: PUBLIC PROC [set: Set] RETURNS [INT] ~ {ERROR};

PickOne: PUBLIC PROC [set: Set] RETURNS [elt: REF ANY] ~ {
See: PROC [ra: REF ANY] ~ {elt _ ra; Escape};
set.Enumerate[See !Escape => CONTINUE];
};

EnumerateSingleton: PROC [set: Set, Consumer: PROC [REF ANY]] = {Consumer[set.data]};

SingletonSize: PROC [set: Set] RETURNS [INT] = {RETURN[1]};

CreateHashSet: PUBLIC PROC [parms: HashParms _ []] RETURNS [set: Set] = {
set _ NEW [SetPrivate _ [class: hashSetClass, data: RefTab.Create[hash: parms.hash, equal: parms.equal]]]};

hashSetClass: SetClass = NEW [SetClassPrivate _ [
TestHashSetMembership,
HashSetUnionSingleton,
HashSetUnionSet,
RemoveHashSetElt,
EnumerateHashSet,
EraseHashSet,
HashSetSize]];

TestHashSetMembership: PROC [set: Set, elt: REF ANY] RETURNS [b: BOOL] = {
ht: RefTab.Ref = NARROW[set.data];
b _ ht.Fetch[elt].found};

HashSetUnionSingleton: PROC [set: Set, elt: REF ANY] RETURNS [new: BOOL] = {
ht: RefTab.Ref = NARROW[set.data];
new _ ht.Store[elt, $T];
};

HashSetUnionSet: PROC [self, other: Set] = {
ht: RefTab.Ref = NARROW[self.data];
Addit: PROC [elt: REF ANY] = {
[] _ ht.Insert[elt, $T]};
other.class.Enumerate[other, Addit];
};

RemoveHashSetElt: PROC [set: Set, elt: REF ANY] RETURNS [had: BOOL] = {
ht: RefTab.Ref = NARROW[set.data];
had _ ht.Delete[elt];
};

EnumerateHashSet: PROC [set: Set, Consumer: PROC [REF ANY]] = {
ht: RefTab.Ref = NARROW[set.data];
PerPair: PROC [key, val: REF ANY] RETURNS [quit: BOOL _ FALSE] --RefTab.EachPairAction-- = {
Consumer[key];
};
[] _ ht.Pairs[PerPair]};

EraseHashSet: PROC [set: Set] = {
ht: RefTab.Ref = NARROW[set.data];
ht.Erase[]};

HashSetSize: PROC [set: Set] RETURNS [size: INT] = {
ht: RefTab.Ref = NARROW[set.data];
size _ ht.GetSize[]};

CreateFilterClass: PUBLIC PROC [TestMembership: PROC [set: Set, elt: REF ANY] RETURNS [BOOL]] RETURNS [class: SetClass] ~ {
class _ NEW [SetClassPrivate _ [TestMembership, DontUnionSingleton, DontUnionSet, DontRemoveElt, DontEnumerate, DontErase, DontAskSetSize]];
};

CreateFilter: PUBLIC PROC [TestMembership: PROC [set: Set, elt: REF ANY] RETURNS [BOOL]] RETURNS [f: Filter] ~ {
class: SetClass ~ CreateFilterClass[TestMembership];
f _ NEW [SetPrivate _ [class, FALSE, NIL]];
};

passAll: PUBLIC Filter ~ CreateFilter[PassAll];

PassAll: PROC [set: Set, elt: REF ANY] RETURNS [BOOL] ~ {RETURN [TRUE]};

Unioned: TYPE = REF UnionedPrivate;
UnionedPrivate: TYPE = RECORD [
incr, decr: SetList, --ordered by increasing size, decreasing size
eltsImmutable: BOOL,
size: INT _ notComputed
];

notComputed: INT = FIRST[INT];

unionSetClass: SetClass = NEW [SetClassPrivate _ [
TestUnionMembership,
DontUnionSingleton,
UnionUnionSet,
DontRemoveElt,
EnumerateUnion,
DontErase,
UnionSize]];

CreateUnion: PUBLIC PROC [sets: SetList, eltsImmutable: BOOL _ TRUE] RETURNS [set: Set] = {
u: Unioned = NEW [UnionedPrivate _ [eltsImmutable: eltsImmutable]];
[u.incr, u.decr] _ SizeSort[sets];
set _ NEW [SetPrivate _ [
class: unionSetClass,
data: u
]];
};

TestUnionMembership: PROC [set: Set, elt: REF ANY] RETURNS [in: BOOL] = {
u: Unioned = NARROW[set.data];
FOR sets: SetList _ u.decr, sets.rest WHILE sets # NIL DO
IF sets.first.class.TestMembership[sets.first, elt] THEN RETURN [TRUE];
ENDLOOP;
in _ FALSE;
};

UnionUnionSet: PROC [self, other: Set] = {
u: Unioned = NARROW[self.data];
[u.incr, u.decr] _ SizeInsert[u.incr, u.decr, other];
u.size _ notComputed;
};

EnumerateUnion: PROC [set: Set, Consumer: PROC [REF ANY]] = {
u: Unioned = NARROW[set.data];
IF u.incr = NIL THEN RETURN;
u.incr.first.class.Enumerate[u.incr.first, Consumer];
EnumerateSetlistRestUnion[u.incr, Consumer];
};

EnumerateSetlistRestUnion: PROC [sets: SetList, Consumer: PROC [REF ANY]] = {
FOR i: SetList _ sets.rest, i.rest WHILE i # NIL DO
Filter: PROC [elt: REF ANY] = {
FOR j: SetList _ sets, j.rest WHILE j # i DO
IF j.first.class.TestMembership[j.first, elt] THEN RETURN;
ENDLOOP;
Consumer[elt];
};
i.first.class.Enumerate[i.first, Filter];
ENDLOOP;
};

UnionSize: PROC [set: Set] RETURNS [size: INT] = {
u: Unioned = NARROW[set.data];
CountIt: PROC [REF ANY] = {size _ size + 1};
IF u.size # notComputed THEN RETURN [u.size];
IF u.decr = NIL THEN RETURN [u.size _ 0];
size _ u.decr.first.class.Size[u.decr.first];
EnumerateSetlistRestUnion[u.decr, CountIt];
IF u.eltsImmutable THEN u.size _ size;
};

SizeSort: PROC [sets: SetList] RETURNS [increasing, decreasing: SetList] = {
increasing _ decreasing _ NIL;
WHILE sets # NIL DO
next: SetList = sets.rest;
increasing _ IncrInsert[increasing, sets];
sets _ next;
ENDLOOP;
FOR sets _ increasing, sets.rest WHILE sets # NIL DO
decreasing _ CONS[sets.first, decreasing];
ENDLOOP;
};

SizeInsert: PROC [oIncr, oDecr: SetList, set: Set] RETURNS [nIncr, nDecr: SetList] = {
nIncr _ IncrInsert[oIncr, LIST[set]];
nDecr _ DecrInsert[oDecr, LIST[set]];
};

IncrInsert: PROC [old, this: SetList] RETURNS [new: SetList] = {
thisSize: INT = this.first.class.Size[this.first];
prev: SetList _ NIL;
following: SetList _ new _ old;
WHILE following # NIL AND thisSize > following.first.class.Size[following.first] DO
prev _ following;
following _ following.rest;
ENDLOOP;
this.rest _ following;
IF prev = NIL THEN new _ this ELSE prev.rest _ this;
};

DecrInsert: PROC [old, this: SetList] RETURNS [new: SetList] = {
thisSize: INT = this.first.class.Size[this.first];
prev: SetList _ NIL;
following: SetList _ new _ old;
WHILE following # NIL AND thisSize <= following.first.class.Size[following.first] DO
prev _ following;
following _ following.rest;
ENDLOOP;
this.rest _ following;
IF prev = NIL THEN new _ this ELSE prev.rest _ this;
};

emptySetClass: SetClass ~ NEW [SetClassPrivate _ [
EmptySetMembership,
DontUnionSingleton,
DontUnionSet,
RemoveEmptySetElt,
EnumerateEmptySet,
EraseEmptySet,
EmptySetSize]];

emptySet: PUBLIC Set ~ NEW [SetPrivate _ [emptySetClass, FALSE, NIL]];

EmptySetMembership: PROC [set: Set, elt: REF ANY] RETURNS [BOOL]
~ {RETURN [FALSE]};
RemoveEmptySetElt: PROC [set: Set, elt: REF ANY] RETURNS [had: BOOL]
~ {RETURN [FALSE]};
EnumerateEmptySet: PROC [set: Set, Consumer: PROC [ra: REF ANY]] ~ {};
EraseEmptySet: PROC [set: Set] ~ {};
EmptySetSize: PROC [set: Set] RETURNS [INT] ~ {RETURN [0]};

DontPutMapping: PUBLIC PROC [m: Mapper, domain, range: REF ANY] RETURNS [newDomain: BOOL] ~ {ERROR};
DontEnumerateMapper: PUBLIC PROC [m: Mapper, Consume: PROC [domain, range: REF ANY]] ~ {ERROR};
DomainCompareByRef: PUBLIC PROC [m: Mapper, r1, r2: REF ANY] RETURNS [BOOL] ~ {RETURN [r1=r2]};
DontAskMapperSize: PUBLIC PROC [m: Mapper] RETURNS [INT] ~ {ERROR};

CreateHashMapper: PUBLIC PROC [parms: HashParms _ []] RETURNS [m: Mapper] = {
hm: HashMapper ~ NEW [HashMapperPrivate _ [RefTab.Create[hash: parms.hash, equal: parms.equal], parms]];
m _ NEW [MapperPrivate _ [class: hashMapperClass, data: hm]]};

CreateHashDictionary: PUBLIC PROC [caseSensitive: BOOL] RETURNS [m: Mapper] = {
m _ CreateHashMapper[IF caseSensitive THEN casefulRopeParms ELSE caselessRopeParms];
};

HashMapper: TYPE ~ REF HashMapperPrivate;
HashMapperPrivate: TYPE ~ RECORD [
ht: RefTab.Ref,
parms: HashParms
];

hashMapperClass: MapperClass = NEW [MapperClassPrivate _ [
Map: MapByHash,
PutMapping: PutHashMapping,
Enumerate: EnumerateHashMapping,
DomainEqual: HashDomainEqual,
Size: HashMappingSize]];

MapByHash: PROC [m: Mapper, domain: REF ANY] RETURNS [range: REF ANY] = {
hm: HashMapper ~ NARROW[m.data];
range _ hm.ht.Fetch[domain].val};

PutHashMapping: PROC [m: Mapper, domain, range: REF ANY] RETURNS [newDomain: BOOL] = {
hm: HashMapper ~ NARROW[m.data];
SELECT range FROM
=NIL => newDomain _ NOT hm.ht.Delete[domain];
#NIL => newDomain _ hm.ht.Store[domain, range];
ENDCASE => ERROR;
};

EnumerateHashMapping: PROC [m: Mapper, Consume: PROC [domain, range: REF ANY]] = {
hm: HashMapper ~ NARROW[m.data];
Pass: PROC [key, val: REF ANY] RETURNS [quit: BOOL _ FALSE] --RefTab.EachPairAction-- = {Consume[key, val]};
[] _ hm.ht.Pairs[Pass];
};

HashDomainEqual: PROC [m: Mapper, r1, r2: REF ANY] RETURNS [BOOL] ~ {
hm: HashMapper ~ NARROW[m.data];
RETURN [IF hm.parms.equal=NIL THEN r1=r2 ELSE hm.parms.equal[r1, r2]];
};

HashMappingSize: PROC [m: Mapper] RETURNS [size: INT] = {
hm: HashMapper ~ NARROW[m.data];
size _ hm.ht.GetSize[]};

CreateProceduralMapperClass: PUBLIC PROC [Map: PROC [m: Mapper, domain: REF ANY] RETURNS [range: REF ANY]] RETURNS [class: MapperClass] ~ {
class _ NEW [MapperClassPrivate _ [Map, DontPutMapping, DontEnumerateMapper, DomainCompareByRef, DontAskMapperSize]];
};

CreateProceduralMapper: PUBLIC PROC [Map: PROC [m: Mapper, domain: REF ANY] RETURNS [range: REF ANY], data: REF ANY _ NIL] RETURNS [m: Mapper] ~ {
class: MapperClass _ CreateProceduralMapperClass[Map];
m _ NEW [MapperPrivate _ [class, FALSE, data]];
};

CreateHashOTO: PUBLIC PROC [hpp: HashParmsPair _ [[], []]] RETURNS [OneToOne] ~ {
RETURN [CreateOTOFromMappers[[leftToRight: CreateHashMapper[hpp[left]], rightToLeft: CreateHashMapper[hpp[right]]]]];
};

CreateOTOFromMappers: PUBLIC PROC [maps: ARRAY Direction OF Mapper] RETURNS [oto: OneToOne] ~ {
mo: MapperOTO ~ NEW [MapperOTOPrivate _ [maps]];
Checkout: PROC [dir: Direction] ~ {
Check: PROC [domain, range: REF ANY] ~ {
IF NOT maps[dir].DomainEqual[maps[OtherDirection[dir]].Map[range], domain] THEN ERROR;
};
maps[dir].EnumerateMap[Check];
};
Checkout[leftToRight];
Checkout[rightToLeft];
oto _ NEW [OneToOnePrivate _ [class: abstractOTOClass, data: mo]];
};

MapperOTO: TYPE ~ REF MapperOTOPrivate;
MapperOTOPrivate: TYPE ~ RECORD [
maps: ARRAY Direction OF Mapper
];

abstractOTOClass: OneToOneClass ~ NEW [OneToOneClassPrivate _ [
Map: MOMap,
PutMapping: PutMOMapping,
Enumerate: EnumerateMO,
Size: MOSize]];

MOMap: PROC [oto: OneToOne, from: REF ANY, dir: Direction] RETURNS [to: REF ANY] ~ {
mo: MapperOTO ~ NARROW[oto.data];
to _ mo.maps[dir].Map[from];
};

PutMOMapping: PROC [oto: OneToOne, pair: Pair] RETURNS [new: LRBits] ~ {
mo: MapperOTO ~ NARROW[oto.data];
oldLeft: REF ANY ~ mo.maps[rightToLeft].Map[pair[right]];
oldRight: REF ANY ~ mo.maps[leftToRight].Map[pair[left]];
leftEq: BOOL ~ mo.maps[leftToRight].DomainEqual[pair[left], oldLeft];
rightEq: BOOL ~ mo.maps[rightToLeft].DomainEqual[pair[right], oldRight];
IF leftEq AND rightEq THEN RETURN [[FALSE, FALSE]];
IF oldLeft#NIL AND NOT leftEq THEN IF mo.maps[leftToRight].PutMapping[oldLeft, NIL] THEN ERROR;
IF oldRight#NIL AND NOT rightEq THEN IF mo.maps[rightToLeft].PutMapping[oldRight, NIL] THEN ERROR;
[] _ mo.maps[leftToRight].PutMapping[pair[left], pair[right]];
[] _ mo.maps[rightToLeft].PutMapping[pair[right], pair[left]];
new _ [oldRight=NIL, oldLeft=NIL];
};

EnumerateMO: PROC [oto: OneToOne, Consume: PROC [Pair]] ~ {
mo: MapperOTO ~ NARROW[oto.data];
Pass: PROC [domain, range: REF ANY] ~ {Consume[[domain, range]]};
mo.maps[leftToRight].EnumerateMap[Pass];
};

MOSize: PROC [oto: OneToOne] RETURNS [size: INT] ~ {
mo: MapperOTO ~ NARROW[oto.data];
size _ mo.maps[leftToRight].MapSize[];
IF mo.maps[rightToLeft].MapSize[] # size THEN ERROR;
};

CreateHashBiRel: PUBLIC PROC [hpp: HashParmsPair _ [[], []]] RETURNS [BiRel] ~ {
hb: HashBiRel ~ NEW [HashBiRelPrivate _ [
parms: hpp,
maps: [CreateHashMapper[hpp[left]], CreateHashMapper[hpp[right]]]
]];
RETURN [NEW [BiRelPrivate _ [hashBiRelClass, TRUE, hb]]];
};

HashBiRel: TYPE ~ REF HashBiRelPrivate;
HashBiRelPrivate: TYPE ~ RECORD [
parms: HashParmsPair,
maps: ARRAY Direction OF Mapper,
size: INT _ 0
];

hashBiRelClass: BiRelClass ~ NEW [BiRelClassPrivate _ [
Map: HBMap,
EnumerateMapping: EnumerateHBMapping,
Enumerate: EnumerateHB,
AddPair: AddHBPair,
RemPair: RemHBPair,
MappingSize: HBMappingSize,
Size: HBSize]];

HBMap: PROC [reln: BiRel, x: REF ANY, dir: Direction] RETURNS [Set] ~ {
hb: HashBiRel ~ NARROW[reln.data];
set: Set ~ NARROW[hb.maps[dir].Map[x]];
RETURN [IF set#NIL THEN set ELSE emptySet];
};

EnumerateHBMapping: PROC [reln: BiRel, x: REF ANY, dir: Direction, Consume: PROC [REF ANY]] ~ {
hb: HashBiRel ~ NARROW[reln.data];
set: Set ~ NARROW[hb.maps[dir].Map[x]];
IF set#NIL THEN set.Enumerate[Consume];
};

EnumerateHB: PROC [reln: BiRel, Consume: PROC [Pair]] ~ {
hb: HashBiRel ~ NARROW[reln.data];
PerLeft: PROC [domain, range: REF ANY] ~ {
set: Set ~ NARROW[range];
PerRight: PROC [right: REF ANY] ~ {Consume[[domain, right]]};
set.Enumerate[PerRight];
};
hb.maps[leftToRight].EnumerateMap[PerLeft];
};

AddHBPair: PROC [reln: BiRel, pair: Pair] RETURNS [news: BOOL] ~ {
hb: HashBiRel ~ NARROW[reln.data];
Add: PROC [dir: Direction] RETURNS [news: BOOL] ~ {
x: REF ANY ~ pair[Source[dir]];
y: REF ANY ~ pair[Dest[dir]];
set: Set _ NARROW[hb.maps[dir].Map[x]];
IF set=NIL THEN IF NOT hb.maps[dir].PutMapping[x, set _ CreateHashSet[hb.parms[Dest[dir]]]] THEN ERROR;
news _ set.UnionSingleton[y];
};
new: ARRAY Direction OF BOOL ~ [Add[leftToRight], Add[rightToLeft]];
IF new[leftToRight] # new[rightToLeft] THEN ERROR;
IF new[leftToRight] THEN hb.size _ hb.size+1;
RETURN [new[leftToRight]];
};

RemHBPair: PROC [reln: BiRel, pair: Pair] RETURNS [had: BOOL] ~ {
hb: HashBiRel ~ NARROW[reln.data];
Rem: PROC [dir: Direction] RETURNS [had: BOOL] ~ {
x: REF ANY ~ pair[Source[dir]];
y: REF ANY ~ pair[Dest[dir]];
set: Set ~ NARROW[hb.maps[dir].Map[x]];
IF set=NIL THEN RETURN [FALSE];
had _ set.RemoveElt[y];
};
hads: ARRAY Direction OF BOOL ~ [Rem[leftToRight], Rem[rightToLeft]];
IF hads[leftToRight] # hads[rightToLeft] THEN ERROR;
IF hads[leftToRight] THEN hb.size _ hb.size-1;
RETURN [hads[leftToRight]];
};

HBMappingSize: PROC [reln: BiRel, x: REF ANY, dir: Direction, limit: INT _ 1] RETURNS [size: INT] ~ {
hb: HashBiRel ~ NARROW[reln.data];
set: Set ~ NARROW[hb.maps[dir].Map[x]];
RETURN [IF set=NIL THEN 0 ELSE set.Size[]];
};

HBSize: PROC [reln: BiRel] RETURNS [INT] ~ {
hb: HashBiRel ~ NARROW[reln.data];
RETURN [hb.size];
};

refAnyParms: PUBLIC HashParms ~ [HashRef, RefEqual];
caselessRopeParms: PUBLIC HashParms ~ [HashRopeModCase, RopeEqualModCase];
casefulRopeParms: PUBLIC HashParms ~ [HashRope, RopeEqual];

HashInt: PROC [key: INT] RETURNS [CARDINAL]
~ {RETURN [HashIntI[key]]};
HashRef: PROC [key: REF ANY] RETURNS [CARDINAL]
~ {RETURN [HashRefI[key]]};
RefEqual: PROC [key1, key2: REF ANY] RETURNS [BOOL]
~ {RETURN [key1 = key2]};
HashRope: PROC [k: REF ANY] RETURNS [CARDINAL]
~ {RETURN [RopeHash.FromRope[NARROW[k], TRUE]]};
RopeEqual: PROC [key1, key2: REF ANY] RETURNS [BOOL]
~ {RETURN [Rope.Equal[NARROW[key1], NARROW[key2], TRUE]]};
HashRopeModCase: PROC [k: REF ANY] RETURNS [CARDINAL]
~ {RETURN [RopeHash.FromRope[NARROW[k], FALSE]]};
RopeEqualModCase: PROC [key1, key2: REF ANY] RETURNS [BOOL]
~ {RETURN [Rope.Equal[NARROW[key1], NARROW[key2], FALSE]]};

END.
\LichenSetTheoryImpl.Mesa
Last tweaked by Mike Spreitzer on May 4, 1987 4:12:38 pm PDT
Κξ˜™Icode™<—J˜KšΟk	œ)˜2K˜šΠbxœœ
˜"Kšœ(˜/Kšœ˜K˜Kšœ
œ˜K˜Kšœœ
œœ
˜ KšΟnœœœ
˜K˜šŸœœ
œœ
œœ˜BKšœœ œ˜6K˜—K˜šœœ˜3K˜K˜K˜
Kš
œ˜K˜Kš
œ
˜
K˜—K˜šŸœœœ
œœœ˜MK˜—K˜KšŸœœ
œœ
œœœœ˜WKšŸœœ
œœ˜7KšŸ
œœ
œœ
œœœœ˜RKšŸ
œœ
œŸœœœ
œœ˜NKšŸ	œœ
œœ˜,KšŸœœ
œœœœ˜?K˜šŸœœ
œœœ
œ˜:KšŸœœœ
œ˜-Kšœœ˜'K˜—K˜KšŸœœŸœœœ
œ˜UK˜Kš
Ÿ
œœœœœ˜;K˜šŸ
œœ
œœ˜IKšœœb˜k—K˜šœœ˜1K˜K˜K˜K˜K˜K˜
K˜—K˜šŸœœœ
œœœ˜JKšœœ˜"K˜—K˜šŸœœœ
œœœ˜LKšœœ˜"K˜K˜—K˜šŸœœ˜,Kšœœ˜#šŸœœœ
œ˜Kš
œ˜—K˜$K˜—K˜šŸœœœ
œœœ˜GKšœœ˜"Kš
œ˜K˜—K˜šŸœœŸœœœ
œ˜?Kšœœ˜"•StartOfExpansionP -- [key: HashTable.Key, value: HashTable.Value] RETURNS [quit: BOOLEAN _ FALSE]šŸœœœ
œœœœΟcœ˜\K˜K˜—Kš
œ˜—K˜šŸœœ˜!Kšœœ˜"K˜—K˜šŸœœœœ˜4Kšœœ˜"Kš
œ˜—K˜šŸœœ
œŸœœœ
œœœœ˜{Kšœœ
˜Œ
K˜—K˜šŸœœ
œŸœœœ
œœœœ˜pKš
œ4˜4Kšœœœœ˜+K˜—K˜Kšœ	œ ˜/K˜KšŸœœœ
œœœœœ˜HK˜Kšœ	œœ˜#šœœœ˜Kšœ -˜BKšœœ
˜Kšœœ˜K˜—K˜Kšœ
œœ
œ˜K˜šœœ˜2K˜K˜K˜K˜K˜K˜
K˜—K˜šŸœœ
œ œœœ˜[Kšœ
œ3˜CKš
œ"˜"šœœ˜Kš
œ˜Kš
œ˜K˜—K˜—K˜šŸœœœ
œœœ˜IKšœ
œ˜šœ#œœ
˜9Kšœ2œ
œœ˜GKšœ
˜—Kšœœ
˜K˜—K˜šŸ
œœ˜*Kšœ
œ˜K˜5K˜K˜—K˜šŸœœŸœœœ
œ˜=Kšœ
œ˜Kšœ
œ
œ
œ
˜Kš
œ5˜5Kš
œ,˜,K˜—K˜šŸœœŸœœœ
œ˜Mšœ œœ
˜3šŸœœœ
œ˜šœœ˜,Kšœ,œ
œ
˜:Kšœ
˜—K˜K˜—Kš
œ)˜)Kšœ
˜—K˜—K˜šŸ	œœœœ˜2Kšœ
œ˜KšŸœœœ
œ˜,Kšœœ
œ
˜-Kšœ
œ
œ
œ˜)Kš
œ-˜-Kš
œ+˜+Kšœœ˜&K˜—K˜šŸœœœ&˜LKšœœ
˜šœœ
˜Kš
œ˜Kš
œ*˜*K˜Kšœ
˜—šœœœ
˜4Kšœ
œ˜*Kšœ
˜—K˜—K˜š
Ÿ
œœ#œΟg
œ‘
œ˜VKš‘
œœ˜%Kš‘
œœ˜%K˜—K˜šŸ
œœœ˜@Kšœ
œ%˜2Kšœœ
˜Kš
œ˜šœ
œ
œ8˜SKš
œ˜Kš
œ˜Kšœ
˜—K˜Kšœœ
œœ˜4K˜—K˜šŸ
œœœ˜@Kšœ
œ%˜2Kšœœ
˜Kš
œ˜šœ
œ
œ9˜TKš
œ˜Kš
œ˜Kšœ
˜—K˜Kšœœ
œœ˜4K˜—K˜šœœ˜2K˜Kš
œ˜Kš
œ
˜
K˜Kš
œ˜Kš
œ˜K˜—K˜Kš	œ
œœœœ˜FK˜šŸœœœ
œœœ
˜@Kšœœœ˜—šŸœœœ
œœœ
˜DKšœœœ˜—KšŸœœŸœœœ
œ˜FKšŸ
œœ˜$Kš
Ÿœœœœœ˜;K˜KšŸœœ
œœ
œœ
œœ˜dKšŸœœ
œ
Ÿœœœ
œœ˜_KšŸœœ
œœ
œœœœ
˜_KšŸœœ
œ
œœœ˜CK˜šŸœœ
œœ˜MKšœœT˜hKšœœ7˜>—K˜š
Ÿœœ
œœœ˜OKšœœœœ˜TK˜—K˜Kšœœœ˜)šœœœ˜"K˜K˜K˜—K˜šœœ˜:KšŸœ˜KšŸ
œ˜KšŸ	œ˜ KšŸœ˜KšŸœ˜—K˜šŸ	œœœ
œœ	œ
œ˜IKšœœ	˜ K˜!—K˜šŸœœœ
œœ
œ˜VKšœœ	˜ šœ˜Kšœ
œœ˜-Kšœ
œ+˜/Kšœœ
˜—K˜—K˜šŸœœ
Ÿœœœ
œ˜RKšœœ	˜ KšŸœœœ
œœœœ œ˜lK˜K˜—K˜šŸœœœ
œœœ˜EKšœœ	˜ Kš
œœœ
œœ˜FK˜—K˜šŸœœ
œœ˜9Kšœœ	˜ Kš
œ˜—K˜šŸœœ
œŸœœœ
œœ	œ
œœ˜‹
Kšœœj˜uK˜—K˜šŸœœ
œŸœœœ
œœ	œ
œ	œ
œœœ˜’
Kš
œ6˜6Kšœœœ	˜/K˜—K˜šŸ
œœ
œ!œ˜QKšœo˜uK˜—K˜šŸœœ
œœœ	œ˜_Kšœœ˜0šŸœœ˜#šŸœœœ
œ˜(Kšœ
œEœ
œ
˜VK˜—Kš
œ˜K˜—Kš
œ˜Kš
œ˜Kšœœ9˜BK˜—K˜Kšœœœ˜'šœœœ˜!Kšœœœ˜K˜—K˜šœ"œ˜?KšŸœ˜KšŸ
œ˜KšŸ	œ˜KšŸœ˜—K˜šŸœœœ
œœœ
œ˜TKšœœ˜!K˜K˜—K˜šŸœœœ˜HKšœœ˜!Kšœ	œ
œ)˜9Kšœ
œ
œ(˜9Kšœœ9˜EKšœ	œ;˜HKšœœ	œ
œœœ˜3Kšœ	œ
œ
œœ
œ*œœ
œ
˜_Kšœ
œ
œ
œ	œ
œ+œœ
œ
˜bK˜>K˜>Kšœœ
œ˜"K˜—K˜šŸœœŸœœ˜;Kšœœ˜!KšŸœœœ
œ˜AK˜(K˜—K˜šŸœœœœ˜4Kšœœ˜!Kš
œ&˜&Kšœ'œ
œ
˜4K˜—K˜šŸœœ
œ!œ˜Pšœœ˜)K˜K˜AK˜—Kšœœ"œ˜9K˜—K˜Kšœœœ˜'šœœœ˜!Kš
œ˜Kšœœœ˜ Kšœœ˜
K˜—K˜šœœ˜7KšŸœ˜KšŸœ˜%KšŸ	œ˜KšŸœ˜KšŸœ˜KšŸœ˜KšŸœ˜—K˜š
Ÿœœœ
œœ
˜GKšœœ˜"Kšœœ˜'Kš
œœœ
œœ˜+K˜—K˜šŸœœœ
œŸœœœ
œ˜_Kšœœ˜"Kšœœ˜'Kšœœ
œ˜'K˜—K˜šŸœœŸœœ˜9Kšœœ˜"šŸœœœ
œ˜*Kšœœ˜KšŸœœ	œ
œ˜=K˜K˜—K˜+K˜—K˜šŸ	œœœœ˜BKšœœ˜"šŸœœœœ˜3Kšœœ
œ˜Kšœœ
œ˜Kšœœ˜'Kšœœ
œ
œ
œFœ
œ
˜gK˜K˜—Kšœœœ
œ(˜DKšœ%œ
œ
˜2Kšœœ˜-Kšœ˜K˜—K˜šŸ	œœœœ˜AKšœœ˜"šŸœœœœ˜2Kšœœ
œ˜Kšœœ
œ˜Kšœœ˜'Kš
œœ
œ
œœ˜Kš
œ˜K˜—Kšœœœ
œ(˜EKšœ'œ
œ
˜4Kšœœ˜.Kšœ˜K˜—K˜šŸ
œœœ
œœœœ˜eKšœœ˜"Kšœœ˜'Kš
œœœ
œœ
˜+K˜—K˜šŸœœœœ˜,Kšœœ˜"Kšœ˜K˜—K˜Kšœ
œ!˜4Kšœœ1˜JKšœœ#˜;K˜š
Ÿœœœœœ
˜+Kšœœ˜—šŸœœœ
œœœ
˜/Kšœœ˜—šŸœœœ
œœœ
˜3Kšœœ˜—šŸœœœ
œœœ
˜.Kšœœœœ˜0—šŸ	œœœ
œœœ
˜4Kš	œœ
œœœ˜:—šŸœœœ
œœœ
˜5Kšœœœœ˜1—šŸœœœ
œœœ
˜;Kš	œœ
œœœ˜;—K˜Kšœ
˜——…—<μS6