DIRECTORY
Atom,
BasicTime,
CedarProcess,
CD,
CDEnvironment,
CDEvents USING [EventProc, RegisterEventProc, ProcessEvent, EventRegistration, RegisterEventType],
CDIO,
CDOps USING [DoTheDelayedRedraws],
CDPrivate,
CDProperties,
CDSequencer,
CDSequencerExtras,
IO,
MBQueue USING [Queue, Create, QueueClientAction, Flush],
MessageWindow,
PopUpSelection,
Process,
ProcessProps,
RefTab,
Rope,
RuntimeError USING [UNCAUGHT],
TerminalIO,
TokenIO,
UserProfile;

CDSequencerImpl: CEDAR MONITOR 
IMPORTS Atom, BasicTime, CedarProcess, CD, CDEvents, CDEnvironment, CDIO, CDOps, CDPrivate, CDProperties, IO, MBQueue, MessageWindow, PopUpSelection, Process, ProcessProps, RefTab, Rope, RuntimeError, TerminalIO, TokenIO, UserProfile 
EXPORTS CDSequencer, CDSequencerExtras, CD = 
BEGIN

Message: PROC [r: Rope.ROPE] = {
MessageWindow.Append[r, TRUE];
MessageWindow.Blink[];
};

ErrorChangeReadOnlyDesign: PROC [d: CD.Design_NIL] = TRUSTED {
Process.Detach[FORK 
Message[Rope.Cat["design """, IF d=NIL THEN "" ELSE d.name, """ readonly"]]
];
ERROR CD.Error[designMutability];
};

Command: TYPE = CDSequencer.Command;
CommandProc: TYPE = CDSequencer.CommandProc;
QueueMethod: TYPE = CDSequencer.QueueMethod;

PrivateSequencerDRep: PUBLIC TYPE = RECORD [
queue: MBQueue.Queue,
whileCommand: INT_0, --modifyed by monitored procedures inside single call proc
whileOutput: BOOL_FALSE, --Set monitored, cleared by one single output process
stopWrite: REF BOOL,
abort: BOOL_FALSE,
abortFlags: LIST OF REF BOOL_NIL,
notInit: BOOL_TRUE,
lastCommand: BasicTime.GMT, 
lastOutput: BasicTime.GMT,
num: INT_0
];

PrivateSequencerTRep: PUBLIC TYPE = RECORD [
commandTab: RefTab.Ref
];

Registration: TYPE = REF RegistrationRec;
RegistrationRec: TYPE = RECORD [p: CommandProc, qm: QueueMethod_dontQueue, setWDir: BOOL_FALSE, registrationData: REF_NIL];
InternalRec: TYPE = RECORD [comm: Command, qm: QueueMethod, reg: Registration_NIL];

globalTab: RefTab.Ref = RefTab.Create[mod: 193]; -- holds commands used in all technologies
quit: ERROR [msg: Rope.ROPE] = CODE; --actually is signal, but we never return...
designNumber: INT _ 0;
now: BasicTime.GMT _ BasicTime.Now[]; --lags behind 
savePeriod: INT _ 0;

reCheck: CONDITION _ [timeout: Process.MsecToTicks[1000]];

EnterCommand: ENTRY PROC [x: REF PrivateSequencerDRep] = INLINE {
ENABLE UNWIND => NULL;
x.whileCommand _ x.whileCommand+1;
};

LeaveCommand: ENTRY PROC [x: REF PrivateSequencerDRep] = INLINE {
ENABLE UNWIND => NULL;
x.whileCommand _ x.whileCommand-1;
};

EnterOutput: ENTRY PROC [x: REF PrivateSequencerDRep] RETURNS [enter: BOOL_FALSE] = {
ENABLE UNWIND => NULL;
IF enter_(x.whileCommand=0) THEN {
IF x.stopWrite=NIL THEN x.stopWrite_NEW[BOOL];
x.stopWrite^ _ FALSE;
x.whileOutput _ TRUE
}
};

DesignRegistrationEvent: CDEvents.EventProc = {
data: REF PrivateSequencerDRep _ NEW[PrivateSequencerDRep_[
queue: MBQueue.Create[],
stopWrite: NEW[BOOL_FALSE],
lastCommand: now, 
lastOutput: now, 
num: designNumber
]];
designNumber _ designNumber+1;
design.cdSequencerPriv _ data;
design.cdSequencerPriv.notInit _ FALSE;
};

TechRegistrationEvent: CDEvents.EventProc = {
tech: CD.Technology = NARROW[x];
tech.cdSequencerPriv _ NEW[PrivateSequencerTRep _ [commandTab: RefTab.Create[mod: 41]]]
};

unKnownRegistration: Registration _ NEW[RegistrationRec_[
p: UnKnownCommand,
qm: dontQueue
]]; 

changeReadOnlyRegistration: Registration _ NEW[RegistrationRec_[
p: ChangeReadonlyDesignCommand,
qm: dontQueue
]]; 

UnKnownCommand: PROC [comm: CDSequencer.Command] = {
key: ATOM _ IF comm.key#NIL THEN comm.key ELSE $NIL;
r: Rope.ROPE _ IO.PutFR["command %g not known", [atom[key]]];
Message[r];
TerminalIO.PutRopes[r, "\n"];
};

ChangeReadonlyDesignCommand: PROC [comm: CDSequencer.Command] = {
key: ATOM _ IF comm.key#NIL THEN comm.key ELSE $NIL;
TerminalIO.PutF["command %g tries to change design ""%g"", but design is readonly\n", 
[atom[key]], [rope[CD.DesignName[comm.design]]]
];
};

WriteMsg: PROC [r: Rope.ROPE] = {
IF Rope.Length[r]>0 THEN {
IF Rope.Fetch[r, Rope.Length[r]-1]#'\n THEN r _ Rope.Concat[r, "\n"];
TerminalIO.PutRope[r];
};
};

InternalExec: PROC [ref: REF ANY] = { --type good for MBQueue.QueueClientAction
ENABLE {
ABORTED => {WriteMsg["** ABORTED"]; GOTO Oops};
quit => {WriteMsg[msg]; GOTO Oops};
CD.Error => IF ec=designMutability THEN {
WriteMsg["** aborted try to change readonly design"]; GOTO Oops
};
TerminalIO.UserAbort => {WriteMsg["** aborted interactive input"]; GOTO Oops};
};
ic: REF InternalRec = NARROW[ref];
ExecIcInline: PROC [] = INLINE {
ic.reg.p[ic.comm ! RuntimeError.UNCAUGHT => IF ShouldDebug[LOOPHOLE[signal]] 
THEN REJECT 
ELSE CONTINUE
];
};
ExecIc: PROC = {ExecIcInline[]};
ExecNWDir: PROC [] = INLINE {
IF ~ic.reg.setWDir 
THEN ExecIcInline[] 
ELSE {
wDir: Rope.ROPE ~ CDEnvironment.GetWorkingDirectory[ic.comm.design];
ProcessProps.AddPropList[
propList: LIST[NEW[Atom.DottedPairNode_[$WorkingDirectory, wDir]]],
inner: ExecIc
]
};
};
IF ic.qm=dontQueue THEN ExecNWDir[] 
ELSE {
de: REF PrivateSequencerDRep = ic.comm.design.cdSequencerPriv;

Protected: PROC [de: REF PrivateSequencerDRep] ~ {
ENABLE UNWIND => LeaveCommand[de];
WHILE de.whileOutput DO
stop: REF BOOL _ de.stopWrite;
IF stop#NIL THEN stop^ _ TRUE;
IF de.whileOutput THEN Process.Pause[1]
ENDLOOP;
de.lastCommand _ now;
IF ic.qm=doQueueAndMark THEN {
IF ~ic.comm.design.changedSinceSaving OR ~ic.comm.design.actual.first.specific.changed THEN 
MarkChanged[ic.comm.design
! CD.Error => 
IF ec=designMutability THEN {
ic.reg _ changeReadOnlyRegistration; CONTINUE;
};
];
};
IF Process.GetPriority[]>Process.priorityNormal THEN CedarProcess.SetPriority[CedarProcess.Priority[normal]];
de.abort _ FALSE;
ExecNWDir[];
de.abortFlags _ NIL;
LeaveCommand[de]
};-- Protected

IF de=NIL THEN ERROR CD.Error[programming];
EnterCommand[de];
Protected[de];
};
CDOps.DoTheDelayedRedraws[ic.comm.design];
EXITS Oops => NULL
};

ShouldDebug: PROC [signal: SIGNAL ANY RETURNS ANY] RETURNS [debug: BOOL_TRUE] = {
WITH CDProperties.GetAtomProp[$CDDebugPrivate, $CDDebugPrivate] SELECT FROM
rs: REF SIGNAL ANY RETURNS ANY => IF signal=rs^ THEN RETURN [TRUE];
ENDCASE => NULL;
IF UserProfile.Boolean["ChipNDale.OpenEventViewers", FALSE] THEN RETURN [TRUE];
DO
SELECT PopUpSelection.Request[
header: "ERROR", 
choice: LIST["continue with ChipNDale", "debug"], 
headerDoc: "error while executing ChipNDale command", 
choiceDoc: LIST["usually ok", "land in debugger (abort will continue ChipNDale)"]
] FROM
1 => RETURN [FALSE];
2 => RETURN [TRUE];
ENDCASE => NULL;
TerminalIO.PutRope["don't skip this!\n"];
ENDLOOP
};

Quit: PUBLIC PROC [message: Rope.ROPE] = {
ERROR quit[message]
};

RegisterCommand: PUBLIC ENTRY PROC [key: ATOM, proc: CommandProc, technology: CD.Technology, queue: QueueMethod, setWDir: BOOL_TRUE, registrationData: REF_NIL] = {
ENABLE UNWIND => NULL; 
table: RefTab.Ref _ globalTab;
IF technology#NIL THEN table _ technology.cdSequencerPriv.commandTab;
[] _ RefTab.Store[table, key, NEW[RegistrationRec _ [p: proc, qm: queue, registrationData: registrationData, setWDir: setWDir]]];
};

ImplementCommand: PUBLIC PROC [key: ATOM, proc: CommandProc, technology: CD.Technology, queue: QueueMethod, registrationData: REF_NIL] = {
RegisterCommand[key, proc, technology, queue, FALSE, registrationData];
};

FetchRegistration: PROC [key: ATOM, technology: CD.Technology, load: BOOL_TRUE] RETURNS [reg: Registration] = {

Fetch: PROC[key: ATOM, technology: CD.Technology] RETURNS [reg: Registration] = INLINE {
IF technology#NIL THEN { -- search first for particular technology
cTab: REF PrivateSequencerTRep = technology.cdSequencerPriv;
val: RefTab.Val _ RefTab.Fetch[cTab.commandTab, key].val;
IF val#NIL THEN RETURN [NARROW[val]];
};
RETURN [NARROW[RefTab.Fetch[globalTab, key].val]];
};

reg _ Fetch[key, technology];
IF reg=NIL AND load THEN {
CDEnvironment.ExecFileEntry[Atom.GetPName[key], technology, "cmds", FALSE, FALSE !
ABORTED => CONTINUE;
RuntimeError.UNCAUGHT => 
SELECT PopUpSelection.Request[
header: "ERROR", 
choice: LIST["continue with ChipNDale", "debug"], 
headerDoc: "error while executing command file", 
choiceDoc: LIST["usually ok", "land in debugger (abort will continue ChipNDale)"]
] FROM
1 => CONTINUE;
2 => REJECT;
ENDCASE => CONTINUE;
];
reg _ Fetch[key, technology];
};
};

FetchCommand: PUBLIC PROC[key: ATOM, technology: CD.Technology, load: BOOL_TRUE] RETURNS [proc: CommandProc_NIL, qm: QueueMethod_dontQueue, registrationData: REF_NIL] = {
reg: Registration _ FetchRegistration[key, technology, load];
IF reg#NIL THEN {proc_reg.p; qm_reg.qm; registrationData_reg.registrationData};
};

Call: PROC [ic: REF InternalRec] = INLINE {
IF ic.qm=useDefault THEN ic.qm _ ic.reg.qm;
IF ic.qm=dontQueue THEN InternalExec[ic]   
ELSE { 
WHILE ic.comm.design.cdSequencerPriv.notInit DO
WaitInitialization[ic.comm.design.cdSequencerPriv]
ENDLOOP;
MBQueue.QueueClientAction[ic.comm.design.cdSequencerPriv.queue, InternalExec, ic]
}
};

ExecuteProc: PUBLIC PROC [proc: CommandProc, design: CD.Design, queue: QueueMethod, comm: CDSequencer.Command] = {
ic: REF InternalRec _ NEW[InternalRec_[
comm: NEW[CDSequencer.CommandRec],
reg: NEW[RegistrationRec_[p: IF proc=NIL THEN UnKnownCommand ELSE proc]],
qm: queue
]];
IF comm#NIL THEN ic.comm^ _ comm^;
IF design#NIL THEN ic.comm.design _ design;
Call[ic]
};

ExecuteCommand: PUBLIC PROC [key: ATOM, design: CD.Design, queue: QueueMethod, comm: CDSequencer.Command] = {
ic: REF InternalRec _ NEW[InternalRec_[
comm: NEW[CDSequencer.CommandRec],
qm: queue
]];
IF comm#NIL THEN ic.comm^ _ comm^;
IF key#NIL THEN ic.comm.key _ key;
IF design#NIL THEN ic.comm.design _ design;
ic.reg _ FetchRegistration[ic.comm.key, ic.comm.design.technology, TRUE];
IF ic.reg=NIL THEN ic.reg _ unKnownRegistration; 
Call[ic]
};

RecheckEdited: PROC [design: CD.Design] = {
[] _ CDEvents.ProcessEvent[recheckEditedRequest, design];
};

SetEdited: PUBLIC PROC [design: CD.Design, edited: BOOL] = {
was: BOOL _ design.edited;
IF edited THEN IF design.mutability#editable THEN ErrorChangeReadOnlyDesign[design];
design.edited _ edited;
IF was#edited THEN RecheckEdited[design];
};

MarkChangedIOOnly: PUBLIC PROC [design: CD.Design] = {
IF ~design.actual.first.specific.changed OR ~design.changedSinceSaving THEN {
IF design.mutability#editable THEN ErrorChangeReadOnlyDesign[design];
design.changedSinceSaving _ TRUE;
design.edited _ TRUE;
TRUSTED {Process.Detach[FORK RecheckEdited[design]]};
}
};

MarkChanged: PUBLIC PROC [design: CD.Design] = {
IF ~design.actual.first.specific.changed OR ~design.changedSinceSaving THEN {
IF design.mutability#editable THEN ErrorChangeReadOnlyDesign[design];
design.actual.first.specific.changed _ TRUE;
design.changedSinceSaving _ TRUE;
design.edited _ TRUE;
TRUSTED {Process.Detach[FORK RecheckEdited[design]]};
}
};

WaitInitialization: ENTRY PROC [sPriv: REF PrivateSequencerDRep] = {
IF sPriv=NIL OR sPriv.notInit THEN WAIT reCheck
};


AbortDesignsCommand: PUBLIC PROC [design: CD.Design, flush: BOOL] = {
IF design=NIL THEN [] _ CDEvents.ProcessEvent[abortRequest, NIL]
ELSE {
de: REF PrivateSequencerDRep = design.cdSequencerPriv;
de.abort _ TRUE;
FOR bl: LIST OF REF BOOL _ de.abortFlags, bl.rest WHILE bl#NIL DO
IF bl.first#NIL THEN bl.first^_TRUE
ENDLOOP;
[] _ CDEvents.ProcessEvent[abortRequest, design];
IF flush THEN MBQueue.Flush[de.queue];
};
};

Aborted: PUBLIC PROC [design: CD.Design] RETURNS [BOOL] = {
RETURN [design.cdSequencerPriv.abort]
};

CheckAborted: PUBLIC PROC [design: CD.Design] = {
IF design.cdSequencerPriv.abort THEN Quit["command aborted"];
CedarProcess.CheckAbort[NIL];
};
UseAbortFlag: PUBLIC PROC [design: CD.Design, flag: REF BOOL] = {
IF design=NIL OR flag=NIL THEN ERROR CD.Error[calling];
design.cdSequencerPriv.abortFlags _ CONS[flag, design.cdSequencerPriv.abortFlags];
};

BackgroundSaveProcess: PROC = {

ProtectedSaveOneDesign: PROC [design: CD.Design] = {
de: REF PrivateSequencerDRep = design.cdSequencerPriv;
done: BOOL _ FALSE;
done _ CDIO.WriteDesign[design: design, to: NIL, quiet: TRUE, emergency: FALSE, stop: de.stopWrite ! TokenIO.Stopped, RuntimeError.UNCAUGHT => GOTO oops];
IF done THEN {
de.lastOutput _ BasicTime.Now[]; 
design.changedSinceSaving _ FALSE;
}
EXITS oops => NULL;
};

CheckDesignForSave: CDPrivate.DesignEnumerator = {
ENABLE RuntimeError.UNCAUGHT => GOTO oops; --give the next design a chance
Process.Pause[1]; -- little bit slower for the benefit of the viewer redraw
IF design#NIL THEN {
de: REF PrivateSequencerDRep = design.cdSequencerPriv; 
IF design.changedSinceSaving AND de#NIL AND de.whileCommand=0 AND BasicTime.Period[from: de.lastCommand, to: now]>2 AND BasicTime.Period[from: de.lastOutput, to: de.lastCommand]>savePeriod AND CDProperties.GetDesignProp[design, $CDxDontBackgroundSave]#$TRUE THEN {
IF EnterOutput[de] THEN  
ProtectedSaveOneDesign[design ! RuntimeError.UNCAUGHT => CONTINUE];
de.whileOutput _ FALSE;
CedarProcess.SetPriority[CedarProcess.Priority[background]]; --speed no more necessary
};
};
EXITS oops => NULL;
};

DO -- forever
now _ BasicTime.Now[]; Process.Pause[Process.SecondsToTicks[8]];
IF savePeriod>=0 THEN [] _ CDPrivate.EnumDesigns[CheckDesignForSave]
ENDLOOP;
};

NoteProfileChange: UserProfile.ProfileChangedProc = {
savePeriod _ UserProfile.Number[key: "ChipNDale.SavePeriod", default: 0];
}; 

abortRequest: CDEvents.EventRegistration = CDEvents.RegisterEventType[$Abort];
recheckEditedRequest: CDEvents.EventRegistration = CDEvents.RegisterEventType[$CheckEdited];
CDEvents.RegisterEventProc[$RegisterTechnology, TechRegistrationEvent];
CDEvents.RegisterEventProc[$CreateNewDesign, DesignRegistrationEvent];
UserProfile.CallWhenProfileChanges[NoteProfileChange];
TRUSTED {Process.Detach[FORK BackgroundSaveProcess[]]};
END. 



šCDSequencerImpl.mesa   (part of ChipNDale)
Copyright c 1983, 1986, 1987 by Xerox Corporation.  All rights reserved.
Created by Christian Jacobi, June 22, 1983 6:02 pm 
Last edited by: Christian Jacobi, June 15, 1987 12:44:47 pm PDT
--Message r on Message window 

--not monitored: is called from inside a command
--CedarProcess.SetPriority[CedarProcess.Priority[normal]]; --so stops quickly if necessary
Κ’˜
codeš
œ*™*Kšœ
Οm
œ=™HKš
œ3™3K™?K˜—š
Οk	˜	K˜Kš
œ
˜
Kš
œ
˜
Kšžœ
˜Kš
œ˜Kšœ	žœT˜bKš
œ˜Kšœžœ˜"Kš
œ
˜
Kš
œ
˜
Kš
œ˜Kš
œ˜Kš
œ˜Kšœžœ+˜8Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ
˜
Kš
œ˜Kš
œ˜Kšœ
žœžœ˜Kš
œ˜Kš
œ˜Kš
œ˜—K˜šΟbœžœ
žœ
˜Kšžœ;žœ žœ~˜κ
Kšžœ!žœ˜-—Kš
ž˜K˜šΟnœžœ
žœ˜ K™Kšœžœ˜Kš
œ˜K˜—K˜š
 œžœžœžœžœ˜>šœžœ
˜Kš	œžœžœ
žœžœ˜KKš
œ˜—Kšžœ
žœ˜!Kš
œ˜K˜—Kšœ	žœ˜$Kšœ
žœ˜,Kšœ
žœ˜,K˜šœžœžœ˜,Kš
œ˜KšœžœΟc:˜OKšœ
žœ
žœ‘5˜NKšœžœ
žœ
˜Kšœžœ
žœ
˜Kšœžœ
žœ
žœ
žœ
žœ
˜!Kšœ	žœ
žœ
˜Kšœžœ˜Kšœžœ
˜Kšœžœ˜
Kš
œ˜—K˜šœžœ
žœžœ˜,K˜K˜—K˜Kšœžœžœ˜)Kš
œžœžœ6žœ
žœžœ
žœ˜{Kšœ
žœžœ4žœ˜SK˜Kšœ1‘*˜[Kšœžœžœžœ‘,˜QKšœžœ˜Kšœžœ‘˜4Kšœžœ˜K˜Kšœ	ž	œ(˜:K˜š
 œžœ
žœžœžœ˜AKšžœ
žœžœ
˜Kš
œ"˜"K˜—K˜š
 œžœ
žœžœžœ˜AKšžœ
žœžœ
˜Kš
œ"˜"K˜—K˜š œžœ
žœžœžœ	žœ
žœ˜UKšžœ
žœžœ
˜šžœžœ˜"Kš
žœ
žœ
žœ
žœ
žœ˜.Kšœžœ
˜Kšœž˜K˜
—K˜—K˜šΠbnœ˜/šœžœžœ˜;Kš
œ˜Kšœžœ
žœ
žœ˜Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ˜—Kš
œ˜Kš
œ˜Kšœ!žœ
˜'Kš
œ˜—K˜šŸœ˜-Kšœžœžœ˜ Kšœžœ=˜WKš
œ˜—K˜šœ$žœ˜9Kš
œ˜Kš
œ
˜
Kš
œ˜—K˜šœ+žœ˜@Kš
œ˜Kš
œ
˜
Kš
œ˜—K˜š œžœ ˜4Kšœžœžœ
žœ
žœ
žœ˜4Kšœžœžœ,˜=Kš
œ˜Kš
œ˜Kš
œ˜—K˜š œžœ ˜AKšœžœžœ
žœ
žœ
žœ˜4š
œV˜VKš
œ/˜/Kš
œ˜—Kš
œ˜—K˜š œžœ
žœ˜!šžœžœ˜Kšžœ%žœ˜EKš
œ˜Kš
œ˜—K˜—K˜š	 œžœžœ
žœ‘)˜Ošžœ˜Kšžœžœ˜/Kšœžœ˜#šžœ
žœžœ˜)Kšœ6žœ˜?Kš
œ˜—KšœCžœ˜NKš
œ˜—Kšœžœžœ˜"š œžœžœ˜ šœ žœžœ
žœ
˜MKšžœ
žœ
˜Kšžœ
ž˜
Kš
œ˜—K˜—Kš œžœ˜ š 	œžœžœ˜šžœ˜Kšžœ˜šžœ˜Kšœžœ5˜Dš
œ˜Kšœ
žœ
žœ1˜CKš
œ
˜
K˜
—Kš
œ˜——K˜—Kšžœžœ
˜$šžœ˜Kšœžœ7˜>K˜š 	œžœžœ˜2Kšžœ
žœ˜"šžœž˜Kšœžœ
žœ˜Kšžœžœ
žœ	žœ
˜Kšžœžœ˜'Kšžœ
˜—Kš
œ˜šžœžœ˜šžœ$žœ/žœ
˜\š
œ˜šœžœ
˜šžœžœ˜Kšœ%žœ
˜.K˜——Kš
œ˜——Kš
œ˜—Kšžœ.žœ9˜mKšœžœ
˜Kš
œ˜Kšœžœ
˜Kš
œ˜Kšœ‘˜—K˜Kš
žœžœ
žœ
žœ
žœ˜+Kš
œ˜Kš
œ˜Kš
œ˜—Kš
œ*˜*Kšžœ	ž˜Kš
œ˜—K˜š œžœ
žœ
žœ
žœ
žœžœ	žœ
žœ˜Qšžœ<žœ
ž˜KKšœžœ
žœ
žœ
žœ
žœžœžœ
žœžœ˜CKšžœžœ
˜—Kš
žœ3žœžœ
žœžœ˜Oš
ž˜šžœ˜Kš
œ˜Kšœžœ&˜2Kš
œ6˜6KšœžœB˜QKšœž˜Kšœžœžœ˜Kšœžœžœ˜Kšžœžœ
˜—K˜)Kš
ž˜—Kš
œ˜—K˜š œžœ
žœžœ˜*Kšžœ˜Kš
œ˜—K˜š œžœ
žœ
žœžœ!žœ*žœ
žœžœ
žœ˜£
Kšžœ
žœžœ˜Kš
œ˜Kšžœžœ
žœ/˜EKšœžœ`˜
Kš
œ˜—K˜š œžœ
žœžœ!žœ3žœ
žœ˜Š
Kšœ.žœ˜GKš
œ˜—K˜š œžœžœžœžœ
žœžœ˜oK˜š œžœžœžœ
žœžœ˜Xšžœžœ
žœ‘)˜BKšœžœ3˜<Kš
œ9˜9Kš
žœžœ
žœ
žœžœ˜%Kš
œ˜—Kšžœžœ$˜2Kš
œ˜—K˜Kš
œ˜šžœžœ
žœžœ˜šœDžœžœ˜RKšžœžœ
˜šœ
žœ˜šžœ˜Kš
œ˜Kšœžœ&˜2Kš
œ1˜1KšœžœB˜QKšœž˜Kšœžœ
˜Kšœžœ
˜Kšžœžœ
˜——Kš
œ˜—Kš
œ˜K˜—K˜—K˜š œžœ
žœžœžœžœ
žœžœžœ/žœ
žœ˜ͺ
Kš
œ=˜=Kšžœžœ
žœ@˜OKš
œ˜—K˜š œžœžœžœ˜+Kšžœžœ˜+Kšžœžœ˜+šžœ˜šžœ(ž˜/Kš
œ2˜2Kšžœ
˜—Kš
œQ˜QK˜
—K˜—K˜š œžœ
žœžœ;˜ršœžœžœ˜'Kšœžœ˜"Kšœžœžœžœ
žœžœ˜IKš
œ	˜	Kš
œ˜—Kšžœžœ
žœ˜"Kšžœžœ
žœ˜+Kš
œ˜Kš
œ˜—K˜š
 œžœ
žœžœ
žœ;˜mšœžœžœ˜'Kšœžœ˜"Kš
œ	˜	Kš
œ˜—Kšžœžœ
žœ˜"Kšžœžœ
žœ˜"Kšžœžœ
žœ˜+KšœCžœ˜IKšžœžœ
žœ˜1Kš
œ˜Kš
œ˜—K˜š 
œžœ
žœ˜+Kš
œ9˜9K˜—K˜š
 	œžœ
žœ
žœžœ˜<Kšœžœ˜Kšžœžœ
žœžœ#˜TKš
œ˜Kšžœžœ˜)K˜—K˜š œžœ
žœ
žœ˜6šžœ'žœžœ˜MKšžœžœ#˜EKšœž˜!Kšœž˜Kšžœžœ˜5K˜
—Kš
œ˜—K˜š œžœ
žœ
žœ˜0šžœ'žœžœ˜MKšžœžœ#˜EKšœ'ž˜,Kšœž˜!Kšœž˜Kšžœžœ˜5K˜
—Kš
œ˜—K˜š œžœ
žœ	žœ˜DKš
žœžœ
žœžœ
žœ˜/Kš
œ˜—K˜K˜š
’œžœ
žœ
žœžœ˜EKšžœžœ
žœ*žœ
˜@šžœ˜Kšœžœ/˜6Kšœžœ
˜šžœžœ
žœ
žœ
žœžœžœ
ž˜AKšžœ
žœ
žœž˜#Kšžœ
˜—Kš
œ1˜1Kšžœžœ˜&K˜—Kš
œ˜—K˜š œžœ
žœ
žœ	žœžœ˜;Kšžœ˜%Kš
œ˜—K˜š œžœ
žœ
žœ˜1Kšžœžœ˜=Kšœžœ˜Kš
œ˜K™—š
 œžœ
žœžœ
žœ˜AKš
œ0™0Kšžœžœ
žœžœ
žœ
žœ
žœ˜7Kšœ$žœ*˜RK˜—K˜š œžœ˜K˜š œžœ
žœ˜4Kšœžœ/˜6Kšœžœžœ
˜Kš
œžœ!žœ	žœ
žœ5žœžœ˜š
šžœžœ˜Kš
œ!˜!Kšœžœ
˜"Kš
œ
˜
—Kšžœ	žœ
˜Kš
œ˜K˜—š œ ˜2Kšžœžœžœ‘˜JKšœ‘9˜Kšžœžœ
žœ˜Kšœžœ0˜7šžœžœžœ
žœžœ3žœFžœBžœ˜ˆKšœ;‘™Zšžœžœ
˜Kšœ-žœžœ˜C—Kšœžœ
˜Kšœ=‘˜VK˜—Kš
œ˜—Kšžœ	žœ
˜Kš
œ˜—K˜šžœ
‘
˜
Kš
œ@˜@Kšžœžœ/˜DKšžœ
˜—Kš
œ˜—K˜šŸœ$˜5Kš
œI˜IKš
œ˜—K˜Kš
œN˜NKš
œ\˜\Kš
œG˜GKš
œF˜FKš
œ6˜6Kšžœžœ˜7Kšžœ˜K˜K˜—…—5tI