DIRECTORY PreDebug, Rope, IO, UnsafePropList, UnsafeFreeList;

UnsafePropListImpl: CEDAR MONITOR
LOCKS locks[idx] USING idx: [0..lockNum) 
IMPORTS PreDebug, IO, UnsafeFreeList
EXPORTS UnsafePropList ~
BEGIN OPEN UnsafePropList; 

debugSelf: BOOL ~ FALSE;  --Debugging aid

PropListAddr: TYPE = POINTER TO PropRef;
PropRef: TYPE = REF PropRec;
PropRec: TYPE = RECORD [key: REF, val: REF, next: PropRef Ź NIL, selfCheck: CARD];

lockNum: CARD = 32; --use multiple locks to avoid lock contention on multiprocessor 
shiftRight: CARD = 16; --means shift 4 bits

locks: ARRAY [0..lockNum) OF MONITORED RECORD [
condition: CONDITION, freeList: PropRef Ź NIL, freeAvail: INT Ź localFreeListMax
];

localFreeListMax: INT ~ 15;
globalFreeList: UnsafeFreeList.Context ~ UnsafeFreeList.NewContext[100];

BadSelfCheck: ERROR [listAddr: PropListAddr] = CODE;

Disguise: PROC [listAddr: PropListAddr] RETURNS [CARD] = INLINE {
RETURN [CARD.LAST - LOOPHOLE[listAddr, CARD]]
};

New: INTERNAL PROC [idx: [0..lockNum)] RETURNS [p: PropRef] = TRUSTED {
p Ź locks[idx].freeList;
IF p#NIL THEN {
IF debugSelf THEN {
IF p.selfCheck#2 THEN ERROR;
};
locks[idx].freeList Ź p.next; 
locks[idx].freeAvail Ź locks[idx].freeAvail+1; 
p.next Ź NIL;
RETURN
};
p Ź LOOPHOLE[UnsafeFreeList.Get[globalFreeList]]; 
IF p=NIL 
THEN p Ź NEW[PropRec] 
ELSE IF debugSelf THEN { IF p.selfCheck#4 THEN ERROR }; 
};

Dispose: INTERNAL PROC [idx: [0..lockNum), p: PropRef] = TRUSTED {
IF debugSelf THEN {IF p.selfCheck MOD 2 = 0 THEN ERROR};
p.key Ź NIL; p.val Ź NIL;
IF locks[idx].freeAvail>0 THEN {--limit growth of free lists
IF debugSelf THEN {p.selfCheck _ 2};
p.next Ź locks[idx].freeList; locks[idx].freeList Ź p;
locks[idx].freeAvail Ź locks[idx].freeAvail-1;
RETURN;
};
IF debugSelf THEN {p.selfCheck _ 4};
UnsafeFreeList.Free[globalFreeList, LOOPHOLE[p]];
};

InternalDisposeMany: INTERNAL PROC [idx: [0..lockNum), p: PropRef] = {
WHILE p#NIL DO
next: PropRef ~ p.next;
Dispose[idx, p];
p Ź next;
ENDLOOP;
};

EntryDisposeMany: ENTRY PROC [idx: [0..lockNum), first: PropRef] = {
InternalDisposeMany[idx, first]
};

InternalPut: INTERNAL PROC [idx: [0..lockNum), listAddr: PropListAddr, first: PropRef, key, val: REF] RETURNS [old: REF Ź NIL] = TRUSTED {
FOR p: PropRef Ź first, p.next WHILE p#NIL DO
IF p.key=key THEN {old Ź p.val; p.val Ź val; RETURN};
ENDLOOP;
BEGIN
n: PropRef ~ New[idx]; 
n.selfCheck Ź Disguise[listAddr]; n.key Ź key; n.val Ź val; n.next Ź first;
listAddr­ Ź n 
END;
};

EntryPutProp: ENTRY PROC [idx: [0..lockNum), listAddr: PropListAddr, key, val: REF] RETURNS [old: REF Ź NIL] = TRUSTED INLINE {
first: PropRef Ź listAddr­;
IF first#NIL AND first.selfCheck#Disguise[listAddr] THEN 
RETURN WITH ERROR BadSelfCheck[listAddr];
old _ InternalPut[idx, listAddr, first, key, val];
};

EntryTrustedAddNewProp: ENTRY PROC [idx: [0..lockNum), listAddr: PropListAddr, key, val: REF] = TRUSTED INLINE {
first: PropRef Ź listAddr­;
IF first#NIL AND first.selfCheck#Disguise[listAddr] THEN 
RETURN WITH ERROR BadSelfCheck[listAddr];
IF val#NIL THEN {
n: PropRef ~ New[idx]; 
n.selfCheck Ź Disguise[listAddr]; n.key Ź key; n.val Ź val; n.next Ź first;
listAddr­ Ź n 
};
};

InternalRem: INTERNAL PROC [idx: [0..lockNum), listAddr: PropListAddr, first: PropRef, key: REF] RETURNS [old: REF Ź NIL] = TRUSTED {
IF first.key=key THEN {
old Ź first.val;
listAddr­ Ź first.next; Dispose[idx, first];
RETURN;
};
FOR p: PropRef Ź first, p.next WHILE p#NIL DO
next: PropRef Ź p.next;
IF next#NIL AND next.key=key THEN {
old Ź next.val;
p.next Ź next.next; Dispose[idx, next];
RETURN;
};
ENDLOOP;
};

EntryRemProp: ENTRY PROC [idx: [0..lockNum), listAddr: PropListAddr, key: REF] RETURNS [old: REF Ź NIL] = TRUSTED INLINE {
p: PropRef Ź listAddr­;
IF p=NIL THEN RETURN;
IF p.selfCheck#Disguise[listAddr] THEN RETURN WITH ERROR BadSelfCheck[listAddr];
old _ InternalRem[idx, listAddr, p, key];
};

InternalGet: INTERNAL PROC [p: PropRef, key: REF] RETURNS [val: REF Ź NIL] = INLINE {
WHILE p#NIL DO
IF p.key=key THEN RETURN [p.val];
p Ź p.next
ENDLOOP;
};

EntryGetProp: ENTRY PROC [idx: [0..lockNum), listAddr: PropListAddr, key: REF] RETURNS [val: REF Ź NIL] = TRUSTED INLINE {
RETURN [InternalGet[listAddr­, key]]
};

EntryConditionalPutProp: ENTRY PROC [idx: [0..lockNum), listAddr: PropListAddr, key, expect, new: REF] RETURNS [old: REF Ź NIL, done: BOOL Ź FALSE] = TRUSTED {
first: PropRef Ź listAddr­;
IF first#NIL AND first.selfCheck#Disguise[listAddr] THEN 
RETURN WITH ERROR BadSelfCheck[listAddr];
FOR t: PropRef Ź first, t.next WHILE t#NIL DO
IF t.key=key THEN {
old Ź t.val;
IF old=expect THEN {t.val Ź new; done Ź TRUE};
RETURN [old, done];
};
ENDLOOP;
IF expect=NIL THEN {
n: PropRef ~ New[idx]; 
n.selfCheck Ź Disguise[listAddr]; n.key Ź key; n.val Ź new; n.next Ź first;
listAddr­ Ź n; 
done Ź TRUE
};
};

EntryConditionalRemProp: ENTRY PROC [idx: [0..lockNum), listAddr: PropListAddr, key, expect: REF] RETURNS [old: REF Ź NIL, done: BOOL Ź FALSE] = TRUSTED {
first: PropRef Ź listAddr­;
IF first#NIL THEN {
IF first.selfCheck#Disguise[listAddr] THEN 
RETURN WITH ERROR BadSelfCheck[listAddr];
IF first.key=key THEN {
old Ź first.val;
IF old=expect THEN {listAddr­ Ź first.next; Dispose[idx, first]; done Ź TRUE};
RETURN [old, done];
};
FOR p: PropRef Ź first, p.next WHILE p#NIL DO
next: PropRef Ź p.next;
IF next#NIL AND next.key=key THEN {
old Ź first.val;
IF old=expect THEN {p.next Ź next.next; Dispose[idx, next]; done Ź TRUE};
RETURN [old, done];
};
ENDLOOP;
};
};

EntryNiloutProp: ENTRY PROC [idx: [0..lockNum), listAddr: PropListAddr] = TRUSTED INLINE {
first: PropRef Ź listAddr­;
IF first#NIL THEN {
listAddr­ Ź NIL;
IF first.selfCheck#Disguise[listAddr] THEN RETURN; --It is not the time to raise errors as some applications might call EntryNiloutProp from finalizers.  However we have to be careful nevertheless.
InternalDisposeMany[idx, first]
};
};

EntryCopy: ENTRY PROC [idx: [0..lockNum), listAddr: PropListAddr, selfCheck: CARD] RETURNS [p: PropRef Ź NIL] = TRUSTED {
tail: PropRef;
source: PropRef Ź listAddr­;
IF source#NIL THEN {
IF source.key=mySpecialKey THEN {
source _ source.next;
IF source=NIL THEN RETURN;
};
p Ź tail Ź New[idx];
tail.selfCheck Ź selfCheck; tail.key Ź source.key; tail.val Ź source.val;
source Ź source.next;
WHILE source#NIL DO
IF source.key#mySpecialKey THEN {
tail.next Ź New[idx]; tail Ź tail.next;
tail.selfCheck Ź selfCheck; tail.key Ź source.key; tail.val Ź source.val;
};
source Ź source.next;
ENDLOOP;
};
};

GetProp: PUBLIC PROC [listAddr: PropListAddr, key: REF] RETURNS [REF] = {
idx: [0..lockNum) ~ (LOOPHOLE[listAddr, CARD]/shiftRight) MOD lockNum;
IF listAddr=NIL THEN ERROR;
RETURN [EntryGetProp[idx, listAddr, key]];
};

PutProp: PUBLIC PROC [listAddr: PropListAddr, key, val: REF] RETURNS [old: REF] = {
idx: [0..lockNum) ~ (LOOPHOLE[listAddr, CARD]/shiftRight) MOD lockNum;
IF listAddr=NIL THEN ERROR;
IF val#NIL 
THEN old Ź EntryPutProp[idx, listAddr, key, val]
ELSE old Ź EntryRemProp[idx, listAddr, key] 
};

RemProp: PUBLIC PROC [listAddr: PropListAddr, key: REF] RETURNS [old: REF] = {
idx: [0..lockNum) ~ (LOOPHOLE[listAddr, CARD]/shiftRight) MOD lockNum;
IF listAddr=NIL THEN ERROR;
old _ EntryRemProp[idx, listAddr, key];
};

TrustedAddNewProp: PUBLIC PROC [listAddr: PropListAddr, key, val: REF] = {
idx: [0..lockNum) ~ (LOOPHOLE[listAddr, CARD]/shiftRight) MOD lockNum;
IF listAddr=NIL THEN ERROR;
EntryTrustedAddNewProp[idx, listAddr, key, val];
};

Enumerate: PUBLIC PROC [listAddr: PropListAddr, map: EachPropProc, data: REF Ź NIL] RETURNS [quit: BOOL Ź FALSE] = TRUSTED {
IF listAddr#NIL AND listAddr­#NIL THEN {
idx: [0..lockNum) ~ (LOOPHOLE[listAddr, CARD]/shiftRight) MOD lockNum;
copy: PropRef Ź EntryCopy[idx, listAddr, 1];
FOR p: PropRef Ź copy, p.next WHILE p#NIL AND ~quit DO
quit Ź map[data, p.key, p.val];
ENDLOOP;
EntryDisposeMany[idx, copy];
};
};

ConditionalPutProp: PUBLIC PROC [listAddr: PropListAddr, key, expect, new: REF] RETURNS [val: REF, done: BOOL] = {
idx: [0..lockNum) ~ (LOOPHOLE[listAddr, CARD]/shiftRight) MOD lockNum;
IF listAddr=NIL THEN ERROR;
IF new#NIL 
THEN [val, done] Ź EntryConditionalPutProp[idx, listAddr, key, expect, new]
ELSE [val, done] Ź EntryConditionalRemProp[idx, listAddr, key, expect] 
};

NiloutPropList: PUBLIC PROC [listAddr: PropListAddr] = TRUSTED {
p: PropRef Ź listAddr­;  --implicite error test of listAddr#NIL
IF p#NIL THEN {
idx: [0..lockNum) ~ (LOOPHOLE[listAddr, CARD]/shiftRight) MOD lockNum;
EntryNiloutProp[idx, listAddr];
};
};

mySpecialKey: REF ATOM Ź NEW[ATOM Ź $SpecialKey]; --this key hangs in arbitrary property list.  Its value is a PropRef whose val field is a property list

EntryAssertSpecial: ENTRY PROC [idx: [0..lockNum), listAddr: PropListAddr] = TRUSTED INLINE  {
first: PropRef Ź listAddr­;
IF first#NIL AND first.selfCheck#Disguise[listAddr] THEN 
RETURN WITH ERROR BadSelfCheck[listAddr];
[] _ InternalAssertSpecial[idx, listAddr, first]
};

InternalAssertSpecial: INTERNAL PROC [idx: [0..lockNum), listAddr: PropListAddr, first: PropRef] RETURNS [PropRef] = TRUSTED  {
WITH InternalGet[first, mySpecialKey] SELECT FROM
s: PropRef => RETURN [s]; 
ENDCASE => {
container: PropRef Ź New[idx]; 
value: PropRef Ź New[idx]; 
value.selfCheck Ź container.selfCheck Ź Disguise[listAddr];  
container.val Ź value; container.key Ź mySpecialKey;
container.next Ź first;
listAddr­ Ź container; 
RETURN [container];
};
};

EntryLockForInit: ENTRY PROC [idx: [0..lockNum), listAddr: PropListAddr, key: REF] RETURNS [must: LockingResult, val: REF] = TRUSTED {
DO --terminated only by calling RETURN 
BEGIN --serves to hold an EXITS redoLoopFromStart
special: PropListAddr;
first: PropRef Ź listAddr­;
FOR p: PropRef Ź first, p.next WHILE p#NIL DO
IF p.key=key THEN {
RETURN [notLockedBecauseValueFound, p.val]; --even if val=NIL !
};
ENDLOOP;
WITH InternalGet[first, mySpecialKey] SELECT FROM
value: PropRef => special Ź LOOPHOLE[@value.val]; 
ENDCASE => {
RETURN WITH ERROR BadSelfCheck[listAddr];
};
FOR p: PropRef Ź special­, p.next WHILE p#NIL DO
IF p.key=key THEN {
WAIT locks[idx].condition;
GOTO redoLoopFromStart; 
};
ENDLOOP;
BEGIN 
s: PropRef Ź New[idx];
s.selfCheck Ź Disguise[listAddr]; 
s.key Ź key; s.val Ź $occupied; 
s.next Ź special­;
IF <<first is not NIL; it contains at least the special property>> first.selfCheck#Disguise[listAddr] THEN 
RETURN WITH ERROR BadSelfCheck[listAddr];
special­ Ź s;
RETURN [newlyLocked, NIL]; 
END;
EXITS redoLoopFromStart => {};
END;
ENDLOOP;
};

EntryUnlockAndStore: ENTRY PROC [idx: [0..lockNum), listAddr: PropListAddr, key, val: REF, storeVal: BOOL] = TRUSTED {
InternalRemoveBlocking: INTERNAL UNSAFE PROC [idx: [0..lockNum), listAddr: PropListAddr, first: PropRef, key: REF] = TRUSTED INLINE {
WITH InternalGet[first, mySpecialKey] SELECT FROM
s: PropRef => {
special: PropListAddr Ź LOOPHOLE[@s.val]; 
specialFirst: PropRef Ź special­;
IF specialFirst=NIL THEN <<oops>> RETURN;
IF specialFirst.next=NIL AND specialFirst.key=key 
THEN {
Dispose[idx, specialFirst];
Dispose[idx, s];
[] _ InternalRem[idx, listAddr, first, mySpecialKey];
}
ELSE {
[] _ InternalRem[idx, special, specialFirst, key];
};
};
ENDCASE => {<<oops; turkey already removed it>>};
};

first: PropRef Ź listAddr­;
IF storeVal THEN {
IF first#NIL AND first.selfCheck#Disguise[listAddr] THEN 
RETURN WITH ERROR BadSelfCheck[listAddr];
IF val=NIL 
THEN [] _ InternalRem[idx, listAddr, first, key]
ELSE [] _ InternalPut[idx, listAddr, first, key, val];
};
first Ź listAddr­; --first might have been overwritten by InternalRem or InternalPut
IF first#NIL AND first.selfCheck#Disguise[listAddr] THEN 
RETURN WITH ERROR BadSelfCheck[listAddr];
InternalRemoveBlocking[idx, listAddr, first, key];
BROADCAST locks[idx].condition;
};

LockingResult: TYPE = {newlyLocked, notLockedBecauseValueFound, occupiedTryAgain};

GetPropOrInit: PUBLIC PROC [listAddr: PropListAddr, key: REF, init: InitializeProcType, data: REF] RETURNS [val: REF, done: BOOL _ FALSE] = {
idx: [0..lockNum) ~ (LOOPHOLE[listAddr, CARD]/shiftRight) MOD lockNum;
IF listAddr=NIL THEN ERROR;
val Ź EntryGetProp[idx, listAddr, key];
IF val#NIL THEN RETURN;
EntryAssertSpecial[idx, listAddr]; 
DO --until success...
res: LockingResult;
[res, val] Ź EntryLockForInit[idx, listAddr, key]; 
SELECT res FROM
newlyLocked =>  {
val Ź init[data, key]; --if init crashes this key will not be cleaned but damage is local and doesn't propagate to other property lists or other keys. 
EntryUnlockAndStore[idx, listAddr, key, val, TRUE];
done Ź TRUE;
RETURN
};
notLockedBecauseValueFound => RETURN;
ENDCASE => {};
ENDLOOP
};


EntryAssign: ENTRY PROC [idx: [0..lockNum), destAddr: PropListAddr, newFirst: PropRef] = TRUSTED {
first: PropRef Ź destAddr­;
IF first#NIL THEN {
IF first.selfCheck#Disguise[destAddr] THEN 
RETURN WITH ERROR BadSelfCheck[destAddr];
destAddr­ Ź NIL;
InternalDisposeMany[idx, first];
};
destAddr­ _ newFirst
};

CopyPropList: PUBLIC PROC [destAddr, sourceAddr: PropListAddr] = {
sIdx: [0..lockNum) ~ (LOOPHOLE[sourceAddr, CARD]/shiftRight) MOD lockNum;
dIdx: [0..lockNum) ~ (LOOPHOLE[destAddr, CARD]/shiftRight) MOD lockNum;
copy: PropRef;
IF destAddr=NIL OR sourceAddr=NIL THEN ERROR;
copy Ź EntryCopy[sIdx, sourceAddr, Disguise[destAddr]];
EntryAssign[dIdx, destAddr, copy];
};

MyExplain: PreDebug.Explainer = {
PreDebug.Raise[signalOrError, args ! BadSelfCheck => {
msg Ź IO.PutFR1["UnsafePropListImpl.BadSelfCheck[listAddr: %g]", IO.card[LOOPHOLE[listAddr]]];
CONTINUE
}];
};

PreDebug.RegisterErrorExplainer[error: BadSelfCheck, explain: MyExplain];
END.

   ¸  
UnsafePropListImpl.mesa
Copyright Ó 1992 by Xerox Corporation.  All rights reserved.
Created by Christian Jacobi, April 9, 1992 11:48:58 am PDT
Christian Jacobi, April 21, 1992 1:59 pm PDT

--Local caches would average out nicely, if there weren't Enumerate
When this error is raised it means that somebody made a copy of a property list.  Not detecting this would be bad because a PropRef then could be put on the free-list while it still is in use by the other copy of the property list. 
Fine point: first is listAddr^ and is checked.  We read listAddr^ just once, to prevent error of clients assigning unchecked PropRef.
Fine point: first is listAddr^ and is checked, but we read listAddr^ just once, to prevent error assigning unchecked PropRef
--IF expect=NIL THEN ... not worth special casing because client crazy	
Makes copy of property list WITHOUT special container
Copies the property list atomically, then enumerates the copy.  
Assert that a property containing a special property list is there.  This simplifies other procedures by not having to deal with inventing it.  However we will not remember it.
Assert that a property containing a special property list is there and returns it.
NOTE: Do not remember the special container after the lock is released; I am afraid a turkey fools around with the original property list in the mean time.  RE-aquireing it is not expensive as this property is at the front of the list most of the time.
Blocks the logical lock for key
--try whether value got put there by somebody else in the mean time
--Get the special property list containing blocked keys; it is at the front most often.
--somebody removed the special property list.  This is bad, but it could really happen with a client erronously overwriting the property list in the mean time.  
RETURN [notLockedBecauseValueFound, NIL]; 
--Check the special property list whether our key should wait
--somebody else holds the lock; lets wait until he is done
--Lock was free; mark it occupied for key
--Use original listAddr disguise instead of special disguise to avoid lock order problem.
--Do not use InternalPut: the disguise would be wrong.  
EntryLockForUpdate: ENTRY PROC [idx: [0..lockNum), listAddr: PropListAddr, key: REF] RETURNS [val: REF] = TRUSTED {
Blocks the logical lock for key
DO --terminated only by calling RETURN 
BEGIN --serves to hold an EXITS redoLoopFromStart
special: PropListAddr;
container: PropRef;
first: PropRef Ź listAddr­;
IF first#NIL AND first.selfCheck#Disguise[listAddr] THEN 
RETURN WITH ERROR BadSelfCheck[listAddr];
container _ InternalAssertSpecial[idx, listAddr, first]; --inside loop for safety against NILout
special Ź LOOPHOLE[@container.val];
--Check the special property list whether our key should wait
FOR p: PropRef Ź special­, p.next WHILE p#NIL DO
IF p.key=key THEN {
--somebody else holds the lock; lets wait until he is done
WAIT locks[idx].condition;
GOTO redoLoopFromStart; 
};
ENDLOOP;
val _ InternalGet[first, key];
--Lock was free; mark it occupied for key
BEGIN 
--Use original listAddr disguise instead of special disguise to avoid lock order problem.
--Do not use InternalPut: the disguise would be wrong.  
s: PropRef Ź New[idx];
s.selfCheck Ź Disguise[listAddr]; 
s.key Ź key; s.val Ź $occupied; 
s.next Ź special­;
special­ Ź s;
END;
EXITS redoLoopFromStart => {};
END;
ENDLOOP;
};

Stores val and frees the logical block for key

--this was the single lock hold (frequent case)
--Order matters as Dispose can be destructive
--there are other locks hold (rare case)
--Check first if the property already is initialized; that is where speed matters
--Carefully assert a logical lock and init the property if necessary within the logical lock
UpdateProcType: TYPE = PROC [data: REF, key, val: REF] RETURNS [new: REF _ NIL, store: BOOL _ FALSE];
Update: PUBLIC PROC [listAddr: PropListAddr, key: REF, update: UpdateProcType, data: REF] = {
I have decided not to export this procedure as it is excluding only itself and GetPropOrInit but not PutProp while the client procedure is executing.  I would know how to fix PutProp and friends, but I do not want to pay availability of Update by slowing down PutProp.  Ch. J. April 15, 1992 4:27:59 pm PDT
new, old: REF; store: BOOL;
idx: [0..lockNum) ~ (LOOPHOLE[listAddr, CARD]/shiftRight) MOD lockNum;
IF listAddr=NIL THEN ERROR;
old Ź EntryLockForUpdate[idx, listAddr, key]; 
[new, store] Ź update[data, key, old ! UNWIND => {store _ FALSE; CONTINUE}]; 
EntryUnlockAndStore[idx, listAddr, key, new, store];
};

 ĘŐ  (cedarcode) styleNewlineDelimiter
 codeK
Ďe1<K::K,K KĎk	4=K Ďn!K)K$KKK KĎc)K K
	(K		K	RK K	 @TK +K 		/K	PKK KHHKCK 4JččK 
AK
-KK 
GKKKKK/K	KKK&2	K
K8KK #BK8K
 <K$K6K.KKK$K$1KK $FKKK	KKK (DKKK GJ-K5KKKKKKKK 7K$9K)K22KK 7pK$9K)KKKKKKK BJ||KK,,KK-K#KK'KKKKK 2zKKK
 PK))KK UK	!K
KKK 2zK$KK ?K$9K)-KK.KKKKKKKKKKK :KJ3G$+K)KK6NKK-K#KK1IKKKKKK 
/ZKKK$ ĹKKKK 	8yK55KK!KKKKKIIK!K'KIIKKKKKK IK	FK
K$*KK $SK	FK
K,0K(,KK NK	FK
K''KK $JK	FK
K00KK 	3|J@

(K	FK,	6KKKKKK ,rK	FK
KGKKCGKK @K &?K	FKKKK K
 gK 
/^J°°K$9K)K00KK 
=JRRJüü"1KKKK=K4KKKKKK 2J $' +1KKJCC-K& ?KKJWW"1K2KĄĄK)J*KJ==0J::KKKKJ))JYYJ88KK"K KĎi;&kK)KKKKKKKK 2sJ $' +1KKK$9K)J9 '`J
#J==0J::KKKKKJ))JYYJ88KK"K KKKKKKKK 7vJ.J B"1K
*K!K
)2K//K--KKK55KK((K22KKK*1KK K
$9K)K,0K26KK AT$9K)K22K	KK K?RK "K	FK
KQQK'KK\\K## KK33K K-3KKKK%KKKK K	eK 
 ]K˛˛K
	K	FK
K..K'MK44KK BbK$+K)KK  KKKK )BK	IK	GKK
-K77K""KK 	!6K9^JJKK KIIKK      4´  [A  