DIRECTORY
Ascii USING [SP],
BasicTime USING [earliestGMT, FromPupTime, GMT],
BcdDefs USING [Base, BcdBase, CTHandle, CTIndex, CTNull, FPHandle, FPIndex, FTIndex, FTSelf, MTHandle, MTIndex, NameRecord, NameString, NTHandle, NTIndex, SGHandle, SGIndex, SpaceID, SPHandle, SPIndex],
BcdOps USING [ProcessConfigs, ProcessFramePacks, ProcessModules, ProcessNames, ProcessSegs, ProcessSpaces],
BootFile USING [Location, Header],
BootStartList USING [Base, Entry, Header, Index, SwapUnitInfo, SpaceType, startIndex, StateVectorCounts, Switches],
IO USING [bool, card, PutChar, PutF, PutRope, rope, time],
MB USING [BIndex, Handle, MT, VirtualGlobalFrame],
MBVM USING [CodeSeg, DataSeg, FileSeg, Seg, Segs],
PrincOps USING [GlobalFrameHandle],
Rope USING [Cat, ROPE];

MBDebug: CEDAR PROGRAM
IMPORTS BasicTime, BcdOps, IO, MB, Rope 
EXPORTS MB =

BEGIN

data: MB.Handle _ NIL;


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

FinishDebug: PUBLIC PROC = {data _ NIL};


DumpSegs: PUBLIC PROC [segs: MBVM.Segs, msg: Rope.ROPE] = {
DumpSeg: PROC [s: MBVM.Seg] = {
data.loadmap.PutF["Seg[%n]  type: ", IO.card[LOOPHOLE[s]]];
WITH s SELECT FROM
seg: MBVM.DataSeg => data.loadmap.PutRope["data"];
seg: MBVM.CodeSeg => data.loadmap.PutRope["code"];
seg: MBVM.FileSeg => data.loadmap.PutRope["file"];
ENDCASE;
data.loadmap.PutF[", vmpage: %n, info: %g, scriptIndex: %n, booted: %z\N",
IO.card[s.base], IO.rope[GetSwapUnitInfo[s.info]],
IO.card[LOOPHOLE[s.index].LONG], IO.bool[s.bootLoaded]];
IF s.objType ~= data THEN
data.loadmap.PutF["  location: %f[%n,%n]\N",
IO.rope[s.file],
IO.card[s.fileBase], IO.card[s.pages]];
};
data.loadmap.PutF["\NSEGMENT TABLE JUST BEFORE %g:\N\N", IO.rope[msg]];
FOR i: CARDINAL IN [0..segs.length) DO DumpSeg[segs[i]]; ENDLOOP;
};

GetSwapUnitInfo: PROC [info: BootStartList.SwapUnitInfo] RETURNS [Rope.ROPE] = {
RETURN[Rope.Cat[
"[readOnly: ",
IF info.readOnly THEN "T, " ELSE "F, ",
SELECT info.state FROM
resident => "resident",
residentDescriptor => "residentDescriptor",
ENDCASE => "swappable",
"]"
]]
};

DumpInputBcds: PUBLIC PROC = TRUSTED {
OPEN BcdDefs, BcdOps;
data.loadmap.PutRope["\NINPUT BCDS:\N\N"];
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] = TRUSTED {
length _ ssb.size[name];
FOR i: CARDINAL IN [name..name+length) DO
data.loadmap.PutChar[ssb.string[i]]; 
ENDLOOP;
};
DumpCTName: PROC [cti: CTIndex] RETURNS [length: CARDINAL _ 0] = TRUSTED {
cth: CTHandle = @ctb[cti];
IF cth.namedInstance THEN {
FindConfigInstanceName: PROC [nth: NTHandle, nti: NTIndex]
RETURNS [BOOL] = TRUSTED {
WITH namee: nth.item SELECT FROM
config => IF namee.cti = cti THEN {length _ DumpName[nth.name]; RETURN[TRUE]};
ENDCASE;
RETURN[FALSE]
};
[] _ ProcessNames[bcd, FindConfigInstanceName];
data.loadmap.PutRope[": "]; length _ length + 2};
length _ length + DumpName[cth.name];
};
DumpMTName: PROC [mti: MTIndex] RETURNS [length: CARDINAL _ 0] = TRUSTED {
mth: MTHandle = @mtb[mti];
IF mth.namedInstance THEN {
FindModuleInstanceName: PROC [nth: NTHandle, nti: NTIndex]
RETURNS [BOOL] = TRUSTED {
WITH namee: nth.item SELECT FROM
module =>
IF namee.mti = mti THEN {length _ DumpName[nth.name]; RETURN[TRUE]};
ENDCASE;
RETURN[FALSE]
};
[] _ ProcessNames[bcd, FindModuleInstanceName];
data.loadmap.PutRope[": "]; length _ length + 2;
};
length _ length + DumpName[mth.name];
};
DumpConfigsWithParent: PROC [parentConfig: CTIndex] = TRUSTED {
DumpConfigsWithinParent: PROC [cth: CTHandle, cti: CTIndex]
RETURNS [BOOL] = TRUSTED {
IF cth.config = parentConfig THEN {
data.loadmap.PutF["%s", IO.card[level]];
[] _ DumpCTName[cti];
IF cth.nControls > 0 THEN {
data.loadmap.PutRope["  control list:"];
FOR i: CARDINAL IN [0..cth.nControls) DO
data.loadmap.PutChar[Ascii.SP];
WITH cItem: cth.controls[i] SELECT FROM
module => [] _ DumpMTName[cItem.mti];
config => [] _ DumpCTName[cItem.cti];
ENDCASE;
ENDLOOP;
};
data.loadmap.PutChar['\N];
level _ level + 2;
DumpConfigsWithParent[cti];
level _ level - 2;
};
RETURN[FALSE]
};
DumpModulesWithinParent: PROC [mth: MTHandle, mti: MTIndex]
RETURNS [BOOL] = TRUSTED {
IF mth.config = parentConfig THEN {
nameLength: CARDINAL;
data.loadmap.PutF["%s", IO.card[level]];
nameLength _ DumpMTName[mti];
data.loadmap.PutF["  links: %g, framesize: %n, residentFrame: %z, packageable: %z, nGFI: %n,\N",
IO.rope[SELECT mth.linkLoc FROM frame => "frame", ENDCASE => "code"],
IO.card[mth.framesize],
IO.bool[mth.residentFrame], IO.bool[mth.packageable],
IO.card[mth.ngfi]
];
data.loadmap.PutF["%scode: [sgi: %n, linkspace: %z, packed: %z, offset: %n",
IO.card[level+nameLength+2],
IO.card[LOOPHOLE[mth.code.sgi].LONG],
IO.bool[mth.code.linkspace], IO.bool[mth.code.packed],
IO.card[mth.code.offset]
];
IF mth.packageable THEN data.loadmap.PutF[", length: %n", IO.card[mth.code.length]];
data.loadmap.PutRope["]\N"];
};
RETURN[FALSE]
};
[] _ ProcessModules[bcd, DumpModulesWithinParent];
[] _ ProcessConfigs[bcd, DumpConfigsWithinParent];
};
DumpSegment: PROC [sgh: SGHandle, sgi: SGIndex] RETURNS [BOOL] = TRUSTED {
IF sgh.class = code THEN {
DumpCodePacksInSegment: PROC [sph: SPHandle, spi: SPIndex]
RETURNS [BOOL] = TRUSTED {
IF sph.seg = sgi THEN {
FOR i: CARDINAL IN [0..sph.length) DO
space: SpaceID = sph.spaces[i];
data.loadmap.PutRope["    "];
[] _ DumpName[space.name];
data.loadmap.PutF["  resident: %z, relative location: [%n,%n]\N",
IO.bool[space.resident], IO.card[space.offset], IO.card[space.pages]
];
ENDLOOP;
};
RETURN[FALSE]
};
data.loadmap.PutF["  Code Segment [sgi: %n], location: ", IO.card[LOOPHOLE[sgi].LONG]];
IF sgh.file = FTSelf THEN data.loadmap.PutRope["(self)"]
ELSE [] _ DumpName[ftb[sgh.file].name];
data.loadmap.PutF["[%n,%n+%n]\N",
IO.card[sgh.base], IO.card[sgh.pages], IO.card[sgh.extraPages]
];
[] _ ProcessSpaces[bcd, DumpCodePacksInSegment];
};
RETURN[FALSE]
};
DumpFramePack: PROC [fph: FPHandle, fpi: FPIndex] RETURNS [BOOL] = TRUSTED {
data.loadmap.PutRope["  Frame Pack "]; [] _ DumpName[fph.name];
FOR i: CARDINAL IN [0..fph.length) DO
data.loadmap.PutRope["\N    "]; [] _ DumpMTName[fph.modules[i]];
ENDLOOP;
data.loadmap.PutChar['\N];
RETURN[FALSE]
};
DumpSwapUnits: PROC = TRUSTED {
data.loadmap.PutF["  BCD is %n pages\N    BCD header occupies [1,%n]\N",
IO.card[bcd.nPages], IO.card[bcd.nPages-bcd.rtPages.pages]
];
IF bcd.rtPages.pages = 0 THEN data.loadmap.PutRope["    No RT extension\N"]
ELSE {
data.loadmap.PutF["    RT extension occupies [%n,%n]\N",
IO.card[1+bcd.rtPages.relPageBase], IO.card[bcd.rtPages.pages]
];
};
};
data.loadmap.PutF["Configurations and Modules in %g:\N",
IO.rope[data.inputBCDs.bcds[i].name]];
DumpConfigsWithParent[CTNull];
data.loadmap.PutF["\NCode Segments, Code Packs, and Frame Packs in %g:\N",
IO.rope[data.inputBCDs.bcds[i].name]];
DumpSwapUnits[];
[] _ ProcessSegs[bcd, DumpSegment];
[] _ ProcessFramePacks[bcd, DumpFramePack];
data.loadmap.PutChar['\N];
ENDLOOP;
};

DumpStartList: PUBLIC PROC = TRUSTED {
base: BootStartList.Base _ data.scriptBase;
p: BootStartList.Index _ BootStartList.startIndex;
data.loadmap.PutRope["\NSTART LIST:\N\N"];
DumpStartListHeader[];
data.loadmap.PutRope["Script\N"];
DO
WITH e: base[p] SELECT FROM
space => {
OPEN e;
data.loadmap.PutF["  Space[%n]  type: ", IO.card[LOOPHOLE[p].LONG]];
DumpSpaceType[type];
data.loadmap.PutF[", backingStore: %g, booted: %z\N",
IO.rope[IF backingStore = self THEN "self" ELSE "null"],
IO.bool[bootLoaded]
];
data.loadmap.PutF["              vmpage: %n, pages: %n",
IO.card[vmPage], IO.card[pages]];
IF backingStore = self THEN
data.loadmap.PutF[", backingPage: %n", IO.card[backingPage]];
data.loadmap.PutChar['\N];
p _ p + SIZE[space BootStartList.Entry];
};
swapUnit => {
OPEN e;
data.loadmap.PutF["  SwapUnit[%n]  parent: %n, base: %n, pages: %n, info: %g\N",
IO.card[LOOPHOLE[p].LONG],
IO.card[LOOPHOLE[parent].LONG],
IO.card[base], IO.card[pages],
IO.rope[GetSwapUnitInfo[info]]
];
p _ p + SIZE[swapUnit BootStartList.Entry];
};
stop => {data.loadmap.PutRope["  Stop\N"];  EXIT};
ENDCASE => {data.loadmap.PutRope["**Unknown BootScript Type\N"];  EXIT};
ENDLOOP;
data.loadmap.PutChar['\N];
};

DumpSpaceType: PROC [type: BootStartList.SpaceType] = {
WITH type SELECT FROM
empty => data.loadmap.PutRope["[empty[]]"];
unitary =>
data.loadmap.PutF["[unitary[swapUnit: %n]]", IO.card[LOOPHOLE[swapUnit].LONG]];
family =>
data.loadmap.PutF["[family[resDescChildren: %z]]", IO.bool[anyResidentDescriptorChildren]];
ENDCASE;
};

DumpStartListHeader: PROC = {
h: REF BootStartList.Header _ data.header;
UCodeTime: PROC [pupTime: LONG CARDINAL] RETURNS [BasicTime.GMT] = {
RETURN [
IF pupTime = 0 THEN BasicTime.earliestGMT ELSE BasicTime.FromPupTime[pupTime]
]
};
data.loadmap.PutF[
"Header (%n)\N  version: %n\N  release: %n.%n.%n\N",
IO.card[LOOPHOLE[data.scriptBaseInVM]],
IO.card[h.version],
IO.card[h.release.major], IO.card[h.release.minor], IO.card[h.release.patch]
];
data.loadmap.PutF["  buildDate: %t\N", IO.time[BasicTime.FromPupTime[h.buildDate]]];
data.loadmap.PutF[
"  uCodeDolphin: %t\N  uCodeDorado: %t\N  uCodeDandelion: %t\N  uCodeDicentra: %t\N",
IO.time[UCodeTime[h.requiredUCode[dolphin]]],
IO.time[UCodeTime[h.requiredUCode[dorado]]],
IO.time[UCodeTime[h.requiredUCode[dandelion]]],
IO.time[UCodeTime[h.requiredUCode[dicentra]]],
];
data.loadmap.PutF["  controlList: %n\N  initLoadState: %n\N",
IO.card[LOOPHOLE[h.controlList].LONG],
IO.card[LOOPHOLE[h.initLoadState].LONG]
];
data.loadmap.PutF["  mdsBase: %n\N  pdaPages: %n\N",
IO.card[h.mdsBase], IO.card[h.pdaPages]
];
data.loadmap.PutRope["  stateVectorCounts: "];
DumpStateVectorCounts[h.stateVectorCounts];
data.loadmap.PutChar['\N];
data.loadmap.PutF[
"  stateVectorSize: %n\N  nProcesses: %n\N  lastVMPage: %n\N  lastBootLoadedPage: %n\N",
IO.card[h.stateVectorSize.LONG],
IO.card[h.nProcesses.LONG],
IO.card[h.lastVMPage],
IO.card[h.lastBootLoadedPage]
];
data.loadmap.PutRope["  switches: "];
DumpSwitches[h.switches];
data.loadmap.PutChar['\N];
data.loadmap.PutRope["  locDebuggerMicrocode: "];
DumpBootLocation[h.locDebuggerMicrocode];
data.loadmap.PutChar['\N];
data.loadmap.PutRope["  locDebuggerGerm: "];
DumpBootLocation[h.locDebuggerGerm];
data.loadmap.PutChar['\N];
data.loadmap.PutRope["  locDebugger: "];
DumpBootLocation[h.locDebugger];
data.loadmap.PutChar['\N];
data.loadmap.PutRope["  locDebuggee: "];
DumpBootLocation[h.locDebuggee];
data.loadmap.PutChar['\N];
};

DumpStateVectorCounts: PROC [svc: BootStartList.StateVectorCounts] = {
data.loadmap.PutChar['[];
FOR i: CARDINAL IN [0..SIZE[BootStartList.StateVectorCounts]) DO
data.loadmap.PutF["%g%n", IO.rope[IF i ~= 0 THEN ", " ELSE NIL], IO.card[svc[i]]];
ENDLOOP;
data.loadmap.PutChar[']];
};

DumpSwitches: PROC [s: BootStartList.Switches] = {
data.loadmap.PutF["[%n, %n, %n, %n]", IO.card[s.a], IO.card[s.b], IO.card[s.c], IO.card[s.d]];
};

DumpBootLocation: PROC [bl: BootFile.Location] = {
bits: ARRAY [0..SIZE[BootFile.Location]) OF CARDINAL = LOOPHOLE[bl];
data.loadmap.PutChar['[];
FOR i: CARDINAL IN [0..SIZE[BootFile.Location]) DO
data.loadmap.PutF["%g%n", IO.rope[IF i ~= 0 THEN ", " ELSE NIL], IO.card[bits[i]]];
ENDLOOP;
data.loadmap.PutChar[']];
};

DumpBootHeader: PUBLIC PROC = {
h: REF BootFile.Header _ data.bootHeader;
data.loadmap.PutF[
"\N\NBOOTFILE HEADER:\N  version: %n\N  creationDate: %t\N  pStartListHeader: %n\N",
IO.card[h.version],
IO.time[BasicTime.FromPupTime[h.creationDate]],
IO.card[LOOPHOLE[h.pStartListHeader.LONG]]];
data.loadmap.PutF["  inLoadMode: %g\N  continuation: ",
IO.rope[SELECT h.inLoadMode FROM load => "load", ENDCASE => "restore"]];
WITH h.continuation SELECT FROM
initial =>
data.loadmap.PutF["initial[mdsi: %n, destination: %n]",
IO.card[mdsi],
IO.card[LOOPHOLE[destination].LONG]];
ENDCASE => data.loadmap.PutRope["unexpected variant!!!"];
data.loadmap.PutF["\N  countData: %n\N\N", IO.card[h.countData]];
};

DumpFrames: PUBLIC PROC = TRUSTED {
data.loadmap.PutRope["\NGLOBAL FRAMES AT COMPLETION OF LOADING:\N\N"];
FOR i: MB.BIndex IN [0..data.inputBCDs.nBcds) DO
mt: MB.MT = data.inputBCDs.bcds[i].mt;
data.loadmap.PutF["%g\N", IO.rope[data.inputBCDs.bcds[i].name]];
FOR gfi: CARDINAL IN [1..mt.length) DO
frame: PrincOps.GlobalFrameHandle;
IF mt[gfi].mth.gfi ~= gfi THEN LOOP;
frame _ mt[gfi].frame;
data.loadmap.PutF[
"  Frame[%n]  gfi: %n, shared: %z, alloced: %z, codelinks: %z",
IO.card[LOOPHOLE[frame].LONG],
IO.card[MB.VirtualGlobalFrame[frame].gfi],
IO.bool[MB.VirtualGlobalFrame[frame].shared],
IO.bool[MB.VirtualGlobalFrame[frame].alloced],
IO.bool[MB.VirtualGlobalFrame[frame].codelinks]
];
data.loadmap.PutF[", codebase: %n\N",
IO.card[LOOPHOLE[MB.VirtualGlobalFrame[frame].code.longbase]]
];
ENDLOOP;
data.loadmap.PutChar['\N];
ENDLOOP;
};

END.


ήMBDebug.mesa  
Copyright c 1985 by Xerox Corporation.  All rights reserved.
Sandman on 28-Jan-81 10:42:17
Lewis on 25-Sep-81 15:33:42
Levin on January 17, 1984 10:24 am
Russ Atkinson on March 8, 1985 5:00:55 pm PST
Κ–

"cedar" style˜
codeš
œ™Kšœ
Οm
œ1™<Kš
œ™Kš
œ™Kš
œ"™"Kš
œ-™-—K˜š
Οk	˜	Kšœžœžœ˜Kšœ
žœžœ˜0Kšœžœ½
˜Κ
Kšœžœ_˜kKšœ	žœ˜"Kšœžœ`˜sKšžœ
žœ2˜:Kšžœ
žœžœ˜2Kšžœ
žœ(˜2Kšœ	žœ˜#Kšœžœžœ˜—K˜šœ	žœ
ž˜Kšžœžœžœ˜(Kšžœ
žœ˜—K˜Kš
ž˜K˜Kšœžœ
žœ
˜K˜K˜KšΟn	œžœ
žœžœ˜3K˜KšŸœžœ
žœžœ˜(K˜K˜š
Ÿœžœ
žœžœžœ˜;šŸœžœžœ	˜Kšœ%žœžœ˜;šžœžœ
ž˜Kšœžœ)˜2Kšœžœ)˜2Kšœžœ)˜2Kšžœ
˜—š
œJ˜JKšžœžœ˜2Kšžœžœ
žœžœ˜8—šžœž˜š
œ,˜,Kšžœ˜Kšžœžœ˜'——Kš
œ˜—Kšœ9žœ˜GKš
žœžœ
žœžœžœ
˜AKš
œ˜K˜—šŸœžœ$žœžœ˜Pšžœ
˜Kš
œ˜Kšžœžœžœ˜'šžœž˜K˜K˜+Kšžœ˜—Kš
œ˜Kš
œ˜—K˜K˜—šŸ
œžœ
žœžœ˜&Kšžœ˜K˜*šžœžœžœž˜0K˜*Kšœžœ˜)Kšœžœ˜)Kšœžœ˜)Kšœžœ˜/Kšœžœ˜š
Ÿœžœžœ
žœžœ˜HK˜šžœžœ
žœž˜)K˜%Kš
ž˜—Kš
œ˜—š
Ÿ
œžœžœ
žœžœ˜JK˜šžœžœ˜šŸœžœ˜:Kšžœžœžœ˜šžœžœ
ž˜ Kš	œ
žœžœžœ
žœ˜NKšžœ
˜—Kšžœ
žœ
˜
Kš
œ˜—K˜/K˜1—K˜%K˜—š
Ÿ
œžœžœ
žœžœ˜JK˜šžœžœ˜šŸœžœ˜:Kšžœžœžœ˜šžœžœ
ž˜ š
œ	˜	Kšžœžœžœ
žœ˜D—Kšžœ
˜—Kšžœ
žœ
˜
Kš
œ˜—K˜/K˜0K˜—K˜%K˜—šŸœžœžœ˜?šŸœžœ˜;Kšžœžœžœ˜šžœžœ˜#Kšœžœ˜(K˜šžœžœ˜K˜(šžœžœ
žœž˜(Kšœžœ˜šžœžœ
ž˜'K˜%K˜%Kšžœ
˜—Kš
ž˜—Kš
œ˜—Kš
œ˜K˜K˜K˜K˜—Kšžœ
žœ
˜
Kš
œ˜—šŸœžœ˜;Kšžœžœžœ˜šžœžœ˜#Kšœžœ
˜Kšœžœ˜(K˜š
œ`˜`Kšžœžœ
žœžœ˜EKšžœ˜Kšžœžœ˜5Kšžœ˜Kš
œ˜—š
œL˜LKšžœ˜Kšžœžœžœ˜%Kšžœžœ˜6Kšžœ˜K˜—Kšžœžœ#žœ˜TKš
œ˜Kš
œ˜—Kšžœ
žœ
˜
Kš
œ˜—K˜2K˜2K˜—š
Ÿœžœžœžœžœ˜Jšžœžœ˜šŸœžœ˜:Kšžœžœžœ˜šžœžœ˜šžœžœ
žœž˜%K˜K˜K˜˜AKšžœžœžœ˜DK˜—Kš
ž˜—Kš
œ˜—Kšžœ
žœ
˜
Kš
œ˜—Kšœ:žœžœžœ˜WKšžœžœ˜8Kšžœ#˜'š
œ!˜!Kšžœžœžœ˜>Kš
œ˜—K˜0K˜—Kšžœ
žœ
˜
Kš
œ˜—š
Ÿ
œžœžœžœžœ˜LKš
œ?˜?šžœžœ
žœž˜%Kš
œ@˜@Kšžœ
˜—Kš
œ˜Kšžœ
žœ
˜
Kš
œ˜—šŸ
œžœžœ˜š
œH˜HKšžœžœ#˜:Kš
œ˜—Kšžœžœ.˜Kšžœ˜š
œ8˜8Kšžœ"žœ˜>Kš
œ˜—Kš
œ˜—Kš
œ˜—š
œ8˜8Kšžœ$˜&—K˜š
œJ˜JKšžœ$˜&—K˜K˜#K˜+Kš
œ˜Kš
ž˜—š
œ˜K˜——šŸ
œžœ
žœžœ˜&K˜+K˜2K˜*K˜K˜!š
ž˜šžœžœ
ž˜˜
Kšžœ˜Kšœ)žœžœžœ˜DK˜˜5Kšžœžœžœžœ	˜8Kšžœ˜K˜—˜8Kšžœžœ˜!—šžœž˜Kšœ'žœ˜=—Kš
œ˜Kšœžœ˜(Kš
œ˜—˜
Kšžœ˜˜PKšžœžœžœ˜Kšžœžœ	žœ˜Kšžœ
žœ
˜Kšžœ˜Kš
œ˜—Kšœžœ˜+Kš
œ˜—Kšœ,žœ˜2Kšžœ;žœ˜H—Kšžœ
˜—Kš
œ˜Kš
œ˜K˜—šŸ
œžœ$˜7šžœžœ
ž˜K˜+š
œ
˜
Kšœ-žœžœžœ˜O—˜	Kšœ3žœ&˜[—Kšžœ
˜—K˜K˜—šŸœžœ˜Kšœžœ$˜*šŸ	œžœžœ
žœžœžœ˜Dšžœ˜Kšžœ
žœžœ˜MKš
œ
˜
—K˜—š
œ˜Kš
œ4˜4Kšžœžœ˜'Kšžœ˜Kšžœžœžœ˜LKš
œ˜—Kšœ&žœ+˜T˜K˜UKšžœ+˜-Kšžœ*˜,Kšžœ-˜/Kšžœ,˜.Kš
œ˜—š
œ=˜=Kšžœžœžœ˜&Kšžœžœžœ
˜'Kš
œ˜—š
œ4˜4Kšžœžœ˜'Kš
œ˜—Kš
œ.˜.K˜+Kš
œ˜š
œ˜Kš
œX˜XKšžœžœ˜ Kšžœžœ˜Kšžœ˜Kšžœ˜Kš
œ˜—Kš
œ%˜%K˜Kš
œ˜Kš
œ1˜1K˜)Kš
œ˜Kš
œ,˜,K˜$Kš
œ˜Kš
œ(˜(K˜ Kš
œ˜Kš
œ(˜(K˜ Kš
œ˜Kš
œ˜K˜—šŸœžœ+˜FK˜š	žœžœ
žœžœ#ž˜@Kš
œžœžœžœžœ
žœžœ˜RKšžœ
˜—K˜K˜K˜—šŸœžœ ˜2Kš	œ&žœžœžœžœ˜^K˜K˜—šŸœžœ˜2Kšœžœžœžœ
žœžœ˜DK˜š	žœžœ
žœžœž˜2Kš
œžœžœžœžœ
žœžœ˜SKšžœ
˜—K˜K˜K˜—šŸœžœ
žœ˜Kšœžœ#˜)š
œ˜Kš
œT˜TKšžœ˜Kšžœ-˜/Kšžœžœžœ˜,—š
œ7˜7Kšžœžœžœžœ˜H—šžœžœ
ž˜˜
Kš
œ7˜7Kšžœ˜Kšžœžœžœ˜%—Kšžœ2˜9—Kšœ+žœ˜AKš
œ˜K˜—šŸ
œžœ
žœžœ˜#K˜Fšžœžœžœž˜0Kšœžœ
žœ˜&Kšœžœ$˜@šžœžœ
žœž˜&K˜"Kšžœžœ
žœ
˜$K˜˜K˜?Kšžœžœžœ˜Kšžœžœ ˜*Kšžœžœ#˜-Kšžœžœ$˜.Kšžœžœ%˜/K˜—˜%Kšžœžœ
žœ*˜=Kš
œ˜—Kšžœ
˜—Kš
œ˜Kšžœ
˜—š
œ˜K˜——Kšžœ
˜˜K˜——…—2NBI