DIRECTORY
Arpa USING [Address, nullAddress],
ArpaBuf USING [Protocol],
ArpaIP USING [AllocBuffers, Buffers, CreateHandle, DestroyHandle, FreeBuffers, GetUserBytes, Handle, OnesComplementAddBlock],
ArpaTCP USING [DByte, Error, maxTimeout, Reason, TCPInfo, Timeout],
ArpaTCPOps USING [Buffer, ConnectionState, defaultProbeTimeout, ProbeTimeoutFromHandle, recvBufferLength, sillyWindowLimit, TCPControlSet, TCPHandle, tcpHdrByteLength, TCPHeaderP, TCPSendBuffer],
ArpaTCPLogging USING [PrintStateChange],
ArpaTCPReceiving USING [ProcessRcvdSegment],
ArpaTCPStates USING [Abort, Close, CloseConnection, CopyHandleList, GetInitialSequenceNumber, Open, ValidHandle],
ArpaTCPTransmit USING [Rexmit, RepacketizeandRexmit, SendSegment, SendSYN],
Basics USING [BITNOT],
BasicTime USING [GetClockPulses, MicrosecondsToPulses, Pulses, PulsesToMicroseconds],
PrincOpsUtils USING [ByteBlt],
Process USING [Abort, Detach, DisableTimeout, EnableAborts, MsecToTicks, PauseMsec, SetTimeout];
ArpaTCPOpsImpl: CEDAR MONITOR LOCKS handle USING handle: TCPHandle
IMPORTS ArpaIP, Basics, BasicTime, PrincOpsUtils, Process,
ArpaTCP, ArpaTCPOps, ArpaTCPLogging, ArpaTCPReceiving, ArpaTCPStates, ArpaTCPTransmit
EXPORTS ArpaTCPOps
~ BEGIN OPEN ArpaTCPOps;
defaultReceiveWindow: PUBLIC INT _ ArpaTCPOps.recvBufferLength;
rexmitSleepTime: INT _ 1000;
repacketizing: PUBLIC BOOL _ FALSE;
ourLocalAddress: PUBLIC Arpa.Address _ Arpa.nullAddress;
tcpIPHandle: PUBLIC ArpaIP.Handle;
retransmitProcess: PROCESS;
zeroChecksum: BOOLEAN _ FALSE;
defaultProbeTimeout: PUBLIC INT _ 2000;
defaultRTT: PUBLIC INT _ 6000;
minRTT: PUBLIC INT _ 500;
maxRTT: PUBLIC INT _ 12000;
defaultInitialTimeout: PUBLIC INT _ 60000;
tcpSegmentLife: PUBLIC INT _ 60;
beta: PUBLIC INT _ 2;
rexmitLimit: PUBLIC INT _ 24;
pktsSent: PUBLIC INT _ 0;
pktsRcvd: PUBLIC INT _ 0;
pktsRexmitted: PUBLIC INT _ 0;
pktsDuplicate: PUBLIC INT _ 0;
pktsWithNoConnection: PUBLIC INT _ 0;
pktsFromFuture: PUBLIC INT _ 0;
pktsFromPast: PUBLIC INT _ 0;
pktsWithBadChecksum: PUBLIC INT _ 0;
Open: PUBLIC PROC [tcpInfo: ArpaTCP.TCPInfo] RETURNS [handle: TCPHandle] ~ {
RETURN ArpaTCPStates.Open[tcpInfo];
};
Close: PUBLIC ENTRY PROC [handle: TCPHandle] ~ {
ENABLE UNWIND => NULL;
ArpaTCPStates.Close[handle];
};
Abort: PUBLIC ENTRY PROC [handle: TCPHandle] ~ {
ENABLE UNWIND => NULL;
IF handle # NIL THEN ArpaTCPStates.Abort[handle];
};
GetDataTimeout: PUBLIC ENTRY PROC [handle: TCPHandle] RETURNS [timeout: INT] ~ {
ENABLE UNWIND => NULL;
RETURN[handle.dataTimeout];
};
SetDataTimeout: PUBLIC ENTRY PROC [handle: TCPHandle, timeout: INT] ~ TRUSTED {
ENABLE UNWIND => NULL;
timeout _ MIN[timeout, ArpaTCP.maxTimeout];
handle.dataTimeout _ timeout;
Process.EnableAborts[@handle.windowAvailable]; -- ajd
Process.SetTimeout[@handle.windowAvailable, Process.MsecToTicks[ProbeTimeoutFromHandle[handle]/2]];
BROADCAST handle.windowAvailable;
Process.EnableAborts[@handle.dataAvailable]; -- ajd
Process.EnableAborts[@handle.urgentAvailable]; -- ajd
IF timeout>=0
THEN {
Process.SetTimeout[@handle.dataAvailable, Process.MsecToTicks[timeout/2]];
Process.SetTimeout[@handle.urgentAvailable, Process.MsecToTicks[timeout/2]]; -- ??? wasn't there, and looks like it ought to be (ajd)
BROADCAST handle.urgentAvailable;
}
ELSE {
Process.DisableTimeout[@handle.dataAvailable];
Process.SetTimeout[@handle.urgentAvailable, Process.MsecToTicks[10000]]; -- ??? wasn't there, and looks like it ought to be (ajd)
};
};
WaitForListenerOpen: PUBLIC ENTRY PROC [handle: TCPHandle, timeout: INT] ~ {
ENABLE UNWIND => NULL;
startTime: BasicTime.Pulses;
IF handle.state = listen THEN {
startTime _ BasicTime.GetClockPulses[];
TRUSTED {
Process.EnableAborts[@handle.notListening]; -- ajd
IF timeout>0
THEN Process.SetTimeout[@handle.notListening, Process.MsecToTicks[MIN[timeout, 5000]]]
ELSE Process.DisableTimeout[@handle.notListening];
};
DO
WAIT handle.notListening;
IF handle.state # listen THEN EXIT;
IF handle.dataTimeout >= 0 AND BasicTime.GetClockPulses[]-startTime > BasicTime.MicrosecondsToPulses[handle.dataTimeout*1000] THEN
EXIT;
ENDLOOP;
};
};
SendCurrentDatagram: PUBLIC ENTRY PROC [handle: TCPHandle, push: BOOL] ~ {
ENABLE UNWIND => NULL;
control: TCPControlSet;

GetNewOutputDatagram: PROC ~ {
handle.currentOutputDatagram _ ArpaIP.AllocBuffers[1];
handle.currentOutputPtr _ tcpHdrByteLength;
handle.currentOutputLimit _ handle.currentOutputPtr+handle.maxSegmentSize;
};

ArpaTCPStates.ValidHandle[handle];
control.psh _ push;
SELECT handle.state FROM 
listen => {
IF NOT (handle.matchForeignPort AND handle.matchForeignAddr) THEN 
ERROR ArpaTCP.Error[neverOpen];
handle.active _ TRUE; 
handle.iss _ ArpaTCPStates.GetInitialSequenceNumber[]; 
handle.sndUna _ handle.iss; 
ArpaTCPLogging.PrintStateChange[handle, synSent]; 
handle.state _ synSent; 
ArpaTCPTransmit.SendSYN[handle]; 
};
synSent, synRcvd, established, closeWait => NULL;
ENDCASE => ERROR ArpaTCP.Error[handle.reason];
QueueSendSegment[handle, handle.currentOutputDatagram, handle.currentOutputPtr-tcpHdrByteLength, control];
GetNewOutputDatagram[];
};
GetNextDatagram: PUBLIC ENTRY PROC [handle: TCPHandle] ~ {
ENABLE UNWIND => NULL;
ArpaTCPStates.ValidHandle[handle];
IF handle.currentInputBuffer # NIL THEN {
ArpaIP.FreeBuffers[handle.currentInputBuffer.datagramPtr];
handle.currentInputBuffer _ NIL;
};
IF handle.readyToReadQueue = NIL THEN {
timeoutTime: BasicTime.Pulses _ SetTimeout[handle.dataTimeout];
WHILE handle.readyToReadQueue=NIL DO
IF NOT ValidRcvState[handle.state] THEN
ERROR ArpaTCP.Error[handle.reason];
IF TimedOut[timeoutTime] THEN {
SIGNAL ArpaTCP.Timeout;
timeoutTime _ SetTimeout[handle.dataTimeout];
};
WAIT handle.dataAvailable;
ENDLOOP;
};
handle.currentInputBuffer _ NARROW[handle.readyToReadQueue.first];
handle.readyToReadQueue _ handle.readyToReadQueue.rest;
handle.rcvWnd _ handle.rcvWnd + handle.currentInputBuffer.dataByteCount;
};
SetUrgent: PUBLIC ENTRY PROC [handle: TCPHandle] ~ {
ENABLE UNWIND => NULL;
ArpaTCPStates.ValidHandle[handle];
IF NOT handle.sndUrgent THEN {
handle.sndUrgent _ TRUE;
handle.sndUp _ handle.sndNxt + handle.nBytesToSend;
};
};
WaitForUrgentData: PUBLIC ENTRY PROC [handle: TCPHandle] RETURNS [urgentIndex: INT] ~ {
ENABLE UNWIND => NULL;
ArpaTCPStates.ValidHandle[handle];
WHILE NOT handle.urgentMode AND ValidRcvState[handle.state] DO
WAIT handle.urgentAvailable;
ENDLOOP;
handle.urgentMode _ FALSE;
IF ValidRcvState[handle.state] THEN
RETURN [handle.rcvUp]
ELSE
ERROR ArpaTCP.Error[handle.reason];
};
TCPChecksum: PUBLIC PROC [data: ArpaIP.Buffers] RETURNS [checksum: ArpaTCP.DByte] ~ TRUSTED {
PseudoHeader: TYPE ~ MACHINE DEPENDENT RECORD [
sourceAddr (0): Arpa.Address, 
dstnAddr (2): Arpa.Address, 
zeroes (4: 0..7): BYTE, 
protocol (4: 8..15): ArpaBuf.Protocol, 
tcpTotalByteCount (5): ArpaTCP.DByte];
pseudoHeader: PseudoHeader;
tcpHdrPtr: TCPHeaderP _ LOOPHOLE[@data.body];
paddedLastByte: PACKED ARRAY [0..2) OF BYTE;
cs: CARDINAL;
pseudoHeader.sourceAddr _ data.hdr1.source;
pseudoHeader.dstnAddr _ data.hdr1.dest;
pseudoHeader.zeroes _ 0;
pseudoHeader.protocol _ data.hdr1.protocol;
pseudoHeader.tcpTotalByteCount _ ArpaIP.GetUserBytes[data].bodyBytes;
cs _ ArpaIP.OnesComplementAddBlock[ptr: tcpHdrPtr, count: (pseudoHeader.tcpTotalByteCount)/2, initialSum: Basics.BITNOT[tcpHdrPtr.checksum]]; -- Start with negative of the checksum that's in the header so that we don't have to smash it to zero to compute the real checksum.
cs _ ArpaIP.OnesComplementAddBlock[ptr: @pseudoHeader, count: PseudoHeader.SIZE, initialSum: cs];
IF pseudoHeader.tcpTotalByteCount MOD 2 # 0 THEN { -- add last byte padded with zeros
paddedLastByte[0] _ data.body.bytes[pseudoHeader.tcpTotalByteCount-1];
paddedLastByte[1] _ 0;
cs _ ArpaIP.OnesComplementAddBlock[ptr: @paddedLastByte, count: 1, initialSum: cs];
};
IF zeroChecksum
THEN RETURN[0] ELSE
RETURN [Basics.BITNOT[cs]]; -- return one's complement of computed sum
};
ChecksumsMatch: PUBLIC PROC [c1, c2: ArpaTCP.DByte] RETURNS [BOOL] ~ {
RETURN [c1 = c2 OR ((c1 = 0 OR c1 = 65535) AND (c2 = 0 OR c2 = 65535))];
};
ValidRcvState: PROC [state: ConnectionState] RETURNS [BOOL] ~ INLINE {
RETURN [state IN [listen..finWait2]];
};
SetTimeout: PUBLIC PROC [delta: INT, base: BasicTime.Pulses _ BasicTime.GetClockPulses[]] RETURNS [BasicTime.Pulses] ~ {
RETURN [IF delta>=0 THEN MAX[base+BasicTime.MicrosecondsToPulses[delta*1000], 1] ELSE 0];
};
TimedOut: PUBLIC PROC [timeoutTime: BasicTime.Pulses] RETURNS [BOOL] ~ {
RETURN [timeoutTime#0 AND LOOPHOLE[BasicTime.GetClockPulses[]-timeoutTime, INT] >= 0];
};
CheckRexmitQueues: PROC [handles: LIST OF REF ANY] = {

WHILE handles # NIL DO
CheckRexmit[NARROW[handles.first] ! ArpaTCP.Error => CONTINUE];
handles.first _ NIL;
handles _ handles.rest
ENDLOOP; -- get next connection 
}; -- CheckRexmitQueues
CheckRexmit: ENTRY PROC [handle: TCPHandle] ~ {
ENABLE UNWIND => NULL;
ArpaTCPStates.ValidHandle[handle];
IF handle.state = timeWait AND TimedOut[handle.timeWaitTime] THEN
ArpaTCPStates.CloseConnection[handle, handle.reason]
ELSE IF handle.rexmitQueue # NIL THEN {
tcpSendBufferPtr: REF TCPSendBuffer _ NARROW[handle.rexmitQueue.first];
IF TimedOut[tcpSendBufferPtr.timeoutTime] THEN {  -- timed out, close connection 
now: BasicTime.Pulses _ BasicTime.GetClockPulses[];
ArpaTCPStates.CloseConnection[handle, transmissionTimeout]; }
ELSE 
IF TimedOut[tcpSendBufferPtr.rexmitTime] THEN 
IF repacketizing THEN -- optionally repacketize on rexmit
ArpaTCPTransmit.RepacketizeandRexmit[handle, tcpSendBufferPtr] 
ELSE 
ArpaTCPTransmit.Rexmit[handle, tcpSendBufferPtr];
};
};
QueueSendSegment: INTERNAL PROC [handle: TCPHandle, sendDatagram: ArpaIP.Buffers, dataByteCount: INT, ctl: TCPControlSet] ~ TRUSTED {
timeoutTime: BasicTime.Pulses _ SetTimeout[handle.dataTimeout];
bytesInWindow: INT;
newDatagram: Buffer _ NIL;
bytesInWindow _ MIN[handle.sndWnd - handle.nBytesToSend, dataByteCount];
IF bytesInWindow >= dataByteCount  -- only send datagram if can send it all
THEN ArpaTCPTransmit.SendSegment[handle, sendDatagram, bytesInWindow, ctl]
ELSE bytesInWindow _ 0; 
 
WHILE bytesInWindow < dataByteCount DO
bytesToSend: INT;
WaitForOpenWindow[handle];
bytesToSend _ MIN[handle.sndWnd - handle.nBytesToSend, dataByteCount - bytesInWindow];
IF bytesToSend < 0 THEN bytesToSend _ 0;  -- maybe the window shrunk?
newDatagram _ ArpaIP.AllocBuffers[1];
bytesToSend _ PrincOpsUtils.ByteBlt[
from: [blockPointer: @sendDatagram.body, startIndex: tcpHdrByteLength+bytesInWindow, stopIndexPlusOne: tcpHdrByteLength+bytesInWindow+bytesToSend],
to: [blockPointer: @newDatagram.body, startIndex: tcpHdrByteLength, stopIndexPlusOne: tcpHdrByteLength+bytesToSend] ];
ArpaTCPTransmit.SendSegment[handle, newDatagram, bytesToSend, ctl];
bytesInWindow _ bytesInWindow + bytesToSend; 
IF TimedOut[timeoutTime] THEN {
SIGNAL ArpaTCP.Timeout;
timeoutTime _ SetTimeout[handle.dataTimeout]; };
ENDLOOP;
IF newDatagram#NIL THEN ArpaIP.FreeBuffers[sendDatagram];
IF ctl.psh THEN WaitForAcks[handle];
}; -- QueueSendSegment
 
WaitForOpenWindow: INTERNAL PROC [handle: TCPHandle, minWindow: INT _ sillyWindowLimit] RETURNS [] ~ {
timeoutTime: BasicTime.Pulses _ SetTimeout[ProbeTimeoutFromHandle[handle]];
WHILE handle.sndWnd - handle.nBytesToSend < minWindow DO
WAIT handle.windowAvailable;
SELECT handle.state FROM
synSent, synRcvd, established, closeWait => NULL;
ENDCASE => ArpaTCP.Error[handle.reason];
IF TimedOut[timeoutTime] THEN EXIT;
ENDLOOP;
};

WaitForAcks: INTERNAL PROC [handle: TCPHandle] RETURNS [] ~ {
start: BasicTime.Pulses _ BasicTime.GetClockPulses[];
timeoutTime: BasicTime.Pulses _ SetTimeout[handle.dataTimeout];
WHILE handle.toNetQueue # NIL OR handle.rexmitQueue # NIL DO
WAIT handle.windowAvailable;
SELECT handle.state FROM
synSent, synRcvd, established, closeWait => NULL;
ENDCASE => ArpaTCP.Error[handle.reason];
IF TimedOut[timeoutTime] THEN {
now: BasicTime.Pulses _ BasicTime.GetClockPulses[];
duration: LONG CARDINAL = BasicTime.PulsesToMicroseconds[now-start];
SIGNAL ArpaTCP.Timeout;
timeoutTime _ SetTimeout[handle.dataTimeout]; };
ENDLOOP;
};
RetransmitProcessProc: PROC ~ {
pool: LIST OF REF ANY _ NIL;
DO
Process.PauseMsec[rexmitSleepTime];
pool _ ArpaTCPStates.CopyHandleList[pool];
CheckRexmitQueues[pool];
ENDLOOP;
};
StartupTCP: PROC ~ {
tcpIPHandle _ ArpaIP.CreateHandle[protocol: tcp, recvProc: ArpaTCPReceiving.ProcessRcvdSegment, recvErrorProc: NIL, acceptLongDatagrams: FALSE];
TRUSTED {
retransmitProcess _ FORK RetransmitProcessProc[];
Process.Detach[retransmitProcess];
};
};
ShutdownTCP: PROC ~ {
TRUSTED {
Process.Abort[retransmitProcess];
};
ArpaIP.DestroyHandle[tcpIPHandle];
};
StartupTCP[];
END.

ArpaTCPOpsImpl.mesa
Copyright (C) 1983 by Xerox Corporation. All rights reserved. The following program was created in 1983 but has not been published within the meaning of the copyright law, is furnished under license, and may not be used, copied and/or disclosed except in accordance with the terms of said license.
Last Edited by: Nichols, September 1, 1983 4:27 pm
Last Edited by: DCraft, November 26, 1983 6:59 pm
Last Edited by: Taft, January 8, 1984 3:24 pm
Last Edited by: HGM, April 23, 1984 4:58:48 pm PST
Demers, September 7, 1988 2:31:40 pm PDT
Doug Terry, April 27, 1988 4:51:21 pm PDT
Hal Murray May 16, 1985 3:14:24 am PDT
John Larson, October 11, 1987 9:40:04 pm PDT

Statistics
Routines used by ArpaTCPMain
Attempts to open a new TCP connection.  Returns a TCPHandle to use or raises ArpaTCP.OpenFailed.
Shut down the connection normally.
Shut down the connection abnormally.
Wait until the listening connection on this socket is open.
The current datagram in the handle is ready to send.  Push is true if the TCP push option should be used.  Empty datagrams are ignored unless push is true.
We are through with the current input datagram and would like another.  Only returns when new datagram has usable data.
The urgent pointer is set to the current position in the output stream.
Wait asynchronously for urgent data indication.
Routines internal to the TCP stuff
Find the checksum to be used in the TCP header.  Call when the IP header has been properly filled in.
Returns true if state is valid for receiving new segments.
Returns a timeout time computed by adding delta milliseconds to the specified base time. If delta is negative, meaning "never time out", returns zero, which is specifically defined (in TimedOut) to mean "never time out" and is never otherwise returned.
Returns true if the specified time has been reached.
Private
This procedure is called periodically to check the RexmitQueue on each handle on the handleList.  It checks the first segment on each retransmit queue; if the segment has timed out, the connection is deleted, if it is time to retransmit the segment, the segment is retransmitted. 
Check the retransmit queues for a handle.  Put here to get the handle lock.
SequenceCompare: PROC [a, b: LONG CARDINAL] RETURNS [Basics.Comparison] ~ {
Determines whether a is "less", "equal", or "greater" than b in mod 2^32 arithmetic. That is, a<b if b-a < 2^31, i.e., the positive distance from a to b is less than halfway around the ring. This is useful for comparing sequence numbers, timeout times, and other quantities that are expected to wrap around.
RETURN[SELECT LOOPHOLE[a-b, INT] FROM
<0 => less,
=0 => equal,
>0 => greater,
ENDCASE => ERROR];
};
Packets are only added to the ToNet queue if they fit within the current send window.  If the window is smaller than the packet to be transmitted then the packet may be split into two or more packets such the the first piece can be sent immediately and the other pieces sent later (when the window opens up more).
Send what I can now
Send rest later by copying bytes from sendDatagram
Copy data to new buffer
Timeout if transmission not completed in a reasonable period
Wait until send window is at least minWindow in size (or the probeTimeout expires).
Wait for what we have sent to get acked
Loops and calls CheckRexmitQueues every so often.
ΚΗ–

"cedar" style˜
headš
œ™Icode2š
œ©™©J™2J™1J™-JšœΟkœ™2Icode™(Mš
œ)™)Mšœ#™&Mš
œ,™,J™š
	˜	Mšœœ˜"Mšœœ˜Lšœœq˜}Lšœœ6˜CLšœœ³
˜Γ
Lšœœ˜(Lšœœ˜,Lšœœ^˜qLšœœ6˜KLšœœœ˜Lšœ
œF˜UMšœœ˜LšœœS˜`——š
Οnœœ
œ
œœ˜BLšœ‰
˜
Lšœ˜Lšœœ
œ˜Lšœœ
œ˜?Lšœœ˜Lšœœ
œœ
˜#Lšœœ!˜8Lšœ
œ˜"Lšœœ
˜Lšœœœ
˜Lšœœ
œ˜'Lšœœ
œ˜Lšœœ
œ˜Mšœœ
œ	˜Lšœœ
œ	˜*Lšœœ
œ˜ Lšœœ
œ˜Lšœ
œ
œ˜—™
Lšœ
œ
œ˜Lšœ
œ
œ˜Lšœœ
œ˜Lšœœ
œ˜Lšœœ
œ˜%Lšœœ
œ˜Lšœœ
œ˜Lšœœ
œ˜$—š
œ™šžœœ
œœ˜LLšœœF™`Lšœ˜#L˜—šžœœ
œ
œ˜0L™"Lšœ
œœ
˜Lš
œ˜L˜—šžœœ
œ
œ˜0L™$Lšœ
œœ
˜Lšœ
œ
œ˜1L˜—šžœœ
œ
œœœ˜PLšœ
œœ
˜Lšœ˜L˜—š
žœœ

œœœ˜OLšœ
œœ
˜Lšœ
œ˜+Lš
œ˜Lšœ/Οc˜5Lš
œc˜cLš	œ˜!Lšœ-Ÿ˜3Lšœ/Ÿ˜5šœ˜
šœ˜Lš
œJ˜JLšœMŸ8˜…
Lš	œ˜!L˜
—šœ˜Lš
œ.˜.LšœIŸ8˜
L˜——L˜—š
žœœ
œ
œœ˜LL™;Lšœ
œœ
˜Lš
œ˜šœœ˜Lš
œ'˜'šœ˜	Lšœ,Ÿ˜2šœ
˜Lšœ>œ˜VLšœ.˜2—Lš
œ˜—š
˜Lšœ˜Lšœœ
œ
˜#šœœ`˜‚
Lšœ
˜—Lšœ
˜—L˜—Lš
œ˜—š
žœœ
œ
œœ˜JLšœJœN™›
Lšœ
œœ
˜Lš
œ˜L˜šžœœ˜Lš
œ6˜6Lš
œ+˜+L˜JL˜L˜—Lš
œ"˜"L˜šœœ
˜š
œ˜šœ
œœœ
˜BLšœ˜—Lšœœ˜Lš
œ7˜7Lš
œ˜Lš
œ2˜2Lš
œ˜Lš
œ!˜!L˜—Lšœ,œ
˜1Lšœœ˜.—Lš
œj˜jL˜L˜—šžœœ
œ
œ˜:L™wLšœ
œœ
˜Lš
œ"˜"šœœ
œ˜)Lš
œ:˜:Lšœœ
˜ L˜—šœœ
œ˜'Lš
œ?˜?šœœ
˜$šœ
œ˜'Lšœ˜#—šœœ˜Lšœ˜Lš
œ-˜-L˜—Lšœ˜Lšœ
˜—L˜—Lšœœ ˜BLš
œ7˜7L˜HL˜—šž	œœ
œ
œ˜4L™GLšœ
œœ
˜Lš
œ"˜"šœ
œœ˜Lšœœ
˜Lš
œ3˜3L˜—L˜—šžœœ
œ
œœœ˜WL™/Lšœ
œœ
˜Lš
œ"˜"šœ
œœ˜>Lšœ˜Lšœ
˜—Lšœœ
˜šœ˜#Lšœ˜—š
˜Lšœ˜#—L˜——šœœ™"š
žœœ
œœœ˜]Lšœ$œ>™eš	œœœ
	œ
œ˜/Lš
œ˜Lš
œ˜Lšœœ˜Lš
œ'˜'Lš
œ&˜&—Lš
œ˜Lšœœ
˜-Lšœœ
œœ
˜,Lšœœ
˜
Lš
œ+˜+Lš
œ'˜'L˜Lš
œ+˜+Lš
œE˜ELšœqœŸƒ
˜‘LšœKœ˜ašœ œœŸ"˜ULš
œF˜FLš
œ˜Lš
œS˜SL˜—šœ
˜Lšœ
œ˜—Lšœ	œŸ*˜FL˜—š
žœœ
œœœ˜FLš
œ
œ
œ
œ	œ˜HL˜—š
ž
œœœœœ˜FLš
œ:™:Lšœœ˜%L˜—š
ž
œœ
œ	œ7œ˜xLš
œό
™ό
Lš
œœ
œ
œ5œ˜YL˜—š
žœœ
œ!œœ˜HL™4Lšœœ
œ)œ˜VL˜——™šžœœœ
œ
œ
œ˜6Lš
œ˜™˜L˜šœœ
˜Lšœœ#œ˜?Lšœœ
˜L˜LšœŸ˜ —LšœŸ˜—šžœœ
œ˜/L™KLšœ
œœ
˜Lš
œ"˜"šœœ˜ALš
œ4˜4—šœ
œœ
œ˜'Lšœœœ˜Gšœ(œŸ˜QLš
œ3˜3Lš
œ=˜=—šœ
˜šœ'œ
˜.šœœ
Ÿ#˜9Lš
œ?˜?—šœ
˜Lš
œ1˜1———L˜—L˜—š
žœœœ
œœ™KL™³š	œ
œ
œœ™%L™L™L™Lšœœ™—L™—š
žœœ
œBœœ˜…
Lš
œΉ™ΉLš
œ?˜?Lšœœ
˜Lšœœ
˜Lš
œ™Lšœœ5˜Hšœ!Ÿ(˜KLšœF˜J—šœ˜Lš
œ
˜
—Lš
œ2™2šœ˜&Lšœ
œ
˜Lš
œ˜LšœœE˜VLšœœŸ˜EL™L˜%š
œ$˜$Lš
œ“
˜“
Lš
œv˜v—Lš
œC˜CLšœ,Ÿ
˜-L™<šœœ˜Lšœ˜Lš
œ0˜0—Lšœ
˜—Lšœ
œ
œ"˜9Lšœ	œ˜$LšœŸ˜Lš
Ÿ
˜
—š
žœœ
œ œœ˜fMš
œS™SLš
œK˜Kšœ1˜8Lšœ˜šœ˜Lšœ,œ
˜1Lšœ!˜(—Lšœœ
œ
˜#Lšœ
˜—M˜M˜—šžœœ
œœ˜=Lš
œ'™'Lš
œ5˜5Lš
œ?˜?š	œœ
œœ
˜<Lšœ˜šœ˜Lšœ,œ
˜1Lšœ!˜(—šœœ˜Lš
œ3˜3Lšœ
œ
œ-˜DLšœ˜Lš
œ0˜0—Lšœ
˜—M˜—šžœœ˜L™1Lšœœ
œ
œ
œœ
˜š
˜Lš
œ#˜#L˜*L˜Lšœ
˜—L˜—šž
œœ˜Lšœoœœ˜
šœ˜	Lšœœ˜1L•StartOfExpansion	[PROCESS]š
œ"˜"L˜—L˜—šžœœ˜šœ˜	L˜!L˜—Lš
œ"˜"L˜—L˜
Lšœ
˜——…—1Lο