DIRECTORY
AllocatorOps USING [Initialize, NewObject],
AtomPrivate USING [UnsafeMakeAtom],
BasicLoadState USING [ConfigID, ConfigInfo, EnumerateConfigs, GlobalFrameToModule, GlobalFrameToType, ModuleToGlobalFrame, SetType, TypeCode],
BcdDefs USING [BcdBase, FTSelf, ModuleIndex, MTHandle, MTIndex, RefLitFrag, RFIndex, RFNull, SGIndex, TFIndex, TFNull, TypeFrag, VersionStamp],
BcdOps USING [ProcessModules],
MPCodes USING [storageInitialized],
PrincOps USING [GlobalFrameHandle, wordsPerPage],
PrincOpsUtils USING [LongCopy],
ProcessorFace USING [SetMP],
RCMap USING [Base, Index, invalidIndex],
RCMapOps USING [Include, MapMap, FindMapMapEntry],
RTBcd USING [AnyStamp, RefLitItem, RTBase, StampList, TypeItem, TypeList, VersionID],
RTSymbolDefs USING [nullXSymbolIndex],
RTTypesBasicPrivate USING [AcquireTypeForLoader, BlessMapStiStd, NotifyAtomRecType, UniqueTypeFinger],
SafeStorage USING [GetPermanentZone, nullType, Type, TypeIndex],
SafeStorageOps USING [],
Table USING [Base],
TimeStamp USING [Null, Stamp],
TypeStrings USING [Code, TypeString],
UnsafeStorage USING [GetSystemUZone];

SafeStorageOpsImpl: PROGRAM
IMPORTS AllocatorOps, AtomPrivate, BasicLoadState, BcdOps, PrincOpsUtils, ProcessorFace, RCMapOps, RTTypesBasicPrivate, SafeStorage, UnsafeStorage
EXPORTS SafeStorageOps
= BEGIN OPEN AtomPrivate, BcdDefs, RTBcd, SafeStorage;

RTBcdVersionMismatch: ERROR = CODE;

uz: UNCOUNTED ZONE = UnsafeStorage.GetSystemUZone[];

configID: BasicLoadState.ConfigID
= BasicLoadState.GlobalFrameToModule[LOOPHOLE[SafeStorageOpsImpl]].config;
bcd: BcdDefs.BcdBase = BasicLoadState.ConfigInfo[configID].bcd;

atomType: Type _ nullType;  -- the concrete type code for ATOM referents

TypeTable: TYPE = RECORD[SEQUENCE length: NAT OF Type];

TypeArray: TYPE = LONG POINTER TO TypeArrayRep;
TypeArrayRep: TYPE = RECORD [SEQUENCE COMPUTED CARDINAL OF Type];

ptt: LONG POINTER TO TypeTable _ NIL;
rcMapMap: RCMapOps.MapMap _ NIL;

atomTypeChain: POINTER TO Type _ NIL;

GetGFRCType: PUBLIC PROC [gfh: PrincOps.GlobalFrameHandle] RETURNS [Type] = {
RETURN[LOOPHOLE[BasicLoadState.GlobalFrameToType[gfh], Type]];
};

AcquireTypesAndLiterals: PUBLIC PROC [bcd: BcdDefs.BcdBase, moduleToGFH: PROC [BcdDefs.ModuleIndex] RETURNS [PrincOps.GlobalFrameHandle], setType: PROC [PrincOps.GlobalFrameHandle, SafeStorage.Type]] = {
rtBase: RTBcd.RTBase;
rfBase, tfBase: Table.Base;
l: NAT;
ptrTypeTable: LONG POINTER TO TypeTable _ NIL;
rrlt: REF RefLitTable _ NIL;
rcmm: RCMapOps.MapMap _ NIL;

doModule: PROC [mth: BcdDefs.MTHandle, mti: BcdDefs.MTIndex] RETURNS [stop: BOOL _ FALSE] = {
WITH mth: mth SELECT FROM
multiple => {
gfh: PrincOps.GlobalFrameHandle = moduleToGFH[mth.gfi];
InternalAssignLiterals[gfh, rrlt, rfBase, mth.refLiterals];
IF mth.types # TFNull THEN {
tFrag: LONG POINTER TO BcdDefs.TypeFrag _ @tfBase[mth.types];
pat: TypeArray _ LOOPHOLE[LONG[gfh+tFrag.offset]];
FOR i: NAT IN [0..tFrag.length) DO
pat[i] _ ptrTypeTable[tFrag[i]]
ENDLOOP;
IF NOT mth.tableCompiled AND mth.frameRefs THEN
setType[gfh, LOOPHOLE[pat[mth.frameType]]];
};
};
ENDCASE;
};

IF (NOT bcd.extended) OR (bcd.rtPages.pages = 0) THEN RETURN;

IF atomType = nullType THEN ERROR;  -- better have done AcquireBasicTypes by now
rtBase _ LOOPHOLE[bcd + bcd.rtPages.relPageBase*PrincOps.wordsPerPage];
IF rtBase.versionIdent # RTBcd.VersionID THEN ERROR RTBcdVersionMismatch;
rfBase _ LOOPHOLE[bcd + bcd.rfOffset];
tfBase _ LOOPHOLE[bcd + bcd.tfOffset];

IF rtBase.rcMapLength # 0 THEN
rcmm _ RCMapOps.Include[LOOPHOLE[@rtBase[rtBase.rcMapBase]], rtBase.rcMapLength, uz];

ptrTypeTable _ AcquireTypes[bcd, rcmm];

l _ rtBase[rtBase.refLitTable].length;
IF l # 0 THEN {
rrlt _ NEW[RefLitTable[l]];  -- collectible!!
FOR i: NAT IN [0..l) DO
rli: RefLitItem = rtBase[rtBase.refLitTable][i];
p: LONG POINTER _ (@rtBase[rtBase.litBase]) + rli.offset;
IF rli.length = 0 THEN {rrlt[i] _ NIL; LOOP};
IF ptrTypeTable[rli.referentType] = atomType
THEN {
rrlt[i] _ UnsafeMakeAtom[LOOPHOLE[p]]
}
ELSE {
rrlt[i] _ AllocatorOps.NewObject[type: ptrTypeTable[rli.referentType], size: rli.length, zone: GetPermanentZone[]];
PrincOpsUtils.LongCopy[from: p, to: LOOPHOLE[rrlt[i]], nwords: rli.length];
};
ENDLOOP;
};

[] _ BcdOps.ProcessModules[bcd, doModule];

IF ptrTypeTable # NIL THEN uz.FREE[@ptrTypeTable];
IF rcmm # NIL THEN uz.FREE[@rcmm];
};

CopyTypesAndLiterals: PUBLIC PROC [bcd: BcdDefs.BcdBase, mi: BcdDefs.ModuleIndex, old, new: PrincOps.GlobalFrameHandle] = {
IF bcd.extended AND bcd.rtPages.pages # 0 THEN {
rtBase: RTBcd.RTBase = LOOPHOLE[bcd + bcd.rtPages.relPageBase*PrincOps.wordsPerPage];
rfBase: Table.Base = LOOPHOLE[bcd + bcd.rfOffset];
tfBase: Table.Base = LOOPHOLE[bcd + bcd.tfOffset];
findMTH: PROC [mth: BcdDefs.MTHandle, mti: BcdDefs.MTIndex] RETURNS [stop: BOOL _ FALSE] = {
IF mi IN [mth.gfi .. mth.gfi + mth.ngfi) THEN {
WITH mth: mth SELECT FROM
multiple => {
InternalCopyLiterals[old, new, rfBase, mth.refLiterals];
IF mth.types # BcdDefs.TFNull THEN {
t: BcdDefs.TFIndex = mth.types;
offset: CARDINAL = tfBase[t].offset;
PrincOpsUtils.LongCopy[
from: LOOPHOLE[LONG[old]+offset],
nwords: tfBase[t].length * SIZE[SafeStorage.Type],
to: LOOPHOLE[LONG[new]+offset]
];
};
};
ENDCASE;
stop _ TRUE;
};
};
IF rtBase.versionIdent # RTBcd.VersionID THEN ERROR;
IF BcdOps.ProcessModules[bcd, findMTH].mth = NIL THEN ERROR;
};  -- end IF bcd.extended AND bcd.rtPages.pages # 0
};

AcquireBasicTypes: PROC = {
rtBase: RTBcd.RTBase;  -- base of RTBcd
tfBase: Table.Base;  -- type table part of the RTBcd

doModule: PROC [mth: BcdDefs.MTHandle, mti: BcdDefs.MTIndex] RETURNS [stop: BOOL _ FALSE] = {
gfh: PrincOps.GlobalFrameHandle = BasicLoadState.ModuleToGlobalFrame[configID, mth.gfi];
IF mth = NIL THEN ERROR;
WITH mth: mth SELECT FROM
multiple =>
IF mth.types # TFNull THEN {
tFrag: LONG POINTER TO BcdDefs.TypeFrag _ @tfBase[mth.types];
pat: POINTER TO Type _ LOOPHOLE[gfh+tFrag.offset];
FOR i: NAT IN [0..tFrag.length) DO
IF ptt[tFrag[i]] = LAST[TypeIndex]
THEN {
(pat+i)^ _ LOOPHOLE[atomTypeChain];
atomTypeChain _ (pat+i);
}
ELSE (pat+i)^ _ ptt[tFrag[i]];
ENDLOOP;
IF NOT mth.tableCompiled AND mth.frameRefs THEN
BasicLoadState.SetType[gfh, LOOPHOLE[(pat+mth.frameType)^]];
};
ENDCASE;
};

IF (NOT bcd.extended) OR (bcd.rtPages.pages = 0) THEN ERROR;
rtBase _ LOOPHOLE[bcd + bcd.rtPages.relPageBase*PrincOps.wordsPerPage];
IF rtBase.versionIdent # RTBcd.VersionID THEN ERROR RTBcdVersionMismatch;
tfBase _ LOOPHOLE[bcd + bcd.tfOffset];
IF rtBase.rcMapLength = 0 THEN ERROR;

rcMapMap _ RCMapOps.Include[LOOPHOLE[@rtBase[rtBase.rcMapBase]], rtBase.rcMapLength, uz];
ptt _ AcquireTypes[bcd, rcMapMap, TRUE];
[] _ BcdOps.ProcessModules[bcd, doModule];
};

AcquireTypes: PROC [bcd: BcdDefs.BcdBase, rcMapMap: RCMapOps.MapMap, initializing: BOOL _ FALSE] RETURNS [ptt: LONG POINTER TO TypeTable _ NIL] = {
rtBase: RTBcd.RTBase = LOOPHOLE[bcd + bcd.rtPages.relPageBase*PrincOps.wordsPerPage];
typeTable: RTBase RELATIVE POINTER TO TypeList _ rtBase.typeTable;
l: NAT _ rtBase[typeTable].length;

IF l # 0 THEN {
ptt _ uz.NEW[TypeTable[l]];
FOR i: NAT IN [0..l) DO
rcmi: RCMap.Index;
ti: TypeItem = rtBase[typeTable][i];
st: RTBase RELATIVE POINTER TO StampList = rtBase.stampTable;
utf: RTTypesBasicPrivate.UniqueTypeFinger
_ [(IF ti.ut.version = AnyStamp
THEN TimeStamp.Null 
ELSE rtBase[st][ti.ut.version]),
[x[ti.ut.sei]]];
ts: TypeStrings.TypeString _ LOOPHOLE[@rtBase[rtBase.litBase] + ti.ct.index];

IF ti.sei = RTSymbolDefs.nullXSymbolIndex THEN {ptt[i] _ nullType; LOOP};
rcmi _ RCMapOps.FindMapMapEntry[rcMapMap, LOOPHOLE[ti.rcMap]];
IF rcmi = RCMap.invalidIndex THEN ERROR;
IF initializing AND IsAtomRecTS[ts]
THEN ptt[i] _ [LAST[TypeIndex]]  -- special case for ATOMs
ELSE {
sgb: Table.Base = LOOPHOLE[bcd + bcd.sgOffset];
ftb: Table.Base = LOOPHOLE[bcd + bcd.ftOffset];
version: TimeStamp.Stamp;
IF sgb[ti.table].file = BcdDefs.FTSelf
THEN version _ bcd.version
ELSE version _ ftb[sgb[ti.table].file].version;
ptt[i] _ RTTypesBasicPrivate.AcquireTypeForLoader [
utf: utf,
std: [symbolsStamp: version, bcd: bcd, sgi: ti.table],
sei: [x[ti.sei]],
ts: ts,
rcmi: rcmi,
canonicalize: TRUE,
initializing: initializing];
};
ENDLOOP;
};
};

AcquireBasicLiterals: PUBLIC PROC [aType: Type] = {
rtBase: RTBcd.RTBase;
rfBase: Table.Base;
l: NAT;
rrlt: REF RefLitTable _ NIL;

doModule: PROC [mth: BcdDefs.MTHandle, mti: BcdDefs.MTIndex] RETURNS [stop: BOOL _ FALSE] = {
IF mth = NIL THEN ERROR;
WITH mth: mth SELECT FROM
multiple => {
gfh: PrincOps.GlobalFrameHandle = BasicLoadState.ModuleToGlobalFrame[configID, mth.gfi];
InternalAssignLiterals[gfh, rrlt, rfBase, mth.refLiterals];
};
ENDCASE;
};


atomType _ aType;
RTTypesBasicPrivate.NotifyAtomRecType[atomType];
UNTIL atomTypeChain = NIL DO
next: POINTER TO Type = LOOPHOLE[atomTypeChain^];
atomTypeChain^ _ atomType;
atomTypeChain _ next;
ENDLOOP;

RTTypesBasicPrivate.BlessMapStiStd[];

rtBase _ LOOPHOLE[bcd + bcd.rtPages.relPageBase*PrincOps.wordsPerPage];
rfBase _ LOOPHOLE[bcd + bcd.rfOffset];

l _ rtBase[rtBase.refLitTable].length;
IF l # 0 THEN {
rrlt _ NEW[RefLitTable[l]];

FOR i: NAT IN [0..l) DO
rli: RefLitItem = rtBase[rtBase.refLitTable][i];
p: LONG POINTER _ (@rtBase[rtBase.litBase]) + rli.offset;
IF rli.length = 0 THEN {rrlt[i] _ NIL; LOOP};
IF ptt[rli.referentType] = LAST[TypeIndex]  -- special case for ATOMs
THEN LOOP
ELSE {rrlt[i] _ AllocatorOps.NewObject[type: ptt[rli.referentType],
size: rli.length,
zone: GetPermanentZone[]];
PrincOpsUtils.LongCopy[from: p, to: LOOPHOLE[rrlt[i]], nwords: rli.length]};
ENDLOOP;
[] _ BcdOps.ProcessModules[bcd, doModule];

FOR i: NAT IN [0..l) DO
rli: RefLitItem = rtBase[rtBase.refLitTable][i];
p: LONG POINTER _ (@rtBase[rtBase.litBase]) + rli.offset;
IF rli.length = 0 THEN {rrlt[i] _ NIL; LOOP};
IF ptt[rli.referentType] = LAST[TypeIndex]  -- special case for ATOMs
THEN rrlt[i] _ UnsafeMakeAtom[LOOPHOLE[p]]
ELSE LOOP;
ENDLOOP;
[] _ BcdOps.ProcessModules[bcd, doModule];
}; 

IF ptt # NIL THEN uz.FREE[@ptt];
IF rcMapMap = NIL THEN ERROR;
uz.FREE[@rcMapMap];

{
p: PROC [otherConfigID: BasicLoadState.ConfigID] RETURNS [BOOL] = {
IF otherConfigID # configID THEN {
moduleToGFH: PROC [mx: BcdDefs.ModuleIndex] RETURNS [PrincOps.GlobalFrameHandle] = {
RETURN[BasicLoadState.ModuleToGlobalFrame[otherConfigID, mx]];
};
setType: PROC [gfh: PrincOps.GlobalFrameHandle, type: Type] = {
BasicLoadState.SetType[gfh, LOOPHOLE[type, BasicLoadState.TypeCode]];
};
AcquireTypesAndLiterals[
bcd: BasicLoadState.ConfigInfo[otherConfigID].bcd,
moduleToGFH: moduleToGFH,
setType: setType
];
};
RETURN[FALSE];
};
[] _ BasicLoadState.EnumerateConfigs[p];
};

ProcessorFace.SetMP[MPCodes.storageInitialized];

};

RefLitTable: TYPE = RECORD [spare: NAT _ 0, refs: SEQUENCE length: NAT OF REF ANY];
RRA: TYPE = REF REF ANY;

InternalAssignLiterals: PROC [gfh: PrincOps.GlobalFrameHandle, rrlt: REF RefLitTable, rfBase: Table.Base, rl: RFIndex] = {
IF rl # RFNull THEN {
rFrag: LONG POINTER TO BcdDefs.RefLitFrag _ @rfBase[rl];
offset: INTEGER _ LOOPHOLE[rFrag.offset, INTEGER];
gfRefTab: LONG POINTER _ LONG[gfh+ABS[offset]];
IF offset > 0
THEN {
FOR i: NAT IN [0..rFrag.length) DO
LOOPHOLE[gfRefTab+i*SIZE[REF ANY], RRA]^ _ rrlt[rFrag[i]]
ENDLOOP;
}
ELSE {
refFrag: REF RefLitTable _ NEW[RefLitTable[rFrag.length]];
FOR i: NAT IN [0..rFrag.length) DO
refFrag[i] _ rrlt[rFrag[i]]
ENDLOOP;
LOOPHOLE[gfRefTab, RRA]^ _ refFrag;
};
};
};

InternalCopyLiterals: PROC [gfh, ngfh: PrincOps.GlobalFrameHandle, rfBase: Table.Base, rl: RFIndex] = {
IF rl # RFNull THEN {
rFrag: LONG POINTER TO BcdDefs.RefLitFrag _ @rfBase[rl];
offset: INTEGER _ LOOPHOLE[rFrag.offset, INTEGER];
abs: NAT _ ABS[offset];
gfRefTab: LONG POINTER _ LONG[gfh+abs];
ngfRefTab: LONG POINTER _ LONG[ngfh+abs];
IF abs = offset
THEN {
refFrag: REF RefLitTable _ NEW[RefLitTable[rFrag.length]];
FOR i: NAT IN [0..rFrag.length) DO
delta: CARDINAL = i*SIZE[REF ANY];
LOOPHOLE[ngfRefTab+delta, RRA]^ _ LOOPHOLE[gfRefTab+delta, RRA]^;
ENDLOOP;
}
ELSE
LOOPHOLE[ngfRefTab, REF REF ANY]^ _ LOOPHOLE[gfRefTab, REF REF ANY]^;
};
};

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


AcquireBasicTypes[];
AllocatorOps.Initialize[];

END.


‚SafeStorageOpsImpl.Mesa
Copyright c 1985 by Xerox Corporation.  All rights reserved.
Paul Rovner, June 27, 1983 11:30 am
Russ Atkinson (RRA) March 2, 1985 11:31:47 pm PST
stuff used during CedarRuntime initialization
communication between AcquireBasicTypes and AcquireBasicLiterals
NOTE assume TypeTable entry in gf is 1 word
this threads thru ATOM referent types in global frame type tables until atomType is known
... is called by the Mesa runtime loader or the Cedar modeller after loading a bcd; this initializes the type table and REF literal table in each new global frame.

foreach module in this bcd...
fill in gftype in gftshadow
START AcquireTypesAndLiterals HERE
Fill in the master tables (types, collectible literals) for the BCD.  Then, foreach MT entry, fix up its type table and collectible literal table in the corresponding GF.
old-style bcd or empty rtBase
now merge the BCD's RCMap base into the rcMapBase that is maintained by RT.
construct rcmm: (BCD rcmapx -> RT rcmapx)
Make a new atom from the pointer.  The allocation will happen inside of UnsafeMakeAtom.
Allocate the literal and copy its contents.
this bcd has an RTBcd
this is the mth for the old global frame
Whiz thru THIS config in the loadstate, acquiring Types.  This config includes SafeStoragePackage.bcd.
foreach module in this bcd...
special case for ATOMs ... link this into atomTypeChain.
fill in gftype in gftshadow
this bcd (SafeStoragePackage and friends) better have somethin' to say
this bcd (SafeStoragePackage and friends) better have somethin' to say
now merge the BCD's RCMap base into the rcMapBase that is maintained by CedarRuntime.
construct rcMapMap: (BCD rcmapx -> CedarRuntime rcmapx)
to solve the atom type bootstrapping problem.
Called AFTER the allocator and ATOM machinery have been initialized.
foreach module found in the loadstate for this config...
START AcquireBasicLiterals here
first, fixup the atom type chain.
next, finish initilizing MapStiStd
next, get the BCD that contains this module (and RT.bcd)
now construct rrlt if there are any REF literals or ATOM constants, and store such REFs in indicated global frames
collectible!! Types have been acquired for SafeStorageOpsImpl by this time.
first acquire REF literals (the rope implementation, invoked by UnsafeMakeAtom, needs 'em)
now acquire ATOMs
UnsafeMakeAtom invokes the ROPE package, which uses REF literals
(but no ATOM literals). The parts of RT.config have no ATOM
literals
now cleanup after the work on this BCD
and foreach config except this one in the basic loadstate invoke (vanilla) AcquireTypesAndLiterals.
now set  the maintenance panel code to indicate that SafeStorage is ready for business
RRA: The spare is not used, but it present to get the REFs on even-word boundaries.  The compiler knows that the references start at word 2, so don't change this!
This used to be a CARDINAL, but we now use it to determine whether we load the literal into the global frame (positive) or into the indirect slot (negative).
Do it the old way, which puts the references into the global frame.
the destination address isn't really a REF, but we need to make the compiler think so in order to increment the reference count correctly.
GFs are initially cleared to all NIL, so this assignment is OK
Do it the new way, which is to use indirection.  The offset tells us where to put the indirect chunk in the global frame, and we put the literal references in the indirect chunk.  This is the way it always should have been done!
This used to be a CARDINAL, but we now use it to determine whether we load the literal into the global frame (positive) or into the indirect slot (negative).
Do it the old way, which gets the references from the global frame.
the addresses are not really REFs, but we need to make the compiler think so;
GFs are initially cleared to all NIL, so this assignment is OK
The literals for the frame are already in the right form, and are at the given slot.
START HERE
ΚŸ˜
codeš
œ™Kšœ
Οm
œ1™<Kš
œ#™#Kš
œ1™1—K˜š
Οk	˜	Kšœ
žœ˜+Kšœžœ˜#Kšœžœz˜Ž
Kšœžœ‚
˜
Kšœžœ˜Kšœžœ˜#Kšœ	žœ#˜1Kšœžœ˜Kšœžœ	˜Kšœžœ˜(Kšœ	žœ$˜2KšœžœJ˜UKšœ
žœ˜&KšœžœM˜fKšœžœ/˜@Kšœžœ˜Kšœžœ˜Kšœ
žœ˜Kšœžœ˜%Kšœžœ˜%K˜—šœž˜Kšžœ‹
˜’
Kšžœ˜Kšœžœ
žœ*˜6—K˜Kšœžœžœ
˜#K˜Kšœž	œ
žœ"˜4K˜˜!Kšœ%žœ˜J—K˜?K˜KšœΟc,˜HK˜Kšœžœžœ
žœ	žœ
žœ˜7K˜Kš	œžœžœ
žœ
žœ˜/Kš
œžœžœžœ
žœ
žœ
žœ˜AK˜š
œ-™-Kš	œžœ
žœ
žœ
žœ
˜%šœžœ
˜ Kš
œ@™@K˜—šœžœ
žœžœ
˜%Kš
œ+™+Kš
œY™YK˜——šΟnœžœ
žœ#žœ˜MKšžœ
žœ/˜>Kš
œ˜K˜—š œžœ
žœ%žœžœ(žœ4˜Λ
Kš
ϣ
™£
K™K˜K˜Kšœžœ
˜Kš	œžœ
žœ
žœ
žœ
˜.Kšœžœžœ
˜Kšœžœ
˜K˜š	œ
žœ/žœžœžœ˜]Kš
œ™šžœ
žœ
ž˜š
œ
˜
Kš
œ7˜7Kš
œ;˜;šžœžœ˜Kšœžœ
žœ
žœ'˜=Kšœžœ
žœ˜2šžœžœ
žœž˜"Kš
œ˜Kšžœ
˜—šžœ
žœžœž˜/Kš
œ™Kšœ
žœ˜+—K˜—K˜—Kšžœ
˜—š
œ˜K˜——š
œ"™"Kš
œͺ
™ͺ
—š
žœžœžœžœ
žœ
˜=Kš
œ™—K˜Kšžœžœ
žœŸ,˜PKšœ	žœ6˜GKšžœ'žœ
žœ˜IKšœ	žœ˜&Kšœ	žœ˜&K˜šžœž˜Kš
œK™KKš
œ)™)šœžœ5˜UK˜——K˜'K˜K˜&šžœžœ˜KšœžœŸ˜-šžœžœ
žœž˜K˜0Kšœžœ
žœ*˜9Kšžœžœžœžœ˜-šžœ*˜,šžœ˜Kš
œW™WKšœžœ˜%K˜
—šžœ˜Kš
œ+™+Kš
œs˜sKšœ$žœ˜KKš
œ˜——Kšžœ
˜—š
œ˜K˜——K˜*K˜Kšžœžœ
žœžœ˜2Kšžœžœ
žœžœ˜"—Kš
œ˜K˜š œžœ
žœZ˜{šžœžœžœ˜0Kš
œ™Kšœžœ6˜UKšœžœ˜2Kšœžœ˜2š	œ	žœ.žœžœžœ˜\šžœžœ žœ˜/Kš
œ(™(šžœ
žœ
ž˜˜
Kš
œ8˜8šžœžœ˜$K˜Kšœžœ˜$š
œ˜Kšœžœ
žœ˜!Kšœžœ˜2Kšœžœ
žœ
˜K˜—K˜—Kš
œ˜—Kšžœ
˜—Kšœžœ
˜Kš
œ˜—Kš
œ˜—Kšžœ'žœ
žœ
˜4Kšžœ+žœ
žœ
žœ
˜<KšœŸ0˜4—K˜—K˜š œžœ˜Kš
œf™fKšœŸ˜'KšœŸ˜4˜Kš
œ™—š	œ
žœ/žœžœžœ˜]Kš
œX˜XKšžœžœ
žœ
žœ
˜šžœ
žœ
ž˜˜šžœžœ˜Kšœžœ
žœ
žœ'˜=Kšœžœ
žœžœ˜2šžœžœ
žœž˜"šžœžœ˜"šžœ˜Kš
œ8™8Kšœžœ˜#Kš
œ˜Kš
œ
˜
—Kšžœ˜—Kšžœ
˜—šžœ
žœžœž˜/Kš
œ™Kšœžœ˜<—K˜——Kšžœ
˜—š
œ˜K˜——š
žœžœžœžœ
žœ
˜<Kš
œF™F—Kšœ	žœ6˜GKšžœ'žœ
žœ˜IKšœ	žœ˜&šžœžœ
žœ
˜%Kš
œF™FK˜—Kš
œU™UKš
œ7™7Kšœžœ5˜YKšœ"žœ˜(K˜*Kš
œ˜K˜—š œžœAžœžœ
žœžœ
žœ
žœ
žœ˜“
Kšœžœ6˜UKšœžœ
žœ
žœ˜BKšœžœ˜"K˜šžœžœ˜Kšœ	žœ˜šžœžœ
žœž˜K˜K˜$Kšœžœ
žœ
žœ˜=˜)šœžœ˜Kšžœ˜Kšžœ˜ K˜——Kšœžœ(˜MK˜Kšžœ(žœžœ˜IKšœ*žœ˜>šžœžœ
žœ
˜(Kš
œ-™-—šžœžœ˜#KšžœžœŸ˜:šžœ˜Kšœžœ˜/Kšœžœ˜/K˜šžœ$˜&Kšžœ˜Kšžœ+˜/—˜3K˜	K˜6K˜K˜K˜Kšœžœ
˜K˜——K˜—Kš
ž˜—Kš
œ˜—š
œ˜K˜——š œžœ
žœ˜3Kš
œD™DKš
œ˜K˜Kšœžœ
˜Kšœžœžœ
˜K˜š	œ
žœ/žœžœžœ˜]Kš
œ8™8Kšžœžœ
žœ
žœ
˜šžœ
žœ
ž˜š
œ
˜
Kš
œX˜XKš
œ;˜;K˜—Kšžœ
˜—Kš
œ˜—K˜š
œ™K˜—Kš
œ!™!K˜K˜0šžœž˜Kšœžœ
žœžœ˜1K˜K˜Kšžœ
˜K˜—Kš
œ"™"K˜%K˜Kš
œ8™8Kšœ	žœ6˜GKšœ	žœ˜&K˜Kš
œr™rK˜&šžœžœ˜Kšœžœ˜Kš
œK™KK˜Kš
œZ™Zšžœžœ
žœž˜K˜0Kšœžœ
žœ*˜9Kšžœžœžœžœ˜-šžœžœ
Ÿ˜EKšžœ
ž˜	šžœ?˜CK˜K˜Kšœ$žœ ˜L——Kšžœ
˜—K˜*˜Kš
œ™—šžœžœ
žœž˜K˜0Kšœžœ
žœ*˜9Kšžœžœžœžœ˜-šžœžœ
Ÿ˜Ešžœžœ˜*Kš
œ@™@Kš
œ;™;Kš
œ™—Kšžœ
žœ
˜
—Kšžœ
˜—K˜*K˜K˜Kš
œ&™&—Kšžœžœ
žœžœ˜ Kšžœžœ
žœ
žœ
˜Kšœžœ˜K˜š
œ
˜
Kš
œc™cšœžœ*žœžœ˜Cšžœžœ˜"šœ
žœž	œ ˜TKšžœ8˜>K˜—šœ	žœ2˜?Kšœžœ!˜EK˜—˜K˜2K˜K˜K˜—K˜—Kšžœ
žœ˜K˜—K˜(K˜—K˜Kš
œV™V˜0K˜—Kš
œ˜—K˜šœ
žœžœ	žœžœ	žœ
žœ
žœ
žœ˜SKš
œ’
™’
—Kš
žœžœžœ
žœ
žœ
˜K˜š œžœ)žœ2˜zšžœ
žœ˜Kšœžœ
žœ
žœ"˜8šœžœžœžœ˜2Kšœžœƒ
™
—Kš	œ
žœ
žœžœžœ
˜/šžœ˜
šžœ˜Kš
œC™Cšžœžœ
žœž˜"š
žœžœ
žœ
žœžœ˜9Kš
œŠ
™Š
Kš
œ>™>—Kšžœ
˜—K˜
—šžœ˜Kš
œδ
™δ
Kšœ	žœžœ˜:šžœžœ
žœž˜"Kš
œ˜Kšžœ
˜—Kšžœžœ
˜#K˜——K˜—K˜K˜—š œžœM˜gšžœ
žœ˜Kšœžœ
žœ
žœ"˜8šœžœžœžœ˜2Kšœžœƒ
™
—Kšœžœžœ	˜Kšœ
žœ
žœžœ
˜'Kšœžœ
žœžœ˜)šžœ
˜šžœ˜Kš
œC™CKšœ	žœžœ˜:šžœžœ
žœž˜"Kš	œžœžœ
žœ
žœ˜"šžœžœžœžœ˜AK™MKš
œ>™>—Kšžœ
˜—K˜
—š
ž˜K™TKšžœžœ
žœ
žœžœžœ
žœ
žœ˜E——K˜—K˜K˜—š œžœžœžœ˜AKšžœžœ	žœ˜FKš
œ˜K˜K˜—š
œ
™
K˜K˜K˜—Kšžœ
˜K˜K˜—…—/ŠO«