DIRECTORY
BcdDefs USING [Base, BcdBase, FPHandle, MTHandle, SPHandle],
BootFile USING [Location],
BootStartList USING [
BackingLocation, Entry, Header, Index, nullSpaceIndex, nullSwapUnitIndex, SpaceIndex, SpaceType, startIndex, SwapUnitIndex, SwapUnitInfo, SwapUnitState, Base, versionID],
MB USING [
BHandle, BIndex, BitArray, BitArrayObject, DumpSegs, EnumerateBCDs, EnumerateCode, EnumerateFramePacks, EnumerateGlobalFrames, EnumerateSpaces, Handle, nullIndex, PreScanSegsForOutput, VirtualGlobalFrame],
MBVM USING [
AllocMDSData, Base, CodeSeg, DataSeg, FileSeg, LongCopyWrite, MDS, Pages, PointerFromSeg, Seg, Segs, SortSegs],
PrincOps USING [GlobalFrameHandle, NullControl],
PrincOpsUtils USING [AddressForPageNumber, LongCOPY, PagesForWords, WordsForPages],
Space USING [Create, Delete, Handle, LongPointer, Map, nullHandle, virtualMemory];

MBScript: PROGRAM
IMPORTS MB, MBVM, PrincOpsUtils, Space
EXPORTS MB =

BEGIN

OPEN BootStartList;

PageState: TYPE = RECORD [busy, resident, in, readOnly, mds, first64K: BOOL];

data: MB.Handle _ NIL;
segs: MBVM.Segs _ NIL;
residentTable, resDescTable, inTable, readOnlyTable: MB.BitArray _ NIL;
suIndex: SwapUnitIndex;

scriptIndex: Index;
scriptPages: CARDINAL;
scriptBase: Base;
scriptSpace: Space.Handle;

InitScript: PUBLIC PROC [h: MB.Handle] = {
nullLocation: BootFile.Location = [
deviceType: null,
deviceOrdinal: 0,
vp: any[a: 0, b: 0, c: 0, d: 0, e: 0, f: 0, g: 0, h: 0]];
data _ h;
data.header _ NEW[Header _ [
version: versionID,
release: [0, 0, 0],
buildDate: 0,
requiredUCode: [0, 0, 0, 0],
controlList:  PrincOps.NullControl,
initLoadState: nullSwapUnitIndex,
mdsBase: 0,
pdaPages: 0,
stateVectorCounts: ALL[0],
stateVectorSize: 0,
nProcesses: 0,
lastVMPage: 0,
lastBootLoadedPage: 0,
switches: [0,0,0,0],
locDebuggerMicrocode: nullLocation,
locDebuggerGerm: nullLocation,
locDebugger: nullLocation,
locDebuggee: nullLocation
]];
scriptIndex _ startIndex;
scriptPages _ 0;
scriptBase _ NIL;
scriptSpace _ Space.nullHandle;
segs _ NIL;
};

FinishScript: PUBLIC PROC = {
residentTable _ resDescTable _ inTable _ readOnlyTable _ NIL;
data.header _ NIL;
IF scriptBase ~= NIL THEN {
Space.Delete[scriptSpace];
scriptBase _ NIL;
scriptSpace _ Space.nullHandle;
};
segs _ NIL;
data _ NIL;
};

InitBitTables: PROC [length: CARDINAL] = {
residentTable _ NEW[MB.BitArrayObject[length]];
FOR i: CARDINAL IN [0..length) DO residentTable[i] _ FALSE; ENDLOOP;
resDescTable _ NEW[MB.BitArrayObject[length]];
FOR i: CARDINAL IN [0..length) DO resDescTable[i] _ FALSE; ENDLOOP;
inTable _ NEW[MB.BitArrayObject[length]];
FOR i: CARDINAL IN [0..length) DO inTable[i] _ FALSE; ENDLOOP;
readOnlyTable _ NEW[MB.BitArrayObject[length]];
FOR i: CARDINAL IN [0..length) DO readOnlyTable[i] _ FALSE; ENDLOOP;
};

MakeScript: PUBLIC PROC = {
header: REF Header = data.header;
r: stop Entry _ Entry[stop[]];
nSpaces: CARDINAL _ 0;
state: PageState _ [FALSE, FALSE, FALSE, FALSE, FALSE, FALSE];
inMDS, inFirst64K: BOOL;
mdsBase: CARDINAL = data.mdsBase;
newState: PageState;
i, nwords, start: CARDINAL;
scriptSeg: MBVM.DataSeg;
segs _ MBVM.SortSegs[];
InitBitTables[data.vmMap.length];
FOR i IN [0..segs.length) DO AddToBitTables[segs[i]] ENDLOOP;
ClassifyPages[];
FOR i IN [0..data.lastVMPage] DO
inMDS _ (i IN [mdsBase..mdsBase+255]);
inFirst64K _ (i IN [0..255]);
newState _ [
busy: data.vmMap[i], resident: residentTable[i], in: inTable[i],
readOnly: readOnlyTable[i], mds: inMDS, first64K: inFirst64K
];
IF newState ~= state THEN {state _ newState;  nSpaces _ nSpaces + 1};
ENDLOOP;
nwords _ 0;
FOR i IN [0..segs.length) DO
WITH seg: segs[i] SELECT FROM
data => nwords _ nwords + SIZE[swapUnit Entry];
code =>
nwords _ nwords +
(IF seg.sph ~= NIL THEN seg.sph.length*SIZE[swapUnit Entry] ELSE SIZE[swapUnit Entry]);
file =>
IF seg.bIndex = MB.nullIndex THEN nwords _ nwords + SIZE[swapUnit Entry]
ELSE {
loadee: MB.BHandle = data.inputBCDs.bcds[seg.bIndex];
IF loadee.bcd.rtPages.pages ~= 0 THEN nwords _ nwords + 2*SIZE[swapUnit Entry]
ELSE nwords _ nwords + SIZE[swapUnit Entry];
};
ENDCASE;
ENDLOOP;
nwords _ (nwords + SIZE[Header] + 16 --?? RL--  + nSpaces*SIZE[space Entry]);
AddScriptWords[nwords];
scriptSeg _ MBVM.AllocMDSData[base: MBVM.MDS, pages: scriptPages];
scriptSeg.bootLoaded _ TRUE;
scriptSeg.info _ [readOnly: FALSE, state: swappable];
AddToBitTables[scriptSeg];
data.scriptBaseInVM _
PrincOpsUtils.AddressForPageNumber[data.mdsBase] +
LOOPHOLE[MBVM.PointerFromSeg[scriptSeg], CARDINAL];
segs _ MBVM.SortSegs[];
FOR i IN [0..segs.length) DO EnterSegment[segs[i]] ENDLOOP;
IF data.debug THEN MB.DumpSegs[segs, "SCRIPT CONSTRUCTION"];
state _ [
busy: data.vmMap[0], resident: residentTable[0], in: inTable[0],
readOnly: readOnlyTable[0], mds: mdsBase = 0, first64K: TRUE
];
start _ 0;
suIndex _ LOOPHOLE[startIndex];
FOR i IN [1..data.lastVMPage] DO
inMDS _ i IN [mdsBase..mdsBase+255];
inFirst64K _ i IN [0..255];
newState _ [
busy: data.vmMap[i], resident: residentTable[i], in: inTable[i],
readOnly: readOnlyTable[i], mds: inMDS, first64K: inFirst64K
];
IF newState ~= state THEN {AddSpace[state, start, i-1];  start _ i;  state _ newState};
ENDLOOP;
AddSpace[state, start, data.lastVMPage];
AppendBootWords[@r, SIZE[stop Entry]];
header.buildDate _ LOOPHOLE[data.buildTime];
header.lastBootLoadedPage _ MB.PreScanSegsForOutput[segs];
header.mdsBase _ data.mdsBase;
header.pdaPages _ data.pdaPages;
header.initLoadState _ data.lsseg.index;
header.lastVMPage _ data.lastVMPage;
header.stateVectorCounts _ data.stateVectorCounts;
header.stateVectorSize _ data.svSize;
header.nProcesses _ data.nProcesses;
scriptBase^ _ header^;
MBVM.LongCopyWrite[
from: scriptBase, to: data.scriptBaseInVM, nwords: PrincOpsUtils.WordsForPages[scriptPages]];
segs _ NIL;
};

AddToBitTables: PROC [seg: MBVM.Seg] = {
resDesc: BOOL = (seg.info.state = residentDescriptor);
resident: BOOL = (seg.info.state = resident);
FOR i: CARDINAL IN [seg.base..seg.base+seg.pages) DO
readOnlyTable[i] _ seg.info.readOnly;
inTable[i] _ seg.bootLoaded;
resDescTable[i] _ resDesc;
residentTable[i] _ resident;
ENDLOOP;
};

ClassifyPages: PROC = {
MB.EnumerateCode[in, BootLoadCode];
MB.EnumerateSpaces[in, BootLoadSpaces];
MB.EnumerateFramePacks[in, BootLoadFramePacks];
MB.EnumerateGlobalFrames[in, BootLoadGlobalFrames];
MB.EnumerateBCDs[in, BootLoadBCDs];
MB.EnumerateCode[resDesc, ResDescCode];
MB.EnumerateSpaces[resDesc, ResDescSpaces];
MB.EnumerateFramePacks[resDesc, ResDescFramePacks];
MB.EnumerateGlobalFrames[resDesc, ResDescGlobalFrames];
MB.EnumerateBCDs[resDesc, ResDescBCDs];
MB.EnumerateCode[resident, ResidentCode];
MB.EnumerateSpaces[resident, ResidentSpaces];
-- resident FramePacks and GlobalFrames were done during loading--
MB.EnumerateBCDs[resident, ResidentBCDs];
};

BootLoadCode: PROC [bh: MB.BHandle, mth: BcdDefs.MTHandle] RETURNS [BOOL] = {
cseg: MBVM.CodeSeg = bh.mt[mth.gfi].code;
MarkSegPages[cseg, @inTable];
RETURN[FALSE]
};

BootLoadSpaces: PROC [bh: MB.BHandle, sph: BcdDefs.SPHandle, index: CARDINAL]
RETURNS [BOOL] = {
MarkSpacePages[sph, index, @inTable];
RETURN[FALSE]
};

BootLoadFramePacks: PROC [bh: MB.BHandle, fph: BcdDefs.FPHandle] RETURNS [BOOL] = {
mtb: BcdDefs.Base = LOOPHOLE[bh.bcd + bh.bcd.mtOffset];
RETURN[BootLoadGlobalFrames[bh, @mtb[fph.modules[0]]]]
};

BootLoadGlobalFrames: PROC [bh: MB.BHandle, mth: BcdDefs.MTHandle] RETURNS [BOOL] = {
frame: PrincOps.GlobalFrameHandle = bh.mt[mth.gfi].frame;
IF ~MB.VirtualGlobalFrame[frame].alloced THEN
MarkSegPages[SegForBase[PageFromAddress[frame] + data.mdsBase], @inTable];
RETURN[FALSE]
};

BootLoadBCDs: PROC [bh: MB.BHandle] RETURNS [BOOL] = {
bcdSeg: MBVM.FileSeg = bh.bcdSeg;
MarkSegPages[bcdSeg, @inTable];
RETURN[FALSE]
};

ResDescCode: PROC [bh: MB.BHandle, mth: BcdDefs.MTHandle] RETURNS [BOOL] = {
cseg: MBVM.CodeSeg = bh.mt[mth.gfi].code;
cseg.info.state _ residentDescriptor;
MarkSegPages[cseg, @resDescTable];
RETURN[FALSE]
};

ResDescSpaces: PROC [bh: MB.BHandle, sph: BcdDefs.SPHandle, index: CARDINAL]
RETURNS [BOOL] = {
MarkSpacePages[sph, index, @resDescTable];
RETURN[FALSE]
};

ResDescFramePacks: PROC [bh: MB.BHandle, fph: BcdDefs.FPHandle] RETURNS [BOOL] = {
mtb: BcdDefs.Base = LOOPHOLE[bh.bcd + bh.bcd.mtOffset];
RETURN[ResDescGlobalFrames[bh, @mtb[fph.modules[0]]]]};

ResDescGlobalFrames: PROC [bh: MB.BHandle, mth: BcdDefs.MTHandle] RETURNS [BOOL] = {
frame: PrincOps.GlobalFrameHandle = bh.mt[mth.gfi].frame;
IF ~MB.VirtualGlobalFrame[frame].alloced THEN
MarkSegPages[SegForBase[PageFromAddress[frame] + data.mdsBase], @resDescTable];
RETURN[FALSE]
};

ResDescBCDs: PROC [bh: MB.BHandle] RETURNS [BOOL] = {
bcdSeg: MBVM.FileSeg = bh.bcdSeg;
bcdSeg.info.state _ residentDescriptor;
MarkSegPages[bcdSeg, @resDescTable];
RETURN[FALSE]
};

ResidentCode: PROC [bh: MB.BHandle, mth: BcdDefs.MTHandle] RETURNS [BOOL] = {
cseg: MBVM.CodeSeg = bh.mt[mth.gfi].code;
cseg.info.state _ resident;
MarkSegPages[cseg, @residentTable];
MarkSegPages[cseg, @inTable];
RETURN[FALSE]
};

ResidentSpaces: PROC [bh: MB.BHandle, sph: BcdDefs.SPHandle, index: CARDINAL]
RETURNS [BOOL] = {
cseg: MBVM.CodeSeg = SegForSpace[sph];
first: CARDINAL = cseg.base+sph.spaces[index].offset;
count: CARDINAL = sph.spaces[index].pages;
MarkTablePages[@residentTable, first, count];
MarkTablePages[@inTable, first, count];
RETURN[FALSE]
};

ResidentBCDs: PROC [bh: MB.BHandle] RETURNS [BOOL] = {
bcdSeg: MBVM.FileSeg = bh.bcdSeg;
bcdSeg.info.state _ resident;
MarkSegPages[bcdSeg, @residentTable];
MarkSegPages[bcdSeg, @inTable];
RETURN[FALSE]
};

MarkSegPages: PROC [seg: MBVM.Seg, table: POINTER TO MB.BitArray] =  INLINE {
MarkTablePages[table, seg.base, seg.pages]};

MarkSpacePages: PROC [
sph: BcdDefs.SPHandle, index: CARDINAL, table: POINTER TO MB.BitArray] = {
cseg: MBVM.CodeSeg = SegForSpace[sph];
MarkTablePages[table, cseg.base + sph.spaces[index].offset, sph.spaces[index].pages]
};

MarkTablePages: PROC [table: POINTER TO MB.BitArray, first, count: CARDINAL] = {
FOR i: CARDINAL IN [first..first+count) DO
table^[i] _ TRUE;
ENDLOOP;
};

SegForBase: PROC [base: CARDINAL] RETURNS [seg: MBVM.Seg] = {
FOR i: CARDINAL IN [0..segs.length) DO
seg _ segs[i];
IF base IN [seg.base..seg.base+seg.pages) THEN EXIT;
REPEAT
FINISHED => ERROR;
ENDLOOP;
};

SegForSpace: PROC [sph: BcdDefs.SPHandle] RETURNS [cseg: MBVM.CodeSeg] = {
FOR i: CARDINAL IN [0..segs.length) DO
WITH s: segs[i] SELECT FROM
code => IF s.sph = sph THEN {cseg _ @s;  EXIT};
ENDCASE;
REPEAT
FINISHED => ERROR;
ENDLOOP;
};

AddScriptWords: PROC [nwords: CARDINAL] = {
newPages: CARDINAL = scriptPages + PrincOpsUtils.PagesForWords[nwords];
newSpace: Space.Handle = Space.Create[newPages, Space.virtualMemory];
newBase: LONG POINTER = Space.LongPointer[newSpace];
Space.Map[newSpace];
IF scriptBase ~= NIL THEN {
PrincOpsUtils.LongCOPY[
from: scriptBase, to: newBase, nwords: PrincOpsUtils.WordsForPages[scriptPages]];
Space.Delete[scriptSpace];
};
scriptPages _ newPages;
data.scriptBase _ scriptBase _ newBase;
scriptSpace _ newSpace;
};

EnterSegment: PROC [seg: MBVM.Seg] = {
WITH s: seg SELECT FROM
data => EnterSimpleSegment[seg];
code =>
IF s.sph = NIL THEN EnterSimpleSegment[seg]
ELSE {
r: swapUnit Entry;
first: BOOL _ TRUE;
s.bootLoaded _ FALSE;
FOR i: CARDINAL IN [0..s.sph.length) DO
base: CARDINAL = s.base+s.sph.spaces[i].offset;
state: SwapUnitState = SELECT TRUE FROM
residentTable[base] => resident,
resDescTable[base] => residentDescriptor,
ENDCASE => swappable;
IF residentTable[base] OR inTable[base] THEN s.bootLoaded _ TRUE;
r _ Entry[swapUnit[info: [s.info.readOnly, state],
pages: s.sph.spaces[i].pages, base: s.sph.spaces[i].offset,
parent: nullSpaceIndex]
];
IF first THEN {first _ FALSE; s.index _ LOOPHOLE[scriptIndex]};
AppendBootWords[@r, SIZE[swapUnit Entry]];
ENDLOOP;
};
file =>
IF s.bIndex = MB.nullIndex THEN EnterSimpleSegment[seg]
ELSE {
bcd: BcdDefs.BcdBase = data.inputBCDs.bcds[s.bIndex].bcd;
r: swapUnit Entry _ Entry[swapUnit[
info: GetSegmentInfo[seg], pages: seg.pages, base: 0, parent: nullSpaceIndex]];
seg.index _ LOOPHOLE[scriptIndex];
IF r.info.state = resident OR bcd.rtPages.pages = 0 THEN
AppendBootWords[@r, SIZE[swapUnit Entry]]
ELSE {
s.nUnits _ 2;
r.pages _ bcd.nPages - bcd.rtPages.pages;
AppendBootWords[@r, SIZE[swapUnit Entry]];
r.pages _ bcd.rtPages.pages; r.base _ bcd.rtPages.relPageBase;
AppendBootWords[@r, SIZE[swapUnit Entry]];
};
};
ENDCASE;
};

EnterSimpleSegment: PROC [seg: MBVM.Seg] = {
r: swapUnit Entry _ Entry[swapUnit[
info: GetSegmentInfo[seg], pages: seg.pages, base: 0, parent: nullSpaceIndex]];
seg.index _ LOOPHOLE[scriptIndex];
AppendBootWords[@r, SIZE[swapUnit Entry]];
};

GetSegmentInfo: PROC [seg: MBVM.Seg] RETURNS [info: SwapUnitInfo] = {
state: SwapUnitState =
IF seg.info.state = resident THEN resident ELSE
SELECT TRUE FROM
residentTable[seg.base] => resident,
resDescTable[seg.base] => residentDescriptor,
ENDCASE => swappable;
seg.bootLoaded _ residentTable[seg.base] OR inTable[seg.base];
RETURN[[seg.info.readOnly, state]]
};

AppendBootWords: PROC [addr: POINTER, count: CARDINAL] = {
IF LOOPHOLE[scriptIndex,CARDINAL]+count > PrincOpsUtils.WordsForPages[scriptPages] OR count = 0 THEN ERROR;
PrincOpsUtils.LongCOPY[from: addr, to: @scriptBase[scriptIndex], nwords: count];
scriptIndex _ scriptIndex + count;
};

AddSpace: PROC [state: PageState, start, end: CARDINAL] = {
r: space Entry;
single: BOOL _ TRUE;
resident: BOOL _ residentTable[start];
anyResDesc, anyReadOnly: BOOL _ FALSE;
allResDesc, allReadOnly: BOOL _ TRUE;
offset: CARDINAL;
pages: CARDINAL = end-start+1;
space: SpaceIndex _ LOOPHOLE[scriptIndex];
IF ~state.busy THEN {AddEmptySpace[start, pages]; RETURN};
r _ Entry[space[
readOnly: state.readOnly,
bootLoaded: (state.resident OR state.in), type: ,
pages: pages, vmPage: start, backingPage: 0,
backingStore: null]
];
AppendBootWords[@r, SIZE[space Entry]];
FOR i: CARDINAL IN [start..end] DO
anyResDesc _ anyResDesc OR resDescTable[i];
allResDesc _ allResDesc AND resDescTable[i];
anyReadOnly _ anyReadOnly OR readOnlyTable[i];
allReadOnly _ allReadOnly AND readOnlyTable[i];
ENDLOOP;
offset _ 0;
DO
scriptBase[suIndex].parent _ space;
scriptBase[suIndex].base _ offset;
offset _ scriptBase[suIndex].pages + offset;
IF offset >= pages THEN EXIT;
suIndex _ suIndex + SIZE[swapUnit Entry];
single _ FALSE;
ENDLOOP;
scriptBase[space].type _ IF ~single THEN
[family[
anyResidentChildren: resident,
anyResidentDescriptorChildren: anyResDesc, 
anySwappableChildren: ~resident, 
allResidentChildren: resident,
allResidentDescriptorChildren: allResDesc, 
allSwappableChildren: ~resident]]
ELSE [unitary[suIndex]];
suIndex _ suIndex + SIZE[swapUnit Entry];
};

AddEmptySpace: PROC [start, pages: CARDINAL] = {
r: space Entry;
space: SpaceIndex _ LOOPHOLE[scriptIndex];
r _ Entry[space[bootLoaded: FALSE, backingStore: null, type: [empty[]],
readOnly: FALSE, pages: pages, vmPage: start, backingPage: 0]
];
AppendBootWords[@r, SIZE[space Entry]];
};

PageFromAddress: PROC [p: POINTER] RETURNS [CARDINAL] = {
RETURN[LOOPHOLE[p, CARDINAL]/256]};

END.



ØMBScript.mesa  
Edited by Sandman on 6-Aug-81 15:42:29
Edited by Lewis on 17-Sep-81 16:15:24
Edited by Levin on September 30, 1983 3:57 pm
Wart Script Management
Beyond this point it is assumed that the vmMap won't grow.
Since the initial vmMap includes the MDS, the following can't cause it to grow
therefore, our bit tables won't need to grow any bigger.
Trinity or later...  anyReadOnlyChildren: anyReadOnly,
Trinity or later... allReadOnlyChildren: allReadOnly,
�ÊD˜Jš
œ™Jš
œ&™&Jš
œ%™%Jš
œ-™-J˜š
Ïk	˜	Jšœ�œ/˜<Jšœ	�œ˜šœ�œ˜J˜ª
—š�œ
�œ˜
J˜Í
—š�œ
�œ˜Jšœ>�œ.˜o—Jšœ	�œ"˜0Jšœ�œ@˜SJšœ�œG˜R—J˜šœ
�˜Jš�œ
�œ�œ˜&Jš�œ
�œ˜J˜—Jš
�˜J˜Jš�œ˜J˜Jšœ�œ�œ/�œ˜MJ˜Jšœ�œ
�œ
˜Jšœ�œ�œ
˜Jšœ5�œ�œ
˜GJ˜J˜Jš
œ™J˜Jšœ
�œ
˜J˜J˜J˜šÏn
œ�œ
�œ�œ˜*˜#J˜J˜J˜9—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˜—šžœ�œ
�œ˜Jšœ9�œ
˜=Jšœ�œ
˜š�œ�œ
�œ˜Jš
œ˜Jšœ
�œ
˜Jš
œ˜Jš
œ˜—Jšœ�œ
˜Jšœ�˜Jš
œ˜J˜—šž
œ�œ
�œ˜*Jšœ�œ
�œ˜/Jš�œ�œ
�œ
�œ�œ�œ
˜DJšœ�œ
�œ˜.Jš�œ�œ
�œ
�œ�œ�œ
˜CJšœ
�œ
�œ˜)Jš�œ�œ
�œ
�œ�œ�œ
˜>Jšœ�œ
�œ˜/Jš�œ�œ
�œ
�œ�œ�œ
˜DJ˜J˜—šž
œ�œ
�œ˜Jšœ�œ˜!J˜Jšœ	�œ˜Jš
œ�œ�œ�œ�œ�œ�œ˜>Jšœ�œ
˜Jšœ	�œ˜!J˜Jšœ�œ
˜Jšœ�œ	˜Jšœ�œ˜Jš
œ!˜!Jš
œ:™:Jš�œ�œ�œ�œ
˜=J˜š�œ�œ�˜ Jšœ�œ˜&Jšœ�œ˜˜J˜@J˜<J˜—Jš�œ�œ,˜EJš�œ
˜—J˜š�œ�œ�˜š�œ�œ
�˜Jšœ�œ˜/˜˜Jš
œ
�œ�œ
�œ�œ�œ
�œ˜W——˜Jš�œ�œ�œ�œ˜Hš�œ˜Jšœ�œ+˜5Jš�œ�œ�œ˜NJš�œ�œ˜,Jš
œ˜——Jš�œ
˜—Jš�œ
˜—Jšœ�œÏc	œ�œ˜MJ˜Jš
œN™NJš
œ8™8Jšœ�œ�œ
�œ˜BJšœ�œ
˜Jšœ�œ˜5J˜š
œ˜Jš
œ2˜2Jš�œ
�œ�œ˜3—Jšœ�œ˜Jš�œ�œ�œ�œ
˜;Jš�œ�œ
�œ'˜<˜	J˜@Jšœ8�˜<Jš
œ˜—J˜
Jšœ
�œ
˜š�œ�œ�˜ Jšœ
�œ˜$Jšœ�œ
˜˜J˜@J˜<J˜—Jš�œ�œ>˜WJš�œ
˜—J˜(Jšœ�œ˜&Jšœ�œ˜,Jšœ�œ˜:J˜J˜ J˜(J˜$J˜2J˜%J˜$J˜š�œ˜Jš
œ]˜]—Jšœ�œ
˜Jš
œ˜J˜—šžœ�œ�œ	˜(Jšœ	�œ)˜6Jšœ
�œ˜-š�œ�œ
�œ �˜4J˜%J˜J˜J˜Jš
�˜—š
œ˜J˜——šž
œ�œ˜Jš�œ!˜#Jš�œ%˜'Jš�œ-˜/Jš�œ1˜3Jš�œ!˜#Jš�œ%˜'Jš�œ)˜+Jš�œ1˜3Jš�œ5˜7Jš�œ%˜'Jš�œ'˜)Jš�œ+˜-Jš
ŸB˜BJš�œ'˜)Jš
œ˜J˜—š
žœ�œ�œ!�œ�œ˜MJšœ�œ˜)J˜Jš�œ
�œ
˜
Jš
œ˜J˜—šžœ�œ�œ(�œ
˜MJš�œ�œ˜J˜%Jš�œ
�œ
˜
Jš
œ˜J˜—š
žœ�œ�œ!�œ�œ˜SJšœ�œ˜7Jš�œ0˜6Jš
œ˜J˜—š
žœ�œ�œ!�œ�œ˜UJ˜9š�œ�œ#�˜-J˜J—Jš�œ
�œ
˜
Jš
œ˜J˜—š
žœ�œ�œ
�œ�œ˜6Jšœ�œ˜!J˜Jš�œ
�œ
˜
Jš
œ˜J˜—š
žœ�œ�œ!�œ�œ˜LJšœ�œ˜)J˜%J˜"Jš�œ
�œ
˜
Jš
œ˜J˜—šž
œ�œ�œ(�œ
˜LJš�œ�œ˜J˜*Jš�œ
�œ
˜
Jš
œ˜J˜—š
žœ�œ�œ!�œ�œ˜RJšœ�œ˜7Jš�œ1˜7J˜—š
žœ�œ�œ!�œ�œ˜TJ˜9š�œ�œ#�˜-J˜O—Jš�œ
�œ
˜
Jš
œ˜J˜—š
žœ�œ�œ
�œ�œ˜5Jšœ�œ˜!J˜'J˜$Jš�œ
�œ
˜
Jš
œ˜J˜—š
žœ�œ�œ!�œ�œ˜MJšœ�œ˜)J˜J˜#J˜Jš�œ
�œ
˜
Jš
œ˜J˜—šžœ�œ�œ(�œ
˜MJš�œ�œ˜Jšœ�œ˜&Jšœ�œ&˜5Jšœ�œ˜*J˜-J˜'Jš�œ
�œ
˜
Jš
œ˜J˜—š
žœ�œ�œ
�œ�œ˜6Jšœ�œ˜!J˜J˜%J˜Jš�œ
�œ
˜
Jš
œ˜J˜—šžœ�œ�œ
�œ
�œ
�œ�œ˜MJ˜,J˜—šžœ�œ˜Jš	œ�œ	�œ
�œ
�œ˜JJšœ�œ˜&J˜TJ˜J˜—šžœ�œ	�œ
�œ
�œ�œ˜Pš�œ�œ
�œ�˜*Jšœ�œ
˜Jš
�˜—š
œ˜J˜——š
ž
œ�œ�œ�œ�œ	˜=š�œ�œ
�œ�˜&J˜Jš�œ�œ �œ
�œ
˜4š
�˜Jš�œ�œ
˜—Jš
�˜—š
œ˜J˜——šžœ�œ�œ�œ
˜Jš�œ�œ
�œ�˜&š�œ�œ
�˜Jšœ�œ
�œ�œ˜/Jš�œ
˜—š
�˜Jš�œ�œ
˜—Jš
�˜—š
œ˜J˜——šžœ�œ
�œ˜+Jšœ
�œ5˜GJš
œE˜EJšœ	�œ˜4Jš
œ˜š�œ�œ
�œ˜˜J˜Q—J˜J˜—J˜J˜'J˜J˜J˜—šžœ�œ�œ	˜&š�œ�œ
�˜J˜ ˜Jš�œ	�œ
�œ˜+š�œ˜J˜Jšœ�œ�œ
˜Jšœ�œ
˜š�œ�œ
�œ�˜'Jšœ�œ!˜/šœ�œ
�œ
�˜'J˜ J˜)Jš�œ˜—Jš�œ�œ�œ�œ
˜A˜2J˜;J˜J˜—Jš�œ�œ
�œ�œ˜?Jšœ�œ˜*Jš
�˜—Jš
œ˜——˜Jš�œ�œ�œ˜7š�œ˜J˜9˜#J˜O—Jšœ�œ˜"š�œ�œ�˜8Jšœ�œ˜)—š�œ˜J˜
J˜)Jšœ�œ˜*J˜>Jšœ�œ˜*Jš
œ˜—Jš
œ˜——Jš
�˜—š
œ˜J˜——šžœ�œ�œ	˜,˜#J˜O—Jšœ�œ˜"Jšœ�œ˜*Jš
œ˜J˜—šžœ�œ�œ�œ˜E˜š�œ�œ
�˜/š�œ
�œ
�˜J˜$J˜-Jš�œ˜———Jšœ)�œ˜>Jš�œ˜"Jš
œ˜J˜—šžœ�œ�œ	�œ˜:Jš�œ
�œ
�œ3�œ�œ
�œ
˜kJ˜PJ˜"J˜J˜—šžœ�œ �œ˜;J˜Jšœ�œ�œ
˜Jšœ
�œ˜&Jšœ�œ�œ
˜&Jšœ�œ�œ
˜%Jšœ�œ
˜Jšœ�œ˜Jšœ�œ˜*Jš�œ
�œ�œ˜:˜J˜Jšœ�œ˜1J˜,Jš
œ˜Jš
œ˜—Jšœ�œ˜'š�œ�œ
�œ�˜"Jšœ�œ˜+Jšœ�œ˜,Jšœ�œ˜.Jšœ�œ˜/Jš�œ
˜—J˜š
�˜J˜#J˜"J˜,Jš�œ�œ
�œ
˜Jšœ�œ˜)Jšœ	�œ
˜Jš�œ
˜—šœ�œ�˜(š
œ˜Jš
œ6™6J˜J˜+J˜!Jš
œ5™5J˜J˜+J˜!—Jš�œ˜—Jšœ�œ˜)Jš
œ˜J˜—šž
œ�œ�œ˜0J˜Jšœ�œ˜*šœ�œ&˜GJšœ
�œ.˜=Jš
œ˜—Jšœ�œ˜'Jš
œ˜J˜—š
žœ�œ�œ�œ�œ˜9Jš�œ
�œ�œ˜#J˜—Jš�œ
˜J˜J˜—…—:nMŠ