DIRECTORY
BcdDefs USING [
Base, CTIndex, CTNull, FPIndex, FTIndex, FTSelf, MTIndex, NameRecord, NTIndex, SGIndex, SpaceID, SPIndex],
BcdOps USING [
BcdBase, CTHandle, FPHandle, MTHandle, NameString, NTHandle, ProcessConfigs, ProcessFramePacks, ProcessModules, ProcessNames, ProcessSegs, ProcessSpaces, SGHandle, SPHandle],
BootFile USING [Header],
LongString USING [AppendLongNumber, EquivalentSubStrings, SubStringDescriptor],
MB USING [BIndex, Handle, MT, VirtualGlobalFrame],
MBOut USING [Char, CR, Line, LongNumber, Number, NumberFormat, Spaces, Text, Time],
MBVM USING [Seg],
PrincOps USING [GlobalFrameHandle],
Segments USING [FHandle, NameForFile],
StartList USING [
Base, BootLocation, Entry, Header, Index, SwapUnitInfo, SpaceType, StartIndex, StateVectorCounts, Switches];

MBDebug: PROGRAM
IMPORTS BcdOps, MB, MBOut, Segments, String: LongString 
EXPORTS MB =

BEGIN

octal: MBOut.NumberFormat =
MBOut.NumberFormat[base: 8, unsigned: TRUE, zerofill: FALSE, columns: 1];

data: MB.Handle _ NIL;


InitDebug: PUBLIC PROC [h: MB.Handle] = {data _ h};

FinishDebug: PUBLIC PROC = {data _ NIL};


DumpSegs: PUBLIC PROC [segs: LONG DESCRIPTOR FOR ARRAY OF MBVM.Seg, msg: STRING] = {
OPEN MBOut;
FileName: PROC [f: Segments.FHandle] = {
name: STRING _ [40];
nss: String.SubStringDescriptor _ [base: name, offset: , length: 4];
bcdss: String.SubStringDescriptor _ [base: ".bcd"L, offset: 0, length: 4];
Segments.NameForFile[name, f];
IF name[name.length-1] = '. THEN name.length _ name.length - 1;
IF name.length > 4 THEN {
nss.offset _ name.length - 4;
IF String.EquivalentSubStrings[@nss, @bcdss] THEN name.length _ name.length - 4;
};
Text[name];
};
DumpSeg: PROC [s: MBVM.Seg] = {
Text["Seg["L];
LongNumber[s, octal];
Text["]  type: "L];
WITH seg: s SELECT FROM
data => Text["data"L];
code => Text["code"L];
file => Text["file"L];
ENDCASE;
Text[", vmpage: "L];
Number[s.base, octal];
Text[", info: "L];
DumpSwapUnitInfo[s.info];
Text[", scriptIndex: "L];
Number[s.index, octal];
Text[", booted: "L];
Boolean[s.bootLoaded];
CR[];
WITH seg: s SELECT FROM
data => NULL;
code => {
Text["  location: "L];
FileName[seg.file]; Char['(]; LongNumber[seg.file, octal]; Char[')];
Char['[]; Number[seg.fileBase, octal]; Char[',];
Number[s.pages, octal]; Char[']]; CR[];
};
file => {
Text["  location: "L];
FileName[seg.file]; Char['(]; LongNumber[seg.file, octal]; Char[')];
Char['[]; Number[seg.fileBase, octal]; Char[',];
Number[s.pages, octal]; Char[']]; CR[];
};
ENDCASE;
};
CR[];
Text["SEGMENT TABLE JUST BEFORE "L]; Text[msg]; Char[':]; CR[];
CR[];
FOR i: CARDINAL IN [0..LENGTH[segs]) DO DumpSeg[segs[i]]; ENDLOOP;
};

DumpSwapUnitInfo: PROC [info: StartList.SwapUnitInfo] = {
OPEN MBOut;
Char['[];
Text["readOnly: "L];
Boolean[info.readOnly];
Text[", "L];
MBOut.Text[SELECT info.state FROM
resident => "resident"L,
residentDescriptor => "residentDescriptor"L,
ENDCASE => "swappable"L];
Char[']];
};

DumpInputBcds: PUBLIC PROC = {
OPEN BcdDefs, BcdOps, MBOut;
CR[];
Line["INPUT BCDS:"L];
CR[];
FOR i: MB.BIndex IN [0..data.inputBCDs.nBcds) DO
bcd: BcdBase = data.inputBCDs.bcds[i].bcd;
ctb: Base = LOOPHOLE[bcd + bcd.ctOffset];
mtb: Base = LOOPHOLE[bcd + bcd.mtOffset];
ftb: Base = LOOPHOLE[bcd + bcd.ftOffset];
ssb: NameString = LOOPHOLE[bcd + bcd.ssOffset];
level: CARDINAL _ 2;
DumpName: PROC [name: NameRecord] RETURNS [length: CARDINAL] = {
length _ ssb.size[name];
FOR i: CARDINAL IN [name..name+length) DO
Char[ssb.string[i]]; 
ENDLOOP;
};
DumpCTName: PROC [cti: CTIndex] RETURNS [length: CARDINAL _ 0] = {
cth: CTHandle = @ctb[cti];
IF cth.namedInstance THEN {
FindConfigInstanceName: PROC [nth: NTHandle, nti: NTIndex] RETURNS [BOOL] = {
WITH namee: nth.item SELECT FROM
config => IF namee.cti = cti THEN {length _ DumpName[nth.name]; RETURN[TRUE]};
ENDCASE;
RETURN[FALSE]
};
[] _ ProcessNames[bcd, FindConfigInstanceName];
Text[": "L]; length _ length + 2};
length _ length + DumpName[cth.name];
};
DumpMTName: PROC [mti: MTIndex] RETURNS [length: CARDINAL _ 0] = {
mth: MTHandle = @mtb[mti];
IF mth.namedInstance THEN {
FindModuleInstanceName: PROC [nth: NTHandle, nti: NTIndex] RETURNS [BOOL] = {
WITH namee: nth.item SELECT FROM
module =>
IF namee.mti = mti THEN {length _ DumpName[nth.name]; RETURN[TRUE]};
ENDCASE;
RETURN[FALSE]
};
[] _ ProcessNames[bcd, FindModuleInstanceName];
Text[": "L]; length _ length + 2;
};
length _ length + DumpName[mth.name];
};
DumpConfigsWithParent: PROC [parentConfig: CTIndex] = {
DumpConfigsWithinParent: PROC [cth: CTHandle, cti: CTIndex] RETURNS [BOOL] = {
IF cth.config = parentConfig THEN {
Spaces[level];
[] _ DumpCTName[cti];
IF cth.nControls > 0 THEN {
Text["  control list:"L];
FOR i: CARDINAL IN [0..cth.nControls) DO
Spaces[1];
WITH cItem: cth.controls[i] SELECT FROM
module => [] _ DumpMTName[cItem.mti];
config => [] _ DumpCTName[cItem.cti];
ENDCASE;
ENDLOOP;
};
CR[];
level _ level + 2;
DumpConfigsWithParent[cti];
level _ level - 2;
};
RETURN[FALSE]
};
DumpModulesWithinParent: PROC [mth: MTHandle, mti: MTIndex] RETURNS [BOOL] = {
IF mth.config = parentConfig THEN {
nameLength: CARDINAL;
Spaces[level];
nameLength _ DumpMTName[mti];
Text["  links: "L];
Text[SELECT mth.linkLoc FROM frame => "frame"L, ENDCASE => "code"L];
Text[", framesize: "L];
Number[mth.framesize, octal];
Text[", residentFrame: "L];
Boolean[mth.residentFrame];
Text[", packageable: "L];
Boolean[mth.packageable];
Text[", nGFI: "L];
Number[mth.ngfi, octal];
Char[',]; CR[];
Spaces[level+nameLength+2];
Text["code: ["L];
Text["sgi: "L];
Number[mth.code.sgi, octal];
Text[", linkspace: "L];
Boolean[mth.code.linkspace];
Text[", packed: "L];
Boolean[mth.code.packed];
Text[", offset: "L];
Number[mth.code.offset, octal];
IF mth.packageable THEN {
Text[", length: "L];
Number[mth.code.length, octal];
};
Text["]"L];
CR[];
};
RETURN[FALSE]
};
[] _ ProcessModules[bcd, DumpModulesWithinParent];
[] _ ProcessConfigs[bcd, DumpConfigsWithinParent];
};
DumpSegment: PROC [sgh: SGHandle, sgi: SGIndex] RETURNS [BOOL] = {
IF sgh.class = code THEN {
DumpCodePacksInSegment: PROC [sph: SPHandle, spi: SPIndex] RETURNS [BOOL] = {
IF sph.seg = sgi THEN {
FOR i: CARDINAL IN [0..sph.length) DO
space: SpaceID = sph.spaces[i];
Spaces[4];
[] _ DumpName[space.name];
Text["  resident: "L]; Boolean[space.resident];
Text[", relative location: ["L]; Number[space.offset, octal];
Char[',]; Number[space.pages, octal]; Char[']];
CR[];
ENDLOOP;
};
RETURN[FALSE]
};
Text["  Code Segment [sgi: "L]; Number[sgi, octal];
Text["], location: "L];
IF sgh.file = FTSelf THEN Text["(self)"L] ELSE [] _ DumpName[ftb[sgh.file].name];
Char['[]; Number[sgh.base, octal]; Char[',]; Number[sgh.pages, octal];
Char['+]; Number[sgh.extraPages, octal]; Char[']];
CR[];
[] _ ProcessSpaces[bcd, DumpCodePacksInSegment];
};
RETURN[FALSE]
};
DumpFramePack: PROC [fph: FPHandle, fpi: FPIndex] RETURNS [BOOL] = {
Text["  Frame Pack "L]; [] _ DumpName[fph.name]; CR[];
FOR i: CARDINAL IN [0..fph.length) DO
Spaces[4]; [] _ DumpMTName[fph.modules[i]]; CR[];
ENDLOOP;
RETURN[FALSE]
};
DumpSwapUnits: PROC = {
Text["  BCD is "L]; Number[bcd.nPages, octal]; Text[" pages"L]; CR[];
Text["    BCD header occupies [1,"L]; Number[bcd.nPages-bcd.rtPages.pages, octal];
Char[']]; CR[];
IF bcd.rtPages.pages = 0 THEN {Text["    No RT extension"L]; CR[]}
ELSE {
Text["    RT extension occupies ["L]; Number[1+bcd.rtPages.relPageBase, octal];
Char[',]; Number[bcd.rtPages.pages, octal]; Char[']]; CR[];
};
};
Text["Configurations and Modules in "L];
Text[data.inputBCDs.bcds[i].name]; Char[':]; CR[];
DumpConfigsWithParent[CTNull];
CR[];
Text["Code Segments, Code Packs, and Frame Packs in "L];
Text[data.inputBCDs.bcds[i].name]; Char[':]; CR[];
DumpSwapUnits[];
[] _ ProcessSegs[bcd, DumpSegment];
[] _ ProcessFramePacks[bcd, DumpFramePack];
CR[];
ENDLOOP;
};

DumpStartList: PUBLIC PROC = {
OPEN MBOut;
base: StartList.Base _ data.scriptBase;
p: StartList.Index _ StartList.StartIndex;
CR[];
Line["START LIST:"L];
CR[];
DumpStartListHeader[];
Line["Script"L];
DO
WITH e: base[p] SELECT FROM
space => {
OPEN e;
Text["  Space["L];
Number[p, octal];
Text["]  type: "L];
DumpSpaceType[type];
Text[", backingStore: "L];
Text[IF backingStore = self THEN "self"L ELSE "null"L];
Text[", booted: "L];
Boolean[bootLoaded];
CR[];
Spaces[14];
Text["vmpage: "L];
Number[vmpage, octal];
Text[", pages: "L];
Number[pages, octal];
IF backingStore = self THEN {
Text[", backingPage: "L];
Number[backingPage, octal];
};
CR[];
p _ p + SIZE[space StartList.Entry];
};
swapUnit => {
OPEN e;
Text["  SwapUnit["L];
Number[p, octal];
Text["]  parent: "L];
Number[parent, octal];
Text[", base: "L];
Number[base, octal];
Text[", pages: "L];
Number[pages, octal];
Text[", info: "L];
DumpSwapUnitInfo[info];
CR[];
p _ p + SIZE[swapUnit StartList.Entry];
};
stop => {Line["  Stop"L];  EXIT};
ENDCASE => {Line["**Unknown BootScript Type"L];  EXIT};
ENDLOOP;
CR[];
};

DumpSpaceType: PROC [type: StartList.SpaceType] = {
OPEN MBOut;
Char['[];
WITH type SELECT FROM
empty => Text["empty[]"L];
unitary => {Text["unitary[swapUnit: "L]; Number[swapUnit, octal]; Char[']]};
family => {
Text["family[resDescChildren: "L]; Boolean[anyResidentDescriptorChildren]; Char[']]};
ENDCASE;
Char[']];
};

DumpStartListHeader: PROC = {
OPEN MBOut;
h: LONG POINTER TO StartList.Header _ data.header;
Line["Header"L];
Text["  version: "L];
Number[h.version, octal];
CR[];
Text["  table: "L];
Number[h.table, octal];
CR[];
Text["  loadState: "L];
Number[h.loadState, octal];
CR[];
Text["  initLoadState: "L];
Number[h.initLoadState, octal];
CR[];
Text["  mdsBase: "L];
Number[h.mdsBase, octal];
CR[];
Text["  pdaPages: "L];
Number[h.pdaPages, octal];
CR[];
Text["  lastVMPage: "L];
Number[h.lastVMPage, octal];
CR[];
Text["  lastBootLoadedPage: "L];
Number[h.lastBootLoadedPage, octal];
CR[];
Text["  stateVectorCounts: "L];
DumpStateVectorCount[@h.stateVectorCounts];
CR[];
Text["  switches: "L];
DumpSwitches[@h.switches];
CR[];
Text["  locDebuggerMicrocode: "L];
DumpBootLocation[@h.locDebuggerMicrocode];
CR[];
Text["  locDebuggerGerm: "L];
DumpBootLocation[@h.locDebuggerGerm];
CR[];
Text["  locDebugger: "L];
DumpBootLocation[@h.locDebugger];
CR[];
Text["  locDebuggee: "L];
DumpBootLocation[@h.locDebuggee];
CR[];
};

DumpStateVectorCount: PROC [svc: LONG POINTER TO StartList.StateVectorCounts] = {
OPEN MBOut;
Char['[];
FOR i: CARDINAL IN [0..SIZE[StartList.StateVectorCounts]) DO
IF i # 0 THEN Text[", "L];
Number[svc[i], octal];
ENDLOOP;
Char[']];
};

DumpSwitches: PROC [s: LONG POINTER TO StartList.Switches] = {
OPEN MBOut;
Char['[];
Number[s.a, octal];
Text[", "L];
Number[s.b, octal];
Text[", "L];
Number[s.c, octal];
Text[", "L];
Number[s.d, octal];
Char[']];
};

DumpBootLocation: PROC [bl: LONG POINTER TO StartList.BootLocation] = {
OPEN MBOut;
Char['[];
FOR i: CARDINAL IN [0..SIZE[StartList.BootLocation]) DO
IF i # 0 THEN Text[", "L];
Number[bl[i], octal];
ENDLOOP;
Char[']];
};

DumpBootHeader: PUBLIC PROC = {
OPEN MBOut;
h: LONG POINTER TO BootFile.Header _ data.bootHeader;
CR[];
CR[];
Line["BOOTFILE HEADER:"L];
Text["  version: "L];
Number[h.version, octal];
CR[];
Text["  creationDate: "L];
Time[h.creationDate];
Text["  pStartListHeader: "L];
Number[h.pStartListHeader, octal];
CR[];
Text["  inLoadMode: "L];
Text[(SELECT h.inLoadMode FROM load => "load"L, ENDCASE => "restore"L)];
CR[];
Text["  continuation: "L];
WITH h.continuation SELECT FROM
initial => {
Text["initial[mdsi: "L];  Number[mdsi, octal];
Text[", destination: "L];  Number[destination, octal];  Char[']];
};
ENDCASE => Text["unexpected variant!!!"L];
CR[];
Text["  countData: "L];
Number[h.countData, octal];
CR[];
CR[];
};

Boolean: PROC [b: BOOLEAN] = {MBOut.Char[IF b THEN 'T ELSE 'F]};

DumpFrames: PUBLIC PROC = {
OPEN MBOut;
CR[];
Line["GLOBAL FRAMES AT COMPLETION OF LOADING:"L];
CR[];
FOR i: MB.BIndex IN [0..data.inputBCDs.nBcds) DO
mt: MB.MT = data.inputBCDs.bcds[i].mt;
Text[data.inputBCDs.bcds[i].name]; CR[];
FOR gfi: CARDINAL IN [1..LENGTH[mt]) DO
frame: PrincOps.GlobalFrameHandle;
s: STRING _ [20];
IF mt[gfi].mth.gfi # gfi THEN LOOP;
frame _ mt[gfi].frame;
Text["  Frame["L];
Number[frame, octal];
Text["]  gfi: "L];
Number[MB.VirtualGlobalFrame[frame].gfi, octal];
Text[", shared: "L];
Boolean[MB.VirtualGlobalFrame[frame].shared];
Text[", alloced: "L];
Boolean[MB.VirtualGlobalFrame[frame].alloced];
Text[", codelinks: "L];
Boolean[MB.VirtualGlobalFrame[frame].codelinks];
Text[", codebase: "L];
String.AppendLongNumber[s, MB.VirtualGlobalFrame[frame].code.longbase, 8];
Text[s];
CR[];
ENDLOOP;
CR[];
ENDLOOP;
};

END.


ŒMBDebug.mesa  
Edited by Sandman on 28-Jan-81 10:42:17
Edited by Lewis on 25-Sep-81 15:33:42
Edited by Levin on April 5, 1983 2:33 pm
�ÊK˜Jš
œ™Jš
œ'™'Jš
œ%™%Jš
œ(™(J˜š
Ïk	˜	šœ�œ˜J˜j—šœ�œ˜J˜®
—Jšœ	�œ
˜Jšœ�œ?˜OJš�œ
�œ�œ˜2Jšœ�œ�œ>˜SJš�œ
�œ˜Jšœ	�œ˜#Jšœ	�œ˜&šœ
�œ˜J˜lJ˜——šœ	�˜Jš�œ	�œ&˜8Jš�œ
�œ˜—J˜Jš
�˜J˜˜Jšœ&�œ�œ˜IJ˜—Jšœ�œ
�œ
˜J˜J˜JšÏn	œ�œ
�œ�œ˜3J˜Jšžœ�œ
�œ�œ˜(J˜J˜šžœ�œ
�œ�œ
�
œ
�œ
�œ
�œ
�œ�œ˜TJš�œ˜šžœ�œ˜(Jšœ�œ˜J˜DJ˜JJ˜Jš�œ�œ˜?š�œ�œ˜J˜Jš�œ+�œ˜PJš
œ˜—J˜J˜—šžœ�œ�œ	˜J˜J˜J˜š�œ�œ
�˜J˜J˜J˜Jš�œ
˜—J˜J˜J˜J˜J˜J˜J˜J˜Jš�œ˜š�œ�œ
�˜Jšœ�œ
˜
˜	J˜J˜DJ˜0Jšœ"�œ˜'Jš
œ˜—˜	J˜J˜DJ˜0Jšœ"�œ˜'Jš
œ˜—Jš�œ
˜—Jš
œ˜—Jš�œ˜Jšœ:�œ˜?Jš�œ˜Jš�œ�œ
�œ�œ�œ�œ
˜BJš
œ˜J˜—šžœ�œ#˜9Jš�œ˜J˜	J˜J˜J˜šœ�œ�˜!J˜J˜,Jš�œ˜—J˜	J˜J˜—šž
œ�œ
�œ˜Jš�œ˜Jš�œ˜J˜Jš�œ˜š�œ�œ�œ�˜0J˜*Jšœ�œ˜)Jšœ�œ˜)Jšœ�œ˜)Jšœ�œ˜/Jšœ�œ˜šžœ�œ�œ
�œ˜@J˜š�œ�œ
�œ�˜)J˜Jš
�˜—Jš
œ˜—šž
œ�œ�œ
�œ	˜BJ˜š�œ�œ˜šžœ�œ�œ�œ˜Mš�œ�œ
�˜ Jš	œ
�œ�œ�œ
�œ˜NJš�œ
˜—Jš�œ
�œ
˜
Jš
œ˜—J˜/J˜"—J˜%J˜—šž
œ�œ�œ
�œ	˜BJ˜š�œ�œ˜šžœ�œ�œ�œ˜Mš�œ�œ
�˜ š
œ	˜	Jš�œ�œ�œ
�œ˜D—Jš�œ
˜—Jš�œ
�œ
˜
Jš
œ˜—J˜/J˜!J˜—J˜%J˜—šžœ�œ˜7šžœ�œ�œ�œ˜Nš�œ�œ˜#J˜J˜š�œ�œ˜J˜š�œ�œ
�œ�˜(J˜
š�œ�œ
�˜'J˜%J˜%Jš�œ
˜—Jš
�˜—Jš
œ˜—Jš�œ˜J˜J˜J˜J˜—Jš�œ
�œ
˜
Jš
œ˜—šžœ�œ�œ�œ˜Nš�œ�œ˜#Jšœ�œ
˜J˜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˜—J˜Jš�œ˜Jš
œ˜—Jš�œ
�œ
˜
Jš
œ˜—J˜2J˜2J˜—šžœ�œ�œ�œ˜Bš�œ�œ˜šžœ�œ�œ�œ˜Mš�œ�œ˜š�œ�œ
�œ�˜%J˜J˜
J˜J˜/J˜=J˜/Jš�œ˜Jš
�˜—Jš
œ˜—Jš�œ
�œ
˜
Jš
œ˜—J˜3J˜Jš�œ�œ�œ#˜QJ˜FJ˜2Jš�œ˜J˜0J˜—Jš�œ
�œ
˜
Jš
œ˜—šž
œ�œ�œ�œ˜DJšœ1�œ˜6š�œ�œ
�œ�˜%Jšœ,�œ˜1Jš�œ
˜—Jš�œ
�œ
˜
Jš
œ˜—šž
œ�œ˜Jšœ@�œ˜EJ˜RJšœ
�œ˜Jš�œ�œ �œ˜Bš�œ˜J˜OJšœ6�œ˜;Jš
œ˜—Jš
œ˜—J˜(Jšœ-�œ˜2J˜Jš�œ˜J˜8Jšœ-�œ˜2J˜J˜#J˜+Jš�œ˜Jš
�˜—š
œ˜J˜——šž
œ�œ
�œ˜Jš�œ˜J˜'J˜*Jš�œ˜J˜Jš�œ˜J˜J˜š
�˜š�œ�œ
�˜˜
Jš�œ˜J˜J˜J˜J˜J˜Jšœ�œ�œ	�œ
˜7J˜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šœ�œ˜!Jš�œ*�œ˜7—Jš�œ
˜—Jš�œ˜Jš
œ˜J˜—šž
œ�œ ˜3Jš�œ˜J˜	š�œ�œ
�˜J˜J˜L˜J˜U—Jš�œ
˜—J˜	J˜J˜—šžœ�œ˜Jš�œ˜Jšœ�œ
�œ
�œ ˜2J˜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˜J˜Jš�œ˜J˜"J˜*Jš�œ˜J˜J˜%Jš�œ˜J˜J˜!Jš�œ˜J˜J˜!Jš�œ˜Jš
œ˜J˜—š
žœ�œ�œ
�œ
�œ!˜QJš�œ˜J˜	š	�œ�œ
�œ�œ�˜<Jš�œ�œ
˜J˜Jš�œ
˜—J˜	J˜J˜—š
žœ�œ�œ
�œ
�œ˜>Jš�œ˜J˜	J˜J˜J˜J˜J˜J˜J˜J˜	J˜J˜—š
žœ�œ�œ
�œ
�œ˜GJš�œ˜J˜	š	�œ�œ
�œ�œ�˜7Jš�œ�œ
˜J˜Jš�œ
˜—J˜	J˜J˜—šžœ�œ
�œ˜Jš�œ˜Jšœ�œ
�œ
�œ#˜5Jš�œ˜Jš�œ˜J˜J˜J˜Jš�œ˜J˜J˜J˜J˜"Jš�œ˜J˜Jšœ�œ�œ�œ˜HJš�œ˜J˜š�œ�œ
�˜˜J˜.J˜AJ˜—Jš�œ#˜*—Jš�œ˜J˜J˜Jš�œ˜Jš�œ˜Jš
œ˜J˜—Jšžœ�œ�œ�œ�œ�œ˜@J˜šž
œ�œ
�œ˜Jš�œ˜Jš�œ˜J˜1Jš�œ˜š�œ�œ�œ�˜0Jšœ�œ
�œ˜&Jšœ#�œ˜(š	�œ�œ
�œ�œ�˜'J˜"Jšœ�œ˜Jš�œ�œ
�œ
˜#J˜J˜J˜J˜Jšœ�œ'˜0J˜Jšœ�œ#˜-J˜Jšœ�œ$˜.J˜Jšœ�œ&˜0J˜Jšœ�œ-˜JJ˜Jš�œ˜Jš�œ
˜—Jš�œ˜Jš�œ
˜—š
œ˜J˜——Jš�œ
˜˜J˜——…—0´?‹