DIRECTORY
BasicTime USING [ToPupTime],
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, LongZero, PagesForWords, WordsForPages],
VM USING [AddressForPageNumber, Allocate, Free, Interval, nullInterval];

MBScript: CEDAR PROGRAM
IMPORTS BasicTime, MB, MBVM, PrincOpsUtils, VM
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;
scriptBase: Base;
scriptBuffer: VM.Interval;

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;
scriptBase _ NIL;
scriptBuffer _ VM.nullInterval;
segs _ NIL;
};

FinishScript: PUBLIC PROC = {
residentTable _ resDescTable _ inTable _ readOnlyTable _ NIL;
data.header _ NIL;
IF scriptBase ~= NIL THEN {
TRUSTED {VM.Free[scriptBuffer]};
scriptBase _ NIL;
scriptBuffer _ VM.nullInterval;
};
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 segs[i] SELECT FROM
seg: MBVM.DataSeg => nwords _ nwords + SIZE[swapUnit Entry];
seg: MBVM.CodeSeg =>
TRUSTED {
nwords _ nwords +
(IF seg.sph ~= NIL THEN seg.sph.length*SIZE[swapUnit Entry] ELSE SIZE[swapUnit Entry]);
};
seg: MBVM.FileSeg =>
IF seg.bIndex = MB.nullIndex THEN nwords _ nwords + SIZE[swapUnit Entry]
ELSE {
loadee: MB.BHandle = data.inputBCDs.bcds[seg.bIndex];
TRUSTED {
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: scriptBuffer.count];
scriptSeg.bootLoaded _ TRUE;
scriptSeg.info _ [readOnly: FALSE, state: swappable];
AddToBitTables[scriptSeg];
TRUSTED {
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];
TRUSTED {AppendBootWords[@r, SIZE[stop Entry]]};
header.buildDate _ BasicTime.ToPupTime[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;
TRUSTED {
scriptBase^ _ header^;
MBVM.LongCopyWrite[
from: scriptBase, to: data.scriptBaseInVM,
nwords: PrincOpsUtils.WordsForPages[scriptBuffer.count]];
};
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] = TRUSTED {
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] = TRUSTED {
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] = TRUSTED {
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] = TRUSTED {
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] = TRUSTED {
MarkSpacePages[sph, index, resDescTable];
RETURN[FALSE]
};

ResDescFramePacks: PROC [bh: MB.BHandle, fph: BcdDefs.FPHandle]
RETURNS [BOOL] = TRUSTED {
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] = TRUSTED {
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] = TRUSTED {
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] = TRUSTED {
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: MB.BitArray] =  INLINE {
MarkTablePages[table, seg.base, seg.pages]};

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

MarkTablePages: PROC [table: 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 segs[i] SELECT FROM
s: MBVM.CodeSeg => IF s.sph = sph THEN {cseg _ s;  EXIT};
ENDCASE;
REPEAT
FINISHED => ERROR;
ENDLOOP;
};

AddScriptWords: PROC [nwords: CARDINAL] = TRUSTED {
newPages: CARDINAL = scriptBuffer.count + PrincOpsUtils.PagesForWords[nwords];
newBuffer: VM.Interval = VM.Allocate[newPages];
newBase: LONG POINTER = VM.AddressForPageNumber[newBuffer.page];
IF scriptBase = NIL THEN
PrincOpsUtils.LongZero[
where: newBase,
nwords: PrincOpsUtils.WordsForPages[newBuffer.count]
]
ELSE {
PrincOpsUtils.LongCopy[
from: scriptBase, to: newBase, nwords: PrincOpsUtils.WordsForPages[scriptBuffer.count]];
VM.Free[scriptBuffer];
PrincOpsUtils.LongZero[
where: newBase + PrincOpsUtils.WordsForPages[scriptBuffer.count],
nwords: PrincOpsUtils.WordsForPages[newBuffer.count - scriptBuffer.count]
];
};
data.scriptBase _ scriptBase _ newBase;
scriptBuffer _ newBuffer;
};

EnterSegment: PROC [seg: MBVM.Seg] = TRUSTED {
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.extended AND 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];
TRUSTED {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] = TRUSTED {
IF LOOPHOLE[scriptIndex,CARDINAL]+count > PrincOpsUtils.WordsForPages[scriptBuffer.count] OR count = 0 THEN ERROR;
PrincOpsUtils.LongCopy[from: addr, to: @scriptBase[scriptIndex], nwords: count];
scriptIndex _ scriptIndex + count;
};

AddSpace: PROC [state: PageState, start, end: CARDINAL] = TRUSTED {
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] = TRUSTED {
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  
Copyright c 1985 by Xerox Corporation.  All rights reserved.
Sandman on 6-Aug-81 15:42:29
Lewis on 17-Sep-81 16:15:24
Levin on January 17, 1984 10:53 am
Russ Atkinson (RRA) March 8, 1985 5:31:09 pm PST
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,
Κ-˜
codeš
œ™Kšœ
Οm
œ1™<Kš
œ™Kš
œ™Kš
œ"™"K™0—K˜š
Οk	˜	Kšœ
žœ
˜Kšœžœ/˜<Kšœ	žœ˜Kšœžœ¬
˜Ώ
Kšžœ
žœΟ
˜Χ
Kšžœ
žœ@žœ.˜{Kšœ	žœ"˜0KšœžœJ˜]Kšžœ
žœ@˜H—K˜šœ
žœ
ž˜Kšžœžœžœž˜.Kšžœ
žœžœ˜&—K˜Kšœžœžœ/žœ˜MK˜Kšœžœ
žœ
˜Kšœžœžœ
˜Kšœ5žœžœ
˜GK˜K˜Kš
œ™K˜K˜Kšœžœ
˜K˜šΟn
œžœ
žœžœ˜*˜#K˜K˜K˜9—K˜	šœžœ˜K˜K˜K˜
Kš
œ˜K˜#K˜!K˜K˜Kšœžœ˜Kš
œ˜K˜K˜K˜K˜Kš
œ#˜#Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜—K˜Kšœ
ž˜Kšœžœ˜Kšœžœ
˜Kš
œ˜K˜—šŸœžœ
žœ˜Kšœ9žœ
˜=Kšœžœ
˜šžœžœ
žœ˜Kšžœžœ˜ Kšœ
žœ
˜Kšœžœ˜Kš
œ˜—Kšœžœ
˜Kšœž˜Kš
œ˜K˜—šŸ
œžœ
žœ˜*Kšœžœ
žœ˜/Kšžœžœ
žœ
žœžœžœ
˜DKšœžœ
žœ˜.Kšžœžœ
žœ
žœžœžœ
˜CKšœ
žœ
žœ˜)Kšžœžœ
žœ
žœžœžœ
˜>Kšœžœ
žœ˜/Kšžœžœ
žœ
žœžœžœ
˜DK˜K˜—šŸ
œžœ
žœ˜Kšœžœ˜!K˜Kšœ	žœ˜Kš
œžœžœžœžœžœžœ˜>Kšœžœ
˜Kšœ	žœ˜!K˜Kšœžœ
˜Kšœžœ	˜Kšœžœ˜Kš
œ!˜!Kš
œ:™:Kšžœžœžœžœ
˜=K˜šžœžœž˜ Kšœžœ˜&Kšœžœ˜˜K˜@K˜<K˜—Kšžœžœ,˜EKšžœ
˜—K˜šžœžœž˜šžœ	žœ
ž˜Kšœžœžœ˜<šœžœ˜šžœ˜	˜Kš
œ
žœžœ
žœžœžœ
žœ˜W—K˜——šœžœ˜Kšžœžœžœžœ˜Hšžœ˜Kšœžœ+˜5šžœ˜	Kšžœžœžœ˜NKšžœžœ˜,K˜—Kš
œ˜——Kšžœ
˜—Kšžœ
˜—KšœžœΟc	œžœ˜MK˜Kš
œN™NKš
œ8™8Kšœžœžœ
žœ˜IKšœžœ
˜Kšœžœ˜5K˜šžœ˜	š
œ˜Kš
œ2˜2Kšžœ
žœžœ˜3—K˜—Kšœžœ˜Kšžœžœžœžœ
˜;Kšžœžœ
žœ'˜<˜	K˜@Kšœ8ž˜<Kš
œ˜—K˜
Kšœ
žœ
˜šžœžœž˜ Kšœ
žœ˜$Kšœžœ
˜˜K˜@K˜<K˜—Kšžœžœ>˜WKšžœ
˜—K˜(Kšžœžœ˜0Kš
œ7˜7Kšœžœ˜:K˜K˜ K˜(K˜$K˜2K˜%K˜$šžœ˜	Kš
œ˜šžœ˜Kš
œ*˜*Kš
œ9˜9—K˜—Kšœžœ
˜Kš
œ˜K˜—šŸœžœžœ	˜(Kšœ	žœ)˜6Kšœ
žœ˜-šžœžœ
žœ ž˜4K˜%K˜K˜K˜Kš
ž˜—š
œ˜K˜——šŸ
œžœ˜Kšžœ!˜#Kšžœ%˜'Kšžœ-˜/Kšžœ1˜3Kšžœ!˜#Kšžœ%˜'Kšžœ)˜+Kšžœ1˜3Kšžœ5˜7Kšžœ%˜'Kšžœ'˜)Kšžœ+˜-Kš
 B˜BKšžœ'˜)Kš
œ˜K˜—šŸœžœžœ!žœžœžœ˜UKšœžœ˜)K˜Kšžœ
žœ
˜
Kš
œ˜K˜—šŸœžœžœ(žœ
˜MKšžœžœ˜K˜$Kšžœ
žœ
˜
Kš
œ˜K˜—šŸœžœžœ ˜@Kšžœžœžœ˜Kšœžœ˜7Kšžœ0˜6Kš
œ˜K˜—šŸœžœžœ ˜BKšžœžœžœ˜K˜9šžœžœ#ž˜-K˜I—Kšžœ
žœ
˜
Kš
œ˜K˜—š
Ÿœžœžœ
žœžœ˜6Kšœžœ˜!K˜Kšžœ
žœ
˜
Kš
œ˜K˜—šŸœžœžœ!žœžœžœ˜TKšœžœ˜)K˜%K˜!Kšžœ
žœ
˜
Kš
œ˜K˜—šŸ
œžœžœ(žœ
˜LKšžœžœžœ˜K˜)Kšžœ
žœ
˜
Kš
œ˜K˜—šŸœžœžœ ˜?Kšžœžœžœ˜Kšœžœ˜7Kšžœ1˜7K˜—šŸœžœžœ ˜AKšžœžœžœ˜K˜9šžœžœ#ž˜-K˜N—Kšžœ
žœ
˜
Kš
œ˜K˜—š
Ÿœžœžœ
žœžœ˜5Kšœžœ˜!K˜'K˜#Kšžœ
žœ
˜
Kš
œ˜K˜—šŸœžœžœ!žœžœžœ˜UKšœžœ˜)K˜K˜"K˜Kšžœ
žœ
˜
Kš
œ˜K˜—šŸœžœžœ(žœ
˜MKšžœžœžœ˜Kšœžœ˜&Kšœžœ&˜5Kšœžœ˜*K˜,K˜&Kšžœ
žœ
˜
Kš
œ˜K˜—š
Ÿœžœžœ
žœžœ˜6Kšœžœ˜!K˜K˜$K˜Kšžœ
žœ
˜
Kš
œ˜K˜—š
Ÿœžœžœ
žœžœ˜BK˜,K˜—šŸœžœ˜Kšœžœ	žœ
žœ˜GKšœžœ˜&K˜TK˜K˜—šŸœžœ	žœžœ˜Ešžœžœ
žœž˜*Kšœžœ
˜Kš
ž˜—š
œ˜K˜——š
Ÿ
œžœžœžœžœ	˜=šžœžœ
žœž˜&K˜Kšžœžœ žœ
žœ
˜4š
ž˜Kšžœžœ
˜—Kš
ž˜—š
œ˜K˜——šŸœžœžœžœ
˜Jšžœžœ
žœž˜&šžœ	žœ
ž˜Kš	œžœžœ
žœ
žœ˜9Kšžœ
˜—š
ž˜Kšžœžœ
˜—Kš
ž˜—š
œ˜K˜——šŸœžœ
žœžœ˜3Kšœ
žœ<˜NKšœžœžœ˜/Kšœ	žœ
žœžœ&˜@šžœžœ
ž˜˜K˜Kš
œ4˜4K˜
——šžœ˜š
œ˜K˜X—Kšžœ˜˜K˜AKš
œI˜IK˜—K˜—K˜'Kš
œ˜K˜K˜—šŸœžœžœžœ˜.šžœžœ
ž˜K˜ ˜Kšžœ	žœ
žœ˜+šžœ˜K˜Kšœžœžœ
˜Kšœžœ
˜šžœžœ
žœž˜'Kšœžœ!˜/šœžœ
žœ
ž˜'K˜ K˜)Kšžœ˜—Kšžœžœžœžœ
˜A˜2K˜;K˜K˜—Kšžœžœ
žœžœ˜?Kšœžœ˜*Kš
ž˜—Kš
œ˜——˜Kšžœžœžœ˜7šžœ˜K˜9˜#K˜O—Kšœžœ˜"šžœžœžœž˜LKšœžœ˜)—šžœ˜K˜
K˜)Kšœžœ˜*K˜>Kšœžœ˜*Kš
œ˜—Kš
œ˜——Kš
ž˜—š
œ˜K˜——šŸœžœžœ	˜,˜#K˜O—Kšœžœ˜"Kšžœžœ˜4Kš
œ˜K˜—šŸœžœžœžœ˜E˜šžœžœ
ž˜/šžœ
žœ
ž˜K˜$K˜-Kšžœ˜———Kšœ)žœ˜>Kšžœ˜"Kš
œ˜K˜—š
Ÿœžœžœ	žœžœ˜BKšžœ
žœ
žœ:žœžœ
žœ
˜rKš
œP˜PK˜"K˜K˜—šŸœžœ žœžœ˜CK˜Kšœžœžœ
˜Kšœ
žœ˜&Kšœžœžœ
˜&Kšœžœžœ
˜%Kšœžœ
˜Kšœžœ˜Kšœžœ˜*Kšžœ
žœžœ˜:˜K˜Kšœžœ˜1K˜,Kš
œ˜Kš
œ˜—Kšœžœ˜'šžœžœ
žœž˜"Kšœžœ˜+Kšœžœ˜,Kšœžœ˜.Kšœžœ˜/Kšžœ
˜—K˜š
ž˜K˜#K˜"K˜,Kšžœžœ
žœ
˜Kšœžœ˜)Kšœ	žœ
˜Kšžœ
˜—šœžœž˜(š
œ˜Kš
œ6™6K˜K˜+K˜!Kš
œ5™5K˜K˜+K˜!—Kšžœ˜—Kšœžœ˜)Kš
œ˜K˜—šŸ
œžœžœžœ˜8K˜Kšœžœ˜*šœžœ&˜GKšœ
žœ.˜=Kš
œ˜—Kšœžœ˜'Kš
œ˜K˜—š
Ÿœžœžœžœžœ˜9Kšžœ
žœžœ˜#K˜—Kšžœ
˜K˜K˜—…—<>P“