DIRECTORY
BasicTime,
CDIO,
CD,
CDDirectory,
CDDirectoryOps,
CDEnvironment,
CDEvents,
CDPrivate,
CDProperties,
CDSequencer,
CDValue,
Convert,
FileNames,
FS,
IO,
Process,
Properties,
Rope,
TerminalIO,
TokenIO;

CDOut: CEDAR PROGRAM 
IMPORTS BasicTime, CD, CDIO, CDDirectory, CDDirectoryOps, CDEnvironment, CDEvents, CDProperties, CDSequencer, CDValue, Convert, FileNames, FS, IO, Process, Properties, Rope, TerminalIO, TokenIO
EXPORTS CDIO
SHARES CDDirectory, CDProperties =
BEGIN

xChipndaleFile: INT = 12121983;
xVersion: INT = 18;
simpleObjectsInTableMax: INT _ 10000;

spaceCnt: INT _ 0; --not exact, it's mainly to pacify user
dotCnt: INT _ 0; --not exact, it's mainly to pacify user
colCnt: INT _ 0; --not exact, it's mainly to pacify user

FileExists: PROC [name: Rope.ROPE] RETURNS [found: BOOL_TRUE] = {
[] _ FS.FileInfo[name: name, remoteCheck: FALSE 
! FS.Error => IF error.group#bug THEN {found _ FALSE; CONTINUE}
];
};

GetNameInteractively: PROC [wDir: Rope.ROPE_NIL] RETURNS [name: Rope.ROPE] = {
TerminalIO.PutRope["file name:"];
IF ~Rope.IsEmpty[wDir] THEN TerminalIO.PutRopes[" (", wDir, ")"];
name _ TerminalIO.RequestRope[" > "]; 
name _ CDIO.MakeName[name, "dale", wDir];
IF FileExists[name] THEN {
TerminalIO.PutRopes["File ", name, " exists "];
IF ~TerminalIO.Confirm["overwrite file"] THEN ERROR TerminalIO.UserAbort;
};
};

WriteIfNoisy: PROC [h: TokenIO.Handle, r: Rope.ROPE] = INLINE {
IF Properties.GetProp[h.properties^, $Noisy]#NIL THEN TerminalIO.PutRope[r];
};

WriteLayer: PUBLIC PROC [h: TokenIO.Handle, l: CD.Layer] = {
TokenIO.WriteAtom[h, CD.LayerKey[l]];
};

WritePos: PUBLIC PROC [h: TokenIO.Handle, p: CD.Position] = {
TokenIO.WriteInt[h, p.x];
TokenIO.WriteInt[h, p.y];
};

WriteRect: PUBLIC PROC[h: TokenIO.Handle, r: CD.Rect] = {
TokenIO.WriteInt[h, r.x1];
TokenIO.WriteInt[h, r.y1];
TokenIO.WriteInt[h, r.x2];
TokenIO.WriteInt[h, r.y2];
};

WriteProperties: PUBLIC PROC [h: TokenIO.Handle, props: CD.PropList] = {
WITH h.clientData SELECT FROM
d: CD.Design => CDSequencer.CheckAborted[d];
ENDCASE => ERROR;
Process.Yield[]; --should make output slower than redraw
FOR l: CD.PropList _ props, l.rest WHILE l#NIL DO
WITH l.first.key SELECT FROM
a: ATOM => {
pp: CDProperties.PropertyProcs = CDProperties.FetchProcs[a];
IF pp#NIL AND pp.internalWrite#NIL THEN {
IF h.truth AND pp.supressTruth THEN LOOP;
IF pp.internalWrite=CDProperties.DontPWrite THEN LOOP;
TokenIO.WriteAtom[h, $Property];
TokenIO.WritePush2[h, a];
pp.internalWrite[h, a, l.first.val];
TokenIO.WritePop[h];
}
ELSE WITH l.first.val SELECT FROM
r: Rope.ROPE => {
TokenIO.WriteAtom[h, $DefaultProperty];
TokenIO.WriteAtom[h, a];
TokenIO.WriteRope[h, r];
};
at: ATOM => {
TokenIO.WriteAtom[h, $DefaultProperty];
TokenIO.WriteAtom[h, a];
TokenIO.WriteAtom[h, at];
};
ri: REF INT => {
TokenIO.WriteAtom[h, $DefaultProperty];
TokenIO.WriteAtom[h, a];
TokenIO.WriteInt[h, ri^];
};
pl: CDPrivate.LayerRef => {
TokenIO.WriteAtom[h, $DefaultProperty];
TokenIO.WritePush2[h, a];
TokenIO.WriteAtom[h, $layer];  -- now comes a property list
WriteLayer[h, pl.number];  
TokenIO.WritePop[h];  
};
pl: CD.PropList => {
TokenIO.WriteAtom[h, $DefaultProperty];
TokenIO.WritePush2[h, a];
TokenIO.WriteAtom[h, $properties];  -- now comes a property list
WriteProperties[h, pl];
TokenIO.WritePop[h];  
};
rl: LIST OF Rope.ROPE => {
TokenIO.WriteAtom[h, $DefaultProperty];
TokenIO.WritePush2[h, a];
TokenIO.WriteAtom[h, $ropeList];  -- now comes a rope list
FOR l: LIST OF Rope.ROPE _ rl, l.rest WHILE l#NIL DO
TokenIO.WriteRope[h, l.first];
ENDLOOP;
TokenIO.WritePop[h];  
};
ENDCASE => NULL; 
};
ra: REF ATOM => IF ra^=$MayBeRemoved THEN KillThisProp[h, ra]; 
ENDCASE => NULL; 
ENDLOOP;
};

WriteOrientation: PUBLIC PROC [h: TokenIO.Handle, orientation: CD.Orientation] = {
TokenIO.WriteInt[h, ORD[orientation]];
};

WriteInstance: PUBLIC PROC [h: TokenIO.Handle, inst: CD.Instance] = {
TokenIO.WriteInt[h, inst.trans.off.x];
TokenIO.WriteInt[h, inst.trans.off.y];
TokenIO.WriteInt[h, ORD[inst.trans.orient]];
WriteProperties[h, inst.properties];
WriteObject[h, inst.ob];
};

WriteObject: PUBLIC PROC [h: TokenIO.Handle, ob: CD.Object] = {
WITH CDProperties.GetObjectProp[from: ob, prop: h.clientKey] SELECT FROM
key: REF INT => { 
IF key^<0 THEN {TerminalIO.PutRope["**** circular object dependency\n"]; ERROR};
IF (dotCnt _ dotCnt+1) >= 80 THEN {
dotCnt _ 0; WriteIfNoisy[h, "."]; 
IF (spaceCnt _ spaceCnt+1) >= 30 THEN {spaceCnt_0; WriteIfNoisy[h, " "]}
};
TokenIO.WriteInt[h, key^];
};
ENDCASE => WriteObjectDefinition[h, ob]
};

WriteObjectDefinition: PROC [h: TokenIO.Handle, ob: CD.Object] = {
key: REF INT _ NIL;

WriteTableKey: PROC[h: TokenIO.Handle, ob: CD.Object] = INLINE {
num: REF INT _ NARROW[CDProperties.GetProp[h.properties, $DirectoryCount]];
num^ _ num^+1;
key _ NEW[INT _ -num^]; --a negative key is not yet finished
TokenIO.WriteInt[h, num^];
CDProperties.PutObjectProp[onto: ob, prop: h.clientKey, val: key];
};

design: CD.Design _ DesignInReadOperation[h];
IF (colCnt _ colCnt+1) >= 30 THEN {
colCnt _ 0; WriteIfNoisy[h, ":"]; 
};
IF ob.class.internalWrite=NIL OR (h.truth AND ob.class.supressTruth) THEN {
ob1: CD.Object _ CDDirectory.Expand1[ob, design].new;
IF ob1=NIL THEN ob1 _ CDDirectory.Expand1ByDraw[ob, CDDirectory.LeaveNextLevel].new;
IF ob1=NIL THEN {
TokenIO.WritePush[h, $Unknown];
TokenIO.WritePop[h];
WriteIfNoisy[h, "*object not written\n"];
}
ELSE {
IF h.truth THEN WriteIfNoisy[h, "*"];
WriteObject[h, ob1];
CDProperties.PutObjectProp[onto: ob, prop: h.clientKey, val: CDProperties.GetObjectProp[ob1, h.clientKey]];
};
}
ELSE {
name: Rope.ROPE _ CDDirectory.Name[ob, design];
IF ob.class.atomicOb   
THEN TokenIO.WritePush[h, $Atomic]
ELSE TokenIO.WritePush[h, ob.class.objectType];
IF ob.layer=CD.errorLayer THEN CDProperties.PutPRefProp[h.properties, $errorObject, ob];
IF ob.class.composed THEN {
IF name#NIL THEN TokenIO.WriteRope[h, name];
WriteTableKey[h, ob];
}
ELSE IF name#NIL THEN {
TokenIO.WriteAtom[h, $CDIOUseDir];
TokenIO.WriteRope[h, name];
WriteTableKey[h, ob];
}
ELSE {
num: REF INT _ NARROW[CDProperties.GetProp[h.properties, $SimpleCount]];
IF num^<simpleObjectsInTableMax OR name#NIL THEN {
num^ _ num^+1;
TokenIO.WriteAtom[h, $CDIOUseTable];
WriteTableKey[h, ob];
}; 
};
ob.class.internalWrite[h, ob];
WriteProperties[h, ob.properties];
TokenIO.WritePop[h];
IF key#NIL THEN key^ _ -key^; --finished: make key positive
};
};

WritePushLevel: PROC [h: TokenIO.Handle, pl: LIST OF CD.PushRec] = {
IF pl=NIL THEN RETURN;
WriteIfNoisy[h, "!"];
IF pl.rest#NIL THEN WritePushLevel[h, pl.rest];
TokenIO.WriteAtom[h, $Push];
IF pl.first.mightReplace#NIL 
THEN WriteInstance[h, pl.first.mightReplace]
ELSE TokenIO.WriteAtom[h, $Nil];
WriteObjectDefinition[h, pl.first.dummyCell.ob];
TokenIO.WriteAtom[h, (IF pl.first.specific.changed THEN $T ELSE $F)];
};

EachChildInDir: CDDirectory.EachObjectProc = {
h: TokenIO.Handle _ NARROW[data];
IF me.class.composed OR 
NARROW[CDProperties.GetProp[h.properties, $SimpleCount], REF INT]^<simpleObjectsInTableMax 
THEN {
xx: REF _ CDProperties.GetObjectProp[from: me, prop: h.clientKey];
IF xx#NIL THEN RETURN; -- it and its children are already written
IF me.class.composed THEN 
[] _ CDDirectory.EnumerateChildObjects[me, EachChildInDir, data];
WriteObject[h, me];
};
};

KillThisProp: PROC [h: TokenIO.Handle, ra: REF ATOM] = {
RemoveOldProperties: PROC[design: CD.Design, key: REF] = {
CDDirectoryOps.RemoveProperties[design, key];
};
IF CDProperties.GetPropProp[h.properties, $RemoveAlso, ra] = NIL THEN {
CDProperties.PutPropProp[h.properties, $RemoveAlso, ra, $yes];
WITH h.clientData SELECT FROM
d: CD.Design => RemoveOldProperties[d, ra];
ENDCASE => {};
};
};

KillOldProps: PROC [h: TokenIO.Handle] = {
WITH h.clientKey SELECT FROM
ra: REF ATOM => {
ra^ _ $MayBeRemoved; 
KillThisProp[h, ra]
};
ENDCASE => NULL;
};

DesignNameForFile: PROC [d: CD.Design] RETURNS [Rope.ROPE_NIL] = {
IF Rope.Length[d.name]>0 AND Rope.Fetch[d.name]#'/ AND Rope.Fetch[d.name]#'[ THEN 
RETURN [d.name];
};

TimeStamp: PROC [] RETURNS [Rope.ROPE] = {
RETURN [Convert.RopeFromTime[from: BasicTime.Now[], end: seconds]];
};

OpenStream: PROC [design: CD.Design, to: REF, emergency, quiet: BOOL] RETURNS [stream: IO.STREAM_NIL, mustClose: BOOL_TRUE, name: Rope.ROPE_NIL, created: BasicTime.GMT_ BasicTime.nullGMT] = {
file: FS.OpenFile _ FS.nullOpenFile;
wDir: Rope.ROPE _ CDIO.GetWorkingDirectory[design];
IF Rope.IsEmpty[wDir] THEN wDir _ FileNames.CurrentWorkingDirectory[];
WITH to SELECT FROM
s: IO.STREAM => RETURN [stream_s, mustClose_FALSE, name_NIL];
r: Rope.ROPE => name _ r;
ENDCASE => IF to#NIL THEN {
TerminalIO.PutRope["bad file parameter in WriteDesign\n"]; to _ NIL;
};
IF Rope.IsEmpty[name] THEN {
IF emergency OR quiet 
THEN name _ "///temp/ChipNDale/saved/temporary/temp"
ELSE name _ GetNameInteractively[wDir];
};
name _ CDIO.MakeName[FileNames.StripVersionNumber[name], "dale", wDir];
file _ FS.Create[name: name, keep: 2, wDir: wDir ! 
FS.Error => {
mustClose _ FALSE; file _ FS.nullOpenFile; 
IF ~quiet THEN TerminalIO.PutRopes["file not created: ", error.explanation, "\n"];
IF error.group#bug THEN CONTINUE;
}
];
IF file#FS.nullOpenFile THEN {
name _ FS.GetName[file].fullFName;
IF FS.GetInfo[file].keep=1 THEN FS.SetKeep[FileNames.StripVersionNumber[name], 2];
stream _ FS.StreamFromOpenFile[openFile: file, accessRights: $write, streamOptions: FS.binaryStreamOptions]; 
created _ FS.GetInfo[file].created;
};
IF stream=NIL AND ~quiet THEN TerminalIO.PutRope["file not created\n"];
};

WriteDesign: PUBLIC PROC [design: CD.Design, to: REF, quiet: BOOL, emergency: BOOL, stop: REF BOOL _ NIL, truth: BOOL _ TRUE] RETURNS [done: BOOL_FALSE] = {

InnerWriteDesign: PROC [h: TokenIO.Handle, design: CD.Design] = {
ENABLE UNWIND => KillOldProps[h];

EachDirectoryEntry: CDDirectory.EachObjectProc = {
IF me.class.composed THEN [] _ EachChildInDir[me, h];
};

directoryMark: TokenIO.Mark;
TokenIO.WriteRope[h, DesignNameForFile[design]];
TokenIO.WriteRope[h, TimeStamp[]];
directoryMark _ TokenIO.MarkAndWriteInt[h, 0]; -- number of entries in directory
[] _ CDDirectory.EnumerateDesign[design: design, proc: EachDirectoryEntry];
WriteProperties[h, design.properties^];
WritePushLevel[h, design.actual];
TokenIO.UpdateMark[
h: h, 
mark: directoryMark, 
value: NARROW[CDProperties.GetProp[h.properties, $DirectoryCount], REF INT]^
];
TokenIO.WriteAtom[h, $EndOfDesign];
KillOldProps[h];
};

h: TokenIO.Handle; hadErrors: BOOL;
mustClose: BOOL _ FALSE; created: BasicTime.GMT;
binFile: IO.STREAM; fileName: Rope.ROPE; sealMark: TokenIO.Mark;  
[binFile, mustClose, fileName, created] _ OpenStream[design, to, emergency, quiet];
IF binFile=NIL THEN RETURN;
IF stop=NIL THEN stop _ NEW[BOOL_FALSE];
truth _ truth OR emergency;
h _ TokenIO.CreateWriter[binFile, stop, truth];
h.clientData _ design;
h.clientKey _ NEW[ATOM _ $UsedForIO];
CDProperties.PutProp[h.properties, $DirectoryCount, NEW[INT_0]];
CDProperties.PutProp[h.properties, $SimpleCount, NEW[INT_0]];
CDProperties.PutProp[h.properties, $RemoveAlso, NIL];
CDProperties.PutProp[h.properties, $Noisy, IF quiet THEN NIL ELSE $TRUE];
[] _ CDEvents.ProcessEvent[eventRegistration: beforeOutputEvent, design: design, x: h, listenToDont: FALSE];
TokenIO.WriteInt[h, xChipndaleFile]; 
TokenIO.WriteInt[h, (IF CDEnvironment.preRelease THEN -xVersion ELSE xVersion)];
sealMark _ TokenIO.MarkAndWriteInt[h, 0]; -- invalid seal; it will be fixed at the end
TokenIO.WriteAtom[h, design.technology.key];
TokenIO.WriteRope[h, design.technology.name];
IF CDEvents.ProcessEvent[eventRegistration: writeEvent, design: design, x: h, listenToDont: TRUE].dont THEN {
WriteIfNoisy[h, "output not done\n"];
RETURN
};
InnerWriteDesign[h, design];
TokenIO.UpdateMark[h, sealMark, IF truth THEN -1 ELSE -2]; -- validate seal
WriteIfNoisy[h, "\n"];
hadErrors _ CDProperties.GetPRefProp[h.properties, $errorObject]#NIL; 
TokenIO.Close[h, mustClose];
IF to=NIL AND mustClose THEN {
IF emergency OR quiet THEN {
goodName: Rope.ROPE _ IO.PutFR["///temp/ChipNDale/%01g/%01g.dale",
IO.rope[IF emergency THEN "ShiftShiftSwat" ELSE "Background"],
IO.rope[CDIO.MakeShortName[design]]
];
FS.Rename[from: fileName, to: goodName, wantedCreatedTime: created !
FS.Error => {goodName _ fileName; CONTINUE}
];
fileName _ goodName;
};
};
TerminalIO.PutF["%ldesign %g written on file %g%g%l\n", 
IO.rope[(IF quiet THEN "i" ELSE IF emergency THEN "b" ELSE " ")], 
IO.rope[CD.DesignName[design]], 
IO.rope[fileName], 
IO.rope[IF truth THEN "" ELSE " cache only"],
IO.rope[" "] 
];
IF ~quiet THEN {
CDValue.Store[boundTo: design, key: $CDxLastFile, value: fileName];
[] _ CDEvents.ProcessEvent[afterOutputEvent, design];
IF hadErrors THEN TerminalIO.PutRope["   output includes some error message(s)\n"];
};
IF mustClose THEN design.changedSinceSaving _ FALSE;
done _ TRUE;
};

DesignInReadOperation: PUBLIC PROC [h: TokenIO.Handle] RETURNS [CD.Design] = {
RETURN [NARROW[h.clientData]]
};

writeEvent: CDEvents.EventRegistration = CDEvents.RegisterEventType[$WriteTechnologyPrivate];
beforeOutputEvent: CDEvents.EventRegistration = CDEvents.RegisterEventType[$BeforeOutput];
afterOutputEvent: CDEvents.EventRegistration = CDEvents.RegisterEventType[$AfterOutput];
END.

hCDOut.mesa
Copyright c 1983, 1987 by Xerox Corporation.  All rights reserved.
Created by Christian Jacobi, December 12, 1983 2:02 pm
Last Edited by: Christian Jacobi, November 20, 1987 4:01:56 pm PST

--may raise TerminalIO.UserAbort
--write onto Terminal
--Properties guarantees properties are not reordered; going through list is ok
--object has internalWrite proc
--if due to funny recursion me is now written out: this will write a reference
--at this place we know that CDDirectoryOps will fork and will set the priority down
--Opens the file but does not do any output to it yet
--Makes the messages on failure
--from now on just create a named file...
--we want a keep of 2 or larger
--to is either a IO.STREAM, a Rope.ROPE, or NIL
--if emergency, some locks are ignored, interactive input is skipped; you better 
--roll back after an emergency write is done
Κ˜
codeš
œ
™
Kšœ
Οm
œ7™BKš
œ6™6K™BK™—š
Οk	˜	Kšœ	ž
˜
Kšžœ
˜Kšžœ
˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ	˜	K˜
K˜
Kš
œ˜Kš
œ˜Kš
œ˜Kšœ	ž
˜
Kšžœ
˜Kšžœ
˜K˜Kš
œ˜Kš
œ˜K˜K˜—K˜šΟnœžœ
žœ
˜Kšžœžœžœpžœ4˜Α
Kšžœ
ž˜Kšžœ˜"—Kš
ž˜K˜Kšœžœ˜Kšœ
žœ˜Kšœžœ	˜%K˜Kšœ
žœΟc(˜:Kšœžœ '˜8Kšœžœ (˜8K˜šŸ
œžœ
žœžœ	žœ
žœ˜Ašœžœ#žœ
˜0Kšœžœ
žœžœ
žœžœ
˜?Kš
œ˜—Kš
œ˜—K˜šŸœžœ
žœ
žœžœ
žœ˜NKš
œ ™ Kš
œ!˜!Kšžœžœ&˜AKš
œ&˜&Kšœžœ˜)šžœžœ˜Kš
œ/˜/Kšžœ'žœ
žœ˜IK˜—Kš
œ˜—K˜šŸœžœžœžœ˜?Kš
 ™Kšžœ+žœ
žœ˜LK˜—K˜šŸ
œžœ
žœžœ˜<Kšœžœ˜%Kš
œ˜—K˜šŸœžœ
žœžœ˜=Kš
œ˜Kš
œ˜Kš
œ˜—K˜šŸ	œžœ
žœžœ
˜9Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜—K˜šŸœžœ
žœžœ˜Hšžœžœ
ž˜Kšœžœ'˜,Kšžœžœ
˜—Kšœ '˜8Kš
œN™Nš	žœžœžœžœ
ž˜1šžœ
žœ
ž˜šœžœ˜Kš
œ<˜<š
žœžœ
žœžœ
žœ˜)Kšžœ	žœžœ
žœ
˜)Kšžœ*žœ
žœ
˜6K˜ 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šœ" ˜:š
žœžœ
žœžœžœžœ
ž˜4Kš
œ˜Jšžœ
˜—Kš
œ˜K˜—Kšžœžœ˜—K˜—Kš	œžœ
žœžœžœ˜?Kšžœžœ˜—Kšžœ
˜—Kš
œ˜—K˜šŸœžœ
žœ"žœ˜RKšœžœ˜&Kš
œ˜K˜—šŸ
œžœ
žœžœ˜EKš
œ&˜&Kš
œ&˜&Kšœžœ˜,K˜$K˜Kš
œ˜K˜—šŸœžœ
žœžœ˜?šžœ9žœ
ž˜Hšœžœ
žœ˜Kšžœžœ;žœ˜Pšžœžœ˜#Kš
œ"˜"Kšžœžœ#˜HKš
œ˜—Kš
œ˜K˜—Kšžœ ˜'—Kš
œ˜—K˜šŸœžœžœ˜BKšœž
œ
˜K˜šŸ
œžœžœžœ˜@Kšœžœ
žœžœ6˜KKš
œ˜Kšœžœ
žœ $˜<Kš
œ˜Kš
œB˜BK˜—K˜Kšœžœ#˜-šžœžœ˜#Kš
œ"˜"Kš
œ˜—š
žœžœ
žœ
žœžœ˜KKšœžœ.˜5Kšžœžœ
žœE˜Tšžœžœ
žœ˜Kš
œ˜Kš
œ˜Kš
œ)˜)K˜
—šžœ˜Kšžœ	žœ˜%Kš
œ˜Kš
œk˜kKš
œ˜—Kš
œ
˜
—šžœ˜Kš
œ™Kšœžœ ˜/šžœ˜Kšžœ˜"Kšžœ+˜/—Kšžœ
žœžœ:˜Xšžœžœ˜Kšžœžœ
žœ˜,Kš
œ˜K˜
—šžœ
žœžœ
žœ˜Kš
œ"˜"Kš
œ˜Kš
œ˜Kš
œ
˜
—šžœ˜Kšœžœ
žœžœ3˜Hšžœžœžœ˜2Kš
œ˜Kš
œ$˜$Kš
œ˜Kš
œ˜—Kš
œ˜—Kš
œ˜Kš
œ"˜"Kš
œ˜Kšžœžœ
žœ ˜;K˜—Kš
œ˜—K˜š
Ÿœžœžœ
žœ
žœ
˜DKšžœžœ
žœ
žœ
˜Kš
œ˜Kšžœ	žœ
žœ˜/Kš
œ˜šžœžœ
˜Kšžœ(˜,Kšžœ˜ —Kš
œ0˜0Kšœžœžœžœ˜EKš
œ˜—K˜šŸœ ˜.Kšœžœ˜!š
žœžœžœ3žœ
žœ˜tšžœ˜Kšœžœ;˜BKš	žœžœ
žœ
žœ *˜Ašžœžœ
˜Kš
œA˜A—Kš
œN™NKš
œ˜K˜——Kš
œ˜—K˜šŸœžœžœ
žœ˜8šŸœžœ	žœžœ˜:Kš
 T™TKš
œ-˜-Kš
œ˜—šžœ;žœ
žœ˜GKš
œ>˜>šžœžœ
ž˜Kšœžœ&˜+Kšžœ˜—K˜—Kš
œ˜—K˜šŸœžœ˜*šžœ
žœ
ž˜šœžœ
žœ˜Kš
œ˜Kš
œ˜K˜—Kšžœžœ
˜—J˜—K˜š
Ÿœžœžœ	žœžœ˜Bšžœžœžœžœ
˜RKšžœ
˜—Kš
œ˜—K˜šŸ	œžœžœžœ˜*Kšžœ=˜CKš
œ˜—K˜šŸ
œžœ
žœ
žœžœžœ
žœ
žœ
žœ
žœ
žœ
žœ
žœžœ˜Ώ
Kš
 5™5Kš
 ™Kšœžœžœ˜$Kšœžœžœ˜3Kšžœžœ,˜Fšžœžœ
ž˜Kšœžœ
žœžœžœžœ˜=Kšœžœ
˜šžœžœžœ
žœ˜Kšœ@žœ
˜DKš
œ˜——Kš
 )™)šžœžœ˜šžœžœ˜Kšžœ0˜4Kšžœ#˜'—Kš
œ˜—Kšœžœ<˜Gšœžœ*˜3šžœ˜
Kšœžœ	žœ˜+KšžœžœD˜RKšžœžœ
žœ
˜!Kš
œ
˜
—Kš
œ˜—šžœžœžœ˜Kš
 ™Kšœžœ˜"Kšžœ
žœžœ
žœ0˜RKšœ	žœIžœ˜mKšœ
žœ˜#Kš
œ˜—Kšžœžœ
žœžœ*˜GKš
œ˜—K˜šŸœžœ
žœ
žœ
žœ	žœ
žœžœ
žœžœ	žœ
žœžœžœ
žœ˜œ
K™/Kš
œQ™QKš
œ,™,K˜šŸœžœžœ˜AKšžœ
žœ˜!K˜šŸœ ˜2Kšžœžœ˜5Kš
œ˜—K˜Kš
œ˜Kš
œ0˜0Kš
œ"˜"Kšœ/ !˜PKš
œK˜KKš
œ'˜'Kš
œ!˜!š
œ˜Kš
œ˜Kš
œ˜Kšœžœ6žœ
žœ˜LKš
œ˜—Kš
œ#˜#Kš
œ˜Kš
œ˜—K˜Kšœžœ
˜#Kšœžœ
žœžœ
˜0Kšœ	žœ
žœžœ˜BKš
œS˜SKšžœ	žœ
žœ
žœ
˜Kšžœžœ
žœžœ
žœ
žœ˜(Kšœžœžœ
˜Kš
œ/˜/Kš
œ˜Kšœžœ
žœ˜%Kšœ4žœ
žœ˜@Kšœ1žœ
žœ˜=Kšœ0žœ˜5Kš	œ+žœžœ
žœ
žœ˜IKšœežœ˜lKš
œ%˜%Kšœžœžœžœ˜PKšœ* ,˜VKš
œ,˜,Kš
œ-˜-šžœZžœžœ˜mKš
œ%˜%Kš
ž˜Kš
œ˜—Kš
œ˜Kšœ žœžœžœ ˜KKš
œ˜KšœAžœ˜FKš
œ˜šžœžœ
žœžœ˜šžœžœžœ˜šœžœžœ*˜BKšžœžœžœžœ˜>Kšžœžœ˜#Kš
œ˜—šžœB˜DKšžœ žœ
˜+Kš
œ˜—Kš
œ˜K˜—K˜—š
œ8˜8Kšžœžœžœžœ
žœžœžœ˜BKšžœžœ˜ Kšžœ˜Kšžœžœžœžœ˜-Kšžœ˜
Kš
œ˜—šžœžœ˜Kš
œC˜CKš
œ5˜5KšžœžœB˜SK˜—Kšžœžœžœ
˜4Kšœžœ
˜Kš
œ˜—K˜šŸœžœžœžœ˜NKšžœžœ˜Kš
œ˜K˜—Kš
œ]˜]Kš
œZ˜ZKš
œX˜XKšžœ
˜K˜—…—3tGσ