DIRECTORY
AMBridge USING [FHFromTV, GetWorld, RemoteFHFromTV, TVForReferent, TVForSignal, TVForType, TVToCardinal, TVToLI],
AMEvents USING [BootedNotifier, BreakAfter, BreakAt, BreakID, ClearBreak, DuplicateBreakpoint, Event, EventProc, GetEvents, NextBreak, Outcome, RegisterBootedNotifier, StopEvents, UnRegisterBootedNotifier],
AMMiniModel USING [GetInterfaceRecord],
AMModel USING [Context, ContextName, ContextWorld, MostRecentNamedContext, ParentSection, RootContext, Section, SectionClass, SectionSource, Source],
AMModelBridge USING [ContextForFrame],
AMModelLocation USING [EntryLocations],
AMTypes USING [DynamicParent, Error, GetEmptyTV, TV, TVToName, TVType, Type, TypeClass],
AMViewerOps USING [ReportProc, SectionFromSelection, SourceFromTV, ViewerFromSection],
Atom USING [GetPropFromList],
BackStop USING [Call],
CedarProcess USING [DoWithPriority],
Commander USING [CommandObject, CommandProc, Handle, Register],
EvalQuote USING [EvalQuoteProc, Register],
FileViewerOps USING [OpenSource],
Interpreter USING [AbortProc, Evaluate],
InterpreterOps USING [Eval, GetArg, RegisterTV, Tree, TreeToName, WorldFromHead],
InterpreterToolPrivate USING [Break, BreakIndex, BreakObject, Handle, InterpreterObject, nullBreakIndex],
IO USING [Close, GetLineRope, Put, PutChar, PutF1, PutFR1, PutRope, Reset, RopeFromROS, ROS, STREAM],
List USING [AList, PutAssoc],
MBQueue USING [Create, CreateMenuEntry, Queue],
Menus USING [ChangeNumberOfLines, InsertMenuEntry, Menu, MenuProc],
PrincOps USING [BytePC],
PrintTV USING [Print, PrintArguments, PrintSignal, PrintType, PrintVariables],
Process USING [Detach, GetCurrent],
ProcessProps USING [AddPropList, GetPropList],
Rope USING [Cat, Concat, Fetch, IsEmpty, Length, ROPE, Substr],
RuntimeError USING [UNCAUGHT],
SafeStorage USING [NarrowRefFault],
SymTab USING [Create, Fetch, Ref],
TiogaOps USING [GetSelection, LastLocWithin, SelectPoint, ViewerDoc],
TypeScript USING [Create, Destroy, TS],
ViewerClasses USING [Viewer],
ViewerEvents USING [EventProc, RegisterEventProc],
ViewerIO USING [CreateViewerStreams],
ViewerOps USING [AddProp, EstablishViewerPosition, FetchProp, OpenIcon, PaintViewer],
UserProfile USING [Boolean, CallWhenProfileChanges, ProfileChangedProc],
WorldVM USING [GetWorld, LocalWorld, World, WorldName];

InterpreterToolImpl: CEDAR MONITOR  -- protects individual interpreters
LOCKS h.LOCK USING h: Handle
IMPORTS AMBridge, AMEvents, AMMiniModel, AMModel, AMModelBridge, AMModelLocation, AMTypes, AMViewerOps, Atom, BackStop, CedarProcess, Commander, EvalQuote, FileViewerOps, Interpreter, InterpreterOps, IO, List, MBQueue, Menus, PrintTV, Process, ProcessProps, Rope, RuntimeError, SafeStorage, SymTab, TiogaOps, TypeScript, UserProfile, ViewerEvents, ViewerIO, ViewerOps, WorldVM
EXPORTS InterpreterToolPrivate  -- nextBI
= BEGIN OPEN Interpreter, Rope;

TV: TYPE = AMTypes.TV;
Type: TYPE = AMTypes.Type;

Handle: TYPE = InterpreterToolPrivate.Handle;  -- one per viewer
InterpreterObject: TYPE = InterpreterToolPrivate.InterpreterObject;

BreakIndex: TYPE = InterpreterToolPrivate.BreakIndex;
nullBreakIndex: BreakIndex = InterpreterToolPrivate.nullBreakIndex;

nextBI: PUBLIC BreakIndex _ 1;  -- BEWARE that these guys aren't protected
dormantH: Handle _ NIL;

BreakObject: TYPE = InterpreterToolPrivate.BreakObject;
Break: TYPE = InterpreterToolPrivate.Break;

NewInterpreter: Commander.CommandProc = TRUSTED {
Process.Detach[LOOPHOLE[FORK CreateTool[NIL--no event--], PROCESS]];
};

CreateTool: PROC [event: AMEvents.Event] RETURNS [outcome: AMEvents.Outcome] = TRUSTED {
h: Handle;
context: AMModel.Context =
IF event = NIL
THEN AMModel.RootContext[WorldVM.LocalWorld[]]
ELSE AMModelBridge.ContextForFrame[event.frame];
remoteWorld: WorldVM.World _ NIL;
inner: PROC = TRUSTED {
IF context = NIL THEN ERROR;
IF WorldVM.LocalWorld[] # AMModel.ContextWorld[context] THEN
remoteWorld _ AMModel.ContextWorld[context];
IF dormantH = NIL
THEN {
h _ NEW[
InterpreterObject
_ [remoteWorld: remoteWorld,
 context: context,
 event: event,
 menuHitQueue: MBQueue.Create[], 
 symTab: SymTab.Create[],
 readEvalPrintProcess: LOOPHOLE[Process.GetCurrent[]]]];
NewViewer[h];
}
ELSE {
name: ROPE _ NIL;
h _ dormantH;  -- NOTE unmonitored
dormantH _ NIL;
h.remoteWorld _ remoteWorld;
h.context _ context;
h.event _ event;
h.readEvalPrintProcess _ LOOPHOLE[Process.GetCurrent[]];
IF h.event # NIL
THEN {
IF h.event.world # WorldVM.LocalWorld[] THEN name _ "WORLDSWAP ";
name _ Cat[name, "Event: ", EventToName[h.event]];
}
ELSE name _ Rope.Concat["Interp: ", AMModel.ContextName[h.context]];
h.ts.name _ name;
IF h.ts.iconic THEN ViewerOps.OpenIcon[h.ts];
IF h.event # NIL THEN ChangeLines[h.ts, 2] ELSE ChangeLines[h.ts, 1];
h.tsOutStream.PutRope[Rope.Concat[name, "\n"]];
};
IF remoteWorld # NIL THEN
AMEvents.RegisterBootedNotifier[BootReturnRequested, remoteWorld, h];
outcome _ MainLoop[h];
IF remoteWorld # NIL THEN
AMEvents.UnRegisterBootedNotifier[BootReturnRequested, remoteWorld, h];
};
CedarProcess.DoWithPriority[normal, inner];
};

EventHandler: AMEvents.EventProc = TRUSTED {
h: Handle _ NIL;
nestingLevel: NAT;  -- that of saved interp status
context: AMModel.Context = AMModelBridge.ContextForFrame[event.frame];

[h, nestingLevel] _ FindInProgressEvaluation[];
IF h # NIL AND h.nestingLevel = nestingLevel
THEN {  -- if this event is "under" an interpreter
oldRemoteWorld: WorldVM.World = h.remoteWorld;  -- save remoteWorld;
oldContext: AMModel.Context = h.context;  -- save context;
oldGlobalContext: AMModel.Context = h.globalContext;  -- save globalContext;
oldEvent: AMEvents.Event = h.event;  -- save event;
oldName: ROPE = h.ts.name;  -- save viewer name;
newName: ROPE _ NIL;
IF event.world # WorldVM.LocalWorld[] THEN newName _ "WORLDSWAP ";
newName _ Cat[newName, "Event: ", EventToName[event]];
IO.PutF1[h.tsOutStream, "***Nesting this InterpreterTool to be a handler for %g\n", [rope[newName]] ];
IF oldEvent = NIL THEN ChangeLines[h.ts, 2];
IF oldRemoteWorld = NIL
THEN
h.remoteWorld
_ IF WorldVM.LocalWorld[] = AMModel.ContextWorld[context]
THEN NIL
ELSE AMModel.ContextWorld[context]
ELSE {
IF WorldVM.LocalWorld[] # AMModel.ContextWorld[context]
AND oldRemoteWorld # AMModel.ContextWorld[context]
THEN ERROR;
};
h.context _ context;
h.globalContext _ NIL;
h.event _ event;
h.ts.name _ newName;
ViewerOps.PaintViewer[h.ts, caption];
h.nestingLevel _ h.nestingLevel + 1;
IF oldRemoteWorld = NIL AND h.remoteWorld # NIL THEN
AMEvents.RegisterBootedNotifier[BootReturnRequested, h.remoteWorld, h];
outcome _ MainLoop[h];

IF oldRemoteWorld = NIL AND h.remoteWorld # NIL THEN
AMEvents.UnRegisterBootedNotifier
[BootReturnRequested, h.remoteWorld, h];
h.ts.name _ oldName;
h.nestingLevel _ h.nestingLevel - 1;
h.event _ oldEvent;
h.globalContext _ oldGlobalContext;
h.context _ oldContext;
h.remoteWorld _ oldRemoteWorld;
ViewerOps.PaintViewer[h.ts, caption];
IF oldEvent = NIL THEN ChangeLines[h.ts, 1];
}
ELSE outcome _ CreateTool[event]; -- if this event is not "under" an interpreter
};

NewViewer: PROC [h: Handle] = {
name: ROPE _ NIL;
LocalRegister: PROC [name: ROPE, ref: REF, help: ROPE] = TRUSTED {
ENABLE AMTypes.Error => GO TO err;
InterpreterOps.RegisterTV[
name: name, tv: AMBridge.TVForReferent[ref],	help: help, symTab: h.symTab
];
EXITS err => {
IO.PutF1[h.tsOutStream, "** Failed to register %g\n", [rope[name]]];
};
};
TRUSTED {
IF h.event # NIL
THEN {
IF h.event.world # WorldVM.LocalWorld[] THEN name _ "WORLDSWAP ";
name _ Cat[name, "Event: ", EventToName[h.event]];
}
ELSE name _ Rope.Concat["Interp: ", AMModel.ContextName[h.context]];
};
h.ts _ TypeScript.Create[info: [name: name, column: right, iconic: FALSE]];
CreateInterpreterMenu[h];
ViewerOps.AddProp[h.ts, $InterpreterHandle, h];
[h.tsInStream, h.tsOutStream] _ ViewerIO.CreateViewerStreams[name: NIL, viewer: h.ts];
h.tsOutStream.PutRope[Rope.Concat[name, "\n"]];
LocalRegister[
"&H", NEW[Handle _ h], "this interpretertool's handle"];
LocalRegister[
"&depth", NEW[INT _ 4], "printing depth for this interpretertool"];
LocalRegister[
"&width", NEW[INT _ 32], "printing width for this interpretertool"];
LocalRegister[
"&WalkStack", NEW[PROC [nFrames: INT _ 1, h: Handle _ NIL] _ WalkStack],
"set a local frame context (eventhandler)"];
LocalRegister[
"&slf", NEW[PROC [nFrames: INT _ 1, h: Handle _ NIL] _ WalkStack],
"set a local frame context (eventhandler)"];
LocalRegister[
"&Proceed", NEW[PROC [h: Handle _ NIL] _ SetProceedRequested],
"proceed the current event"];
LocalRegister[
"&Abort", NEW[PROC [h: Handle _ NIL] _ SetStopRequested],
"abort the current event"];
LocalRegister[
"&ShowFrame", NEW[PROC [h: Handle _ NIL] _ ShowFrame],
"show the current lf context (eventhandler)"];
LocalRegister[
"&Source", NEW[PROC [h: Handle _ NIL] _ Source],
"show source loc of current lf context (eventhandler)"];
LocalRegister[
"&SetBreak", NEW[PROC [h: Handle _ NIL, exit: BOOL _ FALSE] _ SetBreak],
"set break at selected source loc (eventhandler)"];
LocalRegister[
"&ClearBreak",
NEW[PROC [h: Handle _ NIL, breakIndex: BreakIndex _ nullBreakIndex] _ ClearBreak],
"clear specified break"];
LocalRegister[
"&ClearAllBreaks",
NEW[PROC [h: Handle _ NIL] _ ClearAllBreaks],
"clear all breaks"];
LocalRegister[
"&ListBreaks",
NEW[PROC [h: Handle _ NIL] _ ListBreaks],
"list all breaks"];

EvalQuote.Register["&sgf", SetGlobalFrameHelper, h.symTab, h]; 
LocalRegister[
"&sgf",
NEW[PROC [progName: ROPE, h: Handle _ NIL] _ SetGlobalFrameContext],
"&sgf[rope]\tset context to be that for the given module"];

EvalQuote.Register["&gf", GlobalFrameHelper, h.symTab, h]; 
LocalRegister[
"&gf",
NEW[PROC [progName: ROPE, h: Handle _ NIL] RETURNS [TV] _ GlobalFrameContext],
"&gf[rope]\tget the given module's context"];

EvalQuote.Register["&sw", SetWorldHelper, h.symTab, h]; 
LocalRegister[
"&sw",
NEW[PROC [worldName: ROPE, h: Handle _ NIL] _ SetWorldContext],
"&sw[rope]\tset context to be that for the given world"];

EvalQuote.Register["&sir", SetIRHelper, h.symTab, h]; 
LocalRegister[
"&sir",
NEW[PROC [interfaceName: ROPE, h: Handle _ NIL] _ SetIRContext],
"&sir[rope]\tset context to be that for the given IR"];

EvalQuote.Register["&type", TypeHelper, h.symTab, h]; 
LocalRegister[
"&type",
NEW[PROC [expr: ROPE, h: Handle _ NIL] RETURNS [Type] _ TypeGetter],
"&type[expr]\tget the type of the given expr"];

EvalQuote.Register["&ir", IRHelper, h.symTab, h]; 
LocalRegister[
"&ir",
NEW[PROC [interfaceName: ROPE, h: Handle _ NIL] RETURNS [TV] _ IRContext],
"&ir[rope]\tget the given IR"];
};

EventToName: PROC [event: AMEvents.Event] RETURNS [name: ROPE _ NIL] = TRUSTED {
reason: ROPE;
s: IO.STREAM _ NIL;
WITH e: event SELECT FROM
break => {
break: Break _ NIL;
IF e.clientData # NIL
THEN break _ NARROW[e.clientData, Break
! SafeStorage.NarrowRefFault => CONTINUE];
IF break = NIL
THEN reason _ "Unknown breakpoint hit."
ELSE reason _ IO.PutFR1["Breakpoint #%g hit.", [integer[break.index]]];
};
call => reason _ Rope.Concat["Call: ", e.msg];
signal => {
inner: SAFE PROC = TRUSTED {
PrintTV.PrintSignal[e.signal, e.args, s];
IF AMTypes.TypeClass[AMTypes.TVType[e.signal]] = cardinal THEN
[] _ AMBridge.TVForSignal[LOOPHOLE[AMBridge.TVToCardinal[e.signal], ERROR ANY RETURNS ANY]]; 
};
s _ IO.ROS[];
s.PutRope[BackStop.Call[inner]];
reason _ IO.RopeFromROS[s];
};
unknown => reason _ Rope.Concat["Unknown: ", e.why];
 ENDCASE => ERROR;
name _ Cat[reason, ", world: ", WorldVM.WorldName[event.world]];

{
inner: SAFE PROC = TRUSTED {
s.PutRope[", context: "];
s.PutRope[AMModel.ContextName[event.frame]];
s.PutRope[", process: "];
PrintTV.Print[event.process, s, 2, 16];
};
s _ IO.ROS[];
s.PutRope[BackStop.Call[inner]];
name _ Rope.Concat[name, IO.RopeFromROS[s]];
IF Rope.Length[name] > 1000 THEN {
name _ Rope.Concat[Rope.Substr[name, 0, 1000], "..."];
};
};

};

CreateInterpreterMenu: PROC [h: Handle] = {
menu: Menus.Menu _ h.ts.menu;
InsME: PROC [line: NAT, name: ROPE, proc: Menus.MenuProc] = {
Menus.InsertMenuEntry
[menu: menu,
 line: line,
 entry: MBQueue.CreateMenuEntry
[q: h.menuHitQueue, name: name, proc: proc, clientData: h]];
};
InsME[line: 0, name: "STOP!", proc: StopHit];
InsME[line: 0, name: "SetBreak", proc: SetBreakHit];
InsME[line: 0, name: "ClearBreak(s)", proc: ClearBreakHit];
InsME[line: 0, name: "ListBreaks", proc: ListBreaksHit];
InsME[line: 1, name: "WalkStack", proc: WalkStackHit];
InsME[line: 1, name: "ShowFrame", proc: ShowFrameHit];
InsME[line: 1, name: "Proceed", proc: ProceedHit];
InsME[line: 1, name: "Abort", proc: AbortHit];
InsME[line: 1, name: "Source", proc: SourceHit];
IF h.event # NIL THEN ChangeLines[h.ts, 2] ELSE ViewerOps.PaintViewer[h.ts, menu];
};

ChangeLines: PROC [v: ViewerClasses.Viewer, nLines: NAT] = {
Menus.ChangeNumberOfLines[v.menu, nLines];
ViewerOps.EstablishViewerPosition[v, v.wx, v.wy, v.ww, v.wh];
ViewerOps.PaintViewer[v, all];
};

GetIntFromTable: PROC [h: Handle, name: ROPE, default: INT] RETURNS [INT] = TRUSTED {
WITH SymTab.Fetch[h.symTab, name].val SELECT FROM
tv: TV => RETURN [AMBridge.TVToLI[tv ! AMTypes.Error => CONTINUE]];
ENDCASE;
RETURN [default];
};

MainLoop: PROC [h: Handle] RETURNS [outcome: AMEvents.Outcome _ [proceed[NIL]]] = {
ENABLE UNWIND => h.event _ NIL;
somethingHappened: BOOL _ TRUE;
out: IO.STREAM _ h.tsOutStream;
out.PutChar['\n];
UNTIL WasTerminateRequested[h] DO
line: ROPE _ NIL;
result: TV _ NIL;
noResult: BOOL _ TRUE;
errorRope: ROPE _ NIL;
prompt: ROPE _ IO.PutFR1["&%g _ ", [integer[NextVarIndex[h, somethingHappened]]]];
leader: ROPE _ NIL;
printType: BOOL _ FALSE;
depth: INT _ GetIntFromTable[h, "&depth", 4];
width: INT _ GetIntFromTable[h, "&width", 32];
innerPrint: SAFE PROC = TRUSTED {
IF noResult THEN RETURN;
IO.PutRope[out, "=> "];
IF printType
THEN {
IO.PutRope[out, "(type) "];
PrintTV.PrintType[
put: out,
type: AMTypes.TVType[result],
depth: depth,
width: width,
verbose: depth > 4
];
}
ELSE PrintTV.Print[
put: out,
tv: result,
depth: depth,
width: width,
verbose: depth > 4
];
};
brq: BOOL;
brqWorld: WorldVM.World _ NIL;

somethingHappened _ FALSE;
IF WasProceedRequested[h] THEN {
ResetProceedRequested[h];
IF h.event # NIL THEN {
IF h.nestingLevel = 0 THEN {SetDormant[h]; h.event _ NIL};
RETURN;
};
};
IF WasAbortRequested[h] THEN {
ResetAbortRequested[h];
IF h.nestingLevel > 0
THEN RETURN[[quit[]]]  --  RETURN => event proc returns
ELSE IF h.event # NIL THEN {SetDormant[h]; h.event _ NIL; RETURN[[quit[]]]};
};
[brq, brqWorld] _ WasBootReturnRequested[h];
IF brq THEN {
IF brqWorld = h.remoteWorld
THEN {
IF h.nestingLevel = 0
THEN {ResetBootReturnRequested[h]; SetDormant[h]; h.event _ NIL};
RETURN[[quit[]]];
}
ELSE ResetBootReturnRequested[h];
};
FOR i: NAT IN [0..h.nestingLevel) DO leader _ Rope.Concat[leader, "<***>"]; ENDLOOP;
out.PutRope[leader ! RuntimeError.UNCAUGHT => CONTINUE];
out.PutRope[prompt ! RuntimeError.UNCAUGHT => CONTINUE];
{
line _ h.tsInStream.GetLineRope[
! RuntimeError.UNCAUGHT => GOTO handleAborted;
];
EXITS handleAborted => {
ENABLE RuntimeError.UNCAUGHT => CONTINUE;
h.tsInStream.Reset[];
out.PutRope[" XXX\n"];
};
};
SetStuffable[h];
IF line.IsEmpty[] THEN LOOP;
UNTIL line.IsEmpty[] DO
ch: CHAR _ line.Fetch[line.Length[] - 1];
SELECT ch FROM
'! => {depth _ depth + 1; width _ width + width};
'? => printType _ TRUE;
ENDCASE => EXIT;
line _ Rope.Substr[base: line, len: line.Length[] - 1];
ENDLOOP;
line _ Rope.Concat[line, "\n"];
somethingHappened _ TRUE;
ResetStopRequested[h];

{
innerEval: SAFE PROC = TRUSTED {
[result, errorRope, noResult]
_ Interpreter.Evaluate
[rope: Rope.Concat[prompt, line],
 context: IF h.globalContext # NIL THEN h.globalContext ELSE h.context,
 symTab: h.symTab,
 abort: [abortProc, h] 
 ! ABORTED, UNWIND => {errorRope _ " XXX\n"; CONTINUE};
];
};
ch: Commander.Handle = NEW [Commander.CommandObject _ [
in: h.tsInStream,
out: out,
err: out,
commandLine: line,
command: "_",
propertyList: NIL]];
props: List.AList _ NIL;
props _ List.PutAssoc[$CommanderHandle, ch, props];
props _ List.PutAssoc[$InterpreterHandle, h, props];
props _ List.PutAssoc[$InterpreterNestingLevel, NEW[NAT _ h.nestingLevel], props];
props _ List.PutAssoc[$InterpreterSymTab, h.symTab, props];
ProcessProps.AddPropList[props, innerEval];
};

IF errorRope.Length[] # 0
THEN IO.PutF1[out, "*** %g\n", [rope[errorRope]] ]
ELSE IO.PutF1[out, " %g\n", [rope[BackStop.Call[innerPrint]]] ];
ENDLOOP;

IF h.nestingLevel > 0 THEN RETURN[[quit[]]] ELSE Finalize[h];
};

abortProc: Interpreter.AbortProc = TRUSTED {
RETURN[WasStopRequested[NARROW[data, Handle]]];
};

FindInProgressEvaluation: PROC RETURNS [h: Handle _ NIL, nestingLevel: NAT _ 0] = {
hn: Handle = NARROW[Atom.GetPropFromList[ProcessProps.GetPropList[], $InterpreterHandle]];
rn: REF NAT = NARROW[Atom.GetPropFromList[ProcessProps.GetPropList[], $InterpreterNestingLevel]];
IF hn # NIL AND rn # NIL THEN RETURN[hn, rn^];
};

GetHandlePlease: PUBLIC PROC RETURNS [Handle] = {
r: REF = Atom.GetPropFromList[ProcessProps.GetPropList[], $InterpreterHandle];
RETURN[NARROW[r, Handle]];
};

Finalize: PROC [h: Handle] = {
out: IO.STREAM _ h.tsOutStream;
ts: TypeScript.TS _ h.ts;
h.context _ NIL;
h.globalContext _ NIL;
h.event _ NIL;
h.symTab _ NIL;
h.ts _ NIL;
h.tsInStream _ NIL;
h.tsOutStream _ NIL;
h.menuHitQueue _ NIL;
IF h = dormantH THEN dormantH _ NIL;
{
ENABLE RuntimeError.UNCAUGHT => CONTINUE;
IF out # NIL THEN
IO.PutRope[out, "\n\n ~~~~~~~~~~~~~TERMINATED~~~~~~~~~~~~~ \n\n"];
IF ts # NIL THEN TypeScript.Destroy[ts];
IF out # NIL THEN IO.Close[out];
};
};

NextVarIndex: ENTRY PROC [h: Handle, somethingHappened: BOOL] RETURNS [INT] = {
ENABLE UNWIND => NULL;
IF NOT somethingHappened THEN RETURN[h.nextVarIndex];
RETURN[h.nextVarIndex _ h.nextVarIndex + 1];
};

ResetStopRequested: ENTRY PROC [h: Handle] = {
ENABLE UNWIND => NULL;
h.stopRequested _ FALSE;
};

SetStopRequested: PROC [h: Handle] = {
ENABLE UNWIND => NULL;
h.stopRequested _ TRUE;
StuffIt[h, "\n"];
};

WasStopRequested: ENTRY PROC [h: Handle] RETURNS [BOOL] = {
ENABLE UNWIND => NULL;
RETURN[h.stopRequested];
};

StuffIt: ENTRY PROC [h: Handle, rope: ROPE]  = {
ENABLE UNWIND => NULL;
UNTIL h.stuffAble DO WAIT h.Stuffable; ENDLOOP;
h.stuffAble _ FALSE;
h.tsInStream.Reset[];
IF IsEmpty[rope] THEN RETURN;
IF TiogaOps.GetSelection[].viewer = h.ts THEN TiogaOps.SelectPoint[viewer: h.ts, caret: TiogaOps.LastLocWithin[TiogaOps.ViewerDoc[h.ts]]];
h.ts.class.notify[h.ts, LIST[rope]];
};

SetStuffable: ENTRY PROC [h: Handle] = {
ENABLE UNWIND => NULL;
h.stuffAble _ TRUE;
NOTIFY h.Stuffable;
};

SetDormant: ENTRY PROC [h: Handle] = {
ENABLE UNWIND => NULL;
abort: BOOL _ FALSE;
h.readEvalPrintProcess _ NIL;
h.tsOutStream.PutRope["\n~~~~~~~~~~~~~~~~~~~~~\n"
! RuntimeError.UNCAUGHT => CONTINUE];
ChangeLines[h.ts, 0 ! RuntimeError.UNCAUGHT => {abort _ TRUE; CONTINUE}];
IF NOT abort THEN dormantH _ h;
};

SetProceedRequested: ENTRY PROC [h: Handle] = {
ENABLE UNWIND => NULL;
h.proceedRequested _ TRUE;
};

ResetProceedRequested: ENTRY PROC [h: Handle] = {
ENABLE UNWIND => NULL;
h.proceedRequested _ FALSE;
};

WasProceedRequested: ENTRY PROC [h: Handle] RETURNS [BOOL] = {
ENABLE UNWIND => NULL;
RETURN[h.proceedRequested];
};

SetBootReturnRequested: ENTRY PROC [h: Handle, world: WorldVM.World] = {
ENABLE UNWIND => NULL;
h.bootReturnRequested _ TRUE;
h.bootedWorld _ world;
};

ResetBootReturnRequested: ENTRY PROC [h: Handle] = {
ENABLE UNWIND => NULL;
h.bootReturnRequested _ FALSE;
};

WasBootReturnRequested: ENTRY PROC [h: Handle] RETURNS [yes: BOOL, world: WorldVM.World] = {
ENABLE UNWIND => NULL;
RETURN[h.bootReturnRequested, h.bootedWorld];
};

SetAbortRequested: ENTRY PROC [h: Handle] = {
ENABLE UNWIND => NULL;
h.abortRequested _ TRUE;
};

ResetAbortRequested: ENTRY PROC [h: Handle] = {
ENABLE UNWIND => NULL;
h.abortRequested _ FALSE;
};

WasAbortRequested: ENTRY PROC [h: Handle] RETURNS [BOOL] = {
ENABLE UNWIND => NULL;
RETURN[h.abortRequested];
};

SetTerminateRequested: ENTRY PROC [h: Handle] = {
ENABLE UNWIND => NULL;
IF h.tsInStream # NIL THEN
h.tsInStream.Close[ ! RuntimeError.UNCAUGHT => CONTINUE];
IF h = dormantH THEN dormantH _ NIL;
h.terminateRequested _ TRUE;
};

WasTerminateRequested: ENTRY PROC [h: Handle] RETURNS [BOOL] = {
ENABLE UNWIND => NULL;
RETURN[h.terminateRequested];
};

StopHit: Menus.MenuProc = TRUSTED {
SetStopRequested[NARROW[clientData, Handle]];
};

HighlightBreakPoint: PROC [break: Break, err: IO.STREAM] = {
report: AMViewerOps.ReportProc = TRUSTED {err.PutRope[msg]};
inner: SAFE PROC = TRUSTED {
[] _ AMViewerOps.ViewerFromSection[break.section, report];
};  -- yekk.
msg: ROPE _ BackStop.Call[inner];
IF msg # NIL THEN err.PutRope[msg];
};

SetBreakHit: Menus.MenuProc = TRUSTED {
h: Handle = NARROW[clientData, Handle];
SELECT mouseButton FROM
blue => StuffIt[h, "  ----  &SetBreak[h: &H, exit: TRUE]\n"];
ENDCASE => StuffIt[h, "  ----  &SetBreak[h: &H]\n"];
};

SetBreak: PROC [h: Handle _ NIL, exit: BOOL _ FALSE] = TRUSTED {
break: Break _ NIL;
msg: ROPE _ NIL;
err: ROPE _ NIL;
world: WorldVM.World;
inner: SAFE PROC = TRUSTED {
section: AMModel.Section _ NIL;
warning: REF;
h.tsOutStream.PutRope["Setting break..."];
[section, warning] _ AMViewerOps.SectionFromSelection[world];
IF warning = NIL THEN h.tsOutStream.PutRope["-- possible source version mismatch --"];
SELECT AMModel.SectionClass[section] FROM
proc => {};
statement => {
IF exit THEN section _ AMModel.ParentSection[section];
};
ENDCASE => {
err _ "-- section is not valid --";
RETURN;
};
break _ NEW[BreakObject _ [index: 0, breakID: NIL, world: world, section: section]];
{ENABLE AMEvents.DuplicateBreakpoint => GO TO bogus;
break.breakID _ IF exit
THEN AMEvents.BreakAfter[world, section, break]
ELSE AMEvents.BreakAt[world, section, break];
break.index _ nextBI;
nextBI _ nextBI + 1;
EXITS bogus => {
break _ NIL;
err _ "-- duplicate breakpoints not allowed --";
};
};
};

IF h = NIL THEN h _ GetHandlePlease[];
world _ IF h.event # NIL THEN h.event.world ELSE AMModel.ContextWorld[h.context];
msg _ BackStop.Call[inner];
IF msg # NIL THEN err _ msg;
IF err.Length[] = 0 AND break # NIL THEN {
h.tsOutStream.PutF1["Break #%g set.", [integer[break.index]]];
HighlightBreakPoint[break: break, err: h.tsOutStream];
RETURN;
};
h.tsOutStream.PutRope[err];
};

ListBreaksHit: Menus.MenuProc = TRUSTED {
h: Handle = NARROW[clientData, Handle];
StuffIt[h, "  ----  &ListBreaks[h: &H]\n"];
};

SetGlobalFrameContext: PROC [progName: ROPE, h: Handle _ NIL] = TRUSTED {
ERROR  -- defined only for &help; the evalquote proc does the work
};

GlobalFrameContext: PROC [progName: ROPE, h: Handle _ NIL] RETURNS [TV] = TRUSTED {
ERROR  -- defined only for &help; the evalquote proc does the work
};

SetWorldContext: PROC [worldName: ROPE, h: Handle _ NIL] = TRUSTED {
ERROR  -- defined only for &help; the evalquote proc does the work
};

SetIRContext: PROC [interfaceName: ROPE, h: Handle _ NIL] = TRUSTED {
ERROR  -- defined only for &help; the evalquote proc does the work
};

IRContext: PROC [interfaceName: ROPE, h: Handle _ NIL] RETURNS [TV] = TRUSTED {
ERROR  -- defined only for &help; the evalquote proc does the work
};

TypeGetter: PROC [expr: ROPE, h: Handle _ NIL] RETURNS [Type] = TRUSTED {
ERROR  -- defined only for &help; the evalquote proc does the work
};

ListBreaks: PROC [h: Handle _ NIL] = TRUSTED {
msg: ROPE _ NIL;
out: IO.STREAM _ NIL;
inner: SAFE PROC = TRUSTED {
id: AMEvents.BreakID _ NIL;
clientData: REF;
DO
world: WorldVM.World
= IF h.event # NIL THEN h.event.world ELSE AMModel.ContextWorld[h.context];
[id, clientData] _ AMEvents.NextBreak[world: world, prev: id];
IF id = NIL THEN EXIT;
WITH clientData SELECT FROM
b: Break => {
source: AMModel.Source = AMModel.SectionSource[b.section];
pc: PrincOps.BytePC = AMModelLocation.EntryLocations[b.section].list.first.pc;
firstCharIndex: INT _ 0;
WITH s: source SELECT FROM
field => firstCharIndex _ s.firstCharIndex;
ENDCASE;
IF b.world # world THEN {out.PutRope["DISASTER"]; ERROR};
out.PutF1["    Break #%g at ", [integer[b.index]]];
out.Put[[rope[source.fileName]], [rope["["]], [integer[firstCharIndex]]];
out.PutF1["], bytePC = %bb\n", [cardinal[pc]]];
};
ENDCASE;
ENDLOOP;
};
IF h = NIL THEN h _ GetHandlePlease[];
out _ h.tsOutStream;
out.PutRope["Listing all breaks for this world...\n"];
msg _ BackStop.Call[inner];
IF msg # NIL
THEN out.PutF1["Error: %g\n", [rope[msg]]]
ELSE out.PutRope["...Done.\n"];
};

ClearBreakHit: Menus.MenuProc = TRUSTED {
h: Handle = NARROW[clientData, Handle];
SELECT mouseButton FROM
red => StuffIt[h, "  ----  &ClearBreak[h: &H]\n"];
blue => StuffIt[h, "  ----  &ClearAllBreaks[h: &H]\n"];
ENDCASE;
};

ClearAllBreaks: PROC [h: Handle _ NIL] = TRUSTED {
msg: ROPE _ NIL;
out: IO.STREAM _ NIL;
inner: SAFE PROC = TRUSTED {
id: AMEvents.BreakID _ NIL;
clientData: REF;
DO
world: WorldVM.World
= IF h.event # NIL THEN h.event.world ELSE AMModel.ContextWorld[h.context];
[id, clientData] _ AMEvents.NextBreak[world: world, prev: id];
IF id = NIL THEN EXIT;
WITH clientData SELECT FROM
b: Break => {
IF b.world # world THEN {h.tsOutStream.PutRope["DISASTER"]; ERROR};
AMEvents.ClearBreak[b.breakID];
out.Put[[rope["    Break #"]], [integer[b.index]], [rope[" cleared.\n"]] ];
};
ENDCASE;
ENDLOOP;
};
IF h = NIL THEN h _ GetHandlePlease[];
out _ h.tsOutStream;
out.PutRope["Clearing all breaks...\n"];
msg _ BackStop.Call[inner];
IF msg # NIL
THEN out.PutF1["Error: %g\n", [rope[msg]]]
ELSE out.PutRope["...Done.\n"];
};

ClearBreak: PROC [h: Handle _ NIL, breakIndex: BreakIndex _ nullBreakIndex] = TRUSTED {
msg, err: ROPE _ NIL;
break: Break _ NIL;
out: IO.STREAM _ NIL;

inner: SAFE PROC = TRUSTED {
IF breakIndex = nullBreakIndex
THEN {
IF h.event = NIL
THEN err _ "not an event handler"
ELSE
WITH e: h.event SELECT FROM
break => {
AMEvents.ClearBreak[e.id];
WITH e.clientData SELECT FROM
br: Break => break _ br;
ENDCASE;
IF break = NIL
THEN err _ "I didn't place this break but I cleared it anyhow"
ELSE breakIndex _ break.index;
};
ENDCASE => err _ "not a break event";
}
ELSE {
id: AMEvents.BreakID _ NIL;
clientData: REF;
DO
world: WorldVM.World
= IF h.event # NIL THEN h.event.world ELSE AMModel.ContextWorld[h.context];
[id, clientData] _ AMEvents.NextBreak[world: world, prev: id];
IF id = NIL THEN {err _ "No break found with the specified index"; EXIT};
WITH clientData SELECT FROM
b: Break => {
IF b.world # world THEN {h.tsOutStream.PutRope["DISASTER"]; ERROR};
IF b.index = breakIndex THEN {
break _ b;
AMEvents.ClearBreak[b.breakID];
};
};
ENDCASE;
ENDLOOP;
};
};
IF h = NIL THEN h _ GetHandlePlease[];
out _ h.tsOutStream;
IO.PutRope[out, "Clearing break..."];
msg _ BackStop.Call[inner];
SELECT TRUE FROM
msg # NIL => IO.PutF1[out, "Break not cleared: %g", [rope[msg]] ];
break = NIL => IO.PutRope[out, err];
ENDCASE => IO.PutF1[out, "Break #%g cleared.", [integer[breakIndex]] ];
};

WalkStackHit: Menus.MenuProc = TRUSTED {
h: Handle = NARROW[clientData, Handle];
SELECT mouseButton FROM
red => StuffIt[h, "  ----  &WalkStack[nFrames: 1, h: &H]\n"];
yellow => StuffIt[h, "  ----  &WalkStack[nFrames: -1000, h: &H]\n"];
blue => StuffIt[h, "  ----  &WalkStack[nFrames: -1, h: &H]\n"];
ENDCASE => ERROR;
};

WalkStack: PROC [nFrames: INT _ 1, h: Handle _ NIL] = {
inner: SAFE PROC = TRUSTED {
IF h.event = NIL OR h.event.frame = NIL THEN RETURN;
WalkContext[h, nFrames];
PrintTV.Print[tv: h.context, put: h.tsOutStream, depth: 1, verbose: TRUE];
};
IF h = NIL THEN h _ GetHandlePlease[];
h.tsOutStream.PutRope[BackStop.Call[inner]];
};

WalkContext: ENTRY PROC [h: Handle, n: INT] = TRUSTED {
ENABLE UNWIND => NULL;
h.globalContext _ NIL;
SELECT n FROM
> 0 => {
next: TV _ NIL;
this: TV _ h.context;
THROUGH [1..n] DO
this _ AMTypes.DynamicParent[this];
IF this = NIL THEN {h.tsOutStream.PutRope["Can't go any further..."]; EXIT};
next _ this;
ENDLOOP;
IF next # NIL THEN h.context _ AMModelBridge.ContextForFrame[next];
};
< -999 => h.context _ AMModelBridge.ContextForFrame[h.event.frame];
< 0 => {
this: TV _ h.context;
prev: TV _ h.event.frame;
THROUGH [1..-n] DO
t: TV;
IF FHBits[prev] = FHBits[this] THEN {
h.tsOutStream.PutRope["Can't go any further."];
h.context _ AMModelBridge.ContextForFrame[prev];
RETURN};
t _ AMTypes.DynamicParent[prev];
UNTIL FHBits[t] = FHBits[this]
DO prev _ t; t _ AMTypes.DynamicParent[prev] ENDLOOP;
this _ prev;
ENDLOOP;
h.context _ AMModelBridge.ContextForFrame[prev];
};
ENDCASE;
};

FHBits: PROC [lf: TV] RETURNS [fhBits: CARDINAL] = TRUSTED {
local: BOOL = AMBridge.GetWorld[lf] = WorldVM.LocalWorld[];
fhBits _
IF local
THEN LOOPHOLE[AMBridge.FHFromTV[lf], CARDINAL]
ELSE LOOPHOLE[AMBridge.RemoteFHFromTV[lf].fh, CARDINAL];
};

ShowFrameHit: Menus.MenuProc = TRUSTED {
h: Handle = NARROW[clientData, Handle];
StuffIt[h, "  ----  &ShowFrame[h: &H]\n"];
};

ProceedHit: Menus.MenuProc = TRUSTED {
h: Handle = NARROW[clientData, Handle];
SetProceedRequested[h];
StuffIt[h, "\n"];
};

AbortHit: Menus.MenuProc = TRUSTED {
h: Handle = NARROW[clientData, Handle];
SetAbortRequested[h];
StuffIt[h, "\n"];
};

BootReturnRequested: AMEvents.BootedNotifier = TRUSTED {
h: Handle = NARROW[clientData, Handle];
SetBootReturnRequested[h, world];
StuffIt[h, "\n"];
};

SourceHit: Menus.MenuProc = TRUSTED {
h: Handle = NARROW[clientData, Handle];
StuffIt[h, "  ----  &Source[h: &H]\n"];
};

Source: PROC [h: Handle _ NIL] = {
name: ROPE;
index: INT;
report: AMViewerOps.ReportProc = TRUSTED {
h.tsOutStream.PutRope[msg]};
IF h = NIL THEN h _ GetHandlePlease[];
[name, index] _ AMViewerOps.SourceFromTV[h.context, report];
IF name # NIL THEN
FileViewerOps.OpenSource[fileName: name, index: index, feedBack: h.tsOutStream];
};

ViewerEvent: ViewerEvents.EventProc = {
SELECT event FROM
destroy =>
WITH ViewerOps.FetchProp[viewer, $InterpreterHandle] SELECT FROM
h: Handle => {
IF h.event # NIL THEN RETURN [TRUE];
IF NOT h.terminateRequested THEN TRUSTED {
SetTerminateRequested[h];
Process.Detach[FORK StuffIt[h, "\n"]];
};
IF h = dormantH THEN dormantH _ NIL;
};
ENDCASE;
ENDCASE;
};

ShowFrame: PROC [h: Handle _ NIL] =  {
lf: TV;
depth: INT _ 4;
width: INT _ 32;
IF h = NIL THEN h _ GetHandlePlease[];
IF h.event = NIL OR h.event.frame = NIL OR h.globalContext # NIL THEN RETURN;
depth _ GetIntFromTable[h, "&depth", depth];
width _ GetIntFromTable[h, "&width", width];
lf _ h.context;
PrintTV.Print[tv: lf, put: h.tsOutStream, depth: 1, verbose: TRUE];
h.tsOutStream.PutRope["\nArguments--\n"];
PrintTV.PrintArguments[tv: lf, put: h.tsOutStream, depth: depth, width: width, breakBetweenItems: TRUE];
h.tsOutStream.PutRope["\nVariables--\n"];
PrintTV.PrintVariables[tv: lf, put: h.tsOutStream, depth: depth, width: width, all: TRUE, breakBetweenItems: TRUE];
};

worldSwapDebug: BOOL;
SetWorldSwapDebug: UserProfile.ProfileChangedProc = TRUSTED {
wsd: BOOL = UserProfile.Boolean[key: "WorldSwapDebug", default: FALSE];
IF reason = firstTime THEN {
worldSwapDebug _ wsd;
IF NOT worldSwapDebug
THEN AMEvents.GetEvents[WorldVM.LocalWorld[], NIL, EventHandler];
RETURN;
};
IF wsd # worldSwapDebug THEN {  -- user changed his WorldSwapDebug profile entry
IF NOT wsd
THEN AMEvents.GetEvents[WorldVM.LocalWorld[], NIL, EventHandler]
ELSE AMEvents.StopEvents[WorldVM.LocalWorld[]];
worldSwapDebug _ wsd;
}; 
};

TypeHelper: EvalQuote.EvalQuoteProc = TRUSTED {
arg: InterpreterOps.Tree _ InterpreterOps.GetArg[tree, 1];
return _ AMBridge.TVForType[AMTypes.TVType[InterpreterOps.Eval[arg, head, target]]];
};

IRHelper: EvalQuote.EvalQuoteProc = TRUSTED {
arg: InterpreterOps.Tree _ InterpreterOps.GetArg[tree, 1];
rope: ROPE _ InterpreterOps.TreeToName[arg];
IF rope = NIL THEN rope _ AMTypes.TVToName[InterpreterOps.Eval[arg, head, target]];
return _ AMMiniModel.GetInterfaceRecord[rope, InterpreterOps.WorldFromHead[head]];
};

SetIRHelper: EvalQuote.EvalQuoteProc = TRUSTED {
h: Handle = NARROW[data, Handle];
return _ IRHelper[head, tree, target, data];
h.tsOutStream.PutRope["***Setting interface record context...\n"];
h.globalContext _ return;
};

SetWorldHelper: EvalQuote.EvalQuoteProc = TRUSTED {
context: AMModel.Context;
world: WorldVM.World;
h: Handle _ NARROW[data];
arg: InterpreterOps.Tree _ InterpreterOps.GetArg[tree, 1];
rope: ROPE _ InterpreterOps.TreeToName[arg];
IF rope = NIL THEN rope _ AMTypes.TVToName[InterpreterOps.Eval[arg, head, target]];
return _ AMTypes.GetEmptyTV[];
world _ WorldVM.GetWorld[rope];
h.tsOutStream.PutRope["***Setting World context...\n"];
h.tsOutStream.PutRope[WorldVM.WorldName[world]];
context _ AMModel.RootContext[world];
h.globalContext _ context;
};

GlobalFrameHelper: EvalQuote.EvalQuoteProc = TRUSTED {
arg: InterpreterOps.Tree _ InterpreterOps.GetArg[tree, 1];
rope: ROPE _ InterpreterOps.TreeToName[arg];
IF rope = NIL THEN rope _ AMTypes.TVToName[InterpreterOps.Eval[arg, head, target]];
return _ AMModel.MostRecentNamedContext[
rope,
AMModel.RootContext[InterpreterOps.WorldFromHead[head]]
];
};

SetGlobalFrameHelper: EvalQuote.EvalQuoteProc = TRUSTED {
h: Handle _ NARROW[data];
return _ GlobalFrameHelper[head, tree, target, data];
h.tsOutStream.PutRope["***Setting Global Frame context...\n"];
h.globalContext _ return;
};

[] _ ViewerEvents.RegisterEventProc[proc: ViewerEvent, event: destroy];

Commander.Register[key: "///Commands/Interpreter", proc: NewInterpreter, doc: "Create a new interpreter tool"];

UserProfile.CallWhenProfileChanges[SetWorldSwapDebug];

END.

TInterpreterToolImpl.mesa
Copyright c 1985, 1986 by Xerox Corporation.  All rights reserved.
Doug Wyatt, April 25, 1985 0:15:51 am PST
Russ Atkinson (RRA) January 9, 1986 5:53:32 pm PST
[cmd: Commander.Handle]
[data: REF ANY, event: AMEvents.Event] RETURNS [outcome: AMEvents.Outcome]
First, ask if this event is occurring under an interpreter.  Ifso, nest the interpreter.
NOTE assumption of order in FindInProgressEvaluation
[PROCESS, nestingLevel] is in Evaluate, i.e. this event is occurring under an interpreter.  Nest the event.
some lower event of this tool is for a remote world

Now do the recursive call of MainLoop.
Return from recursive call of MainLoop.  Now pop h's state (i.e. restore h).
Won't raise any signals.
[id: BreakID, clientData: REF ANY]
[signal, args: TV ]
AMEvents gave up on symbols; get the error message for BackStop.Call
client bug; psbi and frame are valid.
Too bloody long, so truncate it
flushes viewer cache STOPGAP 'till a viewers bug is fixed
Read/Eval/Print loop. FORK'd for each interpreter viewer.  Called recursively if an error is raised during interpretation.
the interpreter viewer was destroyed
RETURN => event proc returns
strip postfix !'s and ?'s
Here if the interpreter viewer was destroyed. h.tsInStream will have been closed. 
PROC [data: REF] RETURNS [abort: BOOL];
Here to finalize an InterpreterObject (e.g. to break circular structures, close streams)
[parent: REF, clientData: REF, mouseButton: MouseButton, shift, control: BOOL]
[msg: ROPE, severity: Severity]
[parent: REF, clientData: REF, mouseButton: MouseButton, shift, control: BOOL]
[parent: REF, clientData: REF, mouseButton: MouseButton, shift, control: BOOL]

START HERE
[parent: REF, clientData: REF, mouseButton: MouseButton, shift, control: BOOL]
START HERE
clear the break that caused this event
clear the specified break
START HERE
[parent: REF, clientData: REF, mouseButton: MouseButton, shift, control: BOOL]
[parent: REF, clientData: REF, mouseButton: MouseButton, shift, control: BOOL]
[parent: REF, clientData: REF, mouseButton: MouseButton, shift, control: BOOL]
[parent: REF, clientData: REF, mouseButton: MouseButton, shift, control: BOOL]
[world: WorldVM.World, clientData: REF]
[parent: REF, clientData: REF, mouseButton: MouseButton, shift, control: BOOL]
[msg: ROPE, severity: Severity]
[viewer: Viewer, event: ViewerEvent, before: BOOL] RETURNS [abort: BOOL _ FALSE]
[reason: ProfileChangeReason]
[head: EvalHead, tree: Tree, target: Type, data: REF] RETURNS [return: TV]
[head: EvalHead, tree: Tree, target: Type, data: REF] RETURNS [return: TV]
[head: EvalHead, tree: Tree, target: Type, data: REF] RETURNS [return: TV]
[head: EvalHead, tree: Tree, target: Type, data: REF] RETURNS [return: TV]
[head: EvalHead, tree: Tree, target: Type, data: REF] RETURNS [return: TV]
[head: EvalHead, tree: Tree, target: Type, data: REF] RETURNS [return: TV]

START HERE
ส,ฺ–
"unit" style˜
codešฯiœ™Kšœ
ฯm
œ7™BK™)K™2—K˜š
ฯk	˜	Kšœ	Ÿœc˜qKšœ	Ÿœภ
˜ฮ
KšœŸœ˜'KšœŸœˆ
˜•
KšœŸœ˜&KšœŸœ˜'KšœŸœ$Ÿœ#˜XKšœŸœE˜VKšœŸœ˜Kšœ	Ÿœ˜Kšœ
Ÿœ˜$Kšœ
Ÿœ0˜?Kšœ
Ÿœ˜*KšœŸœ˜!KšœŸœ˜(KšœŸœ=˜QKšœŸœM˜iKšŸœ
ŸœPŸœŸœ˜eKšœŸœ˜KšœŸœ"˜/KšœŸœ8˜CKšœ	Ÿœ
˜KšœŸœA˜NKšœŸœ˜#Kšœ
Ÿœ˜.KšœŸœ'Ÿœ
˜?Kšœ
ŸœŸœ˜KšœŸœ˜#KšœŸœ˜"Kšœ	Ÿœ7˜EKšœŸœŸœ˜'KšœŸœ
˜Kšœ
Ÿœ ˜2Kšœ	Ÿœ˜%Kšœ
ŸœF˜UKšœŸœ7˜HKšœŸœ*˜7K˜—šœŸ
œฯc#˜GKšŸœŸœ
Ÿœ
˜KšŸœม
Ÿœฎ
˜๘KšŸœ 	˜)KšœŸœ
Ÿœ˜˜KšŸœŸœŸœ
˜KšœŸœ˜K˜KšœŸœ# ˜@KšœŸœ,˜CK˜KšœŸœ%˜5Kš
œC˜CK˜KšœŸœ *˜JKšœŸœ
˜K˜Kšœ
Ÿœ&˜7šœŸœ ˜+K˜———šฯbœŸœ˜1Kš
œ™Kš
œŸœ
ŸœŸ œŸœ˜DK˜K˜—šฯn
œŸœŸœŸœ˜XKš
œ
˜
š
œ˜šŸœ	Ÿ˜KšŸœ*˜.KšŸœ,˜0——KšœŸœ
˜!šœŸœŸœ˜KšŸœŸœ
Ÿœ
Ÿœ
˜šŸœ6Ÿ˜<Kš
œ,˜,—šŸœŸ˜šŸœ˜šœŸœ
˜š
œ˜š
œ˜Kš
œ˜Kš
œ˜Kš
œ!˜!Kš
œ˜KšœŸœ˜8———Kš
œ
˜
K˜
—šŸœ˜KšœŸœŸœ
˜Kšœ ˜"KšœŸœ
˜Kš
œ˜Kš
œ˜Kš
œ˜KšœŸœ˜8šŸœŸ˜šŸœ˜KšŸœ&Ÿœ˜AKš
œ2˜2Kš
œ
˜
—KšŸœ@˜D—Kš
œ˜KšŸœ
Ÿœ˜-KšŸœŸœ
ŸœŸœ˜EKš
œ/˜/K˜——šŸœŸœ
Ÿ˜Kš
œE˜E—Kš
œ˜šŸœŸœ
Ÿ˜Kš
œG˜G—K˜—K˜+Kš
œ˜K˜—šœ#Ÿœ˜,KšœŸœ
ŸœŸœ™JKšœŸœ
˜KšœŸœ ˜2Kš
œF˜FK˜Kš
œX™XKšœ™4Kš
œ/˜/šŸœŸœ
Ÿœ˜,šŸœ '˜2Kš
œk™kKšœ0 ˜DKšœ* œ
˜:Kšœ6 ˜LKšœ% œ
˜3Kšœ	Ÿœ œ
˜0Kšœ	ŸœŸœ
˜KšŸœ$Ÿœ˜BKš
œ6˜6KšŸœd˜fKšŸœŸœ
Ÿœ˜,šŸœŸ˜š
Ÿ˜š
œ
˜
šœŸœ5˜9KšŸœ
Ÿ˜KšŸœ˜"———šŸœ˜Kš
œ3™3šŸœ5˜7KšŸœ/˜2KšŸœ
Ÿœ
˜—Kš
œ˜——Kš
œ˜KšœŸœ
˜Kš
œ˜Kš
œ˜Kš
œ%˜%Kš
œ$˜$š	ŸœŸœ
ŸœŸœ
Ÿ˜4Kš
œG˜GK™Kš
œ&™&—š
œ˜Kš
œL™L—K˜š	ŸœŸœ
ŸœŸœ
Ÿ˜4š
œ!˜!Kš
œ(˜(——Kš
œ˜Kš
œ$˜$Kš
œ˜Kš
œ#˜#Kš
œ˜Kš
œ˜Kš
œ%˜%KšŸœŸœ
Ÿœ˜,K˜
—KšŸœ .˜P—Kš
œ˜K˜—šข	œŸœ˜KšœŸ
œ
˜šข
œŸœŸœŸœŸœŸœ˜BKšŸœŸœ
Ÿœ˜"š
œ˜Kš
œI˜IKš
œ˜—šŸœ	˜KšŸœB˜DKš
œ˜—K˜—šŸœ˜	šŸœŸ˜šŸœ˜KšŸœ&Ÿœ˜AKš
œ2˜2Kš
œ
˜
—KšŸœ@˜D—K˜—KšœCŸœ˜KKš
œ˜Kš
œ/˜/KšœCŸœ˜VKš
œ/˜/š
œ˜KšœŸœ/˜8—š
œ˜Kšœ
Ÿœ
Ÿœ2˜C—š
œ˜Kšœ
Ÿœ
Ÿœ3˜D—š
œ˜Kš	œŸœ
ŸœŸœŸœ˜HKš
œ,˜,—š
œ˜Kš	œŸœ
ŸœŸœŸœ˜BKš
œ,˜,—š
œ˜KšœŸœ
ŸœŸœ˜>Kš
œ˜—š
œ˜Kšœ
Ÿœ
ŸœŸœ˜9Kš
œ˜—š
œ˜KšœŸœ
ŸœŸœ˜6Kš
œ.˜.—š
œ˜KšœŸœ
ŸœŸœ˜0Kš
œ8˜8—š
œ˜Kšœ
Ÿœ
ŸœŸœŸœŸœ˜HKš
œ3˜3—š
œ˜Kš
œ˜KšŸœ
ŸœŸœ9˜RKš
œ˜—š
œ˜Kš
œ˜KšŸœ
ŸœŸœ˜-Kš
œ˜—š
œ˜Kš
œ˜KšŸœ
ŸœŸœ˜)Kš
œ˜—K˜Kšœ> 
˜?š
œ˜Kš
œ˜KšŸœ
ŸœŸœŸœ˜DKš
œ;˜;—K˜Kšœ: 
˜;š
œ˜Kš
œ˜KšŸœ
ŸœŸœŸœŸœŸœ˜NKš
œ-˜-—K˜Kšœ7 
˜8š
œ˜Kš
œ˜KšŸœ
Ÿœ
ŸœŸœ˜?Kš
œ9˜9—K˜Kšœ5 
˜6š
œ˜Kš
œ˜KšŸœ
ŸœŸœŸœ˜@Kš
œ7˜7—K˜Kšœ5 
˜6š
œ˜Kš
œ˜Kš
Ÿœ
ŸœŸœŸœŸœ˜DKš
œ/˜/—K˜Kšœ1 
˜2š
œ˜Kš
œ˜KšŸœ
ŸœŸœŸœŸœŸœ˜JKš
œ˜—š
œ˜K˜——šะbnœŸœŸœŸœŸœŸœ˜PKš
œ™KšœŸœ
˜
KšœŸœ
ŸœŸœ
˜šŸœ
Ÿœ
Ÿ˜š
œ
˜
Kš
œ"™"KšœŸœ
˜šŸœŸ˜šŸœ	Ÿœ˜'Kšœ Ÿœ˜*——šŸœ	Ÿ˜KšŸœ#˜'KšŸœ
Ÿœ7˜G—K˜—Kš
œ.˜.š
œ˜Kš
œ™šœŸœ
ŸœŸœ˜Kš
œ)˜)šŸœ8Ÿ˜>Kš
œD™DKšœŸœ!Ÿœ
Ÿœ
Ÿœ
Ÿœ˜]—Kš
œ˜—KšœŸœ
Ÿœ˜
Kš
œ ˜ Kšœ	Ÿœ˜K˜—š
œ4˜4Kš
œ%™%——Kšœ
ŸœŸœ
˜š
œ@˜@K˜—š
œ
˜
šœŸœ
ŸœŸœ˜Kš
œ˜Kš
œ,˜,Kš
œ˜Kš
œ'˜'Kš
œ˜—KšœŸœ
Ÿœ˜
Kš
œ ˜ KšœŸœ˜,šŸœŸœ˜"Kš
œ™Kš
œ6˜6K˜—K˜—K˜Kš
œ˜K˜—šขœŸœ˜+Kš
œ˜šขœŸœŸœŸœ˜=š
œ˜Kš
œ˜Kš
œ˜š
œ˜Kš
œ<˜<——Kš
œ˜—Kš
œ-˜-Kš
œ4˜4Kš
œ;˜;Kš
œ8˜8Kš
œ6˜6Kš
œ6˜6Kš
œ2˜2Kš
œ.˜.Kš
œ0˜0KšŸœŸœ
ŸœŸœ#˜RKš
œ˜K˜—šขœŸœ#Ÿœ˜<Kš
œ*˜*š
œ=˜=Kš
œ9™9—Kš
œ˜Kš
œ˜K˜—šขœŸœŸœŸœŸœŸœŸœ˜UšŸœ"Ÿœ
Ÿ˜1KšœŸœŸœ(Ÿœ˜CKšŸœ
˜—KšŸœ˜K˜K˜—šขœŸœŸœ'Ÿœ˜SKš
œz™zKšŸœ
ŸœŸœ
˜KšœŸœŸœ
˜KšœŸœ
Ÿœ˜Kš
œ˜šŸœŸ˜!Kš
œ$™$KšœŸœŸœ
˜KšœŸœŸœ
˜Kšœ
ŸœŸœ
˜KšœŸœŸœ
˜KšœŸœŸœA˜RKšœŸœŸœ
˜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šŸœ
Ÿœ  ˜7KšŸœ
ŸœŸœ
ŸœŸœŸœ˜L—K˜—Kš
œ,˜,šŸœŸœ˜
šŸœ˜šŸœ˜KšŸœ™šŸœ˜KšŸœ8Ÿœ˜A—KšŸœ˜K˜
—KšŸœ˜!—K˜—Kš
ŸœŸœ
ŸœŸœ(Ÿœ
˜TKšœ"ŸœŸœ˜8Kšœ"ŸœŸœ˜8š
œ
˜
š
œ ˜ KšœŸœŸœ˜.Kš
œ˜—šŸœ˜KšŸœŸœŸœ
˜)Kš
œ˜Kš
œ˜K˜—Kš
œ˜—Kš
œ˜KšŸœŸœ
Ÿœ
˜šŸœŸ˜Kš
œ™KšœŸœ!˜)šŸœŸ˜Kš
œ1˜1KšœŸœ
˜KšŸœŸœ
˜—Kš
œ7˜7KšŸœ
˜—Kš
œ˜KšœŸœ
˜Kš
œ˜K˜š
œ
˜
šœŸœ
ŸœŸœ˜ š
œ˜š
œ˜Kš
œ!˜!Kš	œ
ŸœŸœ
ŸœŸœ˜GKš
œ˜Kš
œ˜—KšœŸœŸœŸœ˜7K˜—K˜—šœŸœ˜7Kš
œ˜Kš
œ	˜	Kš
œ	˜	Kš
œ˜Kš
œ
˜
KšœŸœ˜—KšœŸœ
˜Kš
œ3˜3Kš
œ4˜4Kšœ0Ÿœ
Ÿœ˜RKš
œ;˜;Kš
œ+˜+Kš
œ˜—K˜šŸœ˜KšŸœ
Ÿœ+˜2KšŸœ
Ÿœ9˜@—KšŸœ
˜—K˜Kš
œR™RKšŸœŸœ
ŸœŸœ
˜=Kš
œ˜K˜—šœ#Ÿœ˜,KšŸœŸœŸœ	Ÿœ™'KšŸœŸœ˜/Kš
œ˜K˜—š
ขœŸœ
ŸœŸœŸœ	˜SKšœ
ŸœG˜ZKšœŸœŸœM˜aKšŸœŸœ
ŸœŸœ
Ÿœ
Ÿœ
˜.Kš
œ˜K˜—šขœŸœ
Ÿœ
Ÿœ
˜1KšœŸœH˜NKšŸœ
Ÿœ
˜Kš
œ˜K˜—šขœŸœ˜Kš
œX™XKšœŸœ
Ÿœ˜KšœŸœ˜KšœŸœ
˜KšœŸœ
˜Kšœ
Ÿœ
˜KšœŸœ
˜KšœŸœ
˜KšœŸœ
˜KšœŸœ
˜KšœŸœ
˜KšŸœŸœŸœ
˜$˜
KšŸœŸœŸœ
˜)šŸœŸœ
Ÿ˜KšŸœ@˜B—KšŸœŸœ
Ÿœ˜(KšŸœŸœ
Ÿœ
Ÿœ˜ K˜—K˜K˜—šขœŸœ
Ÿœ ŸœŸœŸœ˜OKšŸœ
ŸœŸœ
˜KšŸœ
ŸœŸœ
Ÿœ˜5KšŸœ&˜,Kš
œ˜K˜—šขœŸœ
Ÿœ˜.KšŸœ
ŸœŸœ
˜KšœŸœ
˜Kš
œ˜K˜—šขœŸœ˜&KšŸœ
ŸœŸœ
˜KšœŸœ
˜Kš
œ˜Kš
œ˜K˜—š
ขœŸœ
Ÿœ
ŸœŸœ˜;KšŸœ
ŸœŸœ
˜KšŸœ˜Kš
œ˜K˜—šขœŸ
œŸœ˜0KšŸœ
ŸœŸœ
˜KšŸœ
Ÿœ
ŸœŸœ
˜/KšœŸœ
˜Kš
œ˜KšŸœŸœ
Ÿœ
˜KšŸœ'Ÿœ]˜Š
KšœŸœ˜$Kš
œ˜K˜—šขœŸœ
Ÿœ˜(KšŸœ
ŸœŸœ
˜KšœŸœ
˜KšŸœ
˜Kš
œ˜K˜—šข
œŸœ
Ÿœ˜&KšŸœ
ŸœŸœ
˜KšœŸœŸœ
˜KšœŸœ
˜š
œ1˜1KšœŸœŸœ˜%—Kšœ#Ÿœ
ŸœŸœ˜IKšŸœ
ŸœŸœ˜Kš
œ˜K˜—šขœŸœ
Ÿœ˜/KšŸœ
ŸœŸœ
˜KšœŸœ
˜Kš
œ˜K˜—šขœŸœ
Ÿœ˜1KšŸœ
ŸœŸœ
˜KšœŸœ
˜Kš
œ˜K˜—š
ขœŸœ
Ÿœ
ŸœŸœ˜>KšŸœ
ŸœŸœ
˜KšŸœ˜Kš
œ˜—K˜šขœŸœ
Ÿœ&˜HKšŸœ
ŸœŸœ
˜KšœŸœ
˜Kš
œ˜Kš
œ˜K˜—šขœŸœ
Ÿœ˜4KšŸœ
ŸœŸœ
˜KšœŸœ
˜Kš
œ˜K˜—š
ขœŸœ
Ÿœ
ŸœŸœ˜\KšŸœ
ŸœŸœ
˜KšŸœ'˜-Kš
œ˜K˜—šขœŸœ
Ÿœ˜-KšŸœ
ŸœŸœ
˜KšœŸœ
˜Kš
œ˜K˜—šขœŸœ
Ÿœ˜/KšŸœ
ŸœŸœ
˜KšœŸœ
˜Kš
œ˜K˜—š
ขœŸœ
Ÿœ
ŸœŸœ˜<KšŸœ
ŸœŸœ
˜KšŸœ˜Kš
œ˜—K˜šขœŸœ
Ÿœ˜1KšŸœ
ŸœŸœ
˜šŸœŸœ
Ÿ˜Kšœ#ŸœŸœ˜9—KšŸœŸœŸœ
˜$KšœŸœ
˜Kš
œ˜K˜—š
ขœŸœ
Ÿœ
ŸœŸœ˜@KšŸœ
ŸœŸœ
˜KšŸœ˜Kš
œ˜—K˜šกœŸœ˜#Kšœ	ŸœŸœ,Ÿœ
™NKšœŸœ˜-Kš
œ˜K˜—šขœŸœŸœ
Ÿœ˜<šœ!Ÿœ˜<KšœŸœ™—šœŸœ
ŸœŸœ˜Kš
œ:˜:Kšœ ˜—KšœŸœ˜!KšŸœŸœ
Ÿœ˜#K˜K˜—šกœŸœ˜'Kšœ	ŸœŸœ,Ÿœ
™NKšœŸœ˜'šŸœ
Ÿ˜Kš
œ=˜=KšŸœ-˜4—Kš
œ˜K˜—šฃœŸœŸœŸœŸœŸœ˜@KšœŸœ
˜KšœŸœŸœ
˜KšœŸœŸœ
˜Kš
œ˜šกœŸœ
ŸœŸœ˜KšœŸœ
˜Kšœ	Ÿœ
˜
Kš
œ*˜*Kš
œ=˜=KšŸœŸœ
ŸœA˜VšŸœŸ˜)Kš
œ˜š
œ˜KšŸœŸœ*˜6K˜—šŸœ˜Kš
œ#˜#KšŸœ
˜Kš
œ˜——KšœŸœ#Ÿœ#˜Tšœ
Ÿœ!Ÿœ
Ÿœ˜4šœŸœ˜KšŸœ+˜/KšŸœ)˜-—Kš
œ˜Kš
œ˜šŸœ˜KšœŸœ
˜Kš
œ0˜0Kš
œ˜—K˜—Kš
œ˜—K˜KšŸœŸœ
Ÿœ˜&Kš	œŸœŸœ
ŸœŸœ!˜QK˜KšŸœŸœ
Ÿœ˜šŸœŸœ	Ÿœ
Ÿœ˜*Kš
œ>˜>Kš
œ6˜6KšŸœ
˜Kš
œ˜—Kš
œ˜Kš
œ˜K˜—šก
œŸœ˜)Kšœ	ŸœŸœ,Ÿœ
™NKšœŸœ˜'Kš
œ+˜+Kš
œ˜K˜—š
ฃœŸœŸœŸœŸœ˜IKšŸœ ;˜BKš
œ˜K˜—šฃœŸœŸœŸœŸœŸœŸœ˜SKšŸœ ;˜BKš
œ˜K˜—š
ขœŸœ
ŸœŸœŸœ˜DKšŸœ ;˜BKš
œ˜K˜—š
ขœŸœŸœŸœŸœ˜EKšŸœ ;˜BKš
œ˜K˜—šข	œŸœŸœŸœŸœŸœŸœ˜OKšŸœ ;˜BKš
œ˜K˜—šข
œŸœŸœŸœŸœ
Ÿœ˜IKšŸœ ;˜BKš
œ˜K˜—šก
œŸœŸœŸœ˜.KšœŸœŸœ
˜KšœŸœ
ŸœŸœ
˜šœŸœ
ŸœŸœ˜KšœŸœ
˜KšœŸœ
˜š
Ÿ˜š
œ˜Kš	œŸœŸœ
ŸœŸœ!˜K—Kš
œ>˜>KšŸœŸœ
Ÿœ
Ÿœ
˜šŸœŸœ
Ÿ˜š
œ
˜
Kš
œ:˜:Kš
œN˜NKšœŸœ˜šŸœŸœ
Ÿ˜Kš
œ+˜+KšŸœ
˜—KšŸœŸœŸœ˜9Kš
œ3˜3Kš
œI˜IKš
œ/˜/K˜—KšŸœ
˜—KšŸœ
˜—Kš
œ˜—K™K™
KšŸœŸœ
Ÿœ˜&Kš
œ˜Kš
œ6˜6K˜šŸœŸ˜KšŸœ&˜*KšŸœ˜—Kš
œ˜K˜—šก
œŸœ˜)Kšœ	ŸœŸœ,Ÿœ
™NKšœŸœ˜'šŸœ
Ÿ˜Kš
œ2˜2Kš
œ7˜7KšŸœ
˜—Kš
œ˜K˜—šขœŸœŸœŸœ˜2KšœŸœŸœ
˜KšœŸœ
ŸœŸœ
˜šœŸœ
ŸœŸœ˜KšœŸœ
˜KšœŸœ
˜š
Ÿ˜š
œ˜Kš	œŸœŸœ
ŸœŸœ!˜K—Kš
œ>˜>KšŸœŸœ
Ÿœ
Ÿœ
˜šŸœŸœ
Ÿ˜š
œ
˜
KšŸœŸœ%Ÿœ˜CKš
œ˜Kš
œK˜KK˜—KšŸœ
˜—KšŸœ
˜—Kš
œ˜—K™
KšŸœŸœ
Ÿœ˜&Kš
œ˜Kš
œ(˜(K˜šŸœŸ˜KšŸœ&˜*KšŸœ˜—Kš
œ˜K˜—šฃ
œŸœŸœ-Ÿœ˜WKšœ
ŸœŸœ
˜KšœŸœ
˜KšœŸœ
ŸœŸœ
˜K˜šœŸœ
ŸœŸœ˜šŸœ˜šŸœ˜Kš
œ&™&šŸœŸ˜KšŸœ˜!š
Ÿ˜šŸœŸœ
Ÿ˜š
œ
˜
Kš
œ˜šŸœŸœ
Ÿ˜Kš
œ˜KšŸœ
˜—šŸœ	Ÿ˜KšŸœ:˜>KšŸœ˜—K˜—KšŸœ˜%———K˜
—šŸœ˜Kš
œ™KšœŸœ
˜KšœŸœ
˜š
Ÿ˜š
œ˜Kš	œŸœŸœ
ŸœŸœ!˜K—Kš
œ>˜>KšŸœŸœ
Ÿœ3Ÿœ˜IšŸœŸœ
Ÿ˜š
œ
˜
KšŸœŸœ%Ÿœ˜CšŸœŸœ˜Kš
œ
˜
Kš
œ˜K˜—K˜—KšŸœ
˜—KšŸœ
˜—K˜——Kš
œ˜—K™
KšŸœŸœ
Ÿœ˜&Kš
œ˜KšŸœ#˜%K˜šŸœ
Ÿœ
Ÿ˜KšœŸœŸœ3˜BKšœŸœŸœ˜$KšŸœŸœ:˜G—Kš
œ˜K˜—šกœŸœ˜(Kšœ	ŸœŸœ,Ÿœ
™NKšœŸœ˜'šŸœ
Ÿ˜Kš
œ=˜=Kš
œD˜DKš
œ?˜?KšŸœŸœ
˜—Kš
œ˜K˜—šฃ	œŸœ
ŸœŸœ˜7šœŸœ
ŸœŸœ˜KšŸœŸœ
ŸœŸœ
Ÿœ
Ÿœ
˜4Kš
œ˜KšœDŸœ˜JKš
œ˜—KšŸœŸœ
Ÿœ˜&Kš
œ,˜,Kš
œ˜K˜—š
ฃœŸœ
ŸœŸœŸœ˜7KšŸœ
ŸœŸœ
˜KšœŸœ
˜šŸœŸ˜
˜KšœŸœŸœ
˜KšœŸœ
˜šŸœŸ˜Kš
œ#˜#KšŸœŸœ
Ÿœ4Ÿœ˜LKš
œ˜—KšŸœ
˜KšŸœŸœ
Ÿœ1˜CK˜—Kš
œC˜C˜KšœŸœ
˜KšœŸœ˜šŸœ	Ÿ˜KšœŸœ
˜šŸœŸœ˜%Kš
œ/˜/Kš
œ0˜0KšŸœ˜—Kš
œ ˜ šŸœ˜KšŸœ*Ÿœ
˜5—Kš
œ˜—KšŸœ
˜Kš
œ0˜0K˜——KšŸœ
˜Kš
œ˜K˜—šฃœŸœŸœŸœ
ŸœŸœ˜<KšœŸœ0˜;š
œ˜šŸœ˜KšŸœ
ŸœŸœ
˜.KšŸœ
Ÿœ!Ÿœ˜8——Kš
œ˜K˜—šกœŸœ˜(Kšœ	ŸœŸœ,Ÿœ
™NKšœŸœ˜'Kš
œ*˜*Kš
œ˜K˜—šก
œŸœ˜&Kšœ	ŸœŸœ,Ÿœ
™NKšœŸœ˜'Kš
œ˜Kš
œ˜Kš
œ˜K˜—šกœŸœ˜$Kšœ	ŸœŸœ,Ÿœ
™NKšœŸœ˜'Kš
œ˜Kš
œ˜Kš
œ˜K˜—šกœŸœ˜8Kšœ#Ÿœ
™'KšœŸœ˜'Kš
œ!˜!Kš
œ˜Kš
œ˜K˜—šก	œŸœ˜%Kšœ	ŸœŸœ,Ÿœ
™NKšœŸœ˜'Kš
œ'˜'Kš
œ˜K˜—šฃœŸœŸœ˜"KšœŸœ
˜KšœŸœ
˜šœ!Ÿœ˜*Kš
œ™Kš
œ˜—KšŸœŸœ
Ÿœ˜&Kš
œ<˜<šŸœŸœ
Ÿ˜Kš
œP˜P—Kš
œ˜K˜—šกœ˜'Kš	œ-ŸœŸœ	ŸœŸœ
™PšŸœŸ˜š
œ
˜
šŸœ1Ÿœ
Ÿ˜@š
œ˜Kš
ŸœŸœ
Ÿœ
ŸœŸœ˜$šŸœ
ŸœŸœ
Ÿœ˜*Kš
œ˜KšœŸœ˜&K˜—KšŸœŸœŸœ
˜$K˜—KšŸœ
˜——KšŸœ
˜—Kš
œ˜K˜—šข	œŸœŸœ˜&KšœŸœ
˜KšœŸœ˜KšœŸœ˜KšŸœŸœ
Ÿœ˜&KšŸœŸœ
ŸœŸœ
ŸœŸœ
Ÿœ
Ÿœ
˜MKš
œ,˜,Kš
œ,˜,Kš
œ˜Kšœ=Ÿœ˜CKš
œ)˜)KšœbŸœ˜hKš
œ)˜)KšœTŸœŸœ˜sK˜—K˜KšœŸœ
˜šœ4Ÿœ˜=Kš
œ™KšœŸœ7Ÿœ˜GšŸœŸœ˜Kš
œ˜šŸœ
Ÿœ˜KšŸœ*Ÿœ˜A—KšŸœ
˜K˜—šŸœŸœ 0˜PšŸœ
Ÿœ˜
KšŸœ*Ÿœ˜@KšŸœ+˜/—Kš
œ˜K˜—K˜—K˜šœ&Ÿœ˜/Kšœ1ŸœŸœ
Ÿœ
™JKš
œ:˜:Kš
œT˜TK˜K˜—šœ$Ÿœ˜-Kšœ1ŸœŸœ
Ÿœ
™JKš
œ:˜:KšœŸœ"˜,KšŸœŸœ
ŸœA˜SKš
œR˜RK˜K˜—šœ'Ÿœ˜0Kšœ1ŸœŸœ
Ÿœ
™JKšœŸœ˜!Kš
œ,˜,Kš
œB˜BKš
œ˜K˜K˜—šœ*Ÿœ˜3Kšœ1ŸœŸœ
Ÿœ
™JKš
œ˜Kš
œ˜KšœŸœ˜Kš
œ:˜:KšœŸœ"˜,KšŸœŸœ
Ÿœ@˜SKš
œ˜Kš
œ˜Kš
œ7˜7Kš
œ0˜0Kš
œ%˜%Kš
œ˜K˜K˜—šœ-Ÿœ˜6Kšœ1ŸœŸœ
Ÿœ
™JKš
œ:˜:KšœŸœ"˜,KšŸœŸœ
Ÿœ@˜Sš
œ(˜(Kš
œ˜Kš
œ7˜7Kš
œ˜—K˜K˜—šœ0Ÿœ˜9Kšœ1ŸœŸœ
Ÿœ
™JKšœŸœ˜Kš
œ5˜5Kš
œ>˜>Kš
œ˜K˜—K™š
œ
™
K˜Kš
œG˜GK˜Kš
œo˜oK˜K˜6K˜—šŸœ
˜K˜——…—bน