DIRECTORY
AllocatorOps USING[permanentPageZone],
BrandXSymbolDefs USING[PreDefinedSEI],
BrandYSymbolDefs USING[PreDefinedSEI],
Basics USING[BITAND, BITSHIFT, LowHalf],
RCMap USING[Index],
RCMapOps USING[Initialize],
RTSymbolDefs USING[SymbolIndex, nullSymbolIndex],
RTTypesBasicPrivate USING
[FindSTI, UniqueTypeFinger, STDesc, TMapStiStd, SymbolTableIndex, LOOPHOLEDTMapStiStd, LOOPHOLEDRMapStiStd, TypeDesc, TMapTiTd, PTypeDesc, RMapTiTd],
RTTypesBasicPrivateChanges USING [InitialSTIRangeSize],
SafeStorage USING[TypeIndex, Type, nullType, anyType, lastPredefinedTypeIndex],
StorageTraps USING[],
TimeStamp USING[Null],
TypeHash USING [TypeKey, nullKey, TypeStrHash, WordPerKey],
TypeStrings USING[Code, TypeString],
UnsafeStorage USING[GetSystemUZone],
VM USING[AddressForPageNumber, Allocate];

TypesBasicImpl: MONITOR  -- protects data structures for runtime types
IMPORTS AllocatorOps, Basics, RTTypesBasicPrivate, RCMapOps, TypeHash, UnsafeStorage, VM
EXPORTS RTTypesBasicPrivate, SafeStorage,  StorageTraps

= BEGIN OPEN bx: BrandXSymbolDefs, by: BrandYSymbolDefs, RTSymbolDefs, RTTypesBasicPrivate, RTTypesBasicPrivate, RTTypesBasicPrivateChanges, SafeStorage, TypeHash, TypeStrings;

InitialTiRangeSize: CARDINAL = 10000B;  -- a power of 2, divisible by PageSize (for MapTiTd)
InitialUTFRangeSize: CARDINAL = 10000B;  -- a power of 2, divisible by PageSize (for MapUTFTi)
InitialTsRangeSize: CARDINAL = 4000B;  -- a power of 2, divisible by PageSize (for MapTsTdl)
rcMapBasePages: CARDINAL = 30;

uz: UNCOUNTED ZONE _ UnsafeStorage.GetSystemUZone[];
lastTypeIndex: TypeIndex _ lastPredefinedTypeIndex;
nullTD: TypeDesc _ [utf: [umid: TimeStamp.Null, seIndex: nullSymbolIndex], symbolAccess: [], myType: nullType, typekey: nullKey];
atomRecType: Type _ nullType;

MapTiTd: PUBLIC TMapTiTd; -- table: TypeIndex -> PTypeDesc
TMapTsTdl: TYPE = RECORD[SEQUENCE length: CARDINAL OF PTypeDesc];
MapTsTdl: LONG POINTER TO TMapTsTdl;
TMapUTFTi: TYPE = RECORD[SEQUENCE length: CARDINAL OF TypeIndex];
MapUTFTi: LONG POINTER TO TMapUTFTi;

MapStiStd: PUBLIC TMapStiStd;  -- EXTREMELY delicate initialization. WATCH OUT.

InvalidType: PUBLIC ERROR[type: Type] = CODE;
NarrowFault: PUBLIC ERROR = CODE;
NarrowRefFault: PUBLIC ERROR[ref: REF ANY, targetType: Type] = CODE;
TooManyTypes: ERROR = CODE;



EquivalentTypes: PUBLIC SAFE PROC[t1, t2: Type] RETURNS[BOOLEAN] = TRUSTED {
IF t1 = t2 THEN RETURN[TRUE];
RETURN[GetCanonicalType[t1] = GetCanonicalType[t2]];
};

GetCanonicalType: PUBLIC ENTRY SAFE PROC[t: Type] RETURNS[Type] = TRUSTED {
ENABLE UNWIND => NULL; 
RETURN[DoGetCanonicalType[t]];
};

NotifyAtomRecType: PUBLIC PROC[type: Type] = { atomRecType _ type};

GetLastTypeIndex: PUBLIC PROC RETURNS[ans: TypeIndex _ lastTypeIndex] = {}; 

CheckForNarrowRefFault: PUBLIC PROC[ref: REF ANY, targetType: Type] 
RETURNS[REF ANY] = {
IF ref = NIL THEN RETURN[NIL] 
ELSE ERROR NarrowRefFault[ref: ref, targetType: targetType];
};

GetMapTiTd: PUBLIC PROC RETURNS [ans: LONG POINTER TO RMapTiTd _ MapTiTd] = {}; 

Enter: PUBLIC ENTRY PROC[inner: PROC] = { ENABLE UNWIND => NULL; inner[]; };

AcquireTypeForLoader: PUBLIC ENTRY PROC
[utf: UniqueTypeFinger,
std: STDesc,
sei: SymbolIndex,
ts: TypeString,
rcmi: RCMap.Index,
canonicalize: BOOLEAN _ FALSE,
initializing: BOOL _ FALSE]
RETURNS[Type] = { 
ENABLE UNWIND => NULL;
ptd: PTypeDesc;
IF canonicalize THEN 
ptd _ FindCanonicalPTD[ts]
ELSE ptd _ FindPTD[utf, ts];
RETURN[IF ptd # NIL THEN ptd.myType ELSE 
MakeNewType[utf, std, sei, ts, rcmi, canonicalize, initializing]
];
};


CopyString: PROC[s: LONG STRING] RETURNS[ns: LONG STRING] = {
ns _ LOOPHOLE[uz.NEW[TEXT[s.length]]];
AppendString[to: ns, from: s];
};

AppendString: PROC [to: LONG STRING, from: LONG STRING] = {
i, j, n: CARDINAL;
IF to = NIL OR from = NIL THEN RETURN;
IF from.length + to.length > to.maxlength THEN ERROR;
n _ MIN[from.length, LOOPHOLE[to.maxlength - to.length, CARDINAL]];
i _ to.length;
j _ 0;
WHILE j < n DO to[i] _ from[j]; i _ i + 1; j _ j + 1; ENDLOOP;
to.length _ i;
};

EqualStrings: PROC[s1, s2: LONG STRING] RETURNS [ans: BOOL _ TRUE] = {
IF s1 = NIL AND s2 = NIL THEN RETURN[TRUE];
IF s1 = NIL OR s2 = NIL OR s1.length # s2.length THEN RETURN[FALSE];
FOR i: CARDINAL IN [0..s1.length) DO IF s1[i] # s2[i] THEN RETURN[FALSE]; ENDLOOP;
};

MakeNewType: PUBLIC INTERNAL PROC[utf: UniqueTypeFinger,
std: STDesc,
sei: SymbolIndex,
ts: TypeString,
rcmx: RCMap.Index,
canonicalize: BOOLEAN _ FALSE,
initializing: BOOLEAN _ FALSE,
type: Type _ nullType]
RETURNS[Type] = { 
ptd: PTypeDesc;
   tk: TypeKey = TypeStrHash[ts];
sti: SymbolTableIndex;
IF type = nullType THEN type _ [NewTypeIndex[utf]];
sti _ IF (WITH sei SELECT FROM
			t: SymbolIndex.x => LOOPHOLE[t.e, CARDINAL] IN bx.PreDefinedSEI,
			t: SymbolIndex.y => LOOPHOLE[t.e, CARDINAL] IN by.PreDefinedSEI,
		ENDCASE => ERROR) AND MapStiStd[1] # NIL
	THEN 1
	ELSE FindSTI[std, initializing];
MapTiTd[type] _ ptd _ uz.NEW [TypeDesc _ [rcmx: rcmx,
													   equivalentType: nullType,
													utf: utf,
												 symbolAccess: [sti: sti, sei: sei],
												 myType: type,
												 typekey: tk]
									  ];
IF canonicalize THEN {
ptd.equivalentType _ type;
EnterNewCanonicalType[ptd, ts];
} ELSE
ptd.equivalentType _ DoGetCanonicalType[type, ts];
RETURN[type];
};

DoGetCanonicalType: INTERNAL PROC[t: Type, ts: TypeString _ ""] RETURNS[Type] = { 
cptd, ptd: PTypeDesc;
IF t <= anyType THEN RETURN[t];
ptd _ MapTiTd[t];
IF ptd.equivalentType # nullType THEN RETURN[ptd.equivalentType];

cptd _ FindCanonicalPTD[ts];
IF cptd = NIL THEN { 
ptd.equivalentType _ t;
EnterNewCanonicalType[ptd, ts];
RETURN[t];
}
ELSE { 
ptd.equivalentType _ cptd.equivalentType;
ptd.extension _ cptd.extension;  -- there can't be one already
RETURN[ptd.equivalentType];
};
};


EnterNewCanonicalType: INTERNAL PROC[ptd: PTypeDesc, ts: TypeString] = { 
probe: CARDINAL = TsHash[ts];
ptd.next _ MapTsTdl[probe];
MapTsTdl[probe] _ ptd;
};

NewTypeIndex: INTERNAL PROC[utf: UniqueTypeFinger] RETURNS[typeIndex: TypeIndex] = {
utfProbe: CARDINAL;
nLooks: CARDINAL _ 0;
lastTypeIndex _ (typeIndex _ lastTypeIndex + 1);
IF lastTypeIndex = InitialTiRangeSize OR lastTypeIndex = LAST[TypeIndex] THEN 
ERROR TooManyTypes;
FOR utfProbe _ FirstUTFProbe[utf] , NextUTFProbe[utfProbe] 
UNTIL MapUTFTi[utfProbe] = nullType DO
IF (nLooks _ nLooks + 1) > MapUTFTi.length THEN ERROR TooManyTypes;
ENDLOOP;
MapUTFTi[utfProbe] _ typeIndex;
};

EstablishAtomRecUTF: INTERNAL PROC[utf: UniqueTypeFinger] = { 
utfProbe: CARDINAL;
nLooks: CARDINAL _ 0;
FOR utfProbe _ FirstUTFProbe[utf] , NextUTFProbe[utfProbe]
UNTIL MapUTFTi[utfProbe] = nullType DO
IF (nLooks _ nLooks + 1) > MapUTFTi.length THEN ERROR TooManyTypes;
ENDLOOP;
MapUTFTi[utfProbe] _ atomRecType; MapTiTd[LOOPHOLE[atomRecType]].utf _ utf;
};


FindCanonicalPTD: PUBLIC INTERNAL PROC[ts: TypeString] RETURNS[ptd: PTypeDesc] = {
IF IsAtomRecTS[ts] THEN {
IF atomRecType = nullType THEN ERROR; 
ptd _ MapTiTd[atomRecType];
} ELSE 
ptd _ FindEQVType[ts];
};

FindEQVType: INTERNAL PROC[ts: TypeString] RETURNS[PTypeDesc] = {
key: TypeKey = TypeStrHash [ts]; 
FOR candidate: PTypeDesc _ MapTsTdl[TsHash[ts]], candidate.next UNTIL candidate = NIL
DO IF EqualKey[key, candidate.typekey] THEN RETURN[candidate] ENDLOOP;
RETURN[NIL];
};

FindPTD: PUBLIC INTERNAL PROC[utf: UniqueTypeFinger, ts: TypeString _ NIL]
RETURNS[ptd: PTypeDesc] = {
utfProbe: CARDINAL;
nLooks: CARDINAL _ 0;
FOR typeIndex: TypeIndex _ MapUTFTi[utfProbe _ FirstUTFProbe[utf]], 
MapUTFTi[utfProbe _ NextUTFProbe[utfProbe]] UNTIL Type[typeIndex] = nullType DO
IF MapTiTd[typeIndex].utf = utf THEN
RETURN[MapTiTd[typeIndex]];
IF (nLooks _ nLooks + 1) > MapUTFTi.length THEN ERROR TooManyTypes; 
ENDLOOP;
IF ts # NIL AND IsAtomRecTS[ts] THEN {
IF atomRecType = nullType THEN ERROR;
EstablishAtomRecUTF[utf];
RETURN[MapTiTd[atomRecType]];
} ELSE RETURN[NIL];
}; 

TsHash: INTERNAL PROC[ts: TypeString] RETURNS[CARDINAL] = INLINE {
acc: CARDINAL _ 0;
FOR i: CARDINAL IN [0..MIN[7, ts.length]) DO
acc _ 7*acc+LOOPHOLE[ts[i], CARDINAL];
ENDLOOP;
RETURN[acc MOD InitialTsRangeSize];
};

EqualTS: INTERNAL PROC[ts1, ts2: TypeString] RETURNS[ans: BOOLEAN _ TRUE] =
 INLINE { RETURN[EqualStrings[ts1, ts2]] };

IsAtomRecTS: INTERNAL PROC[ts: TypeString] RETURNS[BOOLEAN] = {
RETURN[ts.length = 1 AND ts[0] = LOOPHOLE[TypeStrings.Code[atomRec]]];
};

EqualKey: PROC [key1, key2: TypeKey] RETURNS [ans: BOOLEAN _ TRUE] = {
FOR i: CARDINAL IN [0..WordPerKey) DO
IF key1[i] # key2[i] THEN RETURN [FALSE];
ENDLOOP;
};

FirstUTFProbe: INTERNAL PROC[utf: UniqueTypeFinger] RETURNS[CARDINAL] = INLINE {
RETURN [
Basics.BITAND[Basics.BITSHIFT[LOOPHOLE[Basics.LowHalf[utf.umid.time], CARDINAL] +
				 LOOPHOLE[utf.seIndex, CARDINAL], 2], MapUTFTi.length-1]
]
};

NextUTFProbe: INTERNAL PROC[probe: CARDINAL] RETURNS[CARDINAL] = 
INLINE { RETURN[Basics.BITAND[probe + 1, MapUTFTi.length-1]] };





LOOPHOLE[MapStiStd, LOOPHOLEDTMapStiStd]  -- until the sun comes up.
_ AllocatorOps.permanentPageZone.NEW[LOOPHOLEDRMapStiStd[InitialSTIRangeSize]];
FOR i: CARDINAL IN [0..InitialSTIRangeSize) DO
 LOOPHOLE[MapStiStd, LOOPHOLEDTMapStiStd][i] _ NIL;
 ENDLOOP;

MapTiTd _ LOOPHOLE[AllocatorOps.permanentPageZone.NEW[RMapTiTd[InitialTiRangeSize]]];
FOR i: CARDINAL IN [0..InitialTiRangeSize) DO MapTiTd[i] _ NIL ENDLOOP;
MapTiTd[nullType] _ @nullTD;

MapUTFTi _
LOOPHOLE[AllocatorOps.permanentPageZone.NEW[TMapUTFTi[InitialUTFRangeSize]]];
FOR i: CARDINAL IN [0..InitialUTFRangeSize) DO MapUTFTi[i] _ nullType ENDLOOP;

MapTsTdl _ LOOPHOLE[AllocatorOps.permanentPageZone.NEW[TMapTsTdl[InitialTsRangeSize]]];
FOR i: CARDINAL IN [0..InitialTsRangeSize) DO MapTsTdl[i] _ NIL ENDLOOP;

RCMapOps.Initialize
[LOOPHOLE
[VM.AddressForPageNumber[VM.Allocate[count: rcMapBasePages, in64K: TRUE].page]],
rcMapBasePages
];

END.

CHANGE LOG

^///users/koo.pa/TypesBasicImplExtra.mesa
Last Modified by Richard Koo on June 28, 1984 3:51:32 pm PDT  

Constants --
Variables --
hash map: TypeStructure -> PTypeDesc
hash map: UniqueTypeFinger -> TypeIndex
ERRORs
PUBLIC procedures
BEWARE NOTE don't microcode this without changing InternalGetCanonicalReferentType
The Atom pkg is ready
Use by CedarProbe
This procedure value goes into SD and used by NARROW
std identifies original source symbolStamp,
bcd and sgi for a symbol seg that contains
below sei (entry may be copied and relocated).

***********************************
PRIVATE procedures
***********************************
BEWARE NOTE don't microcode this without changing InternalGetCanonicalReferentType
here to "canonicalize" t
t would have been canonicalized
here if utf is not yet registered
It would be nice to double the size and chek; get a new hash table; rehash; release old table and try again.
It would be nice to double the size and chek; get a new hash table; rehash; release old table and try again.
keep track of the canonical types. The representation is a hash map: TypeStructure -> PTypeDesc
It would be nice to double the size and chek; get a new hash table; rehash; release old table and try again.
Stolen from TexHash.mesa
*****************************
M O D U L E  I N I T I A L I Z A T I O N   S T A R T S   H E R E 
Changed by Koo on June 28, 1984 3:45:57 pm PDT:
Changes are done throughout to reflect the change of the definition of TypeDesc in RTTypesBasicPrivate.  One significant change is when canonicalization is performed; now it is done when a new type is entered into MapTiTd.
�Ê/˜š
œ(™(Jš
œ>™>J™—š
Ïk	˜	Jšœ
�œ˜&Jšœ�œ˜&Jšœ�œ˜&Jšœ�œ
�œ�œ˜(Jšœ�œ˜Jšœ	�œ
˜Jšœ
�œ˜1šœ�˜Jš
ϥ
˜•
—Jšœ�œ˜7Jšœ�œ>˜OJšœ
�œ˜Jšœ
�œ˜Jšœ	�œ-˜;Jšœ�œ˜$Jšœ�œ˜$Jš�œ
�œ!˜)J˜—šœ�œÏc-˜FJš�œO�˜Xš�œ0˜7J˜——šœ�œ
�œ¤
˜°
J˜—Jš
œ™Jšœ�œž4˜\Jšœ�œž5˜^Jšœ�œž5˜\Jšœ�œ˜J˜Jš
œ™Jšœ�	œ
�œ"˜4J˜3Jš
œ�
˜�
J˜J˜Jšœ	�œž ˜:Jšœ�œ�œ
�œ	�œ
�œ˜Ašœ
�œ
�œ
�œ˜$Jš
œ$™$—Jšœ�œ�œ
�œ	�œ
�œ˜Ašœ
�œ
�œ
�œ˜$Jš
œ'™'J˜—Jšœ�œž0˜OJ˜Jš
œ™Jšœ
�œ
�œ�œ
˜-Jšœ
�œ
�œ�œ
˜!Jšœ�œ
�œ�œ
�œ�œ
˜DJšœ�œ�œ
˜J˜J˜Jš
œ™J˜šÏnœ�œ
�œ
�œ�œ
�œ�œ˜LJš�œ	�œ
�œ
�œ˜Jš�œ.˜4Jš
œ˜J˜—Jš
œR™RšŸœ�œ
�œ
�œ
�œ
�œ	�œ˜KJš�œ
�œ�œ˜Jš�œ˜Jš
œ˜J˜—Jš
ž™JšŸœ�œ
�œ%˜CJ˜Jš
ž™JšŸœ�œ
�œ
�œ'˜LJ˜Jšœ!ž™4š
Ÿœ�œ
�œ�œ
�œ˜Dš�œ
�œ
�œ˜Jš
�œ�œ
�œ
�œ
�œ˜Jš�œ
�œ2˜<—Jš
œ˜J˜—JšŸ
œ�œ
�œ
�œ�œ
�œ
�œ˜PJ˜JšŸœ�œ
�œ
�œ�œ�œ
�œ�œ
˜LJ˜šŸœ�œ
�œ
�˜'˜˜Jš
œ+™+Jš
œ*™*Jš
œ.™.—J˜J˜J˜Jšœ�œ�œ
˜Jšœ�œ�œ
˜—š�œ˜Jš�œ
�œ�œ
˜J˜š�œ�œ
˜Jš
œ˜—Jš�œ˜š
�œ
�œ�œ
�œ�œ
˜)Jš
œ@˜@—Jš
œ˜—š
œ˜J˜——J™Jš
œ#™#Jš
œ™Jš
œ#™#J˜šŸ
œ�œ�œ
�œ�œ�œ
�œ˜=Jšœ�œ�œ
�œ
˜&J˜J˜J˜—šŸœ�œ�œ
�œ�œ
�œ˜;Jšœ	�œ
˜Jš�œ�œ
�œ�œ
�œ
�œ
˜&Jš�œ(�œ
�œ
˜5Jšœ�œ�œ�œ˜CJ˜J˜Jš�œ�œ(�œ
˜>J˜J˜J˜—šŸœ�œ	�œ
�œ�œ�œ�œ˜FJš�œ�œ
�œ�œ
�œ
�œ
�œ˜+Jš�œ�œ
�œ�œ
�œ�œ
�œ
�œ˜DJš�œ�œ
�œ�œ
�œ�œ
�œ
�œ�œ
˜RJ˜J˜—šŸœ�œ
�œ
�œ˜8J˜J˜J˜J˜Jšœ�œ�œ
˜Jšœ�œ�œ
˜J˜š�œ˜Jš
œ˜—˜!J˜Jš�œ�œ˜3šœ�œ�œ�œ
�˜Jšœ�œ�œ�œ˜CJšœ�œ�œ�œ˜CJšœ�œ�œ�œ�˜*Jšœ
�œ˜Jšœ
�œ˜!—Jšœ�œ˜5š
œ)˜)˜J˜0J˜Jš
œ˜——J˜
š�œ�œ˜Jš
œ˜Jš
œ˜—šœ
�˜Jš
œ2˜2—Jš�œ˜
Jš
œ˜——J˜Jš
œR™RšŸœ�œ
�œ�œ˜RJš
œ˜Jš�œ�œ
�œ˜J˜Jš�œ�œ
�œ˜AJ˜Jš
œ™Jš
œ˜š�œ�œ
�œ˜Jš
œ˜Jš
œ˜Jš�œ˜
—Jš
œ
˜
š�œ˜Jš
œ)˜)Jšœ!ž˜>Jš
œ™Jš�œ˜—Jš
œ˜š
œ˜˜J˜———šŸœ�œ
�œ%˜IJšœ�œ˜J˜J˜˜J˜Jš
œ!™!——šŸœ�œ
�œ�œ˜TJšœ
�œ
˜Jšœ�œ˜J˜0š�œ$�œ�œ�œ
˜NJš�œ˜—š�œ8˜;Jš�œ�˜&Jš�œ)�œ
�œ˜CJš
œl™lJš�œ
˜—J˜J˜J˜—šŸœ�œ
�œ˜>Jšœ
�œ
˜Jšœ�œ˜š�œ7˜:š�œ�˜&Jš�œ)�œ
�œ˜CJš
œl™l—Jš�œ
˜—Jšœ*�œ˜KJš
œ˜J˜—Jš
œ_™_J˜š
Ÿœ�œ
�œ
�œ�œ˜Rš�œ�œ˜Jš�œ�œ
�œ˜&Jš
œ˜—šœ
�œ
˜Jš
œ˜—J˜J˜—šŸœ�œ
�œ�œ˜AJš
œ!˜!š�œ=�œ
�˜UJš
�œ
�œ"�œ
�œ�œ
˜F—Jš�œ
�œ˜š
œ˜J˜——š
Ÿœ�œ
�œ
�œ)�œ
˜Jš�œ˜Jšœ
�œ
˜Jšœ�œ˜š�œA˜DJšœ,�œ�˜Oš�œ�˜$Jš�œ˜—Jš�œ)�œ
�œ˜DJš
œl™lJš�œ
˜—š�œ�œ
�œ�œ˜&Jš�œ�œ
�œ
˜%Jš
œ˜Jš�œ˜—Jšœ�œ
�œ
�œ˜—Jš
œ˜—J˜Jš
œ™šŸœ�œ
�œ�œ
�œ�œ˜BJšœ�œ˜š	�œ�œ
�œ�œ�˜,Jšœ�œ�œ˜&Jš�œ
˜—Jš�œ�œ˜#š
œ˜J˜——šŸœ�œ
�œ�œ�œ�œ˜KJšœ
�œ�œ˜+—J˜š
Ÿœ�œ
�œ�œ
�œ˜?Jš�œ�œ	�œ˜FJš
œ˜—š
Ÿœ�œ�œ�œ�œ˜Fš�œ�œ
�œ�˜%Jš�œ�œ
�œ�œ˜)Jš�œ
˜—J˜J˜—šŸ
œ�œ
�œ�œ
�œ�œ˜Pš�œ˜Jš	œ�œ�œ
�œ �œ˜QJšœ�œ�œ˜<Jš
œ
˜
—š
œ˜J˜——šŸœ�œ
�œ�œ�œ
�œ˜AJš�œ�œ�œ"˜?—J˜Jš
œ™J˜J˜J˜Jš
œA™A˜š�œ"ž˜DJšœ!�œ+˜O—š�œ�œ
�œ�˜.Jšœ
�œ&�œ
˜3Jšœ
�œ
˜	J˜—Jšœ
�œ �œ ˜UJš�œ�œ
�œ�œ�œ
�œ
˜GJ˜J˜š
œ
˜
Jš�œ �œ"˜M—Jš
�œ�œ
�œ�œ�œ
˜NJ˜Jšœ�œ �œ!˜WJš�œ�œ
�œ�œ�œ
�œ
˜HJ˜š
œ˜šœ
�˜	Jšœ
�œ�œ(�œ	˜PJš
œ˜—Jš
œ˜J˜——Jš�œ
˜J˜š�œ
�˜
J˜™/Jš
œÞ
™Þ
———…—&L:Ù