DIRECTORY
Basics USING [BITAND, BITOR, Card16FromH, Card32FromF, Comparison, FWORD, HWORD],
BasicTime USING [GMT, Now],
CCTypes USING[CCError, CCErrorCase],
CirioTypes USING [zeroBA],
Commander USING [Register, CommandProc],
CommanderOps USING [ArgumentVector, Parse],
Convert USING[IntFromRope, RopeFromChar],
IO USING[card, EndOf, GetChar, GetFWord, GetHWord, PeekChar, PutF, PutFR, SetIndex, STREAM, time, UnsafeGetBlock],
List USING[LORA, CompareProc, Sort],
ObjectFiles USING [BracketNest, BracketPairKind, CNameOfStab, CreateParsed, FileSegmentPC, GlobalVarLoc, MakeUnknownVarLoc, RopeForStabType, SimpleSeg, Stab, StabBody, StabType, unspecdBitSize, VarLoc, VarLocBody, VersionStampInfo],
ObjectFilesPrivate USING [AlterFunStabType, BracketPair, BracketPairBody, CheckStaticVar, FunStabInfo, FunStabSet, GetSPOffsetType, GetTypeRefProcType, HeaderBody, InstallStaticVarsType, LineNumToPCMapBody, MemorySegmentInfo, Module, ModuleBody, ModuleFromParsedAndPCProcType, ObjectFileFlavorBody, Parsed, ParsedBody, PCtoLineNumMapBody, RaiseUnreadableObjectFileForFun, ReadHeaderProcType, ReadInitialDataAsRope, ReadStab, ReadStabRope, RegisterObjectFileFlavor, ScanSymbolStabs, SLineData, StabList, StabRange, StabSet, TranslationTable, TranslationTableBody, VarLocFromStabProcType],
PFS USING [PathFromRope, RopeFromPath, StreamFromOpenFile, OpenFileFromStream],
PFSNames USING [PATH],
Random USING [ChooseInt, Create, RandomStream],
RCTW USING [GetTokenRope, RCTWData, RCTWDataBody],
Rope USING[Concat, Equal, Fetch, FromChar, Index, IsEmpty, Length, Match, ROPE],
SystemInterface USING[CirioFile, CloseFileSet, CreateFileSet, FileSet, GetCirioFile, GetStreamForFile, ReleaseStreamForFile];



XCOFFFiles: CEDAR MONITOR
IMPORTS Basics, BasicTime, CCTypes, Commander, CommanderOps, Convert, IO, List, ObjectFiles, ObjectFilesPrivate, PFS, Random, RCTW, Rope, SystemInterface
EXPORTS ObjectFiles
= BEGIN

CCError: ERROR[case: CCTypes.CCErrorCase, msg: Rope.ROPE ¬ NIL] ¬ CCTypes.CCError;

ROPE: TYPE ~ Rope.ROPE;
PATH: TYPE ~ PFSNames.PATH;


Stab: TYPE = ObjectFiles.Stab;

StabBody: TYPE = ObjectFiles.StabBody;
StabType: TYPE = ObjectFiles.StabType;

FileSegmentPC: TYPE = ObjectFiles.FileSegmentPC;
VersionStampInfo: TYPE = ObjectFiles.VersionStampInfo;


Block: BYTE = 64H;
Brac: BYTE = 65H;
Fun: BYTE = 8eH;
STSym: BYTE = 85H;
GSym: BYTE = 80H;
PSym: BYTE = 82H;
LSym: BYTE = 81H;
RSym: BYTE = 83H;
SO: BYTE = 67H;
HidEnt: BYTE = 6bH;
XTYSD: BYTE = 1;	-- CSECT Section Definition --
XMCRW: BYTE = 5;	-- Read Write Data --


Parsed: TYPE = REF ParsedBody;
ParsedBody: PUBLIC TYPE = ObjectFilesPrivate.ParsedBody;

Header: TYPE = REF HeaderBody;
HeaderBody: PUBLIC TYPE = ObjectFilesPrivate.HeaderBody;

Module: TYPE = REF ModuleBody;
ModuleBody: PUBLIC TYPE = ObjectFilesPrivate.ModuleBody;

StabList: TYPE = ObjectFilesPrivate.StabList;
StabSet: TYPE = ObjectFilesPrivate.StabSet;
StabRange: TYPE = ObjectFilesPrivate.StabRange;

MemorySegmentInfo: TYPE ~ ObjectFilesPrivate.MemorySegmentInfo;

unspecdBitSize: CARD ~ ObjectFiles.unspecdBitSize;




MOldsun2: CARD = 0;
M68010: CARD = 1;
M68020: CARD = 2;
MSparc: CARD = 3;

OMagic: CARD16 = 0407B; 
NMagic: CARD16 = 0410B; 
ZMagic: CARD16 = 0413B; 


PageSize: CARD32 = 02000H;
OldPageSize: CARD32 = 00800H;

FRelFlg: CARD16 = 0001H;
FExec: CARD16 = 0002H;
FLnNo: CARD16 = 0004H;
FLSyms: CARD16 = 0008H;
FAr16WR: CARD16 = 0080H;
FAr32WR: CARD16 = 0100H;
FAr32W: CARD16 = 0200H;
FDynLoad: CARD16 = 1000H;
FShrObj: CARD16 = 2000H;
FLdMinusR: CARD16 = 8000H;

WireHeader: TYPE = REF WireHeaderBody;
WireHeaderBody: TYPE = MACHINE DEPENDENT RECORD[
magic: Basics.HWORD,
numSections: Basics.HWORD,
timeDate: Basics.FWORD,
symPtr: Basics.FWORD,
numSyms: Basics.FWORD,
sizeOptHdr: Basics.HWORD,
flags: Basics.HWORD];

SectionList: TYPE = REF SectionListBody;
SectionListBody: TYPE = RECORD[
list: SEQUENCE length: CARD OF SectionHeader];

SectionHeader: TYPE = REF SectionHeaderBody;
SectionHeaderBody: TYPE = MACHINE DEPENDENT RECORD[
name: Rope.ROPE ¬ NIL,
pAddr: CARD32,
vAddr: CARD32,
size: CARD32,
dataPtr: CARD32,
relocPtr: CARD32,
lnnoPtr: CARD32,
numRelocEntries: CARD16,
numLnnoEntries: CARD16,
flags: CARD32];

WireSectionHeader: TYPE = REF WireSectionHeaderBody;
WireSectionHeaderBody: TYPE = MACHINE DEPENDENT RECORD[
name: PACKED ARRAY [0..7] OF BYTE,
pAddr: Basics.FWORD,
vAddr: Basics.FWORD,
size: Basics.FWORD,
dataPtr: Basics.FWORD,
relocPtr: Basics.FWORD,
lnnoPtr: Basics.FWORD,
numRelocEntries: Basics.HWORD,
numLnnoEntries: Basics.HWORD,
flags: Basics.FWORD];

WireAuxHeader: TYPE = REF WireAuxHeaderBody;
WireAuxHeaderBody: TYPE = MACHINE DEPENDENT RECORD[
magic: Basics.HWORD,
vStamp: Basics.HWORD,
textSize: Basics.FWORD,
dataSize: Basics.FWORD,
bssSize: Basics.FWORD,
entryPtr: Basics.FWORD,
textBase: Basics.FWORD,
dataBase: Basics.FWORD,
tocAddress: Basics.FWORD,
entryPtSectionNum: Basics.HWORD,
textSectionNum: Basics.HWORD,
dataSectionNum: Basics.HWORD,
tocSectionNum: Basics.HWORD,
loaderSectionNum: Basics.HWORD,
bssSectionNum: Basics.HWORD,
maxAlignmentForText: Basics.HWORD,
maxAlignmentForData: Basics.HWORD,
moduleTypeField: ARRAY [0..1] OF BYTE,
reservedField: ARRAY [0..1] OF BYTE,
maxStackSize: Basics.FWORD,
reservedFields: ARRAY [0..3] OF Basics.FWORD
];

ByteEntry: TYPE = REF ByteEntryBody;
ByteEntryBody: TYPE = MACHINE DEPENDENT RECORD[
val(0:0..7): BYTE];

TwoByteEntry: TYPE = REF TwoByteEntryBody;
TwoByteEntryBody: TYPE = MACHINE DEPENDENT RECORD[
val(0:0..15): Basics.HWORD];

StabSize: CARD ¬ 18;
WireSTEntry: TYPE = REF WireSTEntryBody;
WireSTEntryBody: TYPE = MACHINE DEPENDENT RECORD[
name(0: 0..63): PACKED ARRAY [0..7] OF BYTE,
value(0: 64..95): Basics.FWORD,
sectionNumber(0: 96..111): Basics.HWORD,
derivedType(0: 112..119): BYTE,
type(0: 120..127): BYTE,
storageClass(0: 128..135): BYTE,
numAuxEntries(0: 136..143): BYTE,
pad(0: 144..159): Basics.HWORD
];

AuxType: TYPE = {symbol, file, csect};
WireSTAuxEntry: TYPE = REF WireSTAuxEntryBody;
WireSTAuxEntryBody: TYPE = MACHINE DEPENDENT RECORD[
aux(0: 0..159): SELECT OVERLAID AuxType FROM
symbol => [
name(0: 0..63): PACKED ARRAY [0..7] OF BYTE,
pad(0: 64..159): Basics.HWORD],
file => [
fileName(0: 0..111): PACKED ARRAY [0..13] OF BYTE,
pad(0: 112..159): Basics.HWORD],
csect => [
csectLength(0: 0..31): Basics.FWORD,
parameterType(0: 32..63): Basics.FWORD,
snParameterType(0: 64..79): Basics.HWORD,
alignment(0: 80..84): [0..31],
symbolType(0: 85..87): [0..7],
storageMappingClass(0: 88..95): BYTE,
stab(0: 96..127): Basics.FWORD,
snStab(0: 128..143): Basics.HWORD,
pad(0: 144..159): Basics.HWORD]
ENDCASE];

ReadHeader: ObjectFilesPrivate.ReadHeaderProcType ~ TRUSTED {
wHeader: WireHeader ¬ NEW[WireHeaderBody];
wAuxHeader: WireAuxHeader ¬ NEW[WireAuxHeaderBody];
nBytes: INT ¬ IO.UnsafeGetBlock[stream, [LOOPHOLE[@wHeader­], 0, BYTES[WireHeaderBody]]];
nBytes2: INT ¬ IO.UnsafeGetBlock[stream, [LOOPHOLE[@wAuxHeader­], 0, Basics.Card16FromH[wHeader.sizeOptHdr]]];
magic: CARD ¬ Basics.Card16FromH[wHeader.magic];
nBadMagic: BOOLEAN ¬ (magic # OMagic) AND (magic # NMagic)AND (magic # ZMagic);
flags: CARD ¬ Basics.Card16FromH[wHeader.flags];
nPageSize: CARD ¬ 01000H;
SymbolSize: CARD ¬ 18;
RelocEntrySize: CARD ¬ 10;
LnnoEntrySize: CARD ¬ 6;
textOffset: CARD ¬ Basics.Card32FromF[wAuxHeader.textBase];
textSize: CARD ¬ Basics.Card32FromF[wAuxHeader.textSize];
iDataSeg: MemorySegmentInfo ¬ [Basics.Card32FromF[wAuxHeader.dataBase], Basics.Card32FromF[wAuxHeader.dataSize]];
symsSeg: MemorySegmentInfo ¬ [Basics.Card32FromF[wHeader.symPtr], Basics.Card32FromF[wHeader.numSyms] * SymbolSize];
textLoadOffset: CARD32 ¬ 0;
linnoSeg, debugSeg, textRelocSeg, dataRelocSeg: MemorySegmentInfo ¬ [0, 0];
numSects: CARD ¬ Basics.Card16FromH[wHeader.numSections];
sectionList: SectionList ¬ NEW[SectionListBody[numSects]];
debugIndex, textIndex, dataIndex: CARD ¬ LAST[CARD];
header: Header;
FOR i: CARD IN [0..numSects) DO
wSectionHeader: WireSectionHeader ¬ NEW[WireSectionHeaderBody];
nBytes: INT ¬ IO.UnsafeGetBlock[stream, [LOOPHOLE[@wSectionHeader­], 0, BYTES[WireSectionHeaderBody]]];
sectionList[i] ¬ NEW[SectionHeaderBody];
FOR j: CARD IN [0..8) DO
c: CARD ¬ wSectionHeader.name[j];
ch: CHAR ¬ VAL[c];
IF c = 0 THEN EXIT;
sectionList[i].name ¬ sectionList[i].name.Concat[Convert.RopeFromChar[from: ch, quote: FALSE]];
ENDLOOP;
sectionList[i].pAddr ¬ Basics.Card32FromF[wSectionHeader.pAddr];
sectionList[i].vAddr ¬ Basics.Card32FromF[wSectionHeader.vAddr];
sectionList[i].size ¬ Basics.Card32FromF[wSectionHeader.size];
sectionList[i].dataPtr ¬ Basics.Card32FromF[wSectionHeader.dataPtr];
sectionList[i].relocPtr ¬ Basics.Card32FromF[wSectionHeader.relocPtr];
sectionList[i].lnnoPtr ¬ Basics.Card32FromF[wSectionHeader.lnnoPtr];
sectionList[i].numRelocEntries ¬ Basics.Card16FromH[wSectionHeader.numRelocEntries];
sectionList[i].numLnnoEntries ¬ Basics.Card16FromH[wSectionHeader.numLnnoEntries];
sectionList[i].flags ¬ Basics.Card32FromF[wSectionHeader.flags];
ENDLOOP;
FOR i: CARD IN [0..numSects) DO
IF Rope.Equal[sectionList[i].name, ".debug", TRUE] THEN debugIndex ¬ i;
IF Rope.Equal[sectionList[i].name, ".text", TRUE] THEN textIndex ¬ i;
IF Rope.Equal[sectionList[i].name, ".data", TRUE] THEN dataIndex ¬ i;
IF Rope.Equal[sectionList[i].name, ".loader", TRUE] THEN flags ¬ Basics.BITOR[flags, FLdMinusR];
ENDLOOP;
IF debugIndex # LAST[CARD] THEN {
debugSeg ¬ [sectionList[debugIndex].dataPtr, sectionList[debugIndex].size];
};
IF textIndex # LAST[CARD] THEN {
linnoSeg ¬ [sectionList[textIndex].lnnoPtr, sectionList[textIndex].numLnnoEntries * LnnoEntrySize];
textOffset ¬ sectionList[textIndex].dataPtr;
textRelocSeg ¬ [sectionList[textIndex].relocPtr, sectionList[textIndex].numRelocEntries * RelocEntrySize];
};
IF dataIndex # LAST[CARD] THEN {
iDataSeg.byteOffset ¬ sectionList[dataIndex].dataPtr;
dataRelocSeg ¬ [sectionList[dataIndex].relocPtr, sectionList[dataIndex].numRelocEntries * RelocEntrySize];
};
header ¬ NEW[HeaderBody ¬ [
dynamic: FALSE,
toolversion: BYTE[0],
machtype: BYTE[0],
magic: magic,
flags: flags,
text: [textOffset, textSize],
iData: iDataSeg,
textReloc: textRelocSeg,
dataReloc: dataRelocSeg,
syms: symsSeg,
debug: debugSeg,
linno: linnoSeg,
textLoadOffset: textLoadOffset,
bssSize: Basics.Card32FromF[wAuxHeader.bssSize],
entryPoint: Basics.Card32FromF[wAuxHeader.entryPtr],
nPageSize: nPageSize,
nEntries: Basics.Card32FromF[wHeader.numSyms],
stringOffset: symsSeg.byteOffset+symsSeg.byteLength
]];
RETURN[header];
};


XCOFFModuleFromParsedAndPC: ObjectFilesPrivate.ModuleFromParsedAndPCProcType ~ { 
IF whole = NIL THEN RETURN[NIL] ELSE
{
stabRange, pcRange: StabRange;
firstX, limitX: CARD;
stream: IO.STREAM;

[stabRange, pcRange] ¬ AlternativeFindModuleStabRange[whole, spc.relPC, moduleRope];
IF stabRange.count = 0 THEN RETURN[NIL];

firstX ¬ stabRange.first;
limitX ¬ stabRange.first+stabRange.count;
stream ¬ SystemInterface.GetStreamForFile[whole.file];

{
ENABLE UNWIND => {
SystemInterface.ReleaseStreamForFile[whole.file, stream];
};
firstSO: Stab;
firstPC: CARD32 ¬ pcRange.first;
lag: LIST OF Module ¬ NIL;

[firstSO, ] ¬ BasicReadStab[whole, stream, firstX];
FOR modules: LIST OF Module ¬ whole.modules, modules.rest WHILE modules # NIL DO
IF modules.first.firstPC = firstPC THEN -- we already have it
{
SystemInterface.ReleaseStreamForFile[whole.file, stream]; 
RETURN[modules.first]
};
IF firstPC < modules.first.firstPC THEN -- we should have found it by now
{
newModule: Module ¬ CreateModule[whole, stream, stabRange, pcRange];
cell: LIST OF Module ¬ LIST[newModule];
cell.rest ¬ modules;
IF lag # NIL THEN lag.rest ¬ cell ELSE whole.modules ¬ cell;
SystemInterface.ReleaseStreamForFile[whole.file, stream];
RETURN[newModule];
};
lag ¬ modules;
ENDLOOP;
{
newModule: Module ¬ CreateModule[whole, stream, stabRange, pcRange];
cell: LIST OF Module ¬ LIST[newModule];
IF lag # NIL THEN lag.rest ¬ cell ELSE whole.modules ¬ cell;
SystemInterface.ReleaseStreamForFile[whole.file, stream];
RETURN[newModule];
};
};
};
};


CreateModule: PROC[parsed: Parsed, stream: IO.STREAM, stabRange, pcRange: StabRange ¬ [0, 0]] RETURNS[Module] = {
module: Module ¬ NEW[ModuleBody];
rctw: RCTW.RCTWData ¬ NEW[RCTW.RCTWDataBody];
sizes: REF KnownSizeList ¬ NEW[KnownSizeList ¬ CopyList[KnownSizes]];
firstSO: Stab;
nStabs: CARD;

[firstSO, ] ¬ BasicReadStab[parsed, stream, stabRange.first, sizes];
nStabs ¬ stabRange.count;

module.whole ¬ parsed;
module.firstStabX ¬ 0;
module.limitStabX ¬ stabRange.count;
module.firstPC ¬ pcRange.first; -- firstSO.value;
module.limitPC ¬ parsed.header.text.byteLength; -- (bogus, but it will suffice for reasons given earlier)


module.stabs ¬ NEW[StabSet[nStabs]];
rctw.module ¬ module;
{I: CARD ¬ 0;
current: CARD ¬ 0;
tmp: REF StabSet ¬ NIL;
auxCount: CARD ¬ 0;
funFlag: BOOLEAN ¬ FALSE;
WHILE I<nStabs DO
stab: Stab;
nAux: CARD;

[module.stabs[current], nAux] ¬ BasicReadStab[parsed, stream, stabRange.first+I, sizes];
stab ¬ module.stabs[current];
stab.module ¬ module;
IF funFlag THEN {
module.stabs[current - 1].rope ¬ stab.rope;
funFlag ¬ FALSE;
};
IF stab.stabType = Fun THEN
funFlag ¬ TRUE;
IF stab.stabType = LBrac OR stab.stabType = RBrac THEN
stab.value ¬ stab.value + module.firstPC;
stab.stabX ¬ stab.stabX - auxCount - stabRange.first + GlobalPreDefinedTypes.length;
current ¬ current+1;
I ¬ I+1+nAux;
auxCount ¬ auxCount + nAux;
ENDLOOP;
tmp ¬ module.stabs;
module.stabs ¬ NEW[StabSet[current + 30]];
FOR I IN [0..current) DO
module.stabs[I+GlobalPreDefinedTypes.length] ¬ tmp[I];
ENDLOOP;
FOR I IN [0..GlobalPreDefinedTypes.length) DO
module.stabs[I] ¬ NEW[StabBody ¬ [
module: module,
stabX: I,
stabType: LSym,
size: 0,
value: 0,
rope: GlobalPreDefinedTypes[I]
]];
ENDLOOP;
module.limitStabX ¬ module.stabs[current-1].stabX + GlobalPreDefinedTypes.length + 1;
nStabs ¬ current;
};


module.fileName ¬ PFS.PathFromRope[ObjectFilesPrivate.ReadStabRope[module.stabs[0]]];

module.staticVarsInstalled ¬ FALSE;
module.versionStampInfo ¬ NIL;

module.outerBracket ¬ NEW[BracketPairBody¬[
module: module,
kind: syntheticOuter,
firstX: 0,
limitX: module.whole.header.nEntries,
firstPC: module.firstPC,
pcLimit: module.limitPC,
funStab: NIL,
funIndex: 0,
symbols: NIL,
innerBrackets: NIL]];

InstallPCLineNumMaps[module, stabRange];
RETURN[module];
};


StabIndexTypeAndValue: TYPE = RECORD[stabX, stabXTo: CARD, stabType: StabType, value: CARD32];
NullStabIndexTypeAndValue: StabIndexTypeAndValue = [0, 0, Invalid, 0];

AlternativeFindModuleStabRange: PROC[whole: ObjectFilesPrivate.Parsed, relativePC: CARD, moduleRope: Rope.ROPE ¬ NIL] RETURNS[sr: StabRange, pcRange: StabRange ¬ [0, 0]] = {
stream: IO.STREAM ¬ NIL;
IF whole = NIL THEN RETURN[[0, 0]] ELSE {
ENABLE UNWIND => SystemInterface.ReleaseStreamForFile[whole.file, stream];
stream ¬ SystemInterface.GetStreamForFile[whole.file];
[sr, pcRange] ¬ AlternativeFindModuleStabRangeInner[whole, relativePC, moduleRope, stream];
SystemInterface.ReleaseStreamForFile[whole.file, stream];
};
};

LastStabX: CARD = 0ffffffffH;
AlternativeFindModuleStabRangeInner: PROC[whole: ObjectFilesPrivate.Parsed, relativePC: CARD, moduleRope: Rope.ROPE, stream: IO.STREAM] RETURNS[sr: StabRange, pcRange: StabRange ¬ [0, 0]] = {
firstStabX: CARD ¬ 0;
checkWholeFile: BOOL ¬ moduleRope.IsEmpty;
pattern: Rope.ROPE ¬ Rope.Concat[moduleRope, ".*"];
baseSO: Stab ¬ BasicReadStab[whole, stream, firstStabX].stab;
nextStabX: CARD ¬ IF baseSO.value = 0 OR baseSO.value = LastStabX THEN whole.stabLimit ELSE baseSO.value;
name: Rope.ROPE ¬ baseSO.rope;

IF baseSO.stabType # SO THEN RETURN[[0, 0]];
WHILE firstStabX < whole.stabLimit DO
maxPC: CARD ¬ 0;
minPC: CARD ¬ LAST[CARD];
highDbx: CARD ¬ baseSO.stabX;

IF checkWholeFile OR (~name.IsEmpty AND Rope.Match[pattern, name]) THEN {
FOR x: CARD ¬ baseSO.stabX, highDbx WHILE x < nextStabX DO
info: StabIndexTypeAndValue ¬ CheckStab[whole, stream, x];
IF info.stabType = Fun OR info.stabType = SLine OR info.stabType = LBrac OR info.stabType = RBrac -- OR info.stabType = SO -- THEN {
maxPC ¬ MAX[maxPC, info.value];
minPC ¬ MIN[minPC, info.value];
};
highDbx ¬ info.stabXTo + 1;
ENDLOOP;
IF minPC <= relativePC AND relativePC <= maxPC THEN
RETURN[[baseSO.stabX, nextStabX-baseSO.stabX], [minPC, maxPC]];
};
firstStabX ¬ nextStabX;
baseSO ¬ BasicReadStab[whole, stream, firstStabX].stab;
nextStabX ¬ IF baseSO.value = 0 OR baseSO.value = LastStabX THEN whole.stabLimit ELSE baseSO.value;
name ¬ baseSO.rope;
ENDLOOP;
SystemInterface.ReleaseStreamForFile[whole.file, stream];
RETURN[[0, 0]];
};

CheckStab: ENTRY PROC[whole: Parsed, stream: IO.STREAM, stabX: CARD] RETURNS[StabIndexTypeAndValue] = {
ENABLE UNWIND => NULL;
rope: Rope.ROPE ¬ NIL;
GetRope: PROC [] RETURNS [rope: Rope.ROPE] ~ {
IF stream#previousStream THEN {
cloneStream¬PFS.StreamFromOpenFile[openFile~PFS.OpenFileFromStream[stream]];
previousStream ¬ stream;
};
rope ¬ RopeFromData[whole, stream, wireStabBuffer.name, wireStabBuffer.sectionNumber, wireStabBuffer.storageClass, IF wireStabBuffer.numAuxEntries = 0 THEN wireStabBuffer.name ELSE wsAux.name];
};
GetSymTypeAndClass: PROC [] RETURNS [symType, class: CARD] ~ {
RETURN[wsAux.symbolType, wsAux.storageMappingClass]
};

IO.SetIndex[stream, whole.header.syms.byteOffset+stabX*StabSize];

TRUSTED{[] ¬ IO.UnsafeGetBlock[stream, [LOOPHOLE[@wireStabBuffer­], 0, StabSize]]};
IF wireStabBuffer.numAuxEntries # 0 THEN {
TRUSTED{[] ¬ IO.UnsafeGetBlock[stream, [LOOPHOLE[@wsAux­], 0, StabSize]]};
};

RETURN[[stabX, stabX + wireStabBuffer.numAuxEntries, TypeFromData[wireStabBuffer.storageClass, GetRope, GetSymTypeAndClass, wireStabBuffer.type], Basics.Card32FromF[wireStabBuffer.value]]];
};

XCOFFVarLocFromStab: ObjectFilesPrivate.VarLocFromStabProcType ~ {
header: Header ~ stab.module.whole.header;
MkSegment: PROC [kind: ObjectFiles.SimpleSeg] RETURNS [ObjectFiles.VarLoc] ~ {
segRope:Rope.ROPE;
segBase: CARD ~ SELECT kind FROM
text => 0,
data => header.iData.byteOffset, --header.text.byteLength,--
bss => header.textReloc.byteOffset, --header.text.byteLength + header.iData.byteLength,--
ENDCASE => ERROR;
SELECT kind FROM
text => segRope ¬ "text";
data => segRope ¬ "data";
bss => segRope ¬ "bss";
ENDCASE => ERROR;
RETURN [NEW [ObjectFiles.VarLocBody ¬ [
bitSize: IF stab.size#LAST[CARD] AND stab.size#0 THEN stab.size*8 ELSE unspecdBitSize,
where: fSegment[
[0, segRope],
(stab.value-- - segBase--)*8,
stab.value + segBase] ]]]};
SELECT stab.stabType FROM
Fun => RETURN MkSegment[text];
STSym => RETURN MkSegment[data];
LCSym => RETURN MkSegment[bss];
LSym, PSym => {
byteOffset: INT ~ LOOPHOLE[stab.value];
vLB: ObjectFiles.VarLoc;
IF stab.stabType=PSym AND stab.size>4 AND stab.size#LAST[CARD]
THEN vLB ¬ NEW[ObjectFiles.VarLocBody ¬ [
bitSize: stab.size*8,
where: indirect[
base: NEW[ObjectFiles.VarLocBody ¬ [
bitSize: 32,
where: frame[bitOffset: 8*byteOffset]]],
offset: CirioTypes.zeroBA]]]
ELSE vLB ¬ NEW[ObjectFiles.VarLocBody ¬ [
bitSize: IF stab.size#LAST[CARD] AND stab.size#0 THEN stab.size*8 ELSE unspecdBitSize,
where: frame[bitOffset: 8*byteOffset]]];
RETURN[vLB]};
RSym => {
vLB: ObjectFiles.VarLoc;
IF stab.size>4 AND stab.size#LAST[CARD]
THEN vLB ¬ NEW[ObjectFiles.VarLocBody ¬ [
bitSize: stab.size*8,
where: indirect[
base: NEW[ObjectFiles.VarLocBody ¬ [
bitSize: 32,
where: register[regNum: stab.value]]],
offset: CirioTypes.zeroBA]]]
ELSE vLB ¬ NEW[ObjectFiles.VarLocBody ¬ [
bitSize: IF stab.size#LAST[CARD] AND stab.size#0 THEN stab.size*8 ELSE unspecdBitSize,
where: register[regNum: stab.value]]];
RETURN[vLB]
};
GSym => RETURN [NEW [ObjectFiles.VarLocBody ¬ [
bitSize: IF stab.size#LAST[CARD] AND stab.size#0 THEN stab.size*8 ELSE unspecdBitSize,
where: namedCommon[Rope.Concat["_", ObjectFiles.CNameOfStab[stab]], 0, 0, FALSE, FALSE] ]]];
ENDCASE => RETURN ObjectFiles.MakeUnknownVarLoc[IO.PutFR["unrecognized stabType (%02xH) for %g", [cardinal[stab.size]], [rope[ObjectFiles.CNameOfStab[stab]]] ]];
};


PCtoLineNumMap: TYPE = REF PCtoLineNumMapBody;
PCtoLineNumMapBody: TYPE = ObjectFilesPrivate.PCtoLineNumMapBody;

LineNumToPCMap: TYPE = REF LineNumToPCMapBody;
LineNumToPCMapBody: TYPE = ObjectFilesPrivate.LineNumToPCMapBody;

SLineData: TYPE = ObjectFilesPrivate.SLineData;

FMap: TYPE ~ LIST OF FMapData;
FMapBody: TYPE ~ RECORD [
seq: SEQUENCE len: CARD OF FMapData];
FMapData: TYPE ~ REF FMapDataBody;
FMapDataBody: TYPE ~ RECORD[
fName: Rope.ROPE,
stabOffset: CARD];

InstallPCLineNumMaps: PROC[module: Module, stabRange: StabRange] = {

fMap, fMapTmp: FMap ¬ NIL;
firstStabX: CARD ¬ stabRange.first;
limitStabX: CARD ¬ stabRange.first + stabRange.count;

CompareByCLineNum: PROC[ref1: REF ANY, ref2: REF ANY] RETURNS [Basics.Comparison] =
BEGIN
info1: REF SLineData ¬ NARROW[ref1];
info2: REF SLineData ¬ NARROW[ref2];
IF info1.cLineNum < info2.cLineNum THEN RETURN[less];
IF info1.cLineNum > info2.cLineNum THEN RETURN[greater];
IF info1.parsedRelPC.relPC < info2.parsedRelPC.relPC THEN RETURN[less];
IF info1.parsedRelPC.relPC > info2.parsedRelPC.relPC THEN RETURN[greater];
RETURN[equal];
END;

CompareByPC: PROC[ref1: REF ANY, ref2: REF ANY] RETURNS [Basics.Comparison] =
BEGIN
info1: REF SLineData ¬ NARROW[ref1];
info2: REF SLineData ¬ NARROW[ref2];
IF info1.parsedRelPC.relPC < info2.parsedRelPC.relPC THEN RETURN[less];
IF info1.parsedRelPC.relPC > info2.parsedRelPC.relPC THEN RETURN[greater];
IF info1.cLineNum < info2.cLineNum THEN RETURN[less];
IF info1.cLineNum > info2.cLineNum THEN RETURN[greater];
RETURN[equal];
END;

IF module.pcToLineNum # NIL OR module.lineNumToPC # NIL THEN {
IF module.pcToLineNum = NIL OR module.lineNumToPC = NIL THEN ERROR;
RETURN;
};

{
nItems: INTEGER ¬ 0;
list1: LIST OF REF ANY ¬ NIL; -- LIST OF REF SLineData
list2: LIST OF REF ANY ¬ NIL; -- LIST OF REF SLineData
sortedList: LIST OF REF ANY ¬ NIL;
linno, relPC, pOffset: CARD ¬ 0;
inCurrentModule: BOOLEAN ¬ FALSE;
stream: IO.STREAM ¬ SystemInterface.GetStreamForFile[module.whole.file];

IO.SetIndex[stream, module.whole.header.linno.byteOffset];
FOR I: CARD IN [0..module.whole.header.linno.byteLength / 6) DO
IO.SetIndex[stream, module.whole.header.linno.byteOffset + I*6];
relPC ¬ Basics.Card32FromF[IO.GetFWord[stream]];
linno ¬ Basics.Card16FromH[IO.GetHWord[stream]];
IF linno = 0 THEN
IF relPC <= limitStabX AND relPC >= firstStabX THEN {
inCurrentModule ¬ TRUE;
IO.SetIndex[stream, module.whole.header.syms.byteOffset + 18 * relPC + 18 * 5 + 4];
pOffset ¬ Basics.Card16FromH[IO.GetHWord[stream]];
}
ELSE
inCurrentModule ¬ FALSE
ELSE 
IF inCurrentModule THEN {
info: REF SLineData ¬ NEW[SLineData ¬ [cLineNum: linno + pOffset - 1, parsedRelPC: [[0 --??--, PFS.RopeFromPath[module.fileName]], relPC]]];
list1 ¬ CONS[info, list1];
list2 ¬ CONS[info, list2];
nItems¬nItems + 1;
};
ENDLOOP;
SystemInterface.ReleaseStreamForFile[module.whole.file, stream];

sortedList ¬ List.Sort[list1, CompareByCLineNum];
module.lineNumToPC ¬ NEW[LineNumToPCMapBody[nItems]];
FOR I: INTEGER IN [0..nItems) DO
info: REF SLineData ¬ NARROW[sortedList.first];
module.lineNumToPC[I] ¬ info­;
sortedList ¬ sortedList.rest;
ENDLOOP;

sortedList ¬ List.Sort[list2, CompareByPC];
module.pcToLineNum ¬ NEW[PCtoLineNumMapBody[nItems]];
FOR I: INTEGER IN [0..nItems) DO
info: REF SLineData ¬ NARROW[sortedList.first];
module.pcToLineNum[I] ¬ info­;
sortedList ¬ sortedList.rest;
ENDLOOP;

};
};


BasicReadStab: ENTRY PROC[parsed: Parsed, stream: IO.STREAM, stabX: CARD, sizes: REF KnownSizeList ¬ NIL] RETURNS[stab: Stab, nAux: CARD ¬ 0] ~ {
ENABLE UNWIND => NULL;
stab ¬ NEW[StabBody];
[stab­, nAux] ¬ ReadStabBody[parsed, stream, stabX, sizes];
RETURN
};

TypeFromData: PROC [data: BYTE, getName: PROC RETURNS [Rope.ROPE], getSymTypeAndClass: PROC RETURNS [symType, class: CARD], typ: BYTE ¬ 0] RETURNS [stabType: StabType] ~ {
dataVal: CARD ¬ data;
typeVal: CARD ¬ typ;
IF typeVal = 20H THEN 
stabType ¬ Fun
ELSE
SELECT dataVal FROM 
Block => 
{
name: Rope.ROPE ¬ getName[];
SELECT TRUE FROM
Rope.Equal[".bb", name] => stabType ¬ LBrac;
Rope.Equal[".eb", name] => stabType ¬ RBrac;
ENDCASE => ERROR;
};
Brac => 
{
name: Rope.ROPE ¬ getName[];
SELECT TRUE FROM
Rope.Equal[".bf", name] => stabType ¬ LBrac;
Rope.Equal[".ef", name] => stabType ¬ RBrac;
ENDCASE => ERROR;
};
PSym => stabType ¬ PSym;
LSym => stabType ¬ LSym;
RSym => stabType ¬ RSym;
STSym => stabType ¬ STSym;
GSym => stabType ¬ GSym;
HidEnt =>
{
symType, class: CARD;
[symType, class] ¬ getSymTypeAndClass[];
IF symType = XTYSD AND class = XMCRW THEN stabType ¬ Invalid ELSE stabType ¬ Unspecified;
};
SO => stabType ¬ SO;
ENDCASE => stabType ¬ Unspecified
};

DebugStab: CARD = 0fffeH;
previousStream: IO.STREAM ¬ NIL;
cloneStream: IO.STREAM ¬ NIL;
ReadStabBody: PROC [parsed: Parsed, stream: IO.STREAM, stabX: CARD, sizes: REF KnownSizeList] RETURNS [stab: StabBody, nAux: CARD ¬ 0] ~ {
size: CARD;
rope: Rope.ROPE ¬ NIL;
GetRope: PROC [] RETURNS [Rope.ROPE] ~ {
RETURN[rope]
};
GetSymTypeAndClass: PROC [] RETURNS [symType, class: CARD] ~ {
RETURN[wsAux.symbolType, wsAux.storageMappingClass]
};
IO.SetIndex[stream, parsed.header.syms.byteOffset+stabX*StabSize];
TRUSTED{[] ¬ IO.UnsafeGetBlock[stream, [LOOPHOLE[@wireStabBuffer­], 0, StabSize]]};
IF wireStabBuffer.numAuxEntries # 0 THEN {
TRUSTED{[] ¬ IO.UnsafeGetBlock[stream, [LOOPHOLE[@wsAux­], 0, StabSize]]};
};
nAux ¬ wireStabBuffer.numAuxEntries;
IF stream#previousStream THEN {
cloneStream¬PFS.StreamFromOpenFile[openFile~PFS.OpenFileFromStream[stream]];
previousStream ¬ stream;
};
rope ¬ RopeFromData[parsed, cloneStream, wireStabBuffer.name, wireStabBuffer.sectionNumber, wireStabBuffer.storageClass, IF wireStabBuffer.numAuxEntries = 0 THEN wireStabBuffer.name ELSE wsAux.name];
IF sizes # NIL THEN
[size, sizes­] ¬ SizeFromName[rope, sizes­]
ELSE
size ¬ 0;
stab ¬ [
module: NIL,
stabX: stabX,
stabType: TypeFromData[wireStabBuffer.storageClass, GetRope, GetSymTypeAndClass, wireStabBuffer.type], --wireStabBuffer.type,
value: Basics.Card32FromF[wireStabBuffer.value],
size: size,
rope: rope
];
RETURN};

dataChar: ByteEntry ¬ NEW[ByteEntryBody];
RopeFromData: PROC [parsed: Parsed, stream: IO.STREAM, data: PACKED ARRAY [0..7] OF BYTE, sn: Basics.HWORD, storeClass: BYTE, auxData: PACKED ARRAY [0..7] OF BYTE] RETURNS [name: Rope.ROPE ¬ NIL] ~ TRUSTED {
len: TwoByteEntry ¬ NEW[TwoByteEntryBody];
dbg: BOOL ¬ IF Basics.Card16FromH[sn] = DebugStab THEN TRUE ELSE FALSE;
sum, offset: CARD ¬ 0;
IF dbg AND storeClass = 67H THEN {
data ¬ auxData;
dbg ¬ FALSE;
};
offset ¬ IF dbg THEN parsed.header.debug.byteOffset ELSE parsed.header.stringOffset;
FOR i: CARD IN [0..4) DO
n: CARD ¬ data[i];
sum ¬ sum + n;
ENDLOOP;
IF sum = 0 THEN {
FOR i: CARD IN [4..8) DO
n: CARD ¬ data[i];
sum ¬ sum * 256 + n;
ENDLOOP;
IO.SetIndex[stream, offset + sum];
IF IO.EndOf[stream] THEN RETURN[""];
DO
c: CHAR ¬ ' ;
c ¬ IO.GetChar[stream];
IF c = VAL[0] THEN EXIT;
name ¬ name.Concat[Convert.RopeFromChar[from: c, quote: FALSE]];
ENDLOOP;
}
ELSE
FOR i: CARD IN [0..8) DO
num: CARD ¬ data[i];
IF num = 0 THEN EXIT;
name ¬ name.Concat[Convert.RopeFromChar[from: VAL[num], quote: FALSE]];
ENDLOOP;
RETURN
};

wireStabBuffer: WireSTEntry ¬ NEW[WireSTEntryBody];
wsAux: WireSTAuxEntry ¬ NEW[WireSTAuxEntryBody];

RandomTestFindStabRange: Commander.CommandProc = 
{
args: CommanderOps.ArgumentVector ¬ CommanderOps.Parse[cmd];
path: PATH ¬ PFS.PathFromRope[args[1]];
fileSet: SystemInterface.FileSet ¬ SystemInterface.CreateFileSet[];
{ ENABLE UNWIND => SystemInterface.CloseFileSet[fileSet];
file: SystemInterface.CirioFile ¬ SystemInterface.GetCirioFile[fileSet, path];
nextSeed: INT ¬ IF args.argc < 3 THEN 4466 ELSE Convert.IntFromRope[args[2]];
start: BasicTime.GMT ¬ BasicTime.Now[];
WHILE TRUE DO
rs: Random.RandomStream ¬ Random.Create[seed: nextSeed];
whole: Parsed ¬ ObjectFiles.CreateParsed[file, "XCOFF"];
IO.PutF[cmd.out, "beginning seed = %g at %g\N", IO.card[nextSeed], IO.time[start]];
FOR I: INT IN [0..100) DO
range: StabRange;
pc: CARD ¬ Random.ChooseInt[rs, 0, whole.header.text.byteLength];
[range, ] ¬ AlternativeFindModuleStabRange[whole, pc];
IO.PutF[cmd.out, "\Tpc = %g gives firstX: %g count: %g\N", IO.card[pc], IO.card[range.first], IO.card[range.count]];
ENDLOOP;
ENDLOOP;
};
SystemInterface.CloseFileSet[fileSet];
};


SizeFromName: PROC[name:ROPE, sizes: KnownSizeList ¬ NIL] RETURNS [size: CARD ¬ 0, newSizes: KnownSizeList] ~ {
c: CHAR;
newID: CARD;
where: CARD ¬ 0;
IF sizes = NIL THEN RETURN;
newSizes ¬ sizes;
where ¬ Rope.Index[name, 0, ":"] + 1;
IF where = ABS[name.Length[]]+ 1 THEN RETURN;
IF (c ¬ name.Fetch[where]) # 't AND c # 'T THEN {
typeID: INT;
IF IsDigit[c] OR c = '- THEN
[typeID, ] ¬ GetNum[name, where]
ELSE
[typeID, ] ¬ GetNum[name, where+1];
RETURN[FindInList[typeID, sizes], newSizes];
};
[newID, where] ¬ GetNum[name, where+ 1];
IF name.Fetch[where] # '= THEN ERROR;
where ¬ where + 1;
SELECT name.Fetch[where] FROM
'f => {
type: INT;
[type, where] ¬ GetNum[name, where+ 1];
size ¬ FindInList[type, sizes];
};
'*, 'e => size ¬ 4;
'u, 's => {
[size, where] ¬ GetNum[name, where +1]};
'a => {
garb, start, end, type: INT;
baseSize: CARD;
c: CHAR ¬ name.Fetch[where + 1];
IF c# 'r THEN ERROR;
[garb, where] ¬ GetNum[name, where+2];
IF name.Fetch[where] # '; THEN ERROR;
[start, where] ¬ GetNum[name, where+1];
IF name.Fetch[where] # '; THEN ERROR;
[end, where] ¬ GetNum[name, where+1];
IF name.Fetch[where] # '; THEN ERROR;
[type, where] ¬ GetNum[name, where+1];
baseSize ¬ FindInList[type, sizes];
size ¬ (end - start + 1) * baseSize;
};
ENDCASE => size ¬ 0;
newSizes ¬ CONS[[newID, size], newSizes];
size ¬ 0;
};

GetNum: PROC [rope: ROPE, index: CARD] RETURNS [num: INT ¬ 0, newIndex: CARD ¬ 0] ~ {
len: CARD ¬ rope.Length[];
i: CARD;
negFlag: BOOL ¬ FALSE;
FOR i ¬ index, i + 1 UNTIL i = len DO
c: CHAR ¬ rope.Fetch[i];
IF ~IsDigit[c] AND c # '- THEN {
newIndex ¬ i;
EXIT;
};
IF c = '- THEN
negFlag ¬ TRUE
ELSE 
num ¬ num * 10 + (c - '0);
ENDLOOP;
IF i = len THEN 
newIndex ¬ i;
IF negFlag THEN
num ¬ -num;
};

KnownSize: TYPE ~ RECORD[typeID: INT, size: CARD];
KnownSizeList: TYPE ~ LIST OF KnownSize;
KnownSizes: KnownSizeList ¬ LIST[[-1, 4], [-2, 1], [-3, 2], [-4, 4], [-5, 1], [-6, 1], [-7, 2], [-8, 4], [-9, 4], [-10, 4], [-11, 0], [-12, 4], [-13, 8], [-14, 10], [-15, 4], [-16, 1], [-17, 4], [-18, 8], [-19, 1], [-20, 1], [-21, 1], [-22, 2], [-23, 1], [-24, 1], [-25, 8], [-26, 16], [-27, 1], [-28, 2], [-29, 4], [-30, 2]];

CopyList: PROC [l: KnownSizeList] RETURNS [n: KnownSizeList ¬ NIL] ~ {
n ¬ NIL;
FOR i: KnownSizeList ¬ l, i.rest WHILE i # NIL DO
n ¬ CONS[i.first, n];
ENDLOOP;
};

FindInList: PROC [i: INT, l: KnownSizeList] RETURNS [s: CARD ¬ LAST[CARD]] ~ {
FOR loop: KnownSizeList ¬ l, loop.rest WHILE loop # NIL DO
IF loop.first.typeID = i THEN RETURN[loop.first.size];
ENDLOOP;
ERROR;
};


IsDigit: PROC [c: CHAR] RETURNS [BOOL]
= INLINE { RETURN [c IN ['0 .. '9]] };

XCOFFGetTypeRef: ObjectFilesPrivate.GetTypeRefProcType ~ {
typeRef: Rope.ROPE;
lastChar: CHAR;
IF IsDigit[lastChar ¬ IO.PeekChar[sourceStream]] OR lastChar = '- THEN {
typeRef ¬ RCTW.GetTokenRope[sourceStream];
RETURN[typeRef]}
ELSE DO
lastChar ¬ IO.GetChar[sourceStream];
typeRef ¬ Rope.Concat[typeRef, Rope.FromChar[lastChar]];
IF lastChar = ') THEN RETURN[typeRef]
ENDLOOP
};

XCOFFInstallBracketPairsForOneFunStab: PROC[module: Module, funStabIndex: CARD] =
{
funStab: Stab ¬ module.funStabs[funStabIndex].stab;
paramNames, lastParamName: LIST OF Rope.ROPE ¬ NIL;
paramStabs, lastParamStab: LIST OF Stab ¬ NIL; -- includes param mod stabs
x: CARD ¬ funStab.stabX+1;
good: BOOL ¬ TRUE;
module.funStabs[funStabIndex].brackets ¬ NEW[BracketPairBody¬[
module: module,
kind: syntheticFun,
firstX: funStab.stabX,
limitX: 0,
firstPC: funStab.value,
pcLimit: 0,
funStab: funStab,
funIndex: funStabIndex,
symbols: NIL,
innerBrackets: NIL]];


WHILE x < module.limitStabX DO
stab: Stab ¬ ObjectFilesPrivate.ReadStab[module, x];
TakeBP: PROC ~ {
finalRBracX: CARD;
[finalRBracX, module.funStabs[funStabIndex].brackets.innerBrackets, paramStabs] ¬ ScanOneBracketPairSequence[module, funStab, funStabIndex, x, paramStabs, lastParamStab];
IF good THEN module.funStabs[funStabIndex].brackets.limitX ¬ finalRBracX+1;
module.funStabs[funStabIndex].brackets.pcLimit ¬
IF finalRBracX<module.limitStabX
THEN ObjectFilesPrivate.ReadStab[module, finalRBracX].value
ELSE module.limitPC;
RETURN};
IF stab = NIL THEN LOOP;
SELECT stab.stabType FROM
PSym => {
stabCell: LIST OF Stab ¬ LIST[stab];
name: Rope.ROPE ¬ ObjectFiles.CNameOfStab[stab];
nameCell: LIST OF Rope.ROPE ¬ LIST[name];
IF paramStabs#NIL AND stab=paramStabs.first THEN ERROR;
IF paramNames = NIL THEN paramNames ¬ nameCell ELSE lastParamName.rest ¬ nameCell;
lastParamName ¬ nameCell;
IF paramStabs = NIL THEN paramStabs ¬ stabCell ELSE lastParamStab.rest ¬ stabCell;
lastParamStab ¬ stabCell};
RSym, LSym => {
stabCell: LIST OF Stab ¬ LIST[stab];
name: Rope.ROPE ¬ ObjectFiles.CNameOfStab[stab];
isAParam: BOOLEAN ¬ FALSE; -- initial value
FOR pNames: LIST OF Rope.ROPE ¬ paramNames, pNames.rest WHILE pNames # NIL DO
IF Rope.Equal[name, pNames.first] THEN
{isAParam ¬ TRUE; EXIT};
ENDLOOP;
IF isAParam THEN {
IF paramStabs = NIL THEN paramStabs ¬ stabCell ELSE lastParamStab.rest ¬ stabCell;
lastParamStab ¬ stabCell}
 ELSE -- we are facing the first symbol of a nested block
{TakeBP[]; EXIT};
};
GSym, LCSym, STSym => IF good THEN {
module.funStabs[funStabIndex].brackets.limitX ¬ stab.stabX;
good ¬ FALSE};
SLine, Unspecified => NULL;
LBrac => {TakeBP[]; EXIT};
Fun => {
IF good THEN module.funStabs[funStabIndex].brackets.limitX ¬ stab.stabX;
module.funStabs[funStabIndex].brackets.pcLimit ¬ stab.value;
EXIT};
ENDCASE => ObjectFilesPrivate.RaiseUnreadableObjectFileForFun[
IO.PutFR["Unexpected stab (of stabType %02xH) in intro to %g",
[rope[ObjectFiles.RopeForStabType[stab.stabType]]],
[rope[ObjectFiles.CNameOfStab[funStab]]] ],
module, funStab];
x ¬ x + 1;
REPEAT
FINISHED => {
IF good THEN module.funStabs[funStabIndex].brackets.limitX ¬ module.limitStabX;
module.funStabs[funStabIndex].brackets.pcLimit ¬ module.limitPC;
};
ENDLOOP;
module.funStabs[funStabIndex].brackets.symbols ¬ paramStabs;
RETURN};

BracketPair: TYPE ~ ObjectFilesPrivate.BracketPair;
BracketPairBody: TYPE ~ ObjectFilesPrivate.BracketPairBody;
ScanOneBracketPairSequence: PROC[module: Module, fun: Stab, funIndex: CARD, firstX: CARD, symHead, symTail: StabList] RETURNS[--finalRBracX-- CARD, --innerBrackets-- LIST OF BracketPair, --symbols-- StabList] =
{
innerBrackets: LIST OF BracketPair ¬ NIL;
lastInnerBracket: LIST OF BracketPair ¬ NIL;
x: CARD ¬ firstX;
DO
xAfterSymbs: CARD;
stabAfterSymbs: Stab;
[xAfterSymbs, symHead, symTail] ¬ ObjectFilesPrivate.ScanSymbolStabs[module, x, symHead, symTail];
IF xAfterSymbs >= module.limitStabX THEN
RETURN[xAfterSymbs, innerBrackets, symHead];
stabAfterSymbs ¬ ObjectFilesPrivate.ReadStab[module, xAfterSymbs];
SELECT stabAfterSymbs.stabType FROM
LBrac =>
{
finalRBracX: CARD;
nestedInnerBrackets: LIST OF BracketPair;
bracket: BracketPair;
bracketCell: LIST OF BracketPair;
[finalRBracX, nestedInnerBrackets, symHead] ¬ ScanOneBracketPairSequence[module, fun, funIndex, xAfterSymbs+1, symHead, symTail];
bracket ¬ NEW[BracketPairBody¬[
module: module,
kind: actual,
firstX: stabAfterSymbs.stabX,
limitX: finalRBracX+1,
firstPC: stabAfterSymbs.value,
pcLimit: IF finalRBracX<module.limitStabX THEN ObjectFilesPrivate.ReadStab[module, finalRBracX].value ELSE module.limitPC,
funIndex: funIndex,
symbols: symHead,
innerBrackets: nestedInnerBrackets]];
bracketCell ¬ LIST[bracket];
IF innerBrackets = NIL THEN innerBrackets ¬ bracketCell ELSE lastInnerBracket.rest ¬ bracketCell;
lastInnerBracket ¬ bracketCell;
symHead ¬ symTail ¬ NIL;
x ¬ finalRBracX+1;
};
RBrac, Fun, GSym, STSym, LCSym => RETURN[xAfterSymbs, innerBrackets, symHead];
ENDCASE => ERROR; -- can't happen
ENDLOOP};


GlobalPreDefinedTypes: REF PDTType ¬ NIL; 
GPTDs: LIST OF Rope.ROPE ¬ LIST [
"int:t-1=r-1;-2147483648;2147483647", 
"char:t-2=@s8;r-2;0;255", 
"short:t-3=@s16;r-3;-32768;32767", 
"long:t-4=-1", 
"unsigned char:t-5=@s8;r-5;0;255", 
"signed char:t-6=@s8;r-6;-128;127", 
"unsigned short:t-7=@s16;r-7;0;65535", 
"unsigned int:t-8=r-8;0;4294967295", 
"unsigned:t-9=-8", 
"unsigned long:t-10=-8", 
"void:t-11=r-11;0;0", 
"float:t-12=g-12;4", 
"double:t-13=g-12;8", 
"long double:t-14=g-12;10", 
"integer:t-15=-1", 
"boolean:t-16=efalse:0,true:1,", 
"shortreal:t-17=g-12;4", 
"real:t-18=g-12;8", 
"stringptr:t-19=N-19", 
"character:t-20=@s8;r-20;0;255", 
"logical*1:t-21=@s8;r-21;0;255", 
"logical*2:t-22=@s16;r-22;0;65535", 
"logical*4:t-23=r-23;0;4294967295", 
"logical:t-24=-23", 
"complex:t-25=c-25;8", 
"double complex:t-26=c-25;16", 
"integer*1:t-27=-6", 
"integer*2:t-28=-3", 
"integer*4:t-29=-1", 
"wchar:t-30=@s16;r-30;0;65535"];

PDTType: TYPE ~ RECORD [body: SEQUENCE length: CARD OF Rope.ROPE];

IntallPreDefinedTypes: PROC ~ {
count: CARD ¬ 0;
l: LIST OF Rope.ROPE ¬ NIL;
FOR l ¬ GPTDs, l.rest UNTIL l = NIL DO
count ¬ count + 1;
ENDLOOP;
GlobalPreDefinedTypes ¬ NEW[PDTType[count]];
l ¬ GPTDs;
FOR index: CARD IN [0..count) DO
GlobalPreDefinedTypes[index] ¬ l.first;
l ¬ l.rest;
ENDLOOP;
};

GetDataSectionOffset: PROC[module: Module] RETURNS[CARD] ~ {
IsDotO: PROC RETURNS[BOOL] ~ {
RETURN[Basics.BITAND[module.whole.header.flags, (FLdMinusR+FShrObj+FDynLoad+FExec)] = 0];
};

IF IsDotO[] THEN RETURN [0];
FOR x: CARD DECREASING IN [module.firstStabX..module.limitStabX) DO
stab: Stab ¬ ObjectFilesPrivate.ReadStab[module, x];
IF stab.stabType = Invalid THEN RETURN [stab.value];
ENDLOOP;
RETURN [0];
};

XCOFFInstallStaticVars: ObjectFilesPrivate.InstallStaticVarsType ~ 
{
numFuns: INT ¬ 1;
dataStabOffset: CARD ¬ 0;  -- globalFrame stab seems to be offset from versionStringStab, which has to be searched for at times...
IF NOT module.staticVarsInstalled THEN
FOR y: CARD IN [module.firstStabX..module.limitStabX)
DO
x: CARD ¬ module.firstStabX + module.limitStabX - 1 - y;
stab: Stab ¬ ObjectFilesPrivate.ReadStab[module, x];
IF stab = NIL THEN LOOP;
IF stab.stabType = Fun THEN {
IF numFuns = 0 THEN EXIT;
numFuns ¬ numFuns - 1;
};
IF stab.stabType = STSym OR stab.stabType = LCSym THEN
{
IF module.versionStampStab = NIL THEN
{
gvi: ObjectFiles.GlobalVarLoc ¬ NIL;
gvi ¬ NARROW[ObjectFilesPrivate.CheckStaticVar[stab, "versionStamp", TRUE]];
IF gvi # NIL THEN
{
stream: IO.STREAM ¬ NIL;
dataRope: Rope.ROPE;
module.versionStampStab ¬ stab;
dataStabOffset ¬ GetDataSectionOffset[module];
dataRope ¬ ObjectFilesPrivate.ReadInitialDataAsRope[module, gvi.fileByteOffset + dataStabOffset];
IF dataRope.IsEmpty[] THEN {
ENABLE UNWIND => SystemInterface.ReleaseStreamForFile [module.whole.file, stream];
searchFor: Rope.ROPE ¬ "@(#)";
c: CHAR;
searchForIndex: INT ¬ 0;
found: BOOL ¬ FALSE;
stream ¬ SystemInterface.GetStreamForFile[module.whole.file];
IO.SetIndex[stream, gvi.fileByteOffset + dataStabOffset];
dataRope ¬ "";
WHILE ~found DO
tmpOffset: CARD ¬ 0;
WHILE ((c ¬ IO.GetChar[stream]) # searchFor.Fetch[searchForIndex]) DO 
dataStabOffset ¬ dataStabOffset + 1;
ENDLOOP;
tmpOffset ¬ tmpOffset + 1;
searchForIndex ¬ searchForIndex + 1;
WHILE (searchForIndex < searchFor.Length[] AND (c ¬ IO.GetChar[stream]) = searchFor.Fetch[searchForIndex]) DO
tmpOffset ¬ tmpOffset + 1;
searchForIndex ¬ searchForIndex + 1;
ENDLOOP;
tmpOffset ¬ tmpOffset + 1;
IF searchForIndex = searchFor.Length[] THEN
found ¬ TRUE
ELSE
dataStabOffset ¬ dataStabOffset + tmpOffset;
ENDLOOP;
dataRope ¬ searchFor;
WHILE ((c ¬ IO.GetChar[stream]) # '\000) DO
dataRope ¬ dataRope.Concat[Rope.FromChar[c]];
ENDLOOP;
SystemInterface.ReleaseStreamForFile [module.whole.file, stream];
};
stab.value ¬ stab.value+dataStabOffset;
IF module.globalFrameStab # NIL THEN 
module.globalFrameStab.value ¬ module.globalFrameStab.value + dataStabOffset;
IF module.globalFrameStab # NIL THEN {
module.globalFrameGvl.bitOffset ¬ module.globalFrameGvl.bitOffset + dataStabOffset * 8;
module.globalFrameGvl.fileByteOffset ¬ module.globalFrameGvl.fileByteOffset + dataStabOffset;
};
module.versionStampInfo ¬ NEW[ObjectFiles.VersionStampInfo¬[gvi, dataRope]];
LOOP;
};
};
IF module.globalFrameStab = NIL THEN
{
gvi: ObjectFiles.GlobalVarLoc ¬ NIL;
gvi ¬ NARROW[ObjectFilesPrivate.CheckStaticVar[stab, "globalframe", TRUE]];
IF gvi # NIL THEN
{
module.globalFrameStab ¬ stab;
module.globalFrameGvl ¬ gvi;
LOOP;
};
};
};
ENDLOOP;

module.staticVarsInstalled ¬ TRUE;
};

XCOFFAlterFunStab: ObjectFilesPrivate.AlterFunStabType ~ {
RETURN [module.funStabs[funStabX].stab]; };

XCOFFGetSPOffset: ObjectFilesPrivate.GetSPOffsetType ~ {
RETURN [0];
};


transTable: ObjectFilesPrivate.TranslationTable;
IntallPreDefinedTypes[];
transTable ¬NEW[ObjectFilesPrivate.TranslationTableBody[1]];
Commander.Register["xcoffRandomTestFindStabRange", RandomTestFindStabRange];
transTable[0] ¬ [0, 2, 479, "XCOFF"];
ObjectFilesPrivate.RegisterObjectFileFlavor[NEW [ObjectFilesPrivate.ObjectFileFlavorBody ¬ [ 
"XCOFF", 
XCOFF,
ReadHeader,
XCOFFModuleFromParsedAndPC,
XCOFFVarLocFromStab,
XCOFFGetTypeRef,
XCOFFInstallBracketPairsForOneFunStab,
NIL, NIL, NIL,
FALSE,
XCOFFInstallStaticVars,
XCOFFAlterFunStab,
XCOFFGetSPOffset
]],
transTable];


END.

&¦
XCOFFFiles.mesa
Copyright Ó 1990, 1991, 1992, 1993 by Xerox Corporation.  All rights reserved.
Modified from DotOAccessImpl.mesa
Laurie Horton, June 24, 1992 6:07 pm PDT
Philip James, February 24, 1992 11:40 am PST
Last tweaked by Mike Spreitzer October 2, 1992 1:27 pm PDT
Chauser, March 24, 1992 5:25 pm PST
Katsuyuki Komatsu June 21, 1992 1:55 pm PDT
Useful types
Following types are defined in ObjectFiles
some Stab types
LBrac: BYTE = 00H;
RBrac: BYTE = 00H;
SLine: BYTE = 00H;
LCSym: BYTE = 00H;
Decl: BYTE = 8cH;
interesting symbol type
interesting storage mapping class
Following types are defined in ObjectFilesPrivate

Following values are of global interest

pj theContStab: Stab ~ [edo: NIL, stabX: CARD.LAST, stringX: CARD32.LAST, type: BYTE.LAST, other: BYTE.LAST, desc: CARD16.LAST, value: CARD32.LAST, rope: "don't look at me, I'm a continuation of an earlier stab", dx: CARD.LAST];
This stab is put in edo.stabs[i] wherever continuation stabs would appear.
DotOCookies
The following computations are adapted from /usr/include/sys/exec.h,
obtained by: REdit cartiff -f /usr/include/sys/exec.h
The following computations are adapted from /usr/include/sun4/a.out.h,
obtained by: REdit cartiff -f /usr/include/sun4/a.out.h
The following symbols are adapted from /usr/include/filehdr.h

The following record type was constructed based on page 1339 of the Sun Release 4.0 documentation (A.OUT documentation)
PROC[stream: IO.STREAM] RETURNS[Header] = TRUSTED {
The following computations are adapted from /usr/include/sun4/a.out.h,
obtained by: REdit cartiff -f /usr/include/sun4/a.out.h
IF wHeader.machtype = MOldsun2 THEN OldPageSize ELSE PageSize;
IF wHeader.machtype = MOldsun2 THEN
(IF magic = ZMagic THEN nPageSize ELSE BYTES[WireHeaderBody])
ELSE
(IF magic = ZMagic THEN 0 ELSE BYTES[WireHeaderBody]);
iDataSeg: SegmentInfo _ [textOffset + textSize, Basics.Card32FromF[wHeader.iDataSize]];
dataRelocSeg.byteOffset+dataRelocSeg.byteLength, Basics.Card32FromF[wHeader.symsSize]];
debugSeg: MemorySegmentInfo _ [Basics.Card32FromF[wHeader.symPtr], Basics.Card32FromF[wHeader.numSyms] * SymbolSize];
IF magic = ZMagic THEN 02000H ELSE 0;
text segment is loaded into memory at nominal 0 + textLoadOffset
the 02000H is the largest page size on certain machines, and allows the first page of memory to remain unmapped.
iDataSeg.byteOffset+iDataSeg.byteLength, Basics.Card32FromF[wHeader.trSize]];
textRelocSeg.byteOffset+textRelocSeg.byteLength, Basics.Card32FromF[wHeader.drSize]]
EmbeddedDotOs

We assume that there are dbx stabs located in the dotO in the symbol table entry range [firstX..limitX).
We assume that the first stab is a SO stab whose value is the next module symbol table entry of the embedded dotO.  We assume that this stab is a SO stab containing the file name.
The first and limitX have presumably been obtained by other means.  For example, at this writing the CirioNub will provide access to a table of pc ranges located in the target world.  (In addition, we provide a rather crude mechanism below to use when the CirioNub approach is not available.  (e.g., when examining a file that is not part of a PCedar load state.)
We are unable to define a legitimate limitPC.  We assume that when, later, an attempt is made to look up a pc in the bracket structure, we have already determined that that pc definitely belongs to this EmbeddedDotO.  Thus, we can use header.textSize as a (bogus) limitPC.
PROC[whole: Parsed, spc: FileSegmentPC, moduleRope: ROPE _ NIL] RETURNS[Module] = {
nest so that we can catch unwinds and release the stream
first, see if we already have it
prepare the embeddedDotO for a call on BuildBrackets
lets read the all stabs now (without their ropes)
(I did some timing tests on a Dorado for RopeImpl.  It took about 6 seconds to perform this loop, including the allocates.  On the other hand, it takes about 4 seconds to spin through the entries without allocating the stab records.  So, since at some point I have to traverse all the entries to find the Fun stabs, I might as well allocate them.)
(we also relocate the pc value of bracket stabs.)
now lets finish up
module.firstSO _ module.stabs[0];
module.secondSO _ IF module.stabs[module.stabs[0].dx].stabType = SO THEN module.stabs[module.stabs[0].dx] ELSE NIL;
module.fileName _ PFS.PathFromRope[IF module.secondSO = NIL THEN ReadStabRope[module.firstSO] ELSE ReadStabRope[module.secondSO]];
Finding Embedded dotOs

This procedure should only be used when examining a dotO which is not in the load state.  If we are given a pc in a running PCR, it is far faster to use procedures in LoadStateAccess to obtain the stab range for an embedded dot O.  Those procedures use a table available from the nub to find the stab range, then produce the embedded dotO through a call on CreateEmbeddedDotO.
baseSO.value points the next baseSO on AIX.
baseSO.value points the next baseSO on AIX.

PROC [stab: Stab] RETURNS [DotOAccess.VarLoc] ~ {
PJames 1/31/92: Doesn't look appropriate for XCoff...stab.value has a different type of value...
IF stab.value < segBase THEN ObjectFiles.UnreadableObjectFile[IO.PutFR["value (%xH) less than segment base (%xH) for symbol %g in %g", [cardinal[stab.value]], [cardinal[segBase]], [rope[ObjectFiles.CNameOfStab[stab]]], [rope[ObjectFiles.DescribeModule[stab.module]]] ]];
C Line-Number to Relative-PC maps
sorted by PC
sorted by Line Num
CompareBySI: PROC[ref1: REF ANY, ref2: REF ANY] RETURNS [Basics.Comparison] =
BEGIN
info1: FMapData _ NARROW[ref1];
info2: FMapData _ NARROW[ref2];
IF info1.stabOffset < info2.stabOffset THEN RETURN[less];
IF info1.stabOffset > info2.stabOffset THEN RETURN[greater];
RETURN[equal];
END;

we have to create them
FOR I: CARD IN [module.firstStabX..module.limitStabX) DO
stab: Stab _ ReadStab[module, I];
IF stab.stabType = SLine THEN {
info: REF SLineData _ NEW[SLineData_[cLineNum: --pj fill this in!  stab.desc-- 0, parsedRelPC: [[2, ".text"], stab.value]]];
list1 _ CONS[info, list1];
list2 _ CONS[info, list2];
nItems _ nItems+1};
ENDLOOP;


Stabs

This routine treats stabX as relative to the entire containing dotO file.
warning: does NOT relocate LBrac or RBrac stabs.
warning: does NOT read the associated rope
Also: the edo field is set to NIL;
00000H => SLine; -- no SLine s in XCOFF
Fun => stabType _ Fun; -- gets in the way.
00000H => LCSym; -- ?
00000H => Main; -- not used?
00000H => BIncl;
00000H => EIncl;
00000H => SOL;
TRUSTED{[] _ IO.UnsafeGetBlock[stream, [LOOPHOLE[@dataChar^], 0, 1]]};
c _ dataChar.val;
all users should be in the monitor
typeID: INT _ -1;
IF IsDigit[c] THEN
typeID _ Convert.IntFromRope[name.Substr[where]]
ELSE
typeID _ Convert.IntFromRope[name.Substr[where + 1]]; 
These sizes were determined from /usr/include/dbxstclass.h (no guarantees though)
PROC [sourceStream:IO.STREAM] RETURNS [Rope.ROPE]
The function stab is module.funStabs[funStabIndex].stab

The following loop finds the limitX and pcLimit.  These might be at different X values if there are global symbols between procedures (which can happen with Sun's cc).  good goes false once we've found the limitX and are just looking for the pcLimit.  The loop also accumulates innerBrackets, if any.  We make a feeble attempt to distinguish parameters from local variables; this attempt will fail for Gnu cc; it it's important to get this right, look at the `symbol descriptor' in a variable's stab.
We assume the following structure:
some param stabs
some stabs that modify the param stabs
symbol stabs for the first inner block (if any)

Note that both C compilers feels free to omit the LBrac and RBrac of a procedure with no local variables.  Gnu cc further feels free to omit the L&RBrac of procedures with no non-trivial nested scopes.

this is coded to expect the symbols before the LBrac.  
We have discovered that the Sun C compiler places local variables symbols in the symbol table before their enclosing left bracket.!!  This is confirmed by the example in "Dbx and Dbxtool Interfaces, Second Edition, Revised, 7 January 1988.  See lines 46 and 47 on page 28.  It is also confirmed by some comments in /import/gdb/dbxread.c.  See source position 90236.  This is in the vicinity of "case N_RBRAC".  On the positive side, the code in /import/gdb/dbxread.c confirms that the local variables symbols are expected to be properly sorted in some way with respect to the RBrac/LBrac stabs.
The comment in /import/gdb/dbxread.c also suggests that there are some C compilers that place the symbols inside the LBrac/RBrac pair.  It shouldn't be difficult to recode this to handle the second case.  One will have to collect the symbols during the scan.  For full generality, one might expect to receive the symbols anytime one is outside an inner pair.
We assume that firstX is pointing at the first symbol of the first bracket pair.  (If the enclosing bracket pair is an innermost pair, then firstX is pointing at either an RBrac, a Fun, or is an attempt to go past the end of the symbol table.)
Upon return, nextX will point to an unmatched RBrac, a Fun, or will be an attempt to go past the end of the symbol table.
It seems AIX ld doesn't relocate static symbol (STSym) offset.  So, we get data section's base offset and add the offset to local symbol offset.
Section's base offset doesn't correct if file is .o.
PROC[module: Module] =
this procedure examines all stabs up to the first Fun stab, looking for certain expected stabs.  These are recorded in the whole.
Force find the version stamp mob
Before ld, the version stamp mob is further into the
.data section than usual, and the stab entry shows
no indication of this, so if no rope was found at
the correct location, walk through until @(#) is found.
rope assignement has been done in CreateModule.
module.funStabs[funStabX].stab.rope _ module.stabs[module.funStabs[funStabX].firstX+1].rope;
On AIX, SP offset from FP is always 0 (SP = FP).
Main code

�Ê6–
"cedarcode" style•NewlineDelimiter

™
codeš
œ™Kšœ
Ïe
œC™NK™!K™(K™,K™:K™#K™+—K˜š
Ïk	˜	Kšœžœžœžœ(žœžœ˜QKšœ
žœžœ˜Kšœžœ˜$Kšœžœ
˜Kšœ
žœ˜(Kšœ
žœ˜+Kšœžœ˜)Kšžœ
žœLžœ˜rKšœžœ
žœ˜$Kšœžœ×
˜è
Kšœžœ³˜ËKšžœ
žœF˜OKšœ	žœžœ˜Kšœžœ#˜/Kšžœ
žœ(˜2Kšœžœ@žœ˜PKšœžœh˜}—K˜K˜K˜šÏn
œžœ
ž˜Kšžœ?žœ)žœ
žœ˜™
Kšžœ˜—Kšœž˜K˜KšŸœžœ&žœžœ˜RK˜™Kšžœžœžœ
˜Kšžœžœžœ
˜—K˜™*K˜Kšœžœ˜K˜Kšœ
žœ˜&Kšœ
žœ˜&K˜Kšœžœ˜0Kšœžœ ˜6K˜Kš
œ™K˜KšŸœžœ˜KšŸœžœ˜KšŸœžœ™KšŸœžœ™KšŸœžœ˜KšŸœžœ™KšŸœžœ˜KšŸœžœ™KšŸœžœ™KšŸœžœ˜KšŸœžœ˜KšŸœžœ˜KšŸœžœ˜KšÐbkœžœ˜šŸœžœ˜K™Kš œžœÏc˜/K™!Kš œžœ¡˜&—K˜—K˜™1K™Kšœžœžœ˜Kšœžœ
žœ!˜8K˜Kšœžœžœ˜Kšœžœ
žœ!˜8K˜Kšœžœžœ˜Kšœžœ
žœ!˜8K˜Kšœ
žœ˜-Kšœ	žœ˜+Kšœžœ ˜/K˜Kšœžœ(˜?K˜—™'K™Kšœžœ˜2K˜šœžœ	žœ
žœžœ
žœžœ
žœ	žœ
žœžœ
žœ	žœ
žœGžœ
žœ™ä
K™J——K˜™K˜š
œD™DKš
œ5™5—K˜KšŸœžœ˜Kšžœžœ˜Kšžœžœ˜KšŸœžœ˜K˜KšŸœžœ
˜KšŸœžœ
˜KšŸœžœ
˜K˜š
œF™FKš
œ7™7—K˜KšŸœžœ
˜KšŸœžœ
˜K˜Kš
œ=™=KšŸœžœ	˜KšŸœžœ	˜KšŸœžœ	˜KšŸœžœ	˜KšŸœžœ	˜KšŸœžœ	˜KšŸœžœ	˜KšŸœžœ	˜KšŸœžœ	˜šŸ	œžœ	˜K™Kšœežœ™w—K˜Kšœžœžœ˜&š	œžœžœ
ž	œ
žœ
˜0Kšœžœ
˜Kšœžœ
˜Kšœžœ
˜Kšœžœ
˜Kšœžœ
˜Kšœžœ
˜Kšœžœ˜K˜—Kšœ
žœžœ˜(šœžœžœ
˜Kšœžœ	žœ
žœ˜.K˜—Kšœžœžœ˜,š	œžœžœ
ž	œ
žœ
˜3Kšœžœžœ
˜Kšœžœ
˜Kšœžœ
˜Kšœžœ
˜
Kšœ	žœ
˜Kšœ
žœ
˜Kšœ	žœ
˜Kšœžœ
˜Kšœžœ
˜Kšœžœ˜K˜—Kšœžœžœ˜4š	œžœžœ
ž	œ
žœ
˜7Kš	œžœ
žœžœ
žœ
˜"Kšœžœ
˜Kšœžœ
˜Kšœ
žœ
˜Kšœžœ
˜Kšœžœ
˜Kšœžœ
˜Kšœžœ
˜Kšœžœ
˜Kšœžœ˜K˜—Kšœžœžœ˜,š	œžœžœ
ž	œ
žœ
˜3Kšœžœ
˜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šœžœžœ˜*š	œžœžœ
ž	œ
žœ
˜2Kšœžœ˜K˜—KšŸœžœ˜Kšœ
žœžœ˜(š	œžœžœ
ž	œ
žœ
˜1Kš	œžœ
žœžœ
žœ
˜,Kšœžœ
˜Kšœ"žœ
˜(Kšœžœ
˜Kšœžœ
˜Kšœžœ
˜ Kšœžœ
˜!Kšœž˜Kš
œ˜K˜—Kšœ	žœ˜&Kšœžœžœ˜.š	œžœžœ
ž	œ
žœ
˜4šœžœ
žœ	ž˜,š
œ˜Kš	œžœ
žœžœ
žœ
˜,Kšœžœ˜—š
œ	˜	Kš	œžœ
žœ	žœ
žœ
˜2Kšœžœ˜ —š
œ
˜
Kšœžœ
˜$Kšœ!žœ
˜'Kšœ#žœ
˜)Kš
œ˜Kš
œ˜Kšœ žœ
˜%Kšœžœ
˜Kšœžœ
˜"Kšœžœ
˜—Kšžœ˜	——K˜šŸ
œ*žœ˜=Kš
žœ	žœ
žœžœžœ™3Kšœžœ˜*Kšœžœ˜3Kš	œžœžœžœžœ˜YKšœ	žœžœžœ<˜nKšœžœ%˜0Kšœžœžœžœ˜OKšœžœ%˜0š
œF™FKš
œ7™7—šœžœ
˜Kšžœžœ
žœ
™>—KšÐbn
œžœ˜Kš¢œžœ˜Kš¢
œžœ˜šœžœ+˜;šžœž™#š	œ
žœžœžœ
žœ™=Kš
ž™Kš	œ
žœžœžœ
žœ™6———Kšœ
žœ+˜9˜qKš
œW™W—šœhÏb
œ˜tKš
œW™W—Kšœi£
œ™ušœžœ˜Kšžœžœžœ™%Kš
œ@™@Kš
œp™p—˜KKš
œM™MKš
œT™T—Kšœ
žœ+˜9Kšœžœ˜:Kšœ"žœžœ
žœ˜4K˜šžœžœ
žœž˜Kšœ$žœ˜?Kš	œžœžœžœžœ˜gKšœžœ˜(šžœžœ
žœž˜Kšœžœ˜!Kšœžœžœ˜Kšžœžœ
žœ
˜KšœWžœ˜_Kšžœ
˜—K˜@K˜@K˜>K˜DK˜FK˜DK˜TK˜RK˜@Kšžœ
˜—šžœžœ
žœž˜Kšžœ+žœžœ˜GKšžœ*žœžœ˜EKšžœ*žœžœ˜EKšžœ,žœžœžœ˜`Kšžœ
˜—šžœžœ
žœžœ˜!K˜KK˜—šžœ
žœ
žœžœ˜ KšœT£
œ˜cK˜,KšœZ£œ˜jK˜—šžœ
žœ
žœžœ˜ K˜5KšœZ£œ˜jK˜—šœ	žœ˜Kšœ	žœ
˜Kšœ
žœ˜Kšœ
žœ˜Kš
œ
˜
Kš
œ
˜
Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜K˜Kš
œ˜K˜Kš
œ0˜0Kš
œ4˜4Kš
œ˜Kš
œ.˜.Kš
œ3˜3Kš
œ˜—Kšžœ	˜Kš
œ˜——K˜™
™K™hK™³
K™ëK™�—K˜šŸœ7˜QKšžœ0žœžœžœ™Sšžœ	žœ
žœ
žœ
žœž˜$Kš
œ
˜
K˜Kšœžœ
˜Kšœžœ
žœ
˜K˜K˜TKšžœžœ
žœ
žœ˜(K˜K˜K˜)K˜6K˜™8Kš
œ
˜
šžœ
žœ˜Kš
œ9˜9K˜—Kš
œ˜Kšœ	žœ˜ Kšœžœ
žœ
žœ
˜K˜K˜3K™ šžœ
žœ
žœ&žœžœ
ž˜Pšžœ!žœ
¡˜=š
œ
˜
Kš
œ:˜:Kšžœ˜Kš
œ˜——šžœ!žœ
¡!˜IKš
œ
˜
K˜DKšœžœ
žœ
žœ˜'K˜Kšžœžœ
žœžœ˜<Kš
œ9˜9Kšžœ˜Kš
œ˜—K˜Kšžœ
˜—š
œ
˜
K˜DKšœžœ
žœ
žœ˜'Kšžœžœ
žœžœ˜<Kš
œ9˜9Kšžœ˜Kš
œ˜—Kš
œ˜—Kš
œ˜—Kš
œ˜—K˜K˜š
Ÿœžœžœ
žœ*žœ˜qKšœžœ
˜!Kšœžœžœ
žœ˜-Kšœžœžœ'˜EKš
œ˜Kšœžœ
˜
K˜K˜DK˜K˜K™4K˜K˜K˜$Kšœ ¡˜1Kšœ0¡9˜iK˜™1K™ÛK™1—K˜Kšœžœ˜$K˜Kšœ
Ÿ
œžœ˜
Kšœ	žœ˜Kšœžœžœ
˜Kšœ
žœ˜Kšœ	žœžœ
˜šžœ
ž˜Kš
œ˜Kšœžœ
˜K˜K˜XK˜K˜šžœ	žœ˜K˜+Kšœ
žœ
˜K˜—šžœž˜Kšœ
žœ
˜—šžœžœž˜6K˜)—K˜TK˜K˜
K˜Kšžœ
˜—K˜Kšœžœ˜*šžœžœž˜K˜6Kšžœ
˜—šžœžœ#ž˜-šœžœ
˜"Kš
œ˜Kš
œ	˜	Kš
œ˜Kš
œ˜Kš
œ	˜	Kš
œ˜Kš
œ˜—Kšžœ
˜—K˜UK˜K˜K˜K™Kš
œ!™!Kšœžœ-žœ
žœ"žœ
žœ
™sKšœžœžœžœ
žœžœ ™‚
K˜Kšœžœ@˜UK˜Kšœžœ
˜#Kšœžœ
˜K˜šœžœ˜+Kš
œ˜Kš
œ˜K˜
Kš
œ%˜%Kš
œ˜Kš
œ˜Kšœ	žœ
˜
K˜Kšœ	žœ
˜
Kšœžœ˜K˜—Kš
œ(˜(Kšžœ	˜Kš
œ˜K˜K˜——™K™Kš	œžœžœžœžœ˜^KšŸœ-˜F˜Kš
œø™ø—šŸœžœ/žœžœžœžœ0˜­
Kšœžœ
žœžœ
˜š
žœ	žœ
žœ
žœ	žœ˜)Kšžœ
žœ=˜JK˜6K˜[Kš
œ9˜9Kš
œ˜—Kš
œ˜K˜—KšŸ	œžœ˜šŸ#œžœ/žœžœ
žœ
žœžœ0˜¿
Kšœžœ˜Kšœžœ˜*Kšœžœ!˜3K˜=Kš
œ+™+Kšœžœžœžœžœžœ˜iKšœžœ˜K˜Kšžœžœ
žœ
žœ	˜,šžœž˜%Kšœžœ˜Kšœžœžœ
žœ˜Kšœ	žœ˜K˜šžœžœžœžœ˜Išžœžœžœž˜:K˜:šžœžœžœžœ¡œ
žœ˜„
Kšœžœ˜Kšœžœ˜K˜—K˜Kšžœ
˜—šžœžœž˜3Kšžœ9˜?—K˜—K˜K˜7Kš
œ+™+Kš	œžœžœžœžœ˜cK˜Kšžœ
˜—Kš
œ9˜9Kšžœ	˜Kš
œ˜—K˜šŸ	œžœ
žœžœ
žœ	žœžœ˜gKšžœ
žœžœ
˜Kšœžœžœ
˜šŸœžœžœ
žœ˜.šžœžœ˜Kšœžœžœ˜LK˜K˜—Kšœsžœ"žœžœ
˜Á
K˜—šŸœžœžœžœ˜>Kšžœ-˜3K˜—K˜Kšžœ?˜AK˜Kšžœžœžœ#˜Sšžœ"žœ˜*Kšžœžœžœ˜JK˜—K˜Kšžœ·
˜½
Kš
œ˜K˜——™šŸœ/˜BKšžœžœ™1Kš
œ*˜*šŸ	œžœžœ˜NKšœ
žœ
˜šœ	žœžœž˜ K˜
Kšœ!¡˜<Kšœ$¡5˜YKšžœžœ
˜—™`Kšžœžœ"žœÎ
™Ž—šžœž˜K˜K˜K˜Kšžœžœ
˜—šžœžœ˜'Kš
œ	žœžœ
žœžœ
žœ
žœ˜Vš
œ˜Kš
œ
˜
Kšœ¡œ˜Kš
œ˜———šžœž˜Kšœžœ˜Kšœ	žœ˜ Kšœ	žœ˜š
œ˜Kšœžœžœ
˜'Kš
œ˜Kš
žœžœ
žœžœ
žœ
˜>šžœžœ˜)Kš
œ˜š
œ˜šœžœ˜$K˜Kš
œ(˜(—Kš
œ˜——šžœžœ˜)Kš
œ	žœžœ
žœžœ
žœ
žœ˜VKš
œ(˜(—Kšžœ˜
—š
œ	˜	Kš
œ˜Kšžœ
žœžœ
žœ
˜'šžœžœ˜)Kš
œ˜š
œ˜šœžœ˜$Kš
œ˜Kš
œ&˜&—Kš
œ˜——šžœžœ˜)Kš
œ	žœžœ
žœžœ
žœ
žœ˜VKš
œ&˜&—Kšžœ˜K˜—šœžœžœ˜/Kš
œ	žœžœ
žœžœ
žœ
žœ˜VKšœJžœžœ˜\—Kšžœžœžœo˜¡
—K˜K˜——™!K˜Kšœžœžœ˜.šœžœ)˜AK™—K˜Kšœžœžœ˜.šœžœ)˜AK™—K˜Kšœžœ ˜/K˜Kšœžœžœ
žœ
˜šœ
žœžœ˜Kšœžœžœ
žœ˜%—Kšœ
žœžœ˜"šœžœžœ
˜Kšœžœ
˜Kšœžœ˜K˜—šŸœžœ*˜DK˜Kšœžœ
˜Kšœžœ˜#Kšœžœ%˜5K˜šŸœžœžœ
žœžœ
žœžœ˜SKš
ž˜Kšœžœ
žœ˜$Kšœžœ
žœ˜$Kšžœ!žœ
žœ˜5Kšžœ!žœ
žœ
˜8Kšžœ3žœ
žœ˜GKšžœ3žœ
žœ
˜JKšžœ˜Kšžœ
˜K˜—šŸœžœžœ
žœžœ
žœžœ˜MKš
ž˜Kšœžœ
žœ˜$Kšœžœ
žœ˜$Kšžœ3žœ
žœ˜GKšžœ3žœ
žœ
˜JKšžœ!žœ
žœ˜5Kšžœ!žœ
žœ
˜8Kšžœ˜Kšžœ
˜K˜—šŸœžœžœ
žœžœ
žœžœ™MJš
ž™Jšœžœ™Jšœžœ™Jšžœ%žœ
žœ™9Jšžœ%žœ
žœ
™<Jšžœ™Jšžœ
™J™—š
žœžœ
žœžœ
žœ˜>Kšžœžœ
žœžœ
žœ
žœ
˜CKšžœ
˜Kš
œ˜K˜—™Kš
œ
˜
Kšœžœ˜Kšœžœ
žœ
žœ
žœžœ¡˜6Kšœžœ
žœ
žœ
žœžœ¡˜6Kšœžœ
žœ
žœ
žœžœ
˜"Kšœžœ˜ Kšœžœžœ
˜!Kšœžœ
žœ7˜HK˜Kšžœ8˜:š	žœ
Ÿ
œžœ
žœ/ž˜?Kšžœ9£
œ˜@Kšœžœ˜0Kšœžœ˜0šžœž˜šžœžœžœ˜5Kšœžœ
˜KšžœQ˜SKšœžœ˜2K˜
—š
ž˜Kšœž˜——šžœ
˜šžœžœ˜Kš	œžœ
žœ>¡œžœ*˜Œ
Kšœžœ˜Kšœžœ˜K˜K˜——Kšžœ
˜—Kš
œ@˜@K˜š	žœ
Ÿ
œžœ
žœ(ž™8Kš
œ!™!šžœžœ™Kšœžœ
žœ¡œ.™|Kšœžœ™Kšœžœ™Kš
œ™—šžœ
™K™——K˜1Kšœžœ˜5š	žœ
Ÿ
œžœ
žœ
ž˜ Kšœžœ
žœ˜/Kšœ£
œ
˜K˜Kšžœ
˜—K˜K˜+Kšœžœ˜5š	žœ
Ÿ
œžœ
žœ
ž˜ Kšœžœ
žœ˜/K˜K˜Kšžœ
˜K˜—Kš
œ˜—Kš
œ˜——K™™K™˜K™IK˜Kš
œ0™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˜K˜K˜Kš
œ™K˜˜	˜
Kšœžœ
˜K˜(Kšžœžœ
žœ	žœ
žœžœ˜YK˜——Kš
œ™Kš œžœ
˜Kš
œ™Kš
œ™Kšœ
žœ
™Kšžœ˜!——K˜K˜—KšŸ	œžœ
˜Kšœžœ
žœžœ
˜ Kšœ
žœ
žœžœ
˜šŸœžœžœ
žœ	žœ	žœžœžœ	˜Š
Kšœžœ
˜Kšœžœžœ
˜šŸœžœžœžœ˜(Kšžœ˜K˜—šŸœžœžœžœ˜>Kšžœ-˜3K˜—Kšžœ@˜BKšžœžœžœ#˜Sšžœ"žœ˜*Kšžœžœžœ˜JKš
œ˜—K˜$šžœžœ˜Kšœžœžœ˜LK˜K˜—Kšœyžœ"žœžœ
˜Ç
šžœ	žœ
ž˜K˜+—š
ž˜K˜	—˜Kšœžœ
˜K˜
Kšœg¡˜}Kš
œ0˜0K˜Kš
œ
˜
Kš
œ˜—Kšžœ˜—K˜Kšœžœ˜)š$Ÿœžœžœ
žœžœ
žœžœ
žœ
žœžœžœ
žœžœ
žœžœ
žœžœžœ˜Ï
Kšœžœ˜*Kš
œžœžœ$žœ
žœ
žœ
žœ
˜GKšœ
žœ˜šžœžœžœ˜"K˜Kšœžœ
˜K˜—Kšœ	žœžœ žœ˜Tšžœžœ
žœž˜Kšœžœ˜K˜Kšžœ
˜—šžœ	žœ˜šžœžœ
žœž˜Kšœžœ˜K˜Kšžœ
˜—Kšžœ ˜"Kšžœ
žœžœ
žœ˜$š
ž˜Kšœžœ˜
Kšœžœ˜Kšžœžœžœ™FK™Kšžœžœžœ
žœ
˜Kšœ8žœ˜@Kšžœ
˜—K˜
—š
ž˜šžœžœ
žœž˜Kšœžœ˜Kšžœ	žœ
žœ
˜Kšœ.žœžœ˜GKšžœ
˜——Kš
ž˜Kš
œ˜—K˜Kšœžœ˜3šœžœ˜0Kš
Ït"™"—K˜šŸœ˜1Kš
œ
˜
K˜<Kšœžœžœ˜'˜CKšœžœ
žœ*˜9K˜NKš	œ
žœžœžœžœ˜MKšœžœ˜'šžœ
žœ
ž˜
K˜8K˜8Kšžœ.žœžœ˜Sš	žœ
Ÿ
œžœ
žœ
ž˜Kš
œ˜Kšœžœ9˜AK˜6Kšžœ9žœžœžœ˜tKšžœ
˜—Kšžœ
˜—Kš
œ˜—K˜&Kš
œ˜——K˜˜šŸœžœžœžœžœžœ"˜oKšœžœ
˜Kšœžœ
˜Kšœžœ˜Kšžœ	žœ
žœ
žœ
˜K˜K˜%Kšžœ	žœžœ
žœ
˜-šžœžœžœ˜1Kšœžœ
˜šžœžœž˜K˜ —š
ž˜K˜#—Kšœžœ™šžœž™Kš
œ0™0—š
ž™Kš
œ6™6—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šœžœ˜)K˜	K˜K˜—šŸœžœžœ	žœžœžœžœ	˜UKšœžœ˜Kšœžœ
˜Kšœ	žœžœ
˜šžœžœ	ž˜%Kšœžœ˜šžœ
žœžœ˜ K˜
Kšžœ
˜K˜—šžœž˜Kšœ
ž˜—šžœ
˜K˜—Kšžœ
˜—šžœ	žœ
˜K˜
—šžœ	ž˜K˜—K˜——˜Kš	œžœžœ	žœžœ˜2Kšœžœžœ
žœ˜(Kš
œQ™QKšŸ
œžœ¦˜ÆK˜šŸœžœžœžœ˜FKšœžœ
˜šžœžœžœ
ž˜1Kšœžœ
˜Kšžœ
˜—K˜——˜šŸ
œžœžœžœžœžœ
žœ˜Nšžœ$žœžœ
ž˜:Kšžœžœ
žœ˜6Kšžœ
˜—Kšžœ
˜K˜K˜K˜—š
¢œžœžœžœžœ
˜&Kšœžœžœžœ˜&—K˜šŸœ+˜:Kš
žœžœ
žœžœžœ
™1Kšœžœ
˜Kšœ
žœ
˜šžœžœžœžœ˜HKšœ
žœ˜*Kšžœ
˜—šžœ
ž˜Kšœžœ˜$K˜8Kšžœžœ
žœ	˜%Kš
ž˜—K˜—K˜Kš
œ7™7šŸ%œžœžœ˜QKš
œ
˜
K˜3Kš	œžœ
žœžœžœ
˜3Kšœžœ
žœžœ¡˜JKšœžœ˜Kšœžœžœ
˜K™šœ)žœ˜>Kš
œ˜Kš
œ˜Kš
œ˜K˜
Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kšœ	žœ
˜
Kšœžœ˜—K˜Kšœ�œ�œz�œÇ™ôK˜™"K™K™&K™/K™—K™É
K™šžœž˜K˜4šŸœžœ˜Kšœ
žœ
˜K˜ª
Kšžœžœ?˜K˜0Kšžœ˜ Kšžœ7˜;Kšžœ˜—Kšžœ˜—Kšžœžœ
žœ
žœ
˜šžœž˜š
œ	˜	Kšœ
žœ
žœžœ˜$Kšœžœ!˜0Kš	œ
žœ
žœžœžœ˜)Kš
žœžœ
žœžœ
žœ
˜7Kšžœžœ
žœžœ˜RK˜Kšžœžœ
žœžœ˜RK˜—š
œ˜Kšœ
žœ
žœžœ˜$Kšœžœ!˜0Kšœ
žœžœ¡˜+š
žœ	žœ
žœžœžœ
žœ
ž˜Mšžœ ž˜&Kšœžœžœ˜—Kšžœ
˜—šžœ
žœ˜Kšžœžœ
žœžœ˜RK˜—šœ
žœ
¡3˜9Kšœžœ˜—Kš
œ˜—šœžœžœ˜$K˜;Kšœžœ˜—Kšœžœ
˜Kšœžœ˜š
œ˜Kšžœžœ<˜HK˜<Kšžœ˜——šžœ7˜>šžœ<˜>Kš
œ3˜3Kš
œ+˜+—Kš
œ˜—K˜
Kš
ž˜šžœ˜
KšžœžœC˜OK˜@Kš
œ˜—Kšžœ
˜—K˜<šžœ˜K˜——™7K™ÒK™æK™ó
K™y—Kšœ
žœ"˜3Kšœžœ&˜;šŸœžœ&žœ
žœžœ
¡œ
žœ¡œ
žœ
žœ¡œ˜Ò
Kš
œ
˜
Kšœžœ
žœžœ
˜)Kšœžœ
žœžœ
˜,Kšœžœ
˜š
ž˜Kšœ
žœ
˜Kš
œ˜K˜bšžœ"ž˜(Kšžœ&˜,—K˜Bšžœž˜#˜Kš
œ
˜
Kšœ
žœ
˜Kšœžœ
žœ
˜)Kš
œ˜Kšœ
žœ
žœ
˜!K˜�
šœ
žœ˜Kš
œ˜Kš
œ
˜
Kš
œ˜K˜Kš
œ˜Kšœ	žœžœ8žœ˜zK˜Kš
œ˜Kš
œ%˜%—Kšœžœ
˜Kšžœžœ
žœžœ%˜aK˜Kšœžœ
˜K˜Kš
œ˜—Kšœ"žœ&˜NKšžœžœ¡˜!—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š
œ$˜$Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ ˜ ——˜Kš
œ	žœžœžœ	žœ
žœžœ˜B—˜šŸœžœ˜Kšœžœ˜Kš	œžœ
žœžœžœ
˜šžœžœžœ
ž˜&K˜Kšžœ
˜—Kšœžœ˜,K˜
šžœžœ
žœž˜ K˜'K˜Kšžœ
˜—K˜K˜—Kš
œ�
™�
šŸœžœžœ
žœ˜<šŸœžœ
žœ
žœ˜KšžœžœE˜YKš
œ˜K˜—K™4Kšžœ
žœ
žœ˜š	žœžœ
ž
œ
žœ(ž˜CK˜4Kšžœžœ
žœ˜4Kšžœ
˜—Kšžœ˜K˜K˜—šŸœ-˜CKšžœ™K™�
Kš
œ
˜
Kšœ	žœ˜Kšœžœ¡g˜‚
šžœ
žœž˜&šžœžœ
žœ'˜5Kš
ž˜Kšœžœ1˜8K˜4Kšžœžœ
žœ
žœ
˜šžœžœ˜Kšžœ
žœ
žœ
˜K˜Kš
œ˜—šžœžœž˜6Kš
œ
˜
šžœžœ
ž˜%Kš
œ
˜
Kšœ žœ
˜$Kšœžœ9žœ˜Lšžœžœ
ž˜Kš
œ
˜
Kšœžœ
žœžœ
˜Kšœžœ
˜K˜K˜.K˜ašžœžœ˜Kšžœ
žœE˜RKš
œ ™ Kš
œ4™4Kš
œ2™2Kš
œ1™1K™7Kšœžœ
˜Kšœžœ
˜Kšœžœ˜Kšœžœžœ
˜K˜=Kšžœ7˜9K˜šžœž˜Kšœžœ˜šžœžœ5žœ
˜FK˜$Kšžœ
˜—K˜K˜$šžœ&žœžœ5ž˜mK˜K˜$Kšžœ
˜—K˜šžœ%ž˜+Kšœž˜—š
ž˜K˜,—Kšžœ
˜—K˜šžœžœž˜+K˜-Kšžœ
˜—Kš
œA˜AK˜—K˜'šžœžœ
žœ
˜%K˜M—šžœžœ
žœ˜&K˜WK˜]K˜—Kšœžœ/˜LKšžœ
˜Kš
œ˜—Kš
œ˜—šžœžœ
ž˜$Kš
œ
˜
Kšœ žœ
˜$Kšœžœ8žœ˜Kšžœžœ
ž˜Kš
œ
˜
K˜K˜Kšžœ
˜Kš
œ˜—Kš
œ˜—Kš
œ˜—Kšžœ
˜——K˜Kšœžœ
˜"Kš
œ˜K˜—šŸœ)˜:Kš
œ/™/K™\Kšžœ%˜+K˜—šŸœ(˜8K™0Kšžœ˜Kš
œ˜—˜K˜——K™	™Kš
œ0˜0Kš
œ˜Kšœžœ-˜<Kš
œL˜LK˜%šœ,žœ.˜]Kš
œ	˜	Kšžœ
˜K˜Kš
œ˜K˜Kš
œ˜Kš
œ&˜&Kšžœžœžœ
˜Kšžœ
˜K˜Kš
œ˜Kš
œ˜Kš
œ˜K˜K˜—K˜—Kšžœ
˜K˜—…—Ÿºüs