DIRECTORY
BasicTime USING [GetClockPulses, MicrosecondsToPulses, Pulses],
Booting USING [RegisterProcs, RollbackProc],
PrincOpsUtils USING [LongCopy, PsbHandleToIndex, ReadPSB],
Process USING [Detach, MsecToTicks, priorityClient3, priorityForeground, SetPriority],
PrincOps USING [PsbIndex, PsbNull],
Pup USING [Address, Host, Net, Socket],
PupBuffer USING [Buffer],
PupHop USING [InitialTimeoutPulses],
PupSocket USING [AllocBuffer, CreateServer, FreeBuffer, Get, GetMyAddress, Send, Socket, waitForever],
PupSocketBackdoor USING [SetDirectReceive],
PupWKS USING [rpc],
RPC USING [CallFailed, unencrypted],
RPCInternal USING [DecryptPkt, DoSignal, EncryptPkt, PktExchangeState, pktLengthOverhead, ReplyToRFA, RollbackRPCBinding, RollbackRPCPktStreams, RollbackRPCSecurity, ServerMain, StartRPCBinding, StartRPCPktStreams, StartRPCSecurity],
RPCLupine USING [DataLength, Dispatcher, Header, RPCPkt],
RPCPkt USING [CallCount, Header, Machine, PktID];
RPCPktIO: MONITOR
IMPORTS BasicTime, Booting, PrincOpsUtils, Process, PupHop, PupSocket, PupSocketBackdoor, RPC, RPCInternal
EXPORTS RPCInternal, RPCLupine
SHARES RPCLupine = {

Header: PUBLIC TYPE = RPCPkt.Header;

ConcreteHeader: PROC [abstract: LONG POINTER TO RPCLupine.Header] RETURNS [LONG POINTER TO Header] = INLINE {
RETURN [ abstract ];
};

callSequence: RPCPkt.CallCount _ 0; -- monotonic from this host --


myHost: RPCPkt.Machine;  

sent: CARDINAL _ 0;
recvd: CARDINAL _ 0;
retransmitted: CARDINAL _ 0;


minRetransmitMsecs: CARDINAL = 100; -- retransmit delay for local net --
msecsPerHop: CARDINAL = 500; -- approximate typical gateway hop delay? --
minPingMsecs: CARDINAL = 5000; -- initial interval between pings --
maxPingSecs: CARDINAL = 300; -- long-term ping interval --
maxTransmissions: CARDINAL _ 20; -- give up after too many transmissions --
signalTimeout: BOOL _ TRUE; -- debugging switch --


minRetransmitPulses: BasicTime.Pulses =
BasicTime.MicrosecondsToPulses[LONG[1000] * minRetransmitMsecs];
pulsesPerHop: BasicTime.Pulses =
BasicTime.MicrosecondsToPulses[LONG[1000] * msecsPerHop];
minPingPulses: BasicTime.Pulses =
BasicTime.MicrosecondsToPulses[LONG[1000] * minPingMsecs];
maxPingPulses: BasicTime.Pulses =
BasicTime.MicrosecondsToPulses[LONG[1000]*LONG[1000] * maxPingSecs];

transmitLocalPkts: BOOL _ TRUE;


shortWait: BasicTime.Pulses = -- 10 msecs --
BasicTime.MicrosecondsToPulses[LONG[1000] * 10];
longerWait: BasicTime.Pulses = -- 5 secs --
BasicTime.MicrosecondsToPulses[LONG[1000]*LONG[1000] * 5];


idlerPkt: PupBuffer.Buffer _ NIL;
idlerCond: CONDITION _ [timeout:0];
waiterCond: CONDITION _ [timeout:Process.MsecToTicks[minRetransmitMsecs]];
waiterPkts: REF WaiterArray = NEW[WaiterArray _ ALL[NIL]];
WaiterArray: TYPE = ARRAY PrincOps.PsbIndex OF PupBuffer.Buffer;
wanting: REF WantingArray = NEW[WantingArray _ ALL[FALSE]];
WantingArray: TYPE = PACKED ARRAY PrincOps.PsbIndex OF BOOL;


RecvdPktTooLong: ERROR = CODE;
KillServer: ERROR = CODE;

servers: NAT _ 0;
serversMax: NAT _ 20;
idlers: NAT _ 0;
idlersMax: NAT = 6;
idlersMin: NAT = 2;

PktExchange: PUBLIC PROC [inPkt: RPCLupine.RPCPkt, length: RPCLupine.DataLength, maxlength: RPCLupine.DataLength, state: RPCInternal.PktExchangeState, signalHandler: RPCLupine.Dispatcher _ NIL] RETURNS [newPkt: BOOL, newLength: RPCLupine.DataLength] = {


outPkt: RPCLupine.RPCPkt _ inPkt; -- altered after a signal --
outPktFrame: POINTER _ NIL; -- DoSignal's local frame --
newLen: NAT _ 0;

DO -- loop for signal handlers --

sentTime: BasicTime.Pulses; -- initialized after sending any packet --

NewCallNumber: ENTRY PROC RETURNS [RPCPkt.CallCount] = INLINE {
RETURN [ callSequence _ callSequence+1 ];
};

reply: PupBuffer.Buffer;
recvdHeader: LONG POINTER TO Header;
myPSB: PrincOps.PsbIndex = PrincOpsUtils.PsbHandleToIndex[PrincOpsUtils.ReadPSB[]];
acked: BOOL;
thisPktID: RPCPkt.PktID;
header: LONG POINTER TO Header = @outPkt.header;
pingPulses: BasicTime.Pulses _ minPingPulses;

header.srceHost _ myHost;
header.srceSoc _ PupWKS.rpc;
header.srcePSB _ myPSB;

IF header.pktID.pktSeq = 0 THEN { -- first packet of a call;  yucky interface!
header.type _ SELECT state FROM
sending => [0, rpc, notEnd, pleaseAck, call],
call => [0, rpc, end, dontAck, call],
authReq => [0, rpc, end, dontAck, rfa],
ENDCASE => ERROR; --receiving, endCall
header.pktID.callSeq _ NewCallNumber[];
header.pktID.pktSeq _ 1;
acked _ FALSE; }
ELSE {
header.type _ SELECT state FROM
sending => [0, rpc, notEnd, pleaseAck, data],
receiving => [0, rpc, end, dontAck, ack],
call => [0, rpc, end, dontAck, data],
endCall => [0, rpc, end, dontAck, data],
ENDCASE => ERROR;  --authReq
IF state # receiving THEN {  -- header.type.class = data
header.pktID.pktSeq _ header.pktID.pktSeq+1; acked _ FALSE; }
ELSE acked _ TRUE; };
thisPktID _ header.pktID;
SetWanting[myPSB];

DO -- loop for pings --
ENABLE UNWIND => {
ClearWanting[myPSB];
};
{
transmissions: CARDINAL _ 0;
retransmitPulses: BasicTime.Pulses;
retransmitPulses _ PupHop.InitialTimeoutPulses[header.destHost.net, minRetransmitPulses];
IF retransmitPulses = 0 THEN retransmitPulses _ minRetransmitPulses; -- unreachable
IF outPkt.convHandle # RPC.unencrypted THEN
header.length _ RPCInternal.EncryptPkt[outPkt, length]
ELSE header.length _ length + RPCInternal.pktLengthOverhead;
header.oddByte _ no;

DO -- loop for retransmissions --
{
GeneralSend[outPkt];
sentTime _ BasicTime.GetClockPulses[];
sent _ sent+1;


DO -- loop for each incoming packet (including garbage) --
reply _ MyReceive[
myPSB, sentTime, (IF acked THEN pingPulses ELSE retransmitPulses)];

IF reply = NIL THEN
IF acked THEN GOTO ping
ELSE { header.type.ack _ pleaseAck; GOTO retransmit };

recvdHeader _ LOOPHOLE[@reply.byteLength];

IF recvdHeader.type.class = rfa THEN {
[] _ RPCInternal.ReplyToRFA[
reply, header--encrypted--, thisPktID--clear--, inPkt.convHandle];
LOOP; };

IF outPkt.convHandle # RPC.unencrypted
AND recvdHeader.conv = header.conv
AND recvdHeader.srceHost = header.destHost THEN {
ok: BOOL;
[ok, newLen] _ RPCInternal.DecryptPkt[recvdHeader, outPkt.convHandle];
IF ~ok AND recvdHeader.type.class#ack THEN 
ERROR RPC.CallFailed[runtimeProtocol ! UNWIND => GiveBackBuffer[reply] ]; }
ELSE newLen _ recvdHeader.length - RPCInternal.pktLengthOverhead;

IF recvdHeader.conv = header.conv
AND recvdHeader.srceHost = header.destHost
AND recvdHeader.pktID.activity = thisPktID.activity THEN -- pkt is related to our call
SELECT TRUE FROM
recvdHeader.pktID.callSeq = thisPktID.callSeq => -- pkt is in our call
SELECT TRUE FROM
recvdHeader.pktID.pktSeq = 1+thisPktID.pktSeq => {
IF state = sending OR state = endCall THEN
ERROR RPC.CallFailed[runtimeProtocol ! UNWIND => GiveBackBuffer[reply] ];
SELECT recvdHeader.type.class FROM
data => GOTO done;
ack => {
acked _ TRUE;
GiveBackBuffer[reply]; };
ENDCASE => --call,rfa--
ERROR RPC.CallFailed[runtimeProtocol
! UNWIND => GiveBackBuffer[reply] ]; };
recvdHeader.pktID.pktSeq = thisPktID.pktSeq => {
SELECT recvdHeader.type.class FROM
ack => {
IF header.type.class = call THEN
header.destPSB _ recvdHeader.srcePSB;
acked _ TRUE;
IF state = sending OR state = endCall
THEN {GiveBackBuffer[reply]; reply_NIL; GOTO done}
ELSE -- state = call, authReq, or receiving --
GiveBackBuffer[reply];
};
data, call => -- retransmisson of his packet --
IF state = receiving
THEN IF recvdHeader.type.ack = pleaseAck
THEN {
GiveBackBuffer[reply]; reply _ NIL;
GOTO retransmit -- we're already sending an ack --
}
ELSE GiveBackBuffer[reply]
ELSE ERROR RPC.CallFailed[runtimeProtocol
! UNWIND => GiveBackBuffer[reply] ];
ENDCASE => --rfa --
ERROR RPC.CallFailed[runtimeProtocol
! UNWIND => GiveBackBuffer[reply] ];
};
recvdHeader.pktID.pktSeq < thisPktID.pktSeq =>
GiveBackBuffer[reply]; -- no need to ack it --
ENDCASE =>
ERROR RPC.CallFailed[runtimeProtocol ! UNWIND => GiveBackBuffer[reply] ];
recvdHeader.pktID.callSeq > thisPktID.callSeq AND state=endCall => {
IF recvdHeader.type.class # call
THEN ERROR RPC.CallFailed[runtimeProtocol ! UNWIND => GiveBackBuffer[reply] ];
GOTO done
}
ENDCASE => {
recvdHeader.destPSB _ PrincOps.PsbNull;
EnqueueAgain[reply];
}
ELSE {
recvdHeader.destPSB _ PrincOps.PsbNull;
EnqueueAgain[reply];
};

ENDLOOP--for each incoming packet--;
EXITS
retransmit => {
transmissions _ transmissions+1;
IF (transmissions = maxTransmissions AND signalTimeout) OR state = authReq
THEN { SIGNAL RPC.CallFailed[timeout]; transmissions _ 0 };
retransmitted _ retransmitted+1;
retransmitPulses _ retransmitPulses + minRetransmitPulses;
};
};

ENDLOOP-- for each transmission --;
EXITS
ping => {
header.type _ [0, rpc, end, pleaseAck, ack];
length _ 0; header.pktID _ thisPktID;
acked _ FALSE;
pingPulses _ MIN[maxPingPulses, pingPulses * 2];
};
};

REPEAT done => {
ClearWanting[myPSB];
IF reply = NIL
THEN { --restore clear pktID-- header.pktID _ thisPktID; RETURN [FALSE, newLen] }
ELSE {
IF recvdHeader.outcome = signal AND state = call
AND signalHandler # NIL
THEN [outPkt, length, outPktFrame] _
RPCInternal.DoSignal[reply, newLen, signalHandler, inPkt.convHandle]
ELSE {
IF newLen > maxlength THEN
ERROR RPC.CallFailed[runtimeProtocol ! UNWIND => GiveBackBuffer[reply]];
PrincOpsUtils.LongCopy[
from: recvdHeader, to: @inPkt.header, nwords: recvdHeader.length];
GiveBackBuffer[reply];
RETURN [TRUE, newLen]
};
}
};

ENDLOOP-- for each ping--;


ENDLOOP-- for signal handlers --;


};

GeneralSend: PROC [pkt: RPCLupine.RPCPkt] = {
b: PupBuffer.Buffer = PupSocket.AllocBuffer[socket];
PrincOpsUtils.LongCopy[from: @(pkt.header), to: @(b.byteLength),
nwords: ConcreteHeader[@pkt.header].length];
PupSocket.Send[socket, b, b.dest];
};

SetWanting: ENTRY PROC [myPSB: PrincOps.PsbIndex] = INLINE {
wanting[myPSB] _ TRUE;
};

ClearWanting: PROC [myPSB: PrincOps.PsbIndex] = INLINE {
spare: PupBuffer.Buffer;
InnerClear: ENTRY PROC = INLINE {
wanting[myPSB] _ FALSE;
IF (spare _ waiterPkts[myPSB]) # NIL THEN waiterPkts[myPSB] _ NIL;
};
InnerClear[];
IF spare # NIL THEN GiveBackBuffer[spare] --ignore it, outside monitor--;
};

MyReceive: ENTRY PROC [myPSB: PrincOps.PsbIndex, sentTime, waitTime: BasicTime.Pulses] RETURNS [recvd: PupBuffer.Buffer] = INLINE {
ENABLE UNWIND => NULL;
DO
IF (recvd _ waiterPkts[myPSB]) = NIL
THEN IF BasicTime.GetClockPulses[] - sentTime < waitTime
THEN WAIT waiterCond
ELSE EXIT
ELSE { waiterPkts[myPSB] _ NIL; EXIT };
ENDLOOP;
};

IdleReceive: PUBLIC PROC [pkt: RPCLupine.RPCPkt, maxlength: CARDINAL] = {
b: PupBuffer.Buffer;
InnerIdler: ENTRY PROC = {
IF idlers >= idlersMax THEN { servers _ servers-1; RETURN WITH ERROR KillServer[] };
idlers _ idlers + 1;
DO WAIT idlerCond; IF idlerPkt # NIL THEN EXIT; ENDLOOP;
IF idlers < idlersMin AND servers < serversMax THEN {
servers_servers+1;
Process.Detach[FORK Server[]]; };
b _ idlerPkt;
{
recvdHeader: LONG POINTER TO Header = LOOPHOLE[@b.byteLength];
idlerPkt _ NARROW[idlerPkt.ovh.next];
b.ovh.next _ NIL;
IF recvdHeader.length > maxlength THEN ERROR RecvdPktTooLong[]; --NULL??
PrincOpsUtils.LongCopy[
from: @b.byteLength, to: @pkt.header, nwords: recvdHeader.length];
};
};
InnerIdler[];
GiveBackBuffer[b];--outside monitor--
};

QueuesScrambled: ERROR = CODE;

EnqueueRecvd: ENTRY SAFE PROC [socket: PupSocket.Socket, b: PupBuffer.Buffer, foo: REF ANY] RETURNS [PupBuffer.Buffer] = TRUSTED { -- SAFE/TRUSTED For PupSocketBackdoor
header: LONG POINTER TO Header = LOOPHOLE[@b.byteLength];

IF header.type.subType = rpc THEN {
destPSB: PrincOps.PsbIndex = header.destPSB;
recvd _ recvd+1;
IF ~(destPSB IN (PrincOps.PsbNull..LAST[PrincOps.PsbIndex]])
OR ~wanting[destPSB] THEN {
IF idlers = 0 THEN RETURN[b]; -- too busy, drop the packet
b.ovh.next _ idlerPkt;
idlerPkt _ b;
idlers _ idlers-1;
NOTIFY idlerCond; }
ELSE {
IF waiterPkts[destPSB] # NIL THEN RETURN [b];
waiterPkts[destPSB] _ b;
BROADCAST waiterCond; };
RETURN[NIL] }
ELSE RETURN[b];
};

EnqueueAgain: PUBLIC PROC [b: PupBuffer.Buffer] = {
b _ EnqueueRecvd[socket, b, NIL];
IF b # NIL THEN GiveBackBuffer[b];
};

socket: PupSocket.Socket;
Listener: PROC = {
Process.SetPriority[Process.priorityClient3]; -- Same as Drivers
socket _ PupSocket.CreateServer[
local: PupWKS.rpc,
sendBuffers: 10,
recvBuffers: 10,
getTimeout: PupSocket.waitForever];
PupSocketBackdoor.SetDirectReceive[socket, EnqueueRecvd, NIL];
DO
b: PupBuffer.Buffer _ PupSocket.Get[socket];
b _ EnqueueRecvd[socket, b, NIL];
IF b # NIL THEN GiveBackBuffer[b];
ENDLOOP;
};

AllocBuffer: PUBLIC PROC RETURNS [b: PupBuffer.Buffer] = {
RETURN[PupSocket.AllocBuffer[socket]];
};

SendBuffer: PUBLIC PROC [b: PupBuffer.Buffer] = {
PupSocket.Send[socket, b, b.dest];
};

GiveBackBuffer: PUBLIC PROC [b: PupBuffer.Buffer] = {
PupSocket.FreeBuffer[b];
};


listenerProcess: PROCESS;

Server: PROC = {
Process.SetPriority[Process.priorityForeground];
RPCInternal.ServerMain[ ! KillServer => CONTINUE ];
};


Initialize: ENTRY PROC = {
myAddr: Pup.Address _ PupSocket.GetMyAddress[];
myHost _ [myAddr.net, myAddr.host];
RPCInternal.StartRPCBinding[myHost]; -- exports "RPCInternal.exportTable"
RPCInternal.StartRPCSecurity[myHost]; -- exports "RPCInternal.firstConversation"
RPCInternal.StartRPCPktStreams[myHost]; -- initialize connection states
Booting.RegisterProcs[r: Rollback];
servers _ servers+1;
Process.Detach[FORK Server[]];
listenerProcess _ FORK Listener[];
};


Rollback: Booting.RollbackProc = TRUSTED {
InnerRollback: ENTRY PROC = TRUSTED {
RPCInternal.RollbackRPCPktStreams[]; -- forget connection counts
RPCInternal.RollbackRPCSecurity[]; -- invalidate local conversations
RPCInternal.RollbackRPCBinding[]; -- nothing?
};
InnerRollback[];
};

Initialize[]; 

}.

"RPCPktIO.mesa - Reliable transmission and reception of packets
Copyright c 1984 by Xerox Corporation.  All rights reserved.
Bob Hagmann, February 11, 1985 4:37:25 pm PST 
Swinehart, August 1, 1985 10:37:08 am PDT
Polle Zellweger (PTZ) August 2, 1985 1:39:38 pm PDT
Russ Atkinson (RRA) October 29, 1985 8:57:16 am PST
Hal Murray, June 3, 1986 4:06:28 pm PDT

******** sending and receiving packets ********
"PktExchange" implements a reliable packet exchange.  There are five cases:
sending: transmit data, wait for ack
receiving: transmit ack, wait for data
call: transmit data, wait for data
endCall: transmit data, wait for ack or data (data => start of new call)
authReq: transmit RFA, wait for data (like "call", but no retransmissions)
Data and RFA packets are retransmitted until an ack is received.  Ack packets are retransmitted only in response to "pleaseAck" requests.  No acknowledgement after 14 transmissions is fatal (CallFailed[timeout]).  When the transmitted packet has been acknowledged (if needed), a ping is sent periodically (ack packet saying pleaseAck).  If necessary the ping is retransmitted until it has been acked.  Failure to receive an ack for the ping is fatal (CallFailed[timeout]).  Provided pings continue to be acknowledged, there is no limit on how long we will wait for the next data packet.  If the client gets impatient, he can abort this process.  (This corresponds to the local-machine semantics of a procedure call.)
The retransmission delay is incremented by minPingMsecs each time we timeout, but is reset when we receive the desired packet.  If n=maxTransmissions and i=minRetransmitMsecs and j=hops*msecsPerHop, we give up after i*(n*n+n)/2+n*j msecs. For the local network, that comes to 21 seconds. For a two-hop route, that comes to 41 seconds. The ping delay is doubled at each ping, up to maxPingSecs, which is 5 minutes.  The maxPingSecs value is reached after about 5 minutes.
Constants for WaitUntilSent (inside PktExchange)
Waiting and wanting
Serving and idling
Number of server processes will never exceed "serversMax".  If number of idle servers exceeds "idlersMax", one will abort.  If number of idle servers drops below "idlersMin", one is forked.

On exit if newPkt=TRUE, the packet has been decrypted if needed.
Normally, transmits inPkt and copies result into inPkt.  If a signal occurs, calls DoSignal which handles the signal protocol up to the last resumption packet.  DoSignal returns the last resume packet for us to transmit, which we do by assigning it to outPkt; that packet was allocated in DoSignal's local frame, which we must later deallocate.
We use this internally to represent newLength, since it is possible for a newLength calculation to exceed the bounds of RPCLupine.DataLength (for received packets that are encrypted, but not ours.)
IF outPktFrame # NIL THEN PrincOpsUtils.Free[outPktFrame];
wait for response: an ack or the reply or a timeout
can't set "acked", because we must retransmit our data packet until we obtain the correct destPSB from some ack pkt
a) pkt has next sequence number to ours
he's not allowed to generate that pktSeq!
This can happen if state=call and callee sent next data pkt, but it was lost and now he is responding to our retransmission or ping.  Soon, he will retransmit his data pkt.
b) pkt has same sequence number as ours
acknowledgement of our packet
Even if "pleaseAck", we don't need to ack it,
because other end should send data pkt soon --
c) pkt has earlier sequence number than ours
d) pkt has some future sequence number
acks our last packet, so we can handle the call
wrong call: let someone else do it
wrong conversation or activity: let someone else do it
Incoming RFA packets don't reach here.
Don't retransmit RFA: caller will retransmit call pkt.  Otherwise, if a spurious worker process occurred because of call pkt retransmission before response to RFA, then the spurious worker process sits needlessly retransmitting RFA's until it times out.
only exit from loop is "GOTO done" or UNWIND
This isn't covered by any UNWIND
IF outPktFrame # NIL THEN PrincOpsUtils.Free[outPktFrame];
We get here only after coming back from a call of DoSignal
we can't get here!
Returns NIL if no packet arrives within waitTime pulses after sentTime
Dispatch packet to appropriate RPC process, if any. Packet is known to be a Pup, and is addressed to our socket.
give to idle process to deal with
Pkts are dealt with LIFO by idlers, but it doesn't matter (much)
someone wants this packet: give them it
Dan's voice code got horribly confused with lower priority (even foreground) before direct recv. We never understood why. /HGM, May 86
******** Initialization ********
Bob Hagmann November 1, 1984 7:45:11 am
maxTransmissions _ 20 == this was set up to 100 during the time when Luther was thrashing
Bob Hagmann February 11, 1985 4:37:25 pm PST
changes to: GiveBackBuffer
Polle Zellweger (PTZ) August 2, 1985 1:39:27 pm PDT
changes to: PktExchange -- use newLen (NAT) rather than newLength [0..254] so that full-sized encrypted packets for other conversations don't cause bounds faults (the padding and/or the key can add a few words)
�ÊØ
codeš
œ>™>Kšœ
Ïm
œ1™<Kš
œ.™.K™)K™3K™3K™'K™š
Ïk	˜	Kšœ
žœ0˜?Kšœžœ˜,Kšœžœ'˜:KšœžœI˜VKšœ	žœ˜#Kšœžœ˜'Kšœ
žœ
˜Kšœžœ˜$Kšœ
žœW˜fKšœžœ˜+Kšœžœ˜Kšžœ
žœ˜$KšœžœØ
˜é
Kšœ
žœ*˜9Kšœžœ%˜1——
headšœ
ž˜KšžœSžœ
˜jKšžœÏc
œ
˜Kšžœ˜—K˜Kšœžœ
žœ˜$K˜šÏnœžœžœ
žœ
žœž	œ
žœ
žœ
žœžœ˜mKšžœ˜Kš
œ˜K˜—Kšœ$Ÿ˜BK˜š
œ/™/K˜K˜K˜Kšœžœ˜Kšœžœ˜Kšœžœ˜K˜š
œK™KKš
œ$™$Kš
œ&™&Kš
œ"™"Kš
œH™HKš
œJ™J—Kš
œÌ™ÌK˜KšœžœŸ$˜HKšœ
žœŸ,˜IKšœžœ	Ÿ$˜CKšœ
žœŸ˜:KšœžœŸ*˜KKšœžœžœŸ˜2K˜Kš
œÖ™ÖK˜˜'Kšœžœ˜@—˜ Kšœžœ˜9—˜!Kšœžœ˜:—˜!Kšœžœžœ˜D—K˜Kšœžœžœ
˜K˜Kš
œ0™0K˜šœŸ˜,Kšœžœ
˜0—šœŸ˜+Kšœžœžœ˜:K˜——š
œ™K˜Kšœžœ
˜!Kšœž	œ˜#Kšœž	œ5˜Jš	œžœžœžœ
žœ˜:Kšœ
žœžœžœ˜@—š	œ	žœžœžœ
žœ˜;Kšœžœžœ
žœžœ
žœ
˜<—K˜—™K˜Kš
œ½
™½
K™Kšœžœžœ
˜Kšœžœžœ
˜K˜Kšœ	žœ˜Kšœžœ˜Kšœžœ˜Kšœžœ˜Kšœžœ˜K˜—š œžœ
žœ¤
žœ
ž	œ	žœ&˜ý
Kš
œ@™@K˜Kš
œØ™ØK˜Kšœ"Ÿ˜>Kšœ
žœžœŸ˜8šœžœ˜Kš
ρ
™Å
—K˜šžœ
Ÿ˜!K˜KšœŸ*˜FK˜š
 
œžœ
žœ
žœžœ˜?Kšžœ#˜)Kš
œ˜K˜—K˜Kšœ
žœ
žœ
žœ˜$Kš
œS˜SKšœžœ
˜K˜Kšœžœ
žœ
žœ˜0K˜-K˜K˜K˜K˜K˜šžœžœŸ-˜Nšœžœž˜K˜-K˜%K˜'KšžœžœŸ˜&—K˜'K˜Kšœžœ˜—šžœ˜šœžœž˜K˜-K˜)K˜%K˜(Kšžœžœ
Ÿ˜—šžœžœŸ˜8Kšœ5žœ˜=—Kšžœ	žœ˜—K˜K˜K˜šžœ
Ÿ˜šžœ
žœ˜Kš
œ˜Kšžœžœ
žœ!™:Kš
œ˜—Kš
œ
˜
Kšœžœ˜Kš
œ#˜#Kš
œY˜YKšžœžœ)Ÿœ˜Sšžœžœž˜+Kš
œ6˜6—Kšžœ8˜<K˜K˜šžœ
Ÿ˜!Kš
œ
˜
Kš
œ˜K˜&K˜K˜Kš
œ3™3K˜šžœ
Ÿ7˜:š
œ˜Kšœžœžœžœ˜C—K˜šžœ	ž˜Kšžœžœ
žœ˜Kšžœ žœ˜6—K˜Kšœžœ˜*K˜šžœžœ˜&š
œ˜Kšœ
Ÿ
œŸ	œ˜B—Kš
Ÿs™sKšžœ˜—K˜Kšžœžœ˜&Kšžœ˜"šžœ'žœ˜1Kšœžœ
˜	Kš
œF˜Fšžœžœžœ
˜+Kšžœ
žœžœ˜K——Kšžœ=˜AK˜Kšžœ˜!Kšžœ'˜*Kšžœ0žœ
Ÿ˜Všžœ
žœ
ž˜šœ1Ÿ˜Fšžœ
žœ
ž˜Kš
œ'™'š
œ2˜2šžœžœž˜*Kš
œ)™)Kšžœ
žœžœ˜I—šžœž˜"Kšœžœ˜š
œ˜Kš
œ¬
™¬
Kšœžœ
˜
Kš
œ˜——šžœŸ˜šžœ
žœ˜$Kšœžœ˜'———Kš
œ'™'š
œ0˜0šžœž˜"š
œ˜Kš
œ™šžœž˜ Kš
œ%˜%—Kšœžœ
˜
šžœžœ˜%Kšžœžœžœ˜2šžœ
Ÿ)˜.Kš
œ-™-Kš
œ.™.K˜——Kš
œ˜—šœŸ!˜/šžœ˜šžœ
žœ!˜(šžœ˜Kšœžœ
˜#KšžœŸ"˜2Kš
œ
˜
—Kšžœ˜—šžœ
žœ
žœ˜)Kšœžœ˜$————šžœŸ˜šžœ
žœ˜$Kšœžœ˜$——Kš
œ˜—Kš
œ,™,˜.KšœŸ˜.—Kš
œ&™&—šžœ˜
Kšžœ
žœžœ˜I——šœ.žœ˜DKšžœ˜ Kšžœ
žœ
žœžœ˜NKš
œ/™/Kšžœ˜	Kš
œ
˜
—šžœ˜Kš
œ"™"Kš
œ'˜'Kš
œ˜Kš
œ
˜
—šžœ˜Kš
œ6™6Kš
œ'˜'Kš
œ˜Kš
œ˜——Kš
œ&™&K˜KšžŸœ
˜$—š
ž˜š
œ˜K˜ šžœ#žœžœ˜JKš
œý
™ý
Kšžœžœ
žœ*˜;—K˜ K˜:Kš
œ˜——Kš
œ˜—K˜KšžŸœ
˜#š
ž˜š
œ	˜	K˜,K˜%Kšœžœ
˜Kšœ
žœ ˜0Kš
œ˜——Kš
œ˜—K˜Kš
œ,™,šžœ
˜Kš
œ ™ K˜Kšžœžœ
žœ!™:šžœ	ž˜KšžœŸœžœžœ˜Qšžœ˜šžœžœ
˜0Kšžœž˜šžœ ˜$K˜D—šžœ˜šžœž˜Kšžœ
žœžœ˜H—š
œ˜K˜B—K˜Kšžœžœ	˜Kš
œ˜——Kš
œ
˜
——Kš
œ˜—K˜KšžŸœ
˜K˜Kš
œ:™:—K˜KšžŸœ
˜!K˜Kš
œ™K˜Kš
œ˜K˜—š œžœ˜-K˜4š
œ@˜@K˜,—K˜"Kš
œ˜K˜—š 
œžœ
žœžœ˜<Kšœžœ
˜Kš
œ˜K˜—š œžœžœ˜8K˜š 
œžœ
žœžœ˜!Kšœžœ
˜Kšžœžœ
žœžœ
˜BKš
œ˜—K˜
Kšžœ	žœ
žœŸœ
˜IKš
œ˜K˜—š
 	œžœ
žœ@ž	œžœ˜ƒ
Kšžœ
žœžœ
˜Kš
œF™Fš
ž˜šžœž˜$šžœ
žœ1˜8Kšžœ
žœ˜Kšžœ
ž˜	—Kšžœžœžœ˜'—Kšžœ
˜—Kš
œ˜K˜—š œžœ
žœ#žœ˜IK˜š 
œžœ
žœ˜Kš
žœžœžœ
žœ
žœ˜TK˜Kšžœ
žœžœžœ
žœ
žœ
žœ
˜8šžœžœžœ˜5Kš
œ˜Kšœžœ˜!—K˜
š
œ
˜
Kš	œ
žœ
žœ
žœ
žœ˜>Kšœžœ˜%Kšœ
žœ
˜Kšžœžœ
žœŸ˜Hš
œ˜Kš
œB˜B—Kš
œ˜—Kš
œ˜—K˜
KšœŸ˜%Kš
œ˜K˜—Kšœžœžœ
˜K˜š œžœ
žœ
žœ6žœ
žœžœžœŸ%˜¨
Kš
œp™pKš	œžœ
žœ
žœ
žœ˜9šžœžœ˜$Kš
œ,˜,K˜Kšžœžœžœ˜<šžœžœ˜Kš
œ!™!Kš
œ@™@Kšžœžœ
žœŸ˜:Kš
œ˜Kš
œ
˜
Kš
œ˜Kšžœ
˜—šžœ˜Kš
œ'™'Kšžœžœ
žœ
žœ˜-Kš
œ˜Kšž	œ˜—Kšžœ
žœ˜
—Kšžœ
žœ˜Kš
œ˜K˜—š œžœ
žœ˜3Kšœžœ˜!Kšžœžœ
žœ˜"Kš
œ˜K˜—Kš
œ˜š œžœ˜šœ.Ÿ˜@K™†
—š
œ ˜ Kš
œ˜Kš
œ˜Kš
œ˜Kš
œ#˜#—Kšœ9žœ˜>š
ž˜Kš
œ,˜,Kšœžœ˜!Kšžœžœ
žœ˜"Kšžœ
˜—Kš
œ˜K˜—š œžœ
žœ˜:Kšžœ ˜&K˜K˜—š 
œžœ
žœ˜1K˜"K˜K˜—š œžœ
žœ˜5K˜K˜K˜K˜—Kšœžœ
˜K˜š œžœ˜Kš
œ0˜0Kšœ(žœ˜3Kš
œ˜K˜—Kš
œ ™ K˜š 
œžœ
žœ˜Kš
œ/˜/K˜#Kšœ%Ÿ$˜IKšœ&Ÿ*˜PKšœ(Ÿ˜GK˜#Kš
œ˜Kšœžœ˜Kšœžœ˜"Kš
œ˜K˜—K˜šœ!žœ˜*š 
œžœ
žœžœ˜%Kšœ%Ÿ˜@Kšœ#Ÿ!˜DKšœ"Ÿ˜-Kš
œ˜—K˜Kš
œ˜K˜—K˜K˜Kš
œ˜K˜š
œ'™'Kš
œY™Y—™,KšœÏr™—™3Kšœ¡œ»
™Ò
——…—4ÀZ¥