DIRECTORY
Basics USING [BITAND, BITSHIFT, HighByte, LongNumber, LowByte, LowHalf],
Endian USING [ FWORD ],
IO USING [card, int, PutF, STREAM],
Process USING [MsecToTicks, SetTimeout],
Pup USING [Address, nullAddress ],
PupBuffer USING [ Buffer ],
PupName USING [ AddressLookup, AddressToRope, Error, NameLookup ],
PupSocket USING [ Socket, Get, Send, CreateEphemeral, CreateServer, AllocBuffer, FreeBuffer, Destroy, SetUserSize ],
PupType USING [ Type ],
Rope USING [ROPE],
TeleLoad;

TeleLoadImpl: CEDAR MONITOR
IMPORTS Basics, IO, Process, PupName, PupSocket
EXPORTS TeleLoad = {
OPEN TeleLoad;

BitOp: TYPE = PROC [a, b: UNSPECIFIED] RETURNS [UNSPECIFIED];

And: BitOp = INLINE { RETURN[Basics.BITAND[a,b]]; };
Shift: BitOp = INLINE { RETURN[Basics.BITSHIFT[a,b]]; };

locMaxByte: PUBLIC NAT _ 150;
kingWaitTime: INT _ 200;	-- Packet exchange reply wait time

NameToAddress: PUBLIC PROC [name: Rope.ROPE] RETURNS [address: Pup.Address, ok: BOOL _ TRUE] = {
address _ PupName.NameLookup[name, teleSwatSocket !
PupName.Error => {ok _ FALSE; CONTINUE; }];
};

AddressToName: PUBLIC PROC [address: Pup.Address] RETURNS [nameRope, addressRope: Rope.ROPE] = {
nameRope _ PupName.AddressLookup[address];
addressRope _ PupName.AddressToRope[address];
};

Start: PUBLIC PROC [host: Rope.ROPE, log: IO.STREAM] RETURNS [h: Handle] = {
sendHim: Pup.Address;
allok: BOOL;
[sendHim, allok] _ NameToAddress[host];
sendHim.socket _ TeleLoad.teleSwatSocket;
IF NOT allok THEN RETURN[NIL];
h _ NEW[TLObject _ [
host: host,
address: sendHim,
cacheSize: locMaxByte,
log: log]];
RETURN[h];
};

Stop: PUBLIC PROC [h: Handle] = {
IF h=NIL THEN RETURN;
h.host _ NIL;
h.log _ NIL;
};

Store: PUBLIC ENTRY TeleLoadProc = {
ENABLE UNWIND => NULL;
[ok, attempts] _ GStore[h: h, requestcb: cb, type: coreStoreRequest, tries: tries];
};

Fetch: PUBLIC ENTRY TeleLoadProc = {
ENABLE UNWIND => NULL;
[ok, attempts] _ GFetch[h: h, requestcb: cb, type: coreFetchRequest, tries: tries];
};

SlaveStore: PUBLIC ENTRY TeleLoadProc = {
ENABLE UNWIND => NULL;
[ok, attempts] _ GStore[h: h, requestcb: cb, type: slaveStoreRequest, tries: tries];
};

SlaveFetch: PUBLIC ENTRY TeleLoadProc = {
ENABLE UNWIND => NULL;
[ok, attempts] _ GFetch[h: h, requestcb: cb, type: slaveFetchRequest, tries: tries];
};

Call: PUBLIC ENTRY TeleLoadProc = {
ENABLE UNWIND => NULL;
[ok, attempts] _ GExchange[h: h, requestcb: cb, type: callRequest, tries: tries];
};

Go: PUBLIC ENTRY TeleLoadProc = {
ENABLE UNWIND => NULL;
[ok, attempts] _ GStore[h: h, requestcb: cb, type: goRequest, tries: 1];
};

GoFromBreak: PUBLIC ENTRY TeleLoadProc = {
ENABLE UNWIND => NULL;
[ok, attempts] _ GStore[h: h, requestcb: cb, type: goFromBreakRequest, tries: 1];
};

SingleStep: PUBLIC ENTRY TeleLoadProc = {
ENABLE UNWIND => NULL;
[ok, attempts] _ GStore[h: h, requestcb: cb, type: singleStepRequest, tries: 1];
};

FetchState: PUBLIC ENTRY TeleLoadProc = {
ENABLE UNWIND => NULL;
[ok, attempts] _ GFetch[h: h, requestcb: cb, type: stateFetchRequest, tries: tries];
};

GoToDebugger: PUBLIC ENTRY TeleLoadProc = TRUSTED {
ENABLE UNWIND => NULL;
b: PupBuffer.Buffer _ PupSocket.AllocBuffer[king];
replycb: CorePkt;
replycb _ LOOPHOLE[@b.body];
replycb.advice _ cb.advice;
replycb.address _ cb.address;
replycb.count _ cb.count;
FOR j: CARDINAL IN [0..cb.count) DO
replycb.data[j] _ cb.data[j];
ENDLOOP;
PupSocket.SetUserSize[b, SIZE[CorePktObject]+((cb.count+1)/2)];
b.id _ NewPupID[];
b.type _ debugRequest;
KingSend[b, h.address];
};


eventServerUseCount: INT _ 0;
eventServerActive: BOOL _ FALSE;
eventServerProcess: PROCESS;
eventServerPollingInterval: NAT _ 500;
eventSocket: PupSocket.Socket _ NIL;
eventClientProcedure: EventProc;
eventClientData: REF ANY;

StartEventServer: PUBLIC ENTRY PROC [proc: EventProc, clientData: REF ANY] = {
eventServerUseCount _ eventServerUseCount + 1;
IF eventServerUseCount > 1 THEN RETURN;
IF eventServerActive THEN RETURN;
eventClientProcedure _ proc;
eventClientData _ clientData;
eventServerActive _ TRUE;
eventServerProcess _ FORK TeleloadEventServer[];
};

StopEventServer: PUBLIC ENTRY PROC = TRUSTED {
eventServerUseCount _ MAX[0, eventServerUseCount - 1];
IF eventServerUseCount > 0 THEN RETURN;
eventServerActive _ FALSE;
JOIN eventServerProcess;
};

TeleloadEventServer: PROC =  TRUSTED{
b: PupBuffer.Buffer _ NIL;
er: EventRecord;
cp: CorePkt;
eventSocket _ PupSocket.CreateServer[
local: teleSwatSocket, getTimeout: eventServerPollingInterval];
DO
b _ eventSocket.Get[];
IF b # NIL THEN {
cp _ LOOPHOLE[@b.body];
er _ LOOPHOLE[@cp^.data];
eventClientProcedure[b.source, er^, eventClientData];
PupSocket.FreeBuffer[b];
};
IF NOT eventServerActive THEN EXIT;
ENDLOOP;
eventClientData _ NIL;
eventClientProcedure _ NIL;
PupSocket.Destroy[eventSocket];
};

GStore: INTERNAL PROC [h: Handle, requestcb: CoreBlock, type: PupType.Type, tries: NAT] RETURNS [a: BOOL _ TRUE, actualAttempts: NAT] = TRUSTED {
b: PupBuffer.Buffer _ NIL;
replycb: CorePkt;
IF h=NIL THEN RETURN[FALSE, 0];
FOR actualAttempts IN [1..tries] DO
id: Endian.FWORD _ NewPupID[];
IF b#NIL THEN PupSocket.FreeBuffer[b];
b _ PupSocket.AllocBuffer[king];
replycb _ LOOPHOLE[@b.body];
replycb.advice _ requestcb.advice;
replycb.address _ requestcb.address;
replycb.count _ requestcb.count;
FOR j: CARDINAL IN [0..requestcb.count) DO
replycb.data[j] _ requestcb.data[j];
ENDLOOP;
PupSocket.SetUserSize[b, SIZE[CorePktObject]+((requestcb.count+1)/2)];
b _ Exchange[h, b, type, id];
IF b=NIL THEN LOOP;
replycb _ LOOPHOLE[@b.body];
IF NOT Check[requestcb, replycb] THEN LOOP;
requestcb.advice _ replycb.advice;
EXIT;
REPEAT
FINISHED => a _ FALSE;
ENDLOOP;
IF b#NIL THEN PupSocket.FreeBuffer[b];
};

GFetch: INTERNAL PROC [h: Handle, requestcb: CoreBlock, type: PupType.Type, tries: CARDINAL] RETURNS [a: BOOL _ TRUE, actualAttempts: NAT] = TRUSTED {
b: PupBuffer.Buffer _ NIL;
id: Endian.FWORD _ NewPupID[];
replycb: CorePkt;
IF h=NIL THEN RETURN[FALSE, 0];
FOR actualAttempts IN [1..tries] DO
IF b#NIL THEN PupSocket.FreeBuffer[b];
b _ PupSocket.AllocBuffer[king];
replycb _ LOOPHOLE[@b.body];
replycb.advice _ requestcb.advice;
replycb.address _ requestcb.address;
replycb.count _ requestcb.count;
PupSocket.SetUserSize[b, SIZE[CorePktObject]];
b _ Exchange[h, b, type, id];
IF b=NIL THEN LOOP;
replycb _ LOOPHOLE[@b.body];
IF replycb.address # requestcb.address THEN LOOP;
IF replycb.count # requestcb.count THEN LOOP;
FOR j: CARDINAL IN [0..requestcb.count) DO
requestcb.data[j] _ replycb.data[j];
ENDLOOP;
requestcb.advice _ replycb.advice;
EXIT;
REPEAT
FINISHED => a _ FALSE;
ENDLOOP;
IF b#NIL THEN PupSocket.FreeBuffer[b];
};

GExchange: INTERNAL PROC [h: Handle, requestcb: CoreBlock, type: PupType.Type, tries: CARDINAL] RETURNS [a: BOOL _ TRUE, actualAttempts: NAT] = TRUSTED {
b: PupBuffer.Buffer _ NIL;
id: Endian.FWORD _ NewPupID[];
replycb: CorePkt;
IF h=NIL THEN RETURN[FALSE, 0];
FOR actualAttempts IN [1..tries] DO
IF b#NIL THEN PupSocket.FreeBuffer[b];
b _ PupSocket.AllocBuffer[king];
replycb _ LOOPHOLE[@b.body];
replycb.advice _ requestcb.advice;
replycb.address _ requestcb.address;
replycb.count _ requestcb.count;
FOR j: CARDINAL IN [0..requestcb.count) DO
replycb.data[j] _ requestcb.data[j];
ENDLOOP;
PupSocket.SetUserSize[b, SIZE[CorePktObject]+((requestcb.count+1)/2)];
b.id _ id;
b _ Exchange[h, b, type, id];
IF b=NIL THEN LOOP;
replycb _ LOOPHOLE[@b.body];
IF replycb.address # requestcb.address THEN LOOP;
IF replycb.count # requestcb.count THEN LOOP;
FOR j: CARDINAL IN [0..requestcb.count) DO
requestcb.data[j] _ replycb.data[j];
ENDLOOP;
requestcb.advice _ replycb.advice;
EXIT;
REPEAT
FINISHED => a _ FALSE;
ENDLOOP;
IF b#NIL THEN PupSocket.FreeBuffer[b];
};

Exchange: INTERNAL PROC [h: Handle, request: PupBuffer.Buffer, type: PupType.Type, id: Endian.FWORD] RETURNS[PupBuffer.Buffer] = {
reply: PupBuffer.Buffer _ NIL;
waitTime: INT _ kingWaitTime;
request.id _ id;
request.type _ type;
KingSend[request, h.address];
DO
IF reply#NIL THEN PupSocket.FreeBuffer[reply];
reply _ KingGet[h.address, waitTime];
waitTime _ waitTime + kingWaitTime;
IF reply = NIL THEN RETURN[NIL];
IF reply.type # LOOPHOLE[LOOPHOLE[type, CARDINAL]+1] THEN LOOP;
IF reply.id # id THEN LOOP;
RETURN[reply];
ENDLOOP;
};

Check: INTERNAL PROC [a: CoreBlock, b: CorePkt]	RETURNS [BOOL] = TRUSTED {
IF a.address # b.address THEN RETURN[FALSE];
IF a.count # b.count THEN RETURN[FALSE];
FOR i: CARDINAL IN [0..a.count) DO
IF a.data[i] # b.data[i] THEN RETURN[FALSE];
ENDLOOP;
RETURN[TRUE];
};


Failed: PUBLIC ERROR = CODE;
GetCoreBlock: PUBLIC ENTRY PROC[h: Handle, addr: CoreAddress, count: CARDINAL, addressSpace: AddressSpace _ main] RETURNS [cb: CoreBlock] = {
ENABLE UNWIND => NULL;
RETURN [GetCoreBlockInternal[h, addr, count, addressSpace]];
};

GetCoreBlockInternal: INTERNAL PROC[h: Handle, addr: CoreAddress, count: CARDINAL, addressSpace: AddressSpace] RETURNS [cb: CoreBlock] = {
ok: BOOLEAN;
tries: NAT;
cb _ NEW[CoreBlockObject[count]];
cb.address _ addr;
cb.advice _ [FALSE, FALSE, 0];
[ok, tries] _ GFetch[h, cb, IF addressSpace = main THEN coreFetchRequest ELSE slaveFetchRequest, 5];
IF NOT ok THEN {
IF h.log # NIL THEN h.log.PutF[" ... %d byte read from %08x failed, (%d tries).\n", IO.card[count], IO.card[cb.address], IO.int[tries]];
cb_NIL;
ERROR Failed;
};
};

ReadWord: PUBLIC ENTRY PROC [h: Handle, addr: CoreAddress, addressSpace: AddressSpace _ main] RETURNS [v: CARDINAL] = {
ENABLE UNWIND => NULL;
RETURN [ReadInternal[h, addr, addressSpace] + LOOPHOLE[Shift[ReadInternal[h, addr+1, addressSpace], 8], CARDINAL]];
};

Read: PUBLIC ENTRY PROC [h: Handle, addr: CoreAddress, addressSpace: AddressSpace _ main] RETURNS [v: CARDINAL] = {
ENABLE UNWIND => NULL;
RETURN[ReadInternal[h, addr, addressSpace]];
};

ReadInternal: INTERNAL PROC [h: Handle, addr: CoreAddress, addressSpace: AddressSpace] RETURNS [v: CARDINAL] = {
temp: Basics.LongNumber;
blockAddr: CoreAddress;
count: NAT _ h.cacheSize;
IF h.cacheSize = 0 THEN h.cacheSize _ locMaxByte;
h.cacheSize _ MAX[1, MIN[h.cacheSize, locMaxByte]];
temp.lc _ addr;
temp.lc _ temp.lc - (temp.lc MOD h.cacheSize);
blockAddr _ temp.lc;
IF h.cacheCB = NIL THEN {
h.cacheCB _ GetCoreBlockInternal[h: h, addr: blockAddr, count: h.cacheSize, addressSpace: addressSpace];
h.addressSpace _ addressSpace;
};
IF h.cacheCB.address # blockAddr OR h.addressSpace # addressSpace THEN {
FlushWritesInternal[h];
h.cacheCB _ GetCoreBlockInternal[h: h, addr: blockAddr, count: h.cacheSize, addressSpace: addressSpace];
h.addressSpace _ addressSpace;
};
RETURN[h.cacheCB.data[Basics.LowHalf[addr-blockAddr]]];
};

WriteWord: PUBLIC ENTRY PROC [h: Handle, addr: CoreAddress, value: CARDINAL, addressSpace: AddressSpace _ main] = {
ENABLE UNWIND => NULL;
WriteInternal[h, addr, And[value, 377B], addressSpace];
WriteInternal[h, addr + 1, Shift[value, -8], addressSpace];
};

Write: PUBLIC ENTRY PROC [h: Handle, addr: CoreAddress, value: CARDINAL, addressSpace: AddressSpace _ main] = {
ENABLE UNWIND => NULL;
WriteInternal[h, addr, value, addressSpace];
};

WriteInternal: INTERNAL PROC [h: Handle, addr: CoreAddress, value: CARDINAL, addressSpace: AddressSpace] = {
temp: Basics.LongNumber;
blockAddr: CoreAddress;
[] _ ReadInternal[h, addr, addressSpace];
temp.lc _ addr;
temp.lc _ temp.lc - (temp.lc MOD h.cacheSize);
blockAddr _ temp.lc;
h.cacheCB.data[Basics.LowHalf[addr-blockAddr]] _ value;
h.dirty _ TRUE;
};

FlushWrites: PUBLIC ENTRY PROC [h: Handle] = {
ENABLE UNWIND => NULL;
FlushWritesInternal[h];
};

FlushWritesInternal: INTERNAL PROC [h: Handle] = {
IF h.dirty THEN {
ok: BOOL;
tries: NAT;
[ok, tries] _ GStore[h, h.cacheCB, IF h.addressSpace = main THEN coreStoreRequest ELSE slaveStoreRequest, 5];
h.dirty _ FALSE;
IF NOT ok THEN {
IF h.log # NIL THEN h.log.PutF[" Write to %08x failed (%d tries), cache reset anyway.\n", IO.card[h.cacheCB.address], IO.int[tries]];
ERROR Failed;
};
};
};

ResetCache: PUBLIC ENTRY PROC [h: Handle] = {
ENABLE UNWIND => NULL;
FlushWritesInternal[h];
h.cacheCB _ NIL;
};

SetCacheSize: PUBLIC ENTRY PROC [h: Handle, bytes: NAT] = {
ENABLE UNWIND => NULL;
FlushWritesInternal[h];
h.cacheCB _ NIL;
h.cacheSize _ IF bytes = 0 THEN locMaxByte ELSE MAX[1, MIN[locMaxByte, bytes]];
};

Swab: PUBLIC PROC [a: CARDINAL] RETURNS [b: CARDINAL] = {
b _ Basics.BITSHIFT[Basics.LowByte[a], 8] + Basics.HighByte[a];
};

SwabState: PUBLIC PROC [state: State8086Object] RETURNS [State8086Object] = {
FOR i: Registers8086 IN [AX..FL] DO
state.Regs[i] _ Swab[state.Regs[i]];
ENDLOOP;
RETURN[state];
};

SwabEvent: PUBLIC PROC [state: EventRecordObject] RETURNS [EventRecordObject] = {
state.regs _ SwabState[state.regs];
state.reason _ Swab[state.reason];
state.clockLow _ Swab[state.clockLow];
state.clockHigh _ Swab[state.clockHigh];
state.bootSwitches _ Swab[state.bootSwitches];
state.advice _ Swab[state.advice];
state.monRelays _ Swab[state.monRelays];
state.tlNet _ Swab[state.tlNet];
state.tlHost _ Swab[state.tlHost];
state.tlImHost _ Swab[state.tlImHost];
state.localNet _ Swab[state.localNet];
RETURN[state];
};

kingUseCount: INT _ 0;
kingWait: CONDITION;
lastPacket: PupBuffer.Buffer;
pleaseStopKing: BOOL _ TRUE;
myID: Endian.FWORD _ [1711, 1];

king: PupSocket.Socket;
kingProcess: PROCESS;

KingGet: INTERNAL PROC [from: Pup.Address, waitTime: INT_kingWaitTime] RETURNS [PupBuffer.Buffer] = TRUSTED {
b: PupBuffer.Buffer;
IF lastPacket # NIL AND lastPacket.source.net = from.net AND lastPacket.source.host = from.host THEN {
b _ lastPacket;
lastPacket _ NIL;
RETURN[b];
};
Process.SetTimeout[condition: @kingWait, ticks: Process.MsecToTicks[waitTime]];
WAIT kingWait;
IF lastPacket # NIL AND lastPacket.source.net = from.net AND lastPacket.source.host = from.host THEN {
b _ lastPacket;
lastPacket _ NIL;
RETURN[b];
};
RETURN[NIL];
};

NewPupID: INTERNAL PROC RETURNS [Endian.FWORD] = {
myID.low _ myID.low + 1;
RETURN [myID];
};

KingSend: INTERNAL PROC [b: PupBuffer.Buffer _ NIL, to: Pup.Address] = {
IF king = NIL THEN {
RETURN;
};
PupSocket.Send[king, b, to];
};

KingDaemon: PROC = {
b: PupBuffer.Buffer;
SetKingPacket: ENTRY PROC [b: PupBuffer.Buffer] = {
IF lastPacket # NIL THEN PupSocket.FreeBuffer[lastPacket];
lastPacket _ b;
NOTIFY kingWait;
};
king _ PupSocket.CreateEphemeral[remote: Pup.nullAddress, getTimeout: 500];
DO
IF pleaseStopKing THEN EXIT;
b _ king.Get[];
IF b # NIL THEN SetKingPacket[b];
ENDLOOP;
PupSocket.Destroy[king];
king _ NIL;
SetKingPacket[NIL];
};

StartKing: PUBLIC ENTRY PROC = {
kingUseCount _ kingUseCount + 1;
IF kingUseCount > 1 THEN RETURN;
IF NOT pleaseStopKing THEN RETURN; 
pleaseStopKing _ FALSE;
kingProcess _ FORK KingDaemon[];
};

StopKing: PUBLIC PROC = TRUSTED  {
giveUp: BOOL _ FALSE;
GetLock: ENTRY PROC = TRUSTED {
kingUseCount _ MAX[0, kingUseCount - 1];
IF kingUseCount > 0 THEN giveUp _ TRUE; 
IF pleaseStopKing THEN giveUp _ TRUE; 
pleaseStopKing _ TRUE;
};
GetLock[];
IF NOT giveUp THEN JOIN kingProcess;
};

StopHimProbing: PUBLIC ENTRY PROC [h: Handle, setPointers: BOOL] = TRUSTED {
replycb: CorePkt;
b: PupBuffer.Buffer _ NIL;
IF h = NIL THEN RETURN;
b _ PupSocket.AllocBuffer[king];
replycb _ LOOPHOLE[@b.body];
replycb.advice _ [setPointers, FALSE, 0];
replycb.address _ 0;
replycb.count _ 10;
PupSocket.SetUserSize[b, SIZE[CorePktObject]];
b.id _ NewPupID[];
b.type _ coreFetchRequest;
KingSend[b, h.address];
};

GetEventData: PUBLIC PROC [h: Handle, setPointers: BOOL] RETURNS [event: EventRecordObject, ok: BOOL] = TRUSTED {
deleteOnReturn: BOOL _ FALSE;
er: EventRecord;
cb: CoreBlock;
IF h = NIL THEN RETURN [event: event, ok: FALSE];
cb _ NEW[CoreBlockObject[SIZE[EventRecordObject] * 2]];
cb.address _ 0DA00H;
cb.advice _ [setPointers, FALSE, 0];
ok _ Fetch[h, cb, 1].ok;
IF NOT ok THEN RETURN [event: event, ok: FALSE];
er _ LOOPHOLE[BASE[DESCRIPTOR[cb.data]], EventRecord];
event _ SwabEvent[er^];
RETURN [event: event, ok: TRUE];
};


}.

December 30, 1981	3:14 PM, Stewart, created from AudioSocket.mesa
December 22, 1982 3:17 pm, Stewart, modifications to TeleLoad
April 25, 1983 11:22 am, LCS, new Event interface and locMaxByte
May 28, 1983 5:47 pm, LCS, cacheSize added, in order to make alteration of running program safe!
December 26, 1983 2:40 pm, LCS, patchup addresses with StripChar
May 16, 1986 10:26:24 am PDT, DCS, increase packet exchange wait time, make it a global vbl.
ΦTeleLoadImpl.mesa
Copyright c 1986 by Xerox Corporation.  All rights reserved.
Last Edited by: Stewart, December 26, 1983 4:11 pm
Last Edited by: Swinehart, June 6, 1986 8:16:51 am PDT
Hammonds, July 9, 1986 9:23:21 am PDT
Fires up a process to watch for unsolicited news items from debugees
Communication stuff more conveniently arranged

Here lives the single king socket.

These variables are only touched by procedures in the monitor
These variables are handled outside the monitor
PupSocket.FreeBuffer[b]; -- no socket to free it to, "drop it on the floor".
Swinehart, May 16, 1986 10:01:07 am PDT
Cedar 6.1
changes to: TeleLoadImpl
 , NameToAddress
 , AddressToName
 , Start
 , Stop
 , Store
 , Fetch
 , SlaveStore
 , SlaveFetch
 , Call
 , Go
 , GoFromBreak
 , SingleStep
 , FetchState
 , GoToDebugger
 , StartEventServer
 , StopEventServer
 , TeleloadEventServer
 , GStore
 , GFetch
 , GExchange
 , Exchange
 , GetCoreBlock
 , ReadWord
 , Read
 , WriteWord
 , Write
 , FlushWrites
 , ResetCache
 , SetCacheSize
 , Swab
 , SwabState
 , SwabEvent
 , KingGet
 , KingSend
 , KingDaemon
 , SetKingPacket (local of KingDaemon)
 , StartKing
 , StopKing
 , StopHimProbing
 , GetEventData
 

ΚT˜š
œ™Icodešœ
Οm
œ1™<Jš
œ2™2J™6K™%—J˜š
Οk	˜	Jšœžœžœžœ*˜HJšœžœžœ˜Jšžœ
žœžœ˜#Jšœžœ˜(Jšœžœ˜"Jšœ
žœ˜Jšœžœ5˜BJšœ
žœe˜tJšœžœ
˜Jšœžœžœ˜J˜	J˜—šœž
˜Jšžœ	žœ˜/šžœ
˜Jšžœ
˜—J˜JšΟnœžœžœžœžœžœ˜=J˜Jšœ
žœžœžœ
˜4Jšœžœžœžœ
˜8J˜Jšœžœ
žœ˜JšœžœΟc"˜;J˜šŸ
œžœ
žœ
žœžœžœžœ˜`š
œ3˜3Jšœžœžœ˜+—J˜J˜—š
Ÿ
œžœ
žœžœžœ˜`Jš
œ*˜*Jš
œ-˜-J˜J˜—šŸœžœ
žœ
žœžœ
žœžœ˜LJ˜Jšœžœ
˜J˜'J˜)Jš
žœ
žœžœ
žœ
žœ˜šœžœ
˜Jš
œ˜Jš
œ˜J˜Jš
œ˜—Jšžœ˜
J˜J˜—šŸœžœ
žœ˜!Jšžœžœ
žœ
žœ
˜Jšœ	žœ
˜
Jšœžœ
˜J˜J˜—šœžœ
žœ˜$Jšžœ
žœžœ
˜J˜SJ˜J˜—šœžœ
žœ˜$Jšžœ
žœžœ
˜Jš
œS˜SJ˜J˜—šœžœ
žœ˜)Jšžœ
žœžœ
˜Jš
œT˜TJ˜J˜—šœžœ
žœ˜)Jšžœ
žœžœ
˜Jš
œT˜TJ˜J˜—šœžœ
žœ˜#Jšžœ
žœžœ
˜Jš
œQ˜QJ˜—J˜šœžœ
žœ˜!Jšžœ
žœžœ
˜J˜HJ˜J˜—šœ
žœ
žœ˜*Jšžœ
žœžœ
˜J˜QJ˜J˜—šœžœ
žœ˜)Jšžœ
žœžœ
˜J˜PJ˜J˜—šœžœ
žœ˜)Jšžœ
žœžœ
˜J˜TJ˜J˜—šŸœžœ
žœžœ˜3Jšžœ
žœžœ
˜Jš
œ2˜2J˜Jšœ
žœ
˜J˜J˜J˜šžœžœ
žœž˜#J˜Jšžœ
˜—Jšœžœ"˜?J˜J˜J˜J˜J˜——Jš
œD™D˜Jšœžœ˜Jšœžœžœ
˜ Jšœžœ
˜Jšœžœ˜&Jšœ žœ
˜$Jš
œ ˜ Jšœžœ
žœ
˜J˜šŸœžœ
žœ
žœžœ
žœ˜NJ˜.Jšžœžœ
žœ
˜'Jšžœžœ
žœ
˜!J˜Jš
œ˜Jšœžœ
˜Jšœžœ˜0J˜J˜—š
Ÿœžœ
žœ
žœžœ˜.Jšœžœ˜6Jšžœžœ
žœ
˜'Jšœžœ
˜Jšžœ˜J˜J˜—šŸœžœžœ
˜%Jšœžœ
˜J˜J˜˜%J˜?—š
ž˜J˜šžœžœ
žœ˜Jšœžœ
˜Jšœžœ˜Jš
œ5˜5Jš
œ˜J˜—Jšžœ
žœžœ
žœ
˜#Jšžœ
˜—Jšœžœ
˜Jšœžœ
˜J˜J˜J˜—šŸœžœ
žœ>žœžœžœžœžœžœ˜‘
Jšœžœ
˜J˜Jš
žœžœ
žœ
žœ
žœ˜šžœžœž˜#Jšœžœ˜Jšžœžœ
žœ˜&Jš
œ ˜ Jšœ
žœ
˜J˜"J˜$J˜ šžœžœ
žœž˜*J˜$Jšžœ
˜—Jšœžœ)˜FJ˜Jšžœžœ
žœ
žœ
˜Jšœ
žœ
˜Jšžœ
žœžœ
žœ
˜+J˜"Jšžœ
˜Jš
ž˜Jšžœžœ
˜Jšžœ
˜—Jšžœžœ
žœ˜&J˜J˜—šŸœžœ
žœ>žœžœžœžœžœžœ˜–
Jšœžœ
˜Jšœžœ˜J˜Jš
žœžœ
žœ
žœ
žœ˜šžœžœž˜#Jšžœžœ
žœ˜&Jš
œ ˜ Jšœ
žœ
˜J˜"J˜$J˜ Jšœžœ˜.J˜Jšžœžœ
žœ
žœ
˜Jšœ
žœ
˜Jšžœ%žœ
žœ
˜1Jšžœ!žœ
žœ
˜-šžœžœ
žœž˜*J˜$Jšžœ
˜—J˜"Jšžœ
˜Jš
ž˜Jšžœžœ
˜Jšžœ
˜—Jšžœžœ
žœ˜&J˜J˜—šŸ	œžœ
žœ>žœžœžœžœžœžœ˜™
Jšœžœ
˜Jšœžœ˜J˜Jš
žœžœ
žœ
žœ
žœ˜šžœžœž˜#Jšžœžœ
žœ˜&Jš
œ ˜ Jšœ
žœ
˜J˜"J˜$J˜ šžœžœ
žœž˜*J˜$Jšžœ
˜—Jšœžœ)˜FJ˜
J˜Jšžœžœ
žœ
žœ
˜Jšœ
žœ
˜Jšžœ%žœ
žœ
˜1Jšžœ!žœ
žœ
˜-šžœžœ
žœž˜*J˜$Jšžœ
˜—J˜"Jšžœ
˜Jš
ž˜Jšžœžœ
˜Jšžœ
˜—Jšžœžœ
žœ˜&J˜—J˜š
Ÿœžœ
žœGžœžœ˜‚
Jšœžœ
˜Jšœ
žœ˜Jš
œ˜J˜J˜š
ž˜Jšžœžœ
žœ˜.J˜%Jš
œ#˜#Jš
žœ	žœ
žœ
žœ
žœ˜ Jšžœžœ
žœžœžœ
žœ
˜?Jšžœžœ
žœ
˜Jšžœ˜Jšžœ
˜—J˜J˜—šŸœžœ
žœžœžœžœ˜JJšžœžœ
žœ
žœ˜,Jšžœžœ
žœ
žœ˜(šžœžœ
žœž˜"Jšžœžœ
žœ
žœ˜,Jšžœ
˜—Jšžœ
žœ˜
J˜—J˜J™.J˜Jšœžœ
žœžœ
˜J™šŸœžœ
žœ
žœ&žœ%žœ˜
Jšžœ
žœžœ
˜Jšžœ6˜<J˜—J˜š
Ÿœžœ
žœ&žœžœ˜Š
Jšœžœ
˜Jšœžœ
˜Jšœžœ˜!J˜Jšœ
žœžœ˜Jšœžœžœžœ˜dšžœ
žœžœ˜Jšžœ	žœ
žœAžœžœžœ
˜ˆ
Jšœžœ
˜Jšžœ˜
J˜—J˜—J˜šŸœžœ
žœ
žœCžœžœ˜wJšžœ
žœžœ
˜Jšžœ(žœ2žœ˜sJ˜J˜—šŸœžœ
žœ
žœCžœžœ˜sJšžœ
žœžœ
˜Jšžœ&˜,J˜—J˜š
Ÿœžœ
žœ<žœžœ˜pJ˜J˜Jšœžœ˜Jšžœžœ˜1Jšœžœžœ˜3J˜Jšœžœ˜.J˜šžœ
žœ
žœ˜Jš
œh˜hJš
œ˜J˜—šžœžœžœ˜HJ˜Jš
œh˜hJš
œ˜J˜—Jšžœ1˜7J˜J˜—š
Ÿ	œžœ
žœ
žœ'žœ(˜sJšžœ
žœžœ
˜Jš
œ7˜7Jš
œ;˜;J˜J˜—š
Ÿœžœ
žœ
žœ'žœ(˜oJšžœ
žœžœ
˜Jš
œ,˜,J˜J˜—šŸ
œžœ
žœ'žœ!˜lJ˜J˜Jš
œ)˜)J˜Jšœžœ˜.J˜J˜7Jšœ
žœ
˜J˜—J˜šŸœžœ
žœ
žœ˜.Jšžœ
žœžœ
˜Jš
œ˜J˜—J˜šŸœžœ
žœ˜2šžœ	žœ˜Jšœžœ
˜	Jšœžœ
˜Jšœ#žœžœžœ˜mJšœ
žœ
˜šžœ
žœžœ˜Jš
žœ	žœ
žœGžœžœ
˜…
Jšžœ˜
J˜—J˜—J˜J˜—šŸ
œžœ
žœ
žœ˜-Jšžœ
žœžœ
˜Jš
œ˜Jšœžœ
˜J˜—J˜š
Ÿœžœ
žœ
žœžœ˜;Jšžœ
žœžœ
˜Jš
œ˜Jšœžœ
˜Jšœžœžœžœ
žœžœ˜OJ˜J˜—šŸœžœ
žœžœžœžœ˜9Jšœžœ,˜?J˜—J˜šŸ	œžœ
žœžœ˜Mš	žœžœžœžœž˜#J˜$Jšžœ
˜—Jšžœ˜J˜—J˜šŸ	œžœ
žœžœ˜QJš
œ#˜#Jš
œ"˜"Jš
œ&˜&Jš
œ(˜(Jš
œ.˜.Jš
œ"˜"Jš
œ(˜(Jš
œ ˜ Jš
œ"˜"Jš
œ&˜&Jš
œ&˜&Jšžœ˜J˜—J˜J™"J™J™=Jšœžœ˜Jšœ
ž	œ
˜J˜Jšœžœžœ
˜Jšœ
žœ
˜J˜J™/J˜Jšœ
žœ
˜J˜šŸœžœ
žœžœžœžœ˜mJ˜š
žœžœ
žœ"žœ$žœ˜fJ˜Jšœ
žœ
˜Jšžœ˜
J˜—Jš
œO˜OJšžœ
˜š
žœžœ
žœ"žœ$žœ˜fJ˜Jšœ
žœ
˜Jšžœ˜
J˜—Jšžœ
žœ˜J˜—J˜š
Ÿœžœ
žœ
žœ	žœ˜2Jš
œ˜Jšžœ˜Jš
œ˜—J˜šŸœžœ
žœžœ˜Hšžœžœ
žœ˜Jš
œL™LJšžœ
˜J˜—Jš
œ˜J˜—J˜šŸ
œžœ˜J˜šŸ
œžœ
žœ˜3Jšžœžœ
žœ"˜:J˜Jšžœ
˜J˜—Jš
œK˜Kš
ž˜Jšžœžœ
žœ
˜J˜Jšžœžœ
žœ˜!Jšžœ
˜—Jš
œ˜Jšœžœ
˜Jšœžœ˜J˜—J˜šŸ	œžœ
žœ
žœ˜ J˜ Jšžœžœ
žœ
˜ Jšžœ
žœžœ
žœ˜#Jšœžœ
˜Jšœžœ˜ J˜—J˜šŸœžœ
žœžœ˜"Jšœžœžœ
˜šŸœžœ
žœžœ˜Jšœžœ˜(Jšžœžœ
žœ˜(Jšžœžœ
žœ˜&Jšœžœ
˜J˜—J˜
Jšžœ
žœžœ
žœ
˜$J˜—J˜šŸœžœ
žœ
žœžœžœ˜LJš
œ˜Jšœžœ
˜Jšžœžœ
žœ
žœ
˜J˜ Jšœ
žœ
˜Jšœžœ˜)J˜J˜Jšœžœ˜.Jš
œ˜Jš
œ˜Jš
œ˜J˜—J˜šŸœžœ
žœžœžœ žœžœ˜qJšœžœžœ
˜Jš
œ˜Jš
œ˜Jš
žœžœ
žœ
žœžœ˜1Jšœžœžœ˜7J˜Jšœžœ˜$Jš
œ˜Jš
žœ
žœžœ
žœžœ˜0Jšœžœ
žœ
ž
œ˜6Jš
œ˜Jšžœžœ˜ J˜—J˜J˜Jš
œ˜J˜—Jšœžœ(˜AJ˜=Jšœžœ$˜@JšœžœG˜`Jšœžœ"˜@JšΟtœžœ;˜\™'K™	KšVœΟr
œ
’œ
’œ
’	œ
’œ
’	œ
’	œ
’œ
’œ
’œ
’œ
’œ
’œ
’œ
’œ
’œ
’œ
’œ
’
œ
’
œ
’
œ
’œ
’œ
’œ
’œ
’
œ
’	œ
’œ
’œ
’œ
’œ
’
œ
’
œ
’œ
’œ
’œ
’œ’
œ
’
œ
’œ
’œ
’œ
’
™θ—K™—…—?^Zˆ