DIRECTORY
BasicTime USING [GMT, Now, Update],
Booting USING [Deregister, CheckpointProc, RegisterProcs, RollbackProc],
BTree USING [Entry, Error, New, Open, SalvageEntries, SetState, SetUpdateInProgress, Tree, UpdateInProgress],
BTreeVM USING [FreeBuffers, Handle, Open, ReferencePage, ReleasePage],
File USING [Create, Delete, Error, FindVolumeFromID, FindVolumeFromName, FP, GetVolumeName, Handle, Info, nullFP, Open, PageCount, PageNumber, Reason, SetSize, SystemVolume, Volume, VolumeID],
FileBackdoor USING [CreateVMBacking, GetRoot, GetVolumePages, NextFile, SetFreeboard, SetRoot],
FS USING [Error, ErrorDesc, WordsForPages],
FSBackdoor USING [Entry, EntryPtr, EntryType, MakeFName, TextFromTextRep, TextRep, ProduceError, Version],
FSDir USING [Compare, EntrySize, UpdateAttachedEntry, UpdateCachedEntry, UpdateLocalEntry],
FSFileOps USING [GetNameBodyAndVersion, GetProps, InitializePropertyStorage, RegisterVolumeFlusher, VolumeDesc, VolumeDescObject],
FSName USING [IsLocal],
FSReport USING [FileError, UnknownVolume],
Rope USING [Cat, Equal, Fetch, Length, ROPE, Text];

FSFileOpsImpl: CEDAR MONITOR
IMPORTS BasicTime, Booting, BTree, BTreeVM, File, FileBackdoor, FS, FSBackdoor, FSDir, FSFileOps, FSName, FSReport, Rope 
EXPORTS FSBackdoor, FSFileOps
= {

ROPE: TYPE = Rope.ROPE;


ScavengeDirectoryAndCache: PUBLIC PROC [volName: ROPE] = {
Activate: ENTRY PROC = {
ENABLE UNWIND => NULL;
ActivateVolume[vDesc];
};
errorDesc: FS.ErrorDesc;
vDesc: FSFileOps.VolumeDesc;
Booting.RegisterProcs[c: RejectCheckpoint]; -- mutual exclusion with checkpoints
vDesc _ InnerGetVolumeDesc[ volName, TRUE -- suspension occurred only if no FS.Error
! FS.Error => {errorDesc _ error; CONTINUE} ];
IF errorDesc.group = ok THEN {
Scavenge[ vDesc.vol ! FS.Error => {errorDesc _ error; CONTINUE} ];
Activate[ ! FS.Error => {IF errorDesc.group = ok THEN errorDesc _ error; CONTINUE} ];
};
Booting.Deregister[c: RejectCheckpoint];
IF errorDesc.group # ok THEN ERROR FS.Error[errorDesc];
};

SetFreeboard: PUBLIC PROC [freeboard: INT] = {
vDesc: FSFileOps.VolumeDesc = GetVolumeDesc[NIL];
IF vDesc = NIL THEN FSReport.UnknownVolume[NIL];
FileBackdoor.SetFreeboard[ vDesc.vol, freeboard ! File.Error => FSReport.FileError[why] ];
};

VolumePages: PUBLIC PROC [volName: ROPE _ NIL] RETURNS [size, free, freeboard: INT] = {
vDesc: FSFileOps.VolumeDesc = GetVolumeDesc[volName];
IF vDesc = NIL THEN FSReport.UnknownVolume[NIL];
[size, free, freeboard] _ FileBackdoor.GetVolumePages[ vDesc.vol
! File.Error => FSReport.FileError[why] ];
};

FNameFromHandle: PUBLIC PROC [file: File.Handle] RETURNS [ROPE] = {
nameBody, prefix: ROPE;
version: FSBackdoor.Version;
{ ENABLE File.Error => FSReport.FileError[why];
volume: File.Volume = File.Info[file].volume;
prefix _ IF volume = File.SystemVolume[] THEN NIL ELSE Rope.Cat["[]<", File.GetVolumeName[volume], ">"];
};
[nameBody, version] _ FSFileOps.GetNameBodyAndVersion[file];
RETURN [ FSBackdoor.MakeFName[nameBody, version, prefix] ];
};

CloseVolume: PUBLIC ENTRY PROC [v: File.Volume] = {
ENABLE UNWIND => NULL;
prev, vDesc: FSFileOps.VolumeDesc _ NIL;
FOR vDesc _ volumeDescList, vDesc.next UNTIL vDesc = NIL DO
IF vDesc.vol = v THEN {
IF prev = NIL
THEN volumeDescList _ vDesc.next
ELSE prev.next _ vDesc.next;
IF vDesc = svDesc THEN svDesc _ NIL;
BTree.SetState[vDesc.tree, closed];
IF vDesc.treeVM # NIL THEN {
BTreeVM.FreeBuffers[vDesc.treeVM];
vDesc.treeVM _ NIL;
};
EXIT;
};
prev _ vDesc;
ENDLOOP;
};


GetVolumeDesc: PUBLIC PROC [vName: ROPE] RETURNS [vDesc: FSFileOps.VolumeDesc] = {
errorDesc: FS.ErrorDesc;
vDesc _ InnerGetVolumeDesc[vName, FALSE
! FS.Error => {errorDesc _ error; CONTINUE} ];
IF errorDesc.group # ok THEN ERROR FS.Error[errorDesc];
};

LPCreatedTime: PUBLIC PROC [vol: File.Volume, fp: File.FP] RETURNS [BasicTime.GMT] = {
handle: File.Handle;
handle _ File.Open[ vol, fp
! File.Error => FSReport.FileError[why] ];
RETURN [ FSFileOps.GetProps[handle].created ];
};

OpenFile: PUBLIC PROC [vol: File.Volume, fp: File.FP] RETURNS [h: File.Handle] = {
RETURN [ File.Open[ vol, fp 
! File.Error => FSReport.FileError[why] ] ];
};

CreateFile: PUBLIC PROC [vol: File.Volume, pages: INT, VMBackingFile: BOOL _ FALSE] RETURNS [fp: File.FP, h: File.Handle] = {
ENABLE File.Error => FSReport.FileError[why];
IF VMBackingFile
THEN h _ FileBackdoor.CreateVMBacking[vol, pages, FSFileOps.InitializePropertyStorage]
ELSE h _ File.Create[vol, pages, FSFileOps.InitializePropertyStorage];
fp _ File.Info[h].fp;
};

DeleteFile: PUBLIC PROC [h: File.Handle] = {
File.Delete[ h
! File.Error => FSReport.FileError[why] ];
};

SetFilePages: PUBLIC PROC [h: File.Handle, pages: INT] = {
File.SetSize[h, pages
! File.Error => FSReport.FileError[why] ];
};

GetFileInfo: PUBLIC PROC [h: File.Handle] RETURNS [pages: INT, fp: File.FP] = {
[fp: fp, size: pages] _ File.Info[h
! File.Error => FSReport.FileError[why] ];
};

waitForRollback: BOOL _ FALSE;
rollback: CONDITION;
svDesc, volumeDescList: FSFileOps.VolumeDesc _ NIL;

InnerGetVolumeDesc: ENTRY PROC [vName: ROPE, suspendVolume: BOOL] RETURNS [FSFileOps.VolumeDesc] = {
ENABLE UNWIND => NULL;
vDesc: FSFileOps.VolumeDesc;
vol: File.Volume _ NIL;
WHILE waitForRollback DO
WAIT rollback;
ENDLOOP;
IF Rope.Length[vName] = 0 AND svDesc # NIL THEN {
IF suspendVolume THEN SuspendVolume[svDesc];
RETURN [svDesc];
};
SELECT TRUE FROM
Rope.Length[vName] = 0 => { -- system volume
vol _ File.SystemVolume[];
IF vol = NIL
THEN { -- no system volume is available
IF suspendVolume
THEN FSReport.UnknownVolume[NIL]
ELSE RETURN [NIL];
};
vName _ File.GetVolumeName[vol];
};
(Rope.Fetch[vName, 0] = '#) => { -- volume number
vol _ File.FindVolumeFromID[ MakeVolumeID[vName] ];
IF vol = NIL THEN FSReport.UnknownVolume[vName];
vName _ File.GetVolumeName[vol];
};
ENDCASE;
FOR vDesc _ volumeDescList, vDesc.next UNTIL vDesc = NIL DO
IF Rope.Equal[vName, vDesc.vName, FALSE] THEN {
IF suspendVolume THEN SuspendVolume[vDesc];
RETURN [vDesc];
};
ENDLOOP;
IF vol = NIL THEN {
vol _ File.FindVolumeFromName[vName];
IF vol = NIL THEN FSReport.UnknownVolume[vName];
};  
vDesc _ NEW[ FSFileOps.VolumeDescObject _ [ NIL, vName, NIL, vol, NIL, NIL ] ];
vDesc.tree _ AllocateBTree[];
IF NOT suspendVolume THEN [] _ SetUpBTree[vDesc];
IF vol = File.SystemVolume[]
THEN {
FSFileOps.RegisterVolumeFlusher[vDesc];
svDesc _ vDesc;
}
ELSE vDesc.prefix _ Rope.Cat["[]<", vName, ">"];
vDesc.next _ volumeDescList;
volumeDescList _ vDesc;
RETURN [vDesc];
};
bufferSize: CARDINAL = 4;
buffers: CARDINAL = 32;
basePage: File.PageNumber = [0]; -- first page of the directory/cache btree
initialPages: File.PageCount = basePage + buffers*bufferSize; 

AllocateBTree: PROC RETURNS [BTree.Tree] = {
RETURN [ BTree.New [
repPrim: [compare: FSDir.Compare, entrySize: FSDir.EntrySize],
storPrim: [referencePage: BTreeVM.ReferencePage, releasePage: BTreeVM.ReleasePage],
minEntrySize: SIZE[FSBackdoor.Entry.local] + SIZE[FSBackdoor.TextRep[1]], -- "a"
initialState: suspended
] ];
};

SetUpBTree: PROC [vDesc: FSFileOps.VolumeDesc, scavenge: BOOL _ FALSE, newTemp: BOOL _ FALSE] RETURNS [treeFile: File.Handle _ NIL]= {
newFile: BOOL _ FALSE;
treeFP: File.FP _ File.nullFP;
treeVM: BTreeVM.Handle;
IF ~newTemp THEN treeFP _ FileBackdoor.GetRoot[vDesc.vol, client
! File.Error =>
IF why = nonCedarVolume
THEN FSBackdoor.ProduceError[nonCedarVolume, Rope.Cat["Local volume \"", vDesc.vName, "\" not formatted for Cedar"]]
ELSE FSReport.FileError[why]
].fp;
IF treeFP = File.nullFP
THEN {
treeFile _ File.Create[vDesc.vol, initialPages, NIL
! File.Error => FSReport.FileError[why] ];
newFile _ TRUE;
}
ELSE treeFile _ OpenFile[vDesc.vol, treeFP];
treeVM _ BTreeVM.Open[
file: treeFile,
filePagesPerPage: bufferSize,
cacheSize: buffers,
base: basePage
];
{
ENABLE UNWIND => {
BTreeVM.FreeBuffers[treeVM];
IF newFile THEN DeleteFile[treeFile ! FS.Error => CONTINUE];
};
OpenBTree[vDesc.tree, treeVM, newFile, scavenge];
IF newFile AND ~newTemp THEN FileBackdoor.SetRoot[client, treeFile ! File.Error => FSReport.FileError[why] ];
};
vDesc.treeVM _ treeVM;
};

OpenBTree: PROC [tree: BTree.Tree, treeVM: BTreeVM.Handle, new, scavenge: BOOL] = {
BTree.Open[
tree: tree,
storage: treeVM,
pageSize: FS.WordsForPages[bufferSize],
initialize: new,
maintainRecomputableState: TRUE
!
BTree.UpdateInProgress => IF scavenge THEN RESUME ELSE FSBackdoor.ProduceError[badBTree, "Update in progress when opening the directory/cache BTree"];
BTree.Error => FSBackdoor.ProduceError[badBTree, "BTree.Error when opening the directory/cache BTree"];
File.Error => FSReport.FileError[why];
];
};

MakeVolumeID: PROC [vName: ROPE] RETURNS [id: File.VolumeID] = {
FSBackdoor.ProduceError[notImplemented, "Can't handle hex volume ID's yet"];
};

SuspendVolume: INTERNAL PROC [vDesc: FSFileOps.VolumeDesc] = {
IF vDesc = svDesc THEN
FSFileOps.RegisterVolumeFlusher[NIL];
BTree.SetState[vDesc.tree, suspended]; -- may wait forever
IF vDesc.treeVM # NIL THEN {
BTreeVM.FreeBuffers[vDesc.treeVM];
vDesc.treeVM _ NIL;
};
};

ActivateVolume: INTERNAL PROC [vDesc: FSFileOps.VolumeDesc] = {
[] _ SetUpBTree[vDesc ! FS.Error => DestroyVolumeDesc[vDesc] ];
IF vDesc = svDesc THEN FSFileOps.RegisterVolumeFlusher[svDesc];
};

DestroyVolumeDesc: INTERNAL PROC [victim: FSFileOps.VolumeDesc] = {
prev: FSFileOps.VolumeDesc _ NIL;
FOR vDesc: FSFileOps.VolumeDesc _ volumeDescList, vDesc.next UNTIL vDesc = NIL DO
IF victim = vDesc THEN EXIT;
prev _ vDesc;
REPEAT FINISHED => ERROR;
ENDLOOP;
IF victim = svDesc THEN {
FSFileOps.RegisterVolumeFlusher[NIL];
svDesc _ NIL;
};
BTree.SetState[victim.tree, closed];
IF prev = NIL
THEN volumeDescList _ victim.next
ELSE prev.next _ victim.next;
};

RejectCheckpoint: Booting.CheckpointProc = {
rejection _ "FS scavenge is in progress.";
};

FSCheckpointProc: ENTRY Booting.CheckpointProc = {
ENABLE UNWIND => NULL;
waitForRollback _ TRUE;
FOR vDesc: FSFileOps.VolumeDesc _ volumeDescList, vDesc.next UNTIL vDesc = NIL DO
SuspendVolume[vDesc];
ENDLOOP;
};

FSRollbackProc: ENTRY Booting.RollbackProc = {
ENABLE UNWIND => NULL;
FOR vDesc: FSFileOps.VolumeDesc _ volumeDescList, vDesc.next UNTIL vDesc = NIL DO
ActivateVolume[vDesc ! FS.Error => CONTINUE ];
ENDLOOP;
waitForRollback _ FALSE;
BROADCAST rollback;
};

AttachedEntry: TYPE = RECORD [
next: REF AttachedEntry,
nameBody: Rope.Text,
version: FSBackdoor.Version,
keep: CARDINAL,
created: BasicTime.GMT,
attachedTo: Rope.Text
];

Scavenge: PROC [vol: File.Volume] = TRUSTED {

SaveAttachments: UNSAFE PROC [entry: BTree.Entry] RETURNS [continue: BOOL] = UNCHECKED {
entryPtr: FSBackdoor.EntryPtr = LOOPHOLE[entry];
continue _ TRUE;
WITH e: entryPtr^ SELECT FROM
attached => attHead _ NEW [ AttachedEntry _
[ attHead, FSBackdoor.TextFromTextRep[@entryPtr[e.nameBody]], e.version, e.keep, e.created, FSBackdoor.TextFromTextRep[@entryPtr[e.attachedTo]] ] ];
ENDCASE;
};
fakeUsedTime: BasicTime.GMT = BasicTime.Update[BasicTime.Now[], -60*20];
attHead: REF AttachedEntry _ NIL;
vDesc: FSFileOps.VolumeDesc = NEW [FSFileOps.VolumeDescObject];
fp: File.FP _ File.nullFP;
newFSBTree: File.Handle _ NIL;
oldFSBTree: File.Handle _ NIL;
vDesc.vol _ vol;
vDesc.tree _ AllocateBTree[];
oldFSBTree _ SetUpBTree[vDesc, TRUE];
[] _ BTree.SalvageEntries[vDesc.tree, SaveAttachments];
BTree.SetState[vDesc.tree, closed];
BTreeVM.FreeBuffers[vDesc.treeVM];  -- dump old buffers
vDesc.tree _ AllocateBTree[]; -- get a new BTree
newFSBTree _ SetUpBTree[vDesc, TRUE, TRUE];
OpenBTree[vDesc.tree, vDesc.treeVM, TRUE, TRUE]; -- initialize the BTree  this file is not the root file yet
BTree.SetUpdateInProgress[vDesc.tree, TRUE];
{
ENABLE UNWIND => {
BTree.SetUpdateInProgress[vDesc.tree, FALSE];
BTreeVM.FreeBuffers[vDesc.treeVM] };
FOR attHead _ attHead, attHead.next UNTIL attHead = NIL DO
IF NOT FSName.IsLocal[attHead.nameBody] THEN LOOP;
FSDir.UpdateAttachedEntry[vDesc, attHead.nameBody, attHead.version, attHead.keep, attHead.created, attHead.attachedTo, insertOrReplace];
ENDLOOP;
UNTIL (fp _ FileBackdoor.NextFile[vDesc.vol, fp]) = File.nullFP DO
nameBody: Rope.Text;
version: FSBackdoor.Version;
h: File.Handle = OpenFile[vDesc.vol, fp
! FS.Error => LOOP ];
[nameBody, version] _ FSFileOps.GetNameBodyAndVersion[h
! FS.Error => IF error.code = $invalidPropertyPage THEN LOOP ];
IF Rope.Length[nameBody] = 0
THEN DeleteFile[h] -- creation of this file was not completed
ELSE {
exists: BOOL _ FALSE;
IF FSName.IsLocal[nameBody]
THEN FSDir.UpdateLocalEntry[
vDesc, nameBody, version, FSFileOps.GetProps[h].keep, fp, insert
! BTree.Error => IF reason = wrongUpdateType THEN {exists _ TRUE; CONTINUE}
]
ELSE FSDir.UpdateCachedEntry[
vDesc, nameBody, version, fakeUsedTime, fp, insert
! BTree.Error => IF reason = wrongUpdateType THEN {exists _ TRUE; CONTINUE}
];
IF exists THEN DeleteFile[h];
};
ENDLOOP;
};
BTree.SetUpdateInProgress[vDesc.tree, FALSE];
FileBackdoor.SetRoot[client, newFSBTree ! File.Error => FSReport.FileError[why] ];
File.Delete[oldFSBTree ! File.Error => CONTINUE];
BTreeVM.FreeBuffers[vDesc.treeVM];
};


Booting.RegisterProcs[c: FSCheckpointProc, r: FSRollbackProc];

}. 


FSFileOpsImpl.mesa
Copyright c 1984, 1985 by Xerox Corporation.  All rights reserved.
Schroeder, November 30, 1983 9:07 am
Levin, September 22, 1983 1:21 pm
Bob Hagmann, May 9, 1985 4:45:18 pm PDT
Russ Atkinson (RRA) May 13, 1985 8:34:04 pm PDT
Exported to FSBackdoor
Exported to FSFileOps
Internal procedures
can't make new ones now, so don't even look
want system volume and already have descriptor
found VolumeDesc in list
new tree file, but can't have validation stamp in property page
no SIGNALs or ERRORs
turn off volume flusher if any;  (RRA) must do this before suspending the BTree
assumes that tree already is suspended
special steps for the system volume;  (RRA) must close this before closing the BTree
a little earlier so used times always will be updated after scavenge
put file in directory/cache
Start Code
Bob Hagmann January 29, 1985 3:39:51 pm PST
Cedar 6.0 interface changes

Bob Hagmann April 30, 1985 7:39:58 am PDT
changes to: ScavengeDirectoryAndCache, SetUpBTree, Scavenge, InnerGetVolumeDesc, ActivateVolume
ΚV–

"Cedar" style˜
codeš
œ™Kšœ
Οm
œ7™BK™$K™!K™'K™/—K˜š
Οk	˜	Kšœ
žœžœ˜#Kšœžœ;˜HKšœžœb˜mKšœžœ9˜FKšœžœ?žœu˜ΐ
Kšœ
žœM˜_Kšžœ
žœ#˜+KšœžœZ˜jKšœžœP˜[Kšœ
žœs˜‚
Kšœžœ˜Kšœ	žœ˜*Kšœžœžœ˜3K˜—šœžœ
ž˜Kšžœ9žœ7˜yKšžœ˜Kš
œ˜K˜Kšžœžœžœ
˜K˜—™K˜šΟnœžœ
žœžœ˜:šŸœžœ
žœ˜Kšžœ
žœžœ
˜Kš
œ˜Kš
œ˜—Kšœžœ˜Kš
œ˜Kšœ,Οc$˜Pšœ%žœ
 *˜TKšœžœžœ˜.—šžœžœ˜Kšœžœžœ˜BKš	œžœžœžœžœ˜UKš
œ˜—Kš
œ(˜(Kšžœžœ
žœ
žœ˜7Kš
œ˜—K˜šŸœžœ
žœ
žœ˜.Kšœ,žœ˜1Kšžœ	žœ
žœžœ˜0Kš
œZ˜ZKš
œ˜—K˜šŸœžœ
žœžœžœžœžœ˜WKš
œ5˜5Kšžœ	žœ
žœžœ˜0š
œ@˜@Kš
œ*˜*—Kš
œ˜—K˜š
Ÿœžœ
žœžœžœ˜CKšœžœ
˜Kš
œ˜šœžœ'˜/Kš
œ-˜-Kš	œ	žœžœ
žœ
žœ2˜hKš
œ˜—Kš
œ<˜<Kšžœ5˜;Kš
œ˜—K˜šŸœžœ
žœ
žœ˜3Kšžœ
žœžœ
˜Kšœ$žœ
˜(šžœ$žœ	žœ
ž˜;šžœžœ˜šžœž˜
Kšžœ˜ Kšžœ˜—Kšžœžœ
žœ
˜$Kš
œ#˜#šžœžœ˜Kš
œ"˜"Kšœžœ
˜Kš
œ˜—Kšžœ
˜Kš
œ˜—Kš
œ
˜
Kšžœ
˜—Kš
œ˜K˜——™K˜š
Ÿ
œžœ
žœ	žœžœ"˜RKšœžœ˜šœ"ž˜'Kšœžœžœ˜.—Kšžœžœ
žœ
žœ˜7Kš
œ˜—K˜šŸ
œžœ
žœžœžœžœ˜VK˜š
œ˜Kš
œ*˜*—Kšžœ(˜.Kš
œ˜—K˜š
Ÿœžœ
žœžœžœ˜Ršžœ˜Kš
œ,˜,—Kš
œ˜—K˜šŸ
œžœ
žœžœžœžœ
žœžœ˜}Kšžœ'˜-šžœ˜KšžœR˜VKšžœB˜F—Kš
œ˜Kš
œ˜—K˜šŸ
œžœ
žœ˜,š
œ˜Kš
œ*˜*—Kš
œ˜—K˜šŸœžœ
žœžœ˜:š
œ˜Kš
œ*˜*—Kš
œ˜—K˜šŸœžœ
žœžœ	žœžœ˜Oš
œ#˜#Kš
œ*˜*—Kš
œ˜——™K˜Kšœžœžœ
˜Kšœ
ž	œ
˜Kšœ/žœ
˜3K˜šŸœžœ
žœ	žœžœžœ˜dKšžœ
žœžœ
˜Kš
œ˜Kšœžœ
˜šžœž˜Kš
œ+™+Kšžœ
˜Kšžœ
˜—šžœžœ
žœ
žœ˜1Kš
œ.™.Kšžœžœ˜,Kšžœ
˜Kš
œ˜—šžœ
žœ
ž˜šœž
œ
 ˜,Kš
œ˜Kšžœž˜šžœ
ž
œ
  ˜'Kšžœ˜Kšžœžœ
˜ Kšžœ
žœžœ˜Kš
œ˜—Kš
œ ˜ Kš
œ˜—šœž
œ
 ˜1Kš
œ3˜3Kšžœžœ
žœ˜0Kš
œ ˜ Kš
œ˜—Kšžœ
˜—šžœ$žœ	žœ
ž˜;šžœ žœžœ˜/Kš
œ™Kšžœžœ˜+Kšžœ	˜Kš
œ˜—Kšžœ
˜—šžœžœ˜Kš
œ%˜%Kšžœžœ
žœ˜0Kš
œ˜—Kšœžœ!žœ	žœžœžœ˜OKš
œ˜Kšžœ
žœžœ˜1šžœ˜šžœ˜Kš
œ'˜'Kš
œ˜Kš
œ
˜
—Kšžœ,˜0—Kš
œ˜Kš
œ˜Kšžœ	˜Kš
œ˜—Kšœžœ˜Kšœ	žœ˜Kšœ! *˜KKš
œ>˜>K˜šŸ
œžœ
žœ˜,šžœ˜K˜>Kš
œS˜SKšœžœžœ ˜PK˜K˜—Kš
œ˜—K˜šŸ
œžœ)žœžœžœžœžœžœ˜†
Kšœ	žœžœ
˜Kšœ
žœ˜Kš
œ˜šžœ
žœ0˜@š
œ˜šžœ˜Kšžœp˜tKšžœ˜——Kš
œ˜—šžœ˜šžœ˜Kš
œ?™?šœ0ž˜3Kš
œ*˜*—Kšœ
žœ
˜Kš
œ
˜
—Kšžœ(˜,—š
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜—š
œ
˜
šžœ
žœ˜Kš
œ˜Kšžœ	žœžœ
žœ˜<Kš
œ˜—Kš
œ1˜1Kšžœ	žœ
žœQ˜mKš
œ˜—Kš
œ˜Kš
œ˜—K˜šŸ	œžœ;žœ˜Sš
œ˜Kš
œ˜Kš
œ˜Kšœ
žœ˜'Kš
œ˜Kšœž˜˜
Kš	œžœ
žœ
žœ
žœ`˜–
Kš
œg˜gKš
œ&˜&—K˜—Kš
œ˜—K˜šŸœžœ	žœžœ˜@K˜LKš
œ˜—K˜šŸ
œžœ
žœ"˜>Kš
œ™šžœž˜Kš
œO™OKšœ žœ˜%—Kšœ' ˜:šžœžœ
žœ˜Kš
œ"˜"Kšœžœ
˜Kš
œ˜—Kš
œ˜—K˜šŸœžœ
žœ"˜?Kšœžœ%˜?Kšžœžœ)˜?Kš
œ˜—K˜šŸœžœ
žœ#˜CKš
œ&™&Kšœžœ
˜!šžœ:žœ	žœ
ž˜QKšžœžœ
žœ
˜Kš
œ
˜
Kšžœ
žœžœ
˜Kšžœ
˜—šžœžœ˜Kš
œT™TKšœ žœ˜%Kšœ	žœ
˜
Kš
œ˜—Kš
œ$˜$šžœž˜
Kšžœ˜!Kšžœ˜—Kš
œ˜—K˜š
œ,˜,Kš
œ*˜*Kš
œ˜—K˜šœžœ˜2Kšžœ
žœžœ
˜Kšœžœ
˜šžœ:žœ	žœ
ž˜QKš
œ˜Kšžœ
˜—Kš
œ˜—K˜šΟbœžœ˜.Kšžœ
žœžœ
˜šžœ:žœ	žœ
ž˜QKšœžœ
žœ˜.Kšžœ
˜—Kšœžœ
˜Kšž	œ
˜Kš
œ˜—K˜šœžœžœ˜Kšœžœ˜Kš
œ˜K˜Kšœžœ
˜Kšœžœ
˜K˜K˜—K˜šŸœžœžœ˜-K˜šŸœžœ
žœžœžœž	œ˜XKšœ žœ˜0Kšœžœ
˜šžœžœ
ž˜šœžœ˜+Kš
œ”
˜”
—Kšžœ
˜—Kš
œ˜—šœžœ-˜HKš
œD™D—Kšœ	žœžœ
˜!Kšœžœ˜?Kšœ	žœ˜Kšœžœ
˜Kšœžœ
˜K˜Kš
œ˜Kšœžœ˜%Kš
œ7˜7Kš
œ#˜#Kšœ$ ˜7Kšœ ˜0Kšœž
œ˜+Kšœ$žœžœ <˜mKšœ&žœ˜,š
œ
˜
šžœ
žœ˜Kšœ&žœ˜-Kš
œ$˜$—šžœ!žœžœ
ž˜:Kšžœ
žœ"žœ
žœ
˜2Kš
œˆ
˜ˆ
Kšžœ
˜—šžœ;ž˜BK˜K˜š
œ'˜'Kšœžœ
žœ˜—˜7Kš	œžœ
žœ#žœ
žœ˜?—šžœ˜Kšžœ *˜=šžœ˜Kš
œ™Kšœžœžœ
˜šžœ˜šžœ˜Kš
œ@˜@Kš	œžœžœžœžœ
˜KKš
œ
˜
—šžœ˜Kš
œ2˜2Kš	œžœžœžœžœ
˜KKš
œ˜——Kšžœžœ˜Kš
œ˜——Kšžœ
˜—Kš
œ˜—Kšœ&žœ˜-Kš
œR˜RKšœ'žœ˜1Kš
œ"˜"Kš
œ˜K˜——™
K˜Kš
œ>˜>K˜—Kš
œ˜K˜K˜™+K™K™—™)KšœΟrS™_——…—2ΔG*