DIRECTORY
Ascii,
Basics USING [BytePair],
Disk USING [Channel, DoIO, DriveAttributes, Label, PageCount, PageNumber, Request, Status],
DiskFace USING [DeviceHandle, DiskAddress],
ExtraIagoOps USING [GetAddress],
ExtraIagoUtils,
File USING [Error, FindVolumeFromID, FindVolumeFromName, FP, Handle, Info, nullVolumeID, Open, PageCount, PageNumber, Read, Volume, VolumeFile, VolumeID, wordsPerPage],
FileInternal USING [Handle, FindRun, TranslateLogicalRun],
FS USING [Error],
FSBackdoor USING [Version],
FSFileOps USING [GetNameBodyAndVersion],
IagoOps USING [Confirm, FileError],
IO,
PhysicalVolume USING [GetSubVolumes, Physical, SubVolumeDetailsObject, SubVolumes],
Rope,
VM USING [AddressForPageNumber, Allocate, Free, Interval, nullInterval, PagesForWords, SwapIn, Unpin],
VolumeFormat USING [Attributes, LogicalPage, LogicalRun, RelID];

ExtraIagoUtilsImpl: CEDAR PROGRAM
IMPORTS Basics, Disk, ExtraIagoOps, File, FileInternal, FS, FSFileOps, IagoOps, IO, PhysicalVolume, VM

EXPORTS ExtraIagoUtils =

BEGIN OPEN IO, ExtraIagoUtils;

STREAM: TYPE = IO.STREAM;
ROPE: TYPE = Rope.ROPE;



StatusToRope: PUBLIC PROC[status: Disk.Status] RETURNS[r: ROPE, wasOK: BOOL] = {
wasOK _ FALSE;
WITH s: status SELECT FROM
changed => r _ "drive's ChangeCount changed; no IO performed";
unchanged => SELECT s.status FROM
inProgress => r _ "inProgress";
goodCompletion => {r _ "good Completion"; wasOK _ TRUE};
notReady => r _ "notReady";
recalibrateError => r _ "recalibrateError";
seekTimeout => r _ "seekTimeout";
headerCRCError => r _ "headerCRCError";
labelCRCError => r _ "labelCRCError";
dataCRCError => r _ "dataCRCError";
headerNotFound => r _ "headerNotFound";
labelVerifyError => r _ "labelVerifyError";
dataVerifyError => r _ "dataVerifyError";
overrunError => r _ "overrunError";
writeFault => r _ "writeFault";
memoryError => r _ "memoryError";
memoryFault => r _ "memoryFault";
clientError => r _ "clientError";
operationReset => r _ "operationReset";
otherError => r _ "otherError";
ENDCASE;
ENDCASE;
};

ReportStatus: PUBLIC PROC[out: STREAM, status: Disk.Status, dontReportOK: BOOL _ TRUE] = {
r: ROPE;
wasOK: BOOL;
[r, wasOK]_ StatusToRope[status];
IF dontReportOK AND wasOK THEN RETURN;
out.PutF["\n\n **********Status reported as: %g **********", rope[r]];
};

OKStatusForWrite: PUBLIC PROC[status: Disk.Status, in, out: STREAM] RETURNS[ok: BOOL] = {
WITH s: status SELECT FROM
changed => RETURN[FALSE];
unchanged => SELECT s.status FROM
labelCRCError => NULL;
goodCompletion, dataCRCError, dataVerifyError => RETURN[TRUE];

inProgress, notReady, recalibrateError, seekTimeout, headerCRCError,
headerNotFound, labelVerifyError, overrunError, writeFault, memoryError,
memoryFault, clientError, operationReset, otherError => RETURN[FALSE];
ENDCASE;
ENDCASE;
out.PutRope["\n LabelCRCError reported; attempt the write anyway?"];
ok _ IagoOps.Confirm[in, out];
};

ChannelToDeviceHandle: PUBLIC PROC[c: Disk.Channel]
	RETURNS[d: DiskFace.DeviceHandle] = {
ordinal: CARDINAL _ Disk.DriveAttributes[c].ordinal;
d _ LOOPHOLE[ordinal, DiskFace.DeviceHandle];
};

VolumeFileToRope: PUBLIC PROC[which: File.VolumeFile] RETURNS[ROPE] = {
RETURN[SELECT which FROM
checkpoint => "Checkpoint",
microcode => "Microcode",
germ => "Germ",
bootFile => "BootFile",
debugger => "Debugger",
debuggee => "Debuggee",
VM => "VM",
VAM => "VAM",
client => "FS-root",
alpine => "Alpine-root",
ENDCASE => "Other-root"];
};

AttributesToRope: PUBLIC PROC[attributes: VolumeFormat.Attributes] RETURNS[ROPE] = {
RETURN[SELECT attributes FROM
physicalRoot => "PhysicalRoot",
badPageList => "BadPageList",
badPage => "BadPage",
subVolumeMarker => "SubVolumeMarker",
logicalRoot => "LogicalRoot",
freePage => "FreePage",
header => "HeaderPage",
data => "DataPage",
lastCedar => "LastCedarAttribute",
ENDCASE => "UnknownType"];
};



DescribeOnePage: PUBLIC PROC[
  logicalPage: VolumeFormat.LogicalPage, vol: File.Volume, in, out: STREAM] = TRUSTED {
pageSpace: VM.Interval _ VM.nullInterval;
{ ENABLE UNWIND => FreeSpace[pageSpace];
initLabel: Disk.Label;
data: LONG POINTER;
label: Disk.Label _ initLabel;
request: Disk.Request;
status: Disk.Status;
attr: VolumeFormat.Attributes;
realPage: Disk.PageNumber;
val: WORD;
run: VolumeFormat.LogicalRun;
channel: Disk.Channel;
[pageSpace, data]_ GetSpace[1];
run _ [[logicalPage], 1];
[channel, realPage]_ FileInternal.TranslateLogicalRun[run, vol ! File.Error => {
out.PutF["\nFile.Error (%g) during TranslateLogicalRun of logical page %g\n",
IO.rope[IagoOps.FileError[why]], IO.int[logicalPage]];
GOTO doQuit;
};
];
BEGIN ENABLE File.Error => {
out.PutF["\n File.Error (%g) reading page %g (physical page %g)\n",
rope[IagoOps.FileError[why]], int[logicalPage], int[realPage]];
GOTO keepGoing;
};
request _ [diskPage: [realPage], data: data, incrementDataPtr: FALSE,
command: [verify, read, read], count: 1];
[status, ]_ Disk.DoIO[channel: channel, label: @label, request: @request];
attr _ LOOPHOLE[label.attributes];
IF attr = freePage THEN {
out.PutF["\n Page %g (physical page %g) is free, with status %g",
int[logicalPage], int[realPage], rope[StatusToRope[status].r]];
RETURN
};
IF attr = data OR attr = header THEN {
fp: File.FP _ LOOPHOLE[label.fileID.relID];
handle: File.Handle _ File.Open[vol, fp];
nameBody: Rope.Text;
version: FSBackdoor.Version;
[nameBody, version]_ FSFileOps.GetNameBodyAndVersion[f: handle ! FS.Error => {
out.PutF["\n Page %g (physical page %g),\n\t***FS error: \"%g\"\n",
int[logicalPage], int[realPage], rope[error.explanation] ];
out.PutF["\tFile.FP is: [id: %g (%bB), da: %g (%bB)]\n",
IO.card[LOOPHOLE[fp.id]], IO.card[LOOPHOLE[fp.id]],
IO.card[LOOPHOLE[fp.da]], IO.card[LOOPHOLE[fp.da]]];
out.PutF["\tIs %g page %g of some file",
IF attr = data THEN rope["data"] ELSE rope["header"],
IO.int[label.filePage] ];
CONTINUE}];
IF nameBody # NIL THEN {
out.PutF["\n Page %g (physical page %g), with status %g\n",
int[logicalPage], int[realPage], rope[StatusToRope[status].r]];
out.PutF["      *** is %g page %g of file %g, version %g",
IF attr = data THEN rope["data"] ELSE rope["header"],
int[label.filePage],
rope[nameBody],
int[version]];
};
RETURN;
};
val _ LOOPHOLE[label.attributes];
out.PutF["\nOther type of page: logical: %g (physical %g), attributes: %g (%06b)\n",
IO.int[logicalPage], int[realPage], IO.rope[AttributesToRope[attr]], IO.card[val]];
EXITS
keepGoing => NULL;
END;
FreeSpace[pageSpace];
EXITS
doQuit => FreeSpace[pageSpace];
};
};

CheckPages: PUBLIC PROC[handle: File.Handle, name: ROPE, out: STREAM] = {
ENABLE FS.Error => {
out.PutRope[" ... "];
IF error.code = $invalidPropertyPage
THEN out.PutRope["not an FS file"]
ELSE out.PutRope[error.explanation];
CONTINUE
};
size: File.PageCount _ File.Info[handle].size;
didStop: BOOL _ FALSE;
diskPage: Disk.PageNumber;
channel: Disk.Channel;
pageSpace: VM.Interval _ VM.nullInterval;
numPages: INT = 25;
{
ENABLE UNWIND => FreeSpace[pageSpace];
data: LONG POINTER;
[pageSpace, data]_ GetSpace[numPages];
out.PutF["\nReading pages from %g file (%g pages)\n", IO.rope[name], IO.int[size]];
TRUSTED {
i: File.PageCount _ 0;
WHILE i < size DO
IF i # 0 THEN IF i MOD 100 = 0 THEN
IF i MOD 1000 = 0 THEN out.PutF["(%g)", IO.int[i]] ELSE out.PutChar['~]; 
File.Read[handle, [i], numPages, data ! File.Error =>
{IF why # unknownPage THEN didStop _ TRUE; EXIT}];
i _ i + numPages;
ENDLOOP;
IF didStop THEN {
ff: FileInternal.Handle;
badPage: INT _ -1;
FOR j: File.PageCount IN [i..i+numPages) DO
File.Read[handle, [j], 1, data
! File.Error => {
out.PutF["\nFile error reading page %g\n", IO.int[j]];
out.PutRope[" ... "]; out.PutRope[IagoOps.FileError[why]];
badPage _ j;
EXIT}];
ENDLOOP;
ff _ LOOPHOLE[handle];
[diskPage, , channel]_ FileInternal.FindRun[[badPage], 1, ff.runTable];
out.PutChar['\n];
PrintPageAndDiskAddr[diskPage, ChannelToDeviceHandle[channel], out];
ReadAndReport[NIL, out, diskPage, 1, channel, none];
};
};
FreeSpace[pageSpace];
};
};


LogicalToPhysicalPage: PUBLIC PROC[logicalPage: VolumeFormat.LogicalPage, volName: ROPE]
RETURNS[page: Disk.PageNumber] = {
vol: File.Volume = File.FindVolumeFromName[volName];
IF vol = NIL THEN RETURN[[-1]];
[ , page] _ FileInternal.TranslateLogicalRun[[logicalPage, 1], vol];
};

PhysicalToLogicalPage: PUBLIC PROC[p: PhysicalVolume.Physical, page: Disk.PageNumber]
RETURNS[logicalPage: VolumeFormat.LogicalPage, vol: File.Volume] = {
sv: PhysicalVolume.SubVolumes = PhysicalVolume.GetSubVolumes[p];
FOR i: CARDINAL IN [0..sv.count) DO
addr: INT = sv[i].address;
IF page >= addr AND page < addr+sv[i].size THEN {
logicalPage _ [page-addr];
vol _ File.FindVolumeFromID[sv[i].id];
RETURN
};
ENDLOOP;
RETURN[[0], File.FindVolumeFromID[File.nullVolumeID]];
};

PrintPageAndDiskAddr: PUBLIC PROC[
	page: Disk.PageNumber, d: DiskFace.DeviceHandle, out: STREAM] = {
addr: DiskFace.DiskAddress _ ExtraIagoOps.GetAddress[d, page];
IF addr.cylinder = LAST[CARDINAL] THEN
{ out.PutF[" Drive %g doesn't exist", int[LOOPHOLE[d, INTEGER]]]; RETURN};
out.PutF["   Page: %g (%bB),", int[page], card[page]];
out.PutF[" [cyl: %g (%bB), head: %g, sector: %g]",
card[addr.cylinder], card[addr.cylinder], card[addr.head], card[addr.sector]];
};

ReadAndReport: PUBLIC PROC[in, out: STREAM, first, count: INT, d: Disk.Channel, howToShowData: HowToShowData] = TRUSTED {
pageSpace: VM.Interval _ VM.nullInterval;
{
ENABLE UNWIND => FreeSpace[pageSpace];
origin: Disk.PageNumber;
initLabel: Disk.Label;
data: LONG POINTER;
[pageSpace, data]_ GetSpace[1];

FOR i: INT IN [0 .. count) DO
label: Disk.Label _ initLabel;
val: WORD;
request: Disk.Request;
status: Disk.Status;
countDone: INT;
attr: VolumeFormat.Attributes;
origin _ [first + i];
request _ [diskPage: origin, data: data, incrementDataPtr: FALSE,
command: [verify, read, read], count: 1];
[status, countDone]_ Disk.DoIO[channel: d, label: @label, request: @request];
ReportStatus[out, status];
out.PutF["\n\n *******Label for disk page %g is:\nFileID: ", int[first+i]];
FOR i: INT IN [0..5) DO
val _ LOOPHOLE[@label + i, LONG POINTER TO CARDINAL]^;
out.PutF[" %06b", IO.card[val]];
ENDLOOP;

attr _ LOOPHOLE[label.attributes];
IF attr = data OR attr = header THEN {
relID: VolumeFormat.RelID _ LOOPHOLE[label.fileID.relID];
da: VolumeFormat.LogicalPage _ LOOPHOLE[relID.da];
out.PutF["\n      Logical Address of Header: %g", int[da]];
};
val _ LOOPHOLE[label.attributes];
out.PutF["\nfilePage: %g, attributes: %g (%06b)\n",
IO.int[label.filePage], IO.rope[AttributesToRope[attr]], IO.card[val]];
IF howToShowData # none THEN {
ptr: LONG POINTER TO CARDINAL _ LOOPHOLE[data];
valsPerLine: INT = 8;		-- so its easy to change
numLines: INT _ 256/valsPerLine;
out.PutF["\n *****Data for that page is:\n"];
IF howToShowData = all
THEN {
FOR i: INT IN [0..numLines) DO
out.PutF["%03b/ ", IO.int[i*valsPerLine]];
FOR j: INT IN [0..valsPerLine) DO
val _ (ptr+ j)^; out.PutF[" %06b", IO.card[val]];
ENDLOOP;
out.PutRope["   "];		-- some white space
FOR j: INT IN [0..valsPerLine) DO
bytes: Basics.BytePair;
val _ (ptr+ j)^;
bytes _ LOOPHOLE[val, Basics.BytePair];
out.PutChar[CheckChar[LOOPHOLE[bytes.high, CHAR]]];
out.PutChar[CheckChar[LOOPHOLE[bytes.low, CHAR]]];
ENDLOOP;
out.PutChar['\n];
ptr _ ptr + valsPerLine;
ENDLOOP;
}
ELSE
FOR i: INT IN [0 .. 256) DO
bytes: Basics.BytePair;
val _ (ptr+ i)^;
bytes _ LOOPHOLE[val, Basics.BytePair];
out.PutChar[CheckChar[LOOPHOLE[bytes.high, CHAR]]];
out.PutChar[CheckChar[LOOPHOLE[bytes.low, CHAR]]];
ENDLOOP;
};
ENDLOOP;
FreeSpace[pageSpace];
};
};

CheckChar: PUBLIC PROC[ch: CHAR] RETURNS[CHAR] = {
OPEN Ascii;
xx: CARDINAL [0 .. 377B];
IF ch = NUL THEN RETURN[' ];
IF ch IN [ControlA .. ControlZ] THEN RETURN['*];
IF (xx _ LOOPHOLE[ch]) IN [200B .. 377B] THEN RETURN['!];
RETURN[ch]
};

GetSpace: PROC[num: INT] RETURNS[space: VM.Interval, data: LONG POINTER] = TRUSTED {
space _ VM.Allocate[VM.PagesForWords[num*File.wordsPerPage]];
data _ VM.AddressForPageNumber[space.page];
VM.SwapIn[interval: space, kill: TRUE, pin: TRUE];
};

FreeSpace: PROC[space: VM.Interval] = TRUSTED {
IF space = VM.nullInterval THEN RETURN;
VM.Unpin[space];
VM.Free[space];
space _ VM.nullInterval;
};

END.

BExtraIagoUtilsImpl.mesa
Copyright c 1985 by Xerox Corporation.  All rights reserved.
Willie-Sue, May 21, 1986 4:13:07 pm PDT
Russ Atkinson (RRA) March 11, 1985 8:39:34 pm PST
* * * * * * * * * * * * * * * * * Utility Procedures * * * * * * * * * * * * * * * 
* * * * * * * * commands implementation * * * * * * * *
�Ê­˜
codeš
œ™Kšœ
Ïm
œ1™<K™'K™1—K˜š
Ïk	˜	K˜Kšœžœ˜KšœžœQ˜[Kšœ	žœ˜+Kšœ
žœ˜ K˜Kšœžœ/žœm˜¨
Kšœ
žœ(˜:Kšžœ
žœ	˜Kšœžœ˜Kšœ
žœ˜(Kšœžœ˜#Kšžœ
˜Kšœžœ?˜SKš
œ˜Kšžœ
žœ^˜fKšœ
žœ.˜@K˜—šœžœ
ž˜!Kšžœ1žœžœž˜fK˜šžœ˜K˜Kšžœ
žœ
žœ˜——˜Kšžœžœžœ
žœ
˜Kšžœžœžœ
˜K˜—K˜Kš
œS™SK˜šÏnœžœ
žœžœžœ	žœ˜PKšœžœ
˜šžœžœ
ž˜Kš
œ>˜>šœ
žœ
ž˜!Kš
œ˜Kšœ2žœ˜8Kš
œ˜Kš
œ+˜+Kš
œ!˜!Kš
œ'˜'Kš
œ%˜%Kš
œ#˜#Kš
œ'˜'Kš
œ+˜+Kš
œ)˜)Kš
œ#˜#Kš
œ˜Kš
œ!˜!Kš
œ!˜!Kš
œ!˜!Kš
œ'˜'Kš
œ˜—Kšžœ
˜—Kšžœ
˜K˜—K˜šŸœžœ
žœžœ%žœžœ˜ZKšœžœ
˜Kšœžœ
˜Kš
œ!˜!Kšžœžœžœ
žœ
˜&K˜FKš
œ˜—K˜šŸœžœ
žœžœžœžœ˜Yšžœžœ
ž˜Kšœžœ
žœ˜šœ
žœ
ž˜!Kšœžœ
˜Kšœ1žœ
žœ˜>K˜Kš
œD˜DKš
œH˜HKšœ8žœ
žœ˜F—Kšžœ
˜—Kšžœ
˜K˜DK˜Kš
œ˜—K˜šŸœžœ
žœ˜3Kšœ
žœ˜&Kšœ	žœ#˜4Kšœžœ!˜-Kš
œ˜—K˜š
Ÿœžœ
žœžœ
žœ˜Gšžœ
žœž˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kšžœ	˜Kšžœ
˜
Kš
œ˜Kš
œ˜Kšžœ˜—Kš
œ˜—K˜š
Ÿœžœ
žœ&žœ
žœ˜Tšžœ
žœž˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ%˜%Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ"˜"Kšžœ˜—Kš
œ˜—K˜K˜Kš
œ7™7K˜šŸœžœ
žœ
˜KšœDžœžœ˜WKšœžœžœ˜)šœžœ
žœ˜(K˜Kšœžœ
žœ
˜K˜K˜Kš
œ˜K˜Kš
œ˜Kšœžœ
˜
Kš
œ˜Kš
œ˜K˜Kš
œ˜š
œP˜Pš
œM˜MKšžœžœ˜6Kšžœ˜K˜—Kš
œ˜—šžœ
žœ˜˜CKš
œ?˜?—Kšžœ˜K˜—šœ?žœ
˜EKš
œ)˜)—Kš
œJ˜JKšœžœ˜"šžœžœ˜˜AKš
œ?˜?Kš
ž˜—K˜—šžœ
žœžœ˜&Kšœ	žœžœ˜+Kš
œ)˜)Kš
œ˜Kš
œ˜šœAžœ˜Nš
œC˜CKš
œ;˜;—˜8Kšžœžœ
žœžœ	˜3Kšžœžœ
žœžœ
˜4—š
œ(˜(Kšžœ
žœžœ˜5Kšžœ˜—Kšžœ˜—šžœžœ
žœ˜˜;Kš
œ?˜?—š
œ:˜:Kšžœ
žœžœ˜5Kš
œ˜Kš
œ˜Kš
œ˜—K˜—Kšžœ
˜K˜—Kšœžœ˜!š
œT˜TKšžœ"žœžœ˜S—š
ž˜Kšœ
žœ
˜—Kšžœ
˜Kš
œ˜š
ž˜Kš
œ˜—Kš
œ˜—K˜—K˜š
Ÿ
œžœ
žœžœžœ˜Išžœ
žœ˜K˜šžœ"˜$Kšžœ˜"Kšžœ ˜$—Kš
ž˜Kš
œ˜—Kš
œ.˜.Kšœ	žœžœ
˜Kš
œ˜Kš
œ˜Kšœžœžœ˜)Kšœ
žœ˜š
œ
˜
Kšžœ
žœ˜&Kšœžœ
žœ
˜K˜&Kšœ6žœ
žœ˜Sšžœ˜	Kš
œ˜šžœ
ž˜š	žœžœ
žœžœ	ž˜#Kš
žœžœ
žœžœ	žœ˜I—š
œ5˜5Kš	œ
žœžœžœžœ˜2—K˜Kšžœ
˜—šžœ	žœ˜Kš
œ˜Kšœ	žœ˜šžœžœž˜+š
œ˜š
œ˜Kšœ+žœ	˜6Kš
œ:˜:Kš
œ˜Kšžœ˜——Kšžœ
˜—Kšœžœ	˜Kš
œG˜GK˜K˜DKšœžœ#˜4K˜—Kš
œ˜—K˜Kš
œ˜—Kš
œ˜—K˜K˜šŸœžœ
žœ1žœ
˜Xšžœ˜"Kš
œ4˜4Kšžœžœ
žœ
žœ˜Kš
œD˜DK˜——K˜šŸœžœ
žœ3˜UKšžœ=˜DKš
œ@˜@šžœžœ
žœž˜#Kšœžœ˜šžœžœžœ˜1Kš
œ˜Kš
œ&˜&Kš
ž˜K˜—Kšžœ
˜—Kšžœ0˜6Kš
œ˜—K˜šŸœžœ
žœ
˜"Kšœ7žœ˜BKš
œ>˜>šžœžœ
žœž˜&Kšœ*žœžœžœ˜J—Kš
œ6˜6š
œ2˜2K˜N—Kš
œ˜—K˜šŸ
œžœ
žœ
žœžœ3žœ˜yKšœžœžœ˜)š
œ
˜
Kšžœ
žœ˜&Kš
œ˜K˜Kšœžœ
žœ
˜K˜K˜šžœžœ
žœž˜K˜Kšœžœ
˜
K˜Kš
œ˜Kšœžœ
˜K˜Kš
œ˜šœ;žœ
˜AKš
œ)˜)—Kš
œM˜MKš
œ˜Kš
œK˜Kšžœžœ
žœž˜Kšœžœ
žœ
žœ
žœ
žœ˜6Kšœžœ˜ Kšžœ
˜—K˜Kšœžœ˜"šžœ
žœžœ˜&Kšœžœ˜9Kšœžœ˜2K˜;K˜—Kšœžœ˜!š
œ3˜3Kšžœžœžœ˜G—šžœžœ˜Kšœžœ
žœ
žœ
žœžœ˜/Kšœ
žœÏc˜/Kšœ
žœ˜ Kš
œ-˜-šžœ˜šžœ˜šžœžœ
žœž˜Kšœžœ˜*šžœžœ
žœž˜!Kšœ#žœ˜1Kšžœ
˜—Kšœ ˜(šžœžœ
žœž˜!Kš
œ˜Kš
œ˜Kšœžœ˜'Kšœžœ
žœ˜3Kšœžœžœ˜2Kšžœ
˜—Kš
œ˜Kš
œ˜Kšžœ
˜—Kš
œ
˜
—š
ž˜šžœžœ
žœž˜Kš
œ˜Kš
œ˜Kšœžœ˜'Kšœžœ
žœ˜3Kšœžœžœ˜2Kšžœ
˜———Kš
œ˜—Kšžœ
˜—K˜Kš
œ˜—Kš
œ˜—K˜šŸ	œžœ
žœžœžœ
žœ˜2Kšžœ˜Kšœžœ
˜Kšžœžœ
žœ
žœ˜Kšžœžœžœ
žœ˜0Kš
žœžœžœžœ
žœ˜9Kšžœ˜
Kš
œ˜—K˜šŸœžœžœžœžœžœ
žœžœ˜TKšœžœ
žœ'˜=Kšœžœ"˜+Kšžœžœžœ˜2Kš
œ˜—K˜šŸ	œžœžœ
žœ˜/Kšžœ	žœžœ
žœ
˜'Kšžœ˜Kšžœ
˜Kšœžœ˜Kš
œ˜—K˜Kšžœ
˜—…—/>ÿ