DIRECTORY
AlpFile,
AlpineEnvironment,
AlpineFile,
AlpineInterimDirectory,
AlpInstance,
AlpTransaction,
Basics,
BasicTime,
Buttons,
IO,
List,
Real,
Rope,
ViewerClasses,
ViewerTools,
YodelData;

YodelAdministrator: CEDAR PROGRAM

IMPORTS AlpFile, AlpInstance, AlpineInterimDirectory, AlpTransaction, Buttons, IO, List, Real, Rope,  ViewerTools, YodelData

EXPORTS YodelData


 =

BEGIN OPEN YodelData;

ROPE: TYPE = Rope.ROPE;
OwnerPropertyValuePairList: TYPE = LIST OF AlpineEnvironment.OwnerPropertyValuePair;

CompareProc: SAFE PROC [ref1, ref2: REF ANY]
      RETURNS [Basics.Comparison] = CHECKED {
      RETURN [Rope.Compare[NARROW[ref1], NARROW[ref2], FALSE]];
      };

trimWedges: PROC [inRope: ROPE] RETURNS [outRope: ROPE _NIL] = {
len: INT _ inRope.InlineLength[];
IF len < 2 OR inRope.Fetch[0] ~= '< OR inRope.Fetch[len-1] ~= '> THEN ERROR;
RETURN [ inRope.Substr[start: 1, len: len-2]];
};


ChangeAssertWheel: PUBLIC Buttons.ButtonProc = {
d: MyData = NARROW[clientData];
p: ViewerClasses.Viewer = NARROW[parent];
d.assertWheel _ NOT d.assertWheel ;
IF d.assertWheel
THEN Buttons.SetDisplayStyle[p, $WhiteOnBlack]
ELSE Buttons.SetDisplayStyle[p, $BlackOnWhite];
};

ChangeBreakLocks: PUBLIC Buttons.ButtonProc = {
d: MyData = NARROW[clientData];
p: ViewerClasses.Viewer = NARROW[parent];
d.breakLocks _ NOT d.breakLocks ;
IF d.breakLocks
THEN Buttons.SetDisplayStyle[p, $WhiteOnBlack]
ELSE Buttons.SetDisplayStyle[p, $BlackOnWhite];
};

createOwner: PROC [trans: AlpTransaction.Handle, server: ROPE, directory: ROPE, user: ROPE _ NIL, password: ROPE _ NIL , properties: OwnerPropertyValuePairList, d: MyData]
RETURNS [resultList: LIST OF REF ANY] = {
spaceLeftOnVolumeGroup: INT;
owner: ROPE _ trimWedges[directory];
IF trans = NIL THEN RETURN [CONS[NARROW["Bad Server Name", ROPE], NIL]];
trans.AssertAlpineWheel[TRUE];
[spaceLeftOnVolumeGroup: spaceLeftOnVolumeGroup] _ trans.CreateOwner[
volumeGroupID: trans.GetNextVolumeGroup[previousGroup:
         AlpineEnvironment.nullVolumeGroupID, lock: [none, wait]],
owner: owner,
properties: properties];
IF (trans.Finish[requestedOutcome: commit, continue: FALSE] # commit) THEN {
resultList _ CONS[
first: NARROW["Alpine transaction aborted -- owner NOT created", ROPE],
rest: NIL];
} ELSE resultList _ CONS[
first: IO.PutFR["Owner added; space left on volume group is %g",
  IO.int[spaceLeftOnVolumeGroup]],
rest: NIL];
};

CreateOwnerProc: PUBLIC Buttons.ButtonProc = {
resultList: LIST OF REF ANY _ NIL;
d: MyData = NARROW[clientData];
server, user, password: ROPE;
directory: ROPE;
properties: OwnerPropertyValuePairList ;
pageLimit: INT;
newPageLimitRope: ROPE;
scratchStream: IO.STREAM _ NIL;

callCreate: YodelData.PerformProc = {
RETURN[createOwner[trans, server, directory, user, password, properties, d]];
};
d.stopFlag _ FALSE;
[user, password, server, directory] _ ParseSArgs[d];
newPageLimitRope _ ViewerTools.GetContents[viewer: d.oQuota];
IF newPageLimitRope.IsEmpty[] THEN {
d.out.PutF["\nCreate Owner has no quota specified\n"];
}
 ELSE {
IF directory.Size[] <= 2 OR hasPattern[directory] THEN {
d.out.PutF["\nCreate Owner has an invalid owner name to create.  Name is %g\n", IO.rope[directory]];
}
 ELSE {
scratchStream _ IO.RIS[newPageLimitRope, scratchStream];
pageLimit _ IO.GetInt[scratchStream];
properties _ LIST[[quota[pageLimit]]];

d.out.PutF["\nCreate Owner of [%g]%g for %g pages\n", IO.rope[server], IO.rope[directory], IO.int[pageLimit]];
resultList _ PerformOp[performProc: callCreate, server: server, user: user, password: password];
DO
nowRope: ROPE _ NARROW[List.Car[resultList]];
IF resultList = NIL THEN EXIT;
resultList _ List.Cdr[resultList];
d.out.PutF["  %g\n", IO.rope[nowRope]];
ENDLOOP;
};
};
};

destroyOwner: PROC [trans: AlpTransaction.Handle, server: ROPE, directory: ROPE, user: ROPE _ NIL, password: ROPE _ NIL , d: MyData]
RETURNS [resultList: LIST OF REF ANY] = {
destroyOwnerEnumProc: PROC [fileName: REF TEXT,
     universalFile: AlpineEnvironment.UniversalFile] RETURNS [quit: BOOL] = {
thereIsAFile _ TRUE;
};
owner: ROPE _ trimWedges[directory];
thereIsAFile: BOOL _ FALSE;
properties: LIST OF AlpineEnvironment.OwnerPropertyValuePair;
rootFile: AlpineEnvironment.UniversalFile _ AlpineEnvironment.nullUniversalFile ;
IF trans = NIL THEN RETURN [CONS[NARROW["Bad Server Name", ROPE], NIL]];
trans.AssertAlpineWheel[TRUE];
AlpineInterimDirectory.EnumerateDirectoryUnderTrans[
	       transHandle: trans,
	       directoryName: Rope.Concat["[",Rope.Concat[server,Rope.Concat["]",directory]]],
  	     enumProc: destroyOwnerEnumProc];
IF thereIsAFile THEN RETURN [ CONS[
            NARROW["Delete all files in the directory before destroying the owner",ROPE]
            ,NIL]];
properties _ AlpTransaction.ReadOwnerProperties[
handle: trans,
volumeGroupID: AlpTransaction.GetNextVolumeGroup[handle: trans, 
  previousGroup: AlpineEnvironment.nullVolumeGroupID, lock: [none, fail]],
owner: owner];
UNTIL properties = NIL DO -- because ReadOwnerProperties does not sort them yet ...
WITH properties.first SELECT FROM
q: AlpineEnvironment.OwnerPropertyValuePair.createAccessList => {
};
s: AlpineEnvironment.OwnerPropertyValuePair.modifyAccessList => {
};
r: AlpineEnvironment.OwnerPropertyValuePair.rootFile => {
rootFile _ r.rootFile ;
};
t: AlpineEnvironment.OwnerPropertyValuePair.quota => {};
u: AlpineEnvironment.OwnerPropertyValuePair.spaceInUse => {};
ENDCASE ;
properties _ properties.rest;
ENDLOOP;
IF rootFile # AlpineEnvironment.nullUniversalFile THEN {
fileHandle: AlpFile.Handle _ NIL;
[fileHandle] _ AlpFile.Open[transHandle: trans,
universalFile: rootFile,
access: readWrite,
lock: [write, fail]
! AlpInstance.Unknown => CONTINUE;
  ];
IF fileHandle # NIL THEN AlpFile.Delete[fileHandle ! AlpInstance.Unknown => CONTINUE;];
};
[] _ trans.DestroyOwner[
volumeGroupID: trans.GetNextVolumeGroup[
  previousGroup: AlpineEnvironment.nullVolumeGroupID,
  lock: [none, wait]],
owner: owner];
IF (trans.Finish[requestedOutcome: commit, continue: FALSE] # commit) THEN {
resultList _ CONS[
first: NARROW["Alpine transaction aborted -- owner NOT destroyed", ROPE],
rest: NIL];
} ELSE resultList _ CONS[ first: NARROW["Owner destroyed", ROPE], rest: NIL];
};

DestroyOwnerProc: PUBLIC Buttons.ButtonProc = {
resultList: LIST OF REF ANY _ NIL;
d: MyData = NARROW[clientData];
server, user, file, password: ROPE;
directory: ROPE;

callDestroy: YodelData.PerformProc = {
RETURN[destroyOwner[trans, server, directory, user, password, d]];
};

d.stopFlag _ FALSE;
[user, password, server, directory, file] _ ParseSArgs[d];
d.out.PutF["\nDestroy Owner of [%g]%g \n", IO.rope[server], IO.rope[directory]];
resultList _ PerformOp[performProc: callDestroy, server: server, user: user, password: password];
DO
nowRope: ROPE _ NARROW[List.Car[resultList]];
IF resultList = NIL THEN EXIT;
resultList _ List.Cdr[resultList];
d.out.PutF["  %g\n", IO.rope[nowRope]];
ENDLOOP;
};

writeQuota: PROC [trans: AlpTransaction.Handle, server: ROPE, directory: ROPE, user: ROPE _ NIL, password: ROPE _ NIL , properties: OwnerPropertyValuePairList, d: MyData]
RETURNS [resultList: LIST OF REF ANY] = {
owner: ROPE _ trimWedges[directory];
IF trans = NIL THEN RETURN [CONS[NARROW["Bad Server Name", ROPE], NIL]];
trans.AssertAlpineWheel[TRUE];
[] _ trans.WriteOwnerProperties[
volumeGroupID: trans.GetNextVolumeGroup[previousGroup:
         AlpineEnvironment.nullVolumeGroupID, lock: [none, wait]],
owner: owner,
properties: properties];
IF (trans.Finish[requestedOutcome: commit, continue: FALSE] # commit) THEN {
resultList _ CONS[
first: NARROW["Alpine transaction aborted -- quota NOT changed", ROPE],
rest: NIL];
} ELSE resultList _ CONS[ first: NARROW["Quota changed", ROPE], rest: NIL];
};


WriteQuotaProc: PUBLIC Buttons.ButtonProc = {
resultList: LIST OF REF ANY _ NIL;
d: MyData = NARROW[clientData];
server, user, password: ROPE;
directory: ROPE;
properties: OwnerPropertyValuePairList ;
pageLimit: INT;
newPageLimitRope: ROPE;
scratchStream: IO.STREAM _ NIL;

callWriteQuota: YodelData.PerformProc = {
RETURN[writeQuota[trans, server, directory, user, password, properties, d]];
};
{
d.stopFlag _ FALSE;
[user, password, server, directory] _ ParseSArgs[d];
newPageLimitRope _ ViewerTools.GetContents[viewer: d.oQuota];
scratchStream _ IO.RIS[newPageLimitRope, scratchStream];
pageLimit _ IO.GetInt[scratchStream ! IO.EndOfStream, IO.Error => GOTO badInt];
properties _ LIST[[quota[pageLimit]]];

d.out.PutF["\nWrite quota for Owner of [%g]%g to %g pages\n", IO.rope[server], IO.rope[directory], IO.int[pageLimit]];
resultList _ PerformOp[performProc: callWriteQuota, server: server, user: user, password: password];
DO
nowRope: ROPE _ NARROW[List.Car[resultList]];
IF resultList = NIL THEN EXIT;
resultList _ List.Cdr[resultList];
d.out.PutF["  %g\n", IO.rope[nowRope]];
ENDLOOP;
EXITS
badInt => {
d.out.PutF["\nWrite quota: bad quota specified\n"];
};
};
};

listOwners: PROC [trans: AlpTransaction.Handle] RETURNS [resultList: LIST OF REF ANY] = {
owner: ROPE _ NIL ;
properties: LIST OF AlpineEnvironment.OwnerPropertyValuePair;
result: ROPE;
totalQuota: INT _ 0 ;
totalSpaceInUse: INT _ 0 ;
IF trans = NIL THEN RETURN [CONS[NARROW["Bad Server Name", ROPE], NIL]];
trans.AssertAlpineWheel[TRUE];
DO
quota: INT _ 0;
spaceInUse: INT _ 0;
[owner, properties] _ trans.ReadNextOwner[
        volumeGroupID: trans.GetNextVolumeGroup[previousGroup:
         AlpineEnvironment.nullVolumeGroupID, lock: [none, wait]],
        previousOwner: owner,
        desiredProperties: ALL [TRUE]];
IF owner = NIL THEN EXIT;
result _ IO.PutFR["%g\t\t", IO.rope[owner]];
UNTIL properties = NIL DO
property: AlpineEnvironment.OwnerPropertyValuePair _ properties.first ;
properties _ properties.rest;
SELECT property.property FROM
quota => {
quota _ NARROW[property,
                  AlpineEnvironment.OwnerPropertyValuePair.quota].quota;
totalQuota _ totalQuota + quota ;
result _ Rope.Concat[result,
                  IO.PutFR["quota %5g ", IO.int[quota]]];
};
spaceInUse => {
spaceInUse _ NARROW[property,
                  AlpineEnvironment.OwnerPropertyValuePair.spaceInUse].spaceInUse;
totalSpaceInUse _ totalSpaceInUse + spaceInUse ;
result _ Rope.Concat[result,
                  IO.PutFR["spaceInUse %5g ", IO.int[spaceInUse]]];
};
ENDCASE;
ENDLOOP;
IF quota > 0 THEN {
percent: INT _ Real.Fix[(spaceInUse * 100.0)/quota];
result _ Rope.Concat[result,
                  IO.PutFR[" (%2g%%) ", IO.int[percent]]];
IF percent > 90 THEN result _ Rope.Concat[result, " <-----"];
};
resultList _ CONS[
first: result, rest: resultList];
ENDLOOP;
resultList _ CONS[
first: IO.PutFR[" totals\t\tspaceInUse %5g\tquota %5g\n", IO.int[totalSpaceInUse], IO.int[totalQuota] ],
rest: resultList];
}; 

ListOwnersProc: PUBLIC Buttons.ButtonProc = {
callListOwners: YodelData.PerformProc = {
RETURN[listOwners[trans]];
};
resultList: LIST OF REF ANY _ NIL;
d: MyData = NARROW[clientData];
server, user, password: ROPE;

d.stopFlag _ FALSE;
 
[user, password, server] _ ParseSArgs[d];
d.out.PutF["\nList Owners for server %g\n", IO.rope[server]];
resultList _ PerformOp[performProc: callListOwners, server: server, user: user, password: password];
resultList _ List.Sort[resultList, CompareProc];
DO
nowRope: ROPE _ NARROW[List.Car[resultList]];
IF resultList = NIL THEN EXIT;
resultList _ List.Cdr[resultList];
d.out.PutF["  %g\n", IO.rope[nowRope]];
ENDLOOP;
};

readDBProperties: PROC [trans: AlpTransaction.Handle]
RETURNS [resultList: LIST OF REF ANY] = {
nOwners, nEntriesUsed, nEntries: NAT;
totalQuota, totalSpaceInUse, volumeGroupSize: AlpineEnvironment.PageCount;
IF trans = NIL THEN RETURN [CONS[NARROW["Bad Server Name", ROPE], NIL]];
trans.AssertAlpineWheel[TRUE];
TRUSTED {
[nOwners, nEntriesUsed, nEntries, totalQuota, totalSpaceInUse, volumeGroupSize] _ trans.inst.owner.ReadDBProperties[conversation: trans.inst.conversation, transID: trans.transID, volumeGroupID: trans.GetNextVolumeGroup[previousGroup:
         AlpineEnvironment.nullVolumeGroupID, lock: [none, wait]]];
};
resultList _ CONS[
first: IO.PutFR[" owners %g,  entries used %g,  entries %g",
  IO.int[nOwners], IO.int[nEntriesUsed], IO.int[nEntries]],
rest: CONS[
  IO.PutFR[" total quota %g,  total space in use %g, volume group size %g",
    IO.int[totalQuota], IO.int[totalSpaceInUse], IO.int[volumeGroupSize]],
  NIL]
];
};

ReadDBPropertiesProc: PUBLIC Buttons.ButtonProc = {
callReadDBPropertiesProc: YodelData.PerformProc = {
RETURN[readDBProperties[trans]];
};
resultList: LIST OF REF ANY _ NIL;
d: MyData = NARROW[clientData];
server, user, password: ROPE;

d.stopFlag _ FALSE;
 
[user, password, server] _ ParseSArgs[d];
d.out.PutF["\nRead Statistics for server %g\n", IO.rope[server]];
resultList _ PerformOp[performProc: callReadDBPropertiesProc, server: server, user: user, password: password];
resultList _ List.Sort[resultList, CompareProc];
DO
nowRope: ROPE _ NARROW[List.Car[resultList]];
IF resultList = NIL THEN EXIT;
resultList _ List.Cdr[resultList];
d.out.PutF["  %g\n", IO.rope[nowRope]];
ENDLOOP
};


END.





ÔYodelAdministrator.mesa
Last Edited by: Hagmann, April 4, 1984 4:24:43 pm PST
filler to use all the variants so the compiler won't blow up
(this is the cedar version of the "don't delete this line" comment
�Ê4˜Jš
œ™Jš
œ5™5J˜š
Ïk	˜	Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ
˜
Jš
œ˜Jš�œ
˜Jš
œ˜J˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ
˜
—J˜Jšœ�œ
�˜!J˜Jš�œH�œ+˜|J˜Jš�œ
˜J˜J˜Jš
œ˜J˜Jš�œ
�œ˜J˜Jš�œ�œ�œ
˜Jšœ�œ�œ
�œ*˜TJ˜JšÏnœ�œ
�œ�œ
�œ�œ�œ	�œ�œ�œ�œ
˜¤
šÏb
œ�œ
�œ�œ�œ�œ˜@Jšœ�œ˜!Jš
�œ	�œ�œ�œ
�œ
˜LJš�œ(˜.J˜—J˜J˜šŸœ�œ˜0Jšœ�œ
˜Jšœ�œ	˜)Jšœ�œ˜#Jš�œ�œ+�œ+˜oJš
œ˜—J˜šŸœ�œ˜/Jšœ�œ
˜Jšœ�œ	˜)Jšœ�œ˜!Jš�œ�œ+�œ+˜nJš
œ˜—J˜šŸœ�œ(�œ
�œ�œ�œ�œ�œ6�œ�œ
�œ
�œ
�œ˜Õ
Jšœ�œ
˜Jšœ�œ˜$Jš�œ	�œ
�œ
�œ�œ
�œ�œ�œ˜HJšœ�œ˜Jš
Ͼ
˜æ
š�œ3�œ�œ˜LJš	œ
�œ	�œ4�œ	�œ˜fJšœ�œ�œ	�œ:�œ%�œ˜‰
—J˜J˜—šŸœ�œ˜.Jšœ�œ
�œ
�œ
�œ�œ
˜"Jšœ�œ
˜Jšœ�œ
˜Jšœ�œ
˜Jš
œ(˜(Jšœ�œ
˜Jšœ�œ
˜Jšœ�œ
�œ�œ
˜J˜š
œ%˜%Jš�œG˜MJ˜—Jšœ
�œ
˜Jš
œ4˜4Jš
œ=˜=š�œ�œ˜$Jš
œ6˜6J˜
—šœ
�œ˜š�œ�œ�œ˜8JšœP�œ˜dJ˜
—šœ
�œ˜Jšœ�œ
�œ"˜8Jšœ�œ˜%Jšœ
�œ˜&J˜Jšœ6�œ�œ�œ˜nJš
œ`˜`š
�˜Jšœ	�œ�œ˜-Jš�œ�œ
�œ
�œ
˜Jš
œ"˜"Jšœ�œ˜'Jš�œ
˜—J˜—J˜—J˜—J˜šŸœ�œ(�œ
�œ�œ�œ�œ�œ�œ�œ
�œ
�œ
�œ˜®
šŸœ�œ�œ
�œ7�œ�œ˜}Jšœ�œ
˜J˜—Jšœ�œ˜$Jšœ�œ�œ
˜Jšœ�œ
�œ*˜=Jš
œQ˜QJš�œ	�œ
�œ
�œ�œ
�œ�œ�œ˜HJšœ�œ˜Jš
τ
˜Ñ
Jš�œ�œ
�œ�œ�œA�œ�œ˜�
Jš
œÚ
˜Ú
š�œ�œ
�œ
Ïc9˜Sš�œ�œ
�˜!š
œA˜AJš
œ˜—š
œA˜AJš
œ˜—Jš
œ<™<Jš
œB™Bš
œ9˜9Jš
œ˜Jš
œ˜—Jš
œ8˜8Jš
œ=˜=Jš�œ˜	—Jš
œ˜Jš�œ
˜—š�œ0�œ˜8Jšœ�œ
˜!Jšœ‰
�œ
˜’
Jš
œ˜Jš�œ�œ
�œ4�œ˜WJ˜—Jš
œ�
˜�
š�œ3�œ�œ˜LJš	œ
�œ	�œ6�œ	�œ˜hJšœ�œ�œ	�œ�œ	�œ˜M—J˜—J˜šŸœ�œ˜/Jšœ�œ
�œ
�œ
�œ�œ
˜"Jšœ�œ
˜Jšœ�œ
˜#Jšœ�œ
˜J˜š
œ&˜&Jš�œ<˜BJ˜—J˜Jšœ
�œ
˜Jš
œ:˜:Jšœ+�œ�œ˜PJš
œa˜aš
�˜Jšœ	�œ�œ˜-Jš�œ�œ
�œ
�œ
˜Jš
œ"˜"Jšœ�œ˜'Jš�œ
˜—J˜—J˜šŸ
œ�œ(�œ
�œ�œ�œ�œ�œ6�œ�œ
�œ
�œ
�œ˜Ô
Jšœ�œ˜$Jš�œ	�œ
�œ
�œ�œ
�œ�œ�œ˜HJšœ�œ˜Jš
œÁ
˜Á
š�œ3�œ�œ˜LJš	œ
�œ	�œ4�œ	�œ˜fJšœ�œ�œ	�œ�œ	�œ˜K—J˜J˜—J˜šŸœ�œ˜-Jšœ�œ
�œ
�œ
�œ�œ
˜"Jšœ�œ
˜Jšœ�œ
˜Jšœ�œ
˜Jš
œ(˜(Jšœ�œ
˜Jšœ�œ
˜Jšœ�œ
�œ�œ
˜J˜š
œ)˜)Jš�œF˜LJ˜—˜
Jšœ
�œ
˜Jš
œ4˜4Jš
œ=˜=Jšœ�œ
�œ"˜8Jš	œ�œ�œ�œ
�œ	˜OJšœ
�œ˜&J˜Jšœ>�œ�œ�œ˜vJš
œd˜dš
�˜Jšœ	�œ�œ˜-Jš�œ�œ
�œ
�œ
˜Jš
œ"˜"Jšœ�œ˜'Jš�œ
˜—š
�˜š
œ˜Jš
œ3˜3J˜——J˜—J˜—J˜šŸ
œ�œ �œ�œ
�œ
�œ
�œ˜YJšœ�œ�œ˜Jšœ�œ
�œ*˜=Jšœ�œ
˜
Jšœ�œ˜Jšœ�œ˜Jš�œ	�œ
�œ
�œ�œ
�œ�œ�œ˜HJšœ�œ˜š
�˜Jšœ�œ˜Jšœ�œ˜Jšœæ
�œ�œ˜ò
Jš�œ	�œ
�œ
�œ
˜Jšœ	�œ�œ˜,š�œ�œ
�˜Jš
œG˜GJš
œ˜š�œ�˜˜
Jšœ�œ
˜Jš
œH˜HJš
œ!˜!Jš
œ˜Jšœ�œ�œ˜9J˜—š
œ˜Jšœ
�œ
˜Jš
œR˜RJš
œ0˜0Jš
œ˜Jšœ�œ�œ˜CJ˜—Jš�œ
˜—Jš�œ
˜—š�œ�œ˜Jšœ	�œ(˜4Jš
œ˜Jšœ�œ�œ˜:Jš�œ�œ)˜=J˜—Jšœ
�œ#˜4Jš�œ
˜—Jš	œ
�œ	�œ1�œ�œ&˜Ž
Jš
œ˜—J˜šŸœ�œ˜-š
œ)˜)Jš�œ˜J˜—Jšœ�œ
�œ
�œ
�œ�œ
˜"Jšœ�œ
˜Jšœ�œ
˜J˜Jšœ
�œ
˜J˜
Jš
œ)˜)Jšœ,�œ˜=Jš
œd˜dJš
œ0˜0š
�˜Jšœ	�œ�œ˜-Jš�œ�œ
�œ
�œ
˜Jš
œ"˜"Jšœ�œ˜'Jš�œ
˜—J˜—J˜šŸœ�œ �œ�œ
�œ
�œ
�œ˜_Jšœ!�œ
˜%Jš
œJ˜JJš�œ	�œ
�œ
�œ�œ
�œ�œ�œ˜HJšœ�œ˜š�œ˜	Jš
œ­˜­J˜—Jšœ
�œ	�œ6�œ�œ�œ�œ�œL�œ�œ�œ�œ˜¸J˜—J˜šŸœ�œ˜3š
œ3˜3Jš�œ˜ J˜—Jšœ�œ
�œ
�œ
�œ�œ
˜"Jšœ�œ
˜Jšœ�œ
˜J˜Jšœ
�œ
˜J˜
Jš
œ)˜)Jšœ0�œ˜AJš
œn˜nJš
œ0˜0š
�˜Jšœ	�œ�œ˜-Jš�œ�œ
�œ
�œ
˜Jš
œ"˜"Jšœ�œ˜'Jš
�˜—J˜J˜—J˜Jš�œ
˜J˜J˜J˜J˜J˜—…—2ÆAÎ