DIRECTORY
FS USING [Read, Write],
IO USING [int, PutFR, STREAM],
Jukebox USING [bytesPerChirp, CloseTune, EOF, Error, FindChirp, MissingChirp, OpenTune, TuneSize, RunComponent, singlePktLength, RunElementType, RunArrayRange, Tune],
Process USING [Detach, Priority, priorityNormal, SetPriority],
Rope USING [ROPE],
RuntimeError USING [ UNCAUGHT ],
VM USING [AddressForPageNumber],
VoiceStream;

VoiceStreamServerImpl: MONITOR LOCKS VoiceStream.Lock
IMPORTS FS, IO, Jukebox, Process, RuntimeError, VM, VoiceStream
EXPORTS VoiceStream =

BEGIN
Foo: SIGNAL = CODE;
debugRuns: BOOL _ FALSE;
serverPriority: Process.Priority _ Process.priorityNormal;

GetServerBuffer: ENTRY PROC RETURNS [handle: VoiceStream.Handle] = {


ENABLE UNWIND => NULL;

buffer: REF VoiceStream.Buffer;

WHILE TRUE DO
handle _ VoiceStream.vSList;
WHILE handle # NIL DO
IF (handle.errorRope = NIL) THEN {
IF (handle.firstServerBuffer # NIL) THEN {
buffer _ handle.firstServerBuffer;
handle.firstServerBuffer _ buffer.next;
buffer.next _ handle.firstIdleBuffer;
handle.firstIdleBuffer _ buffer;
RETURN [handle];
}
ELSE
IF (handle.piece # NIL) THEN {
IF handle.firstClientBuffer = NIL THEN RETURN [handle];
IF (NOT handle.piece.flush
AND (handle.piece.intervalSpec.length > 0)
AND (handle.firstIdleBuffer # NIL))
THEN RETURN [handle]; 
};           
};
handle _ handle.next;
ENDLOOP;


BROADCAST VoiceStream.closeCondition;
WAIT VoiceStream.serverCondition;
ENDLOOP;
};


GiveClientBuffer: ENTRY PROC [handle: VoiceStream.Handle] = {
ENABLE UNWIND => NULL;

buffer, b2: REF VoiceStream.Buffer;

buffer _ handle.firstIdleBuffer;
handle.firstIdleBuffer _ buffer.next;
buffer.next _ NIL;
IF handle.firstClientBuffer = NIL
THEN {
handle.firstClientBuffer _ buffer;
NOTIFY handle.newPiece;
}
ELSE {
b2 _ handle.firstClientBuffer;
WHILE b2.next # NIL DO b2 _ b2.next ENDLOOP;
b2.next _ buffer;
};
BROADCAST VoiceStream.client;
};

SetError: PUBLIC ENTRY PROC [handle: VoiceStream.Handle, rope: Rope.ROPE, code: VoiceStream.ErrorCode] = {


ENABLE UNWIND => NULL;
handle.errorRope _ rope;
handle.errorCode _ code;
BROADCAST VoiceStream.client;
BROADCAST VoiceStream.waitCondition;
};


GetPiece: ENTRY PROC [handle: VoiceStream.Handle] RETURNS [VoiceStream.Piece] = {



ENABLE UNWIND => NULL;

piece: VoiceStream.Piece;
tune: Jukebox.Tune_NIL;

WHILE TRUE DO
piece _ handle.piece;
IF piece = NIL THEN { handle.pieceInProgress _ FALSE; RETURN [NIL]; };
IF piece.flush THEN piece.intervalSpec.length _ 0;
IF handle.pieceInProgress THEN {
nxP: VoiceStream.Piece _ piece.next;
IF piece.intervalSpec.length > 0 THEN RETURN [piece];
tune _ piece.tune;
IF (handle.firstClientBuffer # NIL)
OR (handle.firstServerBuffer # NIL) THEN RETURN [NIL]; -- No buffer-ahead
IF handle.proc#NIL THEN -- Report completion of a piece
handle.proc[handle, $finished, piece.clientData];
IF tune # NIL AND (nxP = NIL OR nxP.intervalSpec.tuneID # piece.intervalSpec.tuneID)
THEN {
Jukebox.CloseTune[handle.jukebox, tune];
tune _ NIL;
};
handle.piece _ piece _ piece.next;
};
handle.pieceInProgress _ TRUE;
IF piece = NIL THEN { BROADCAST VoiceStream.client; LOOP; };
IF tune=NIL THEN tune _
Jukebox.OpenTune[handle.jukebox, piece.intervalSpec.tuneID, ~piece.playback];
piece.tune _ tune;
IF handle.proc#NIL THEN -- Report start of next piece (see AddPiece for report of first)
handle.proc[handle, $started, handle.piece.clientData];
ENDLOOP;
RETURN [NIL];
};


Server: PROC [] = {


handle: VoiceStream.Handle;
buffer: REF VoiceStream.Buffer;
ourSize: INT;
skipLeading: INT;
piece: VoiceStream.Piece;
noChirp: BOOLEAN;

Process.SetPriority[serverPriority];

WHILE TRUE DO
ENABLE {
Jukebox.Error => {
SetError[handle: handle, code: BadPiece,
rope: IO.PutFR["Piece for tune id %d starting at byte %d can't be accessed.",
IO.int[piece.intervalSpec.tuneID], IO.int[piece.intervalSpec.start]]];
CONTINUE;
};


Jukebox.EOF => {
piece.intervalSpec.length _ 0;
CONTINUE;
};

RuntimeError.UNCAUGHT => {
SetError[handle: handle, code: Bug,
rope: "Unknown error in voice stream demon."];
REJECT;
};
};
handle _ GetServerBuffer[];
buffer _ handle.firstIdleBuffer;


IF buffer.toJukebox AND buffer.valid THEN {
buffer.valid _ FALSE;
buffer.window _ Jukebox.FindChirp[self: handle.jukebox, tune: handle.piece.tune,
chirp: buffer.chirp, signalMissingChirp: FALSE, signalEOF: FALSE];
IF buffer.bytesAccountedFor < Jukebox.bytesPerChirp THEN {
IF buffer.runData.runArray[buffer.runIndex].elementType ~= silence THEN {
buffer.runIndex _ buffer.runIndex +
(IF buffer.runData.runArray[buffer.runIndex].elementType = soundEnergy THEN 2 ELSE 1);
buffer.runData.runArray[buffer.runIndex] _ [silence[0]];
};
buffer.runData.runArray[buffer.runIndex]_[
silence[
NARROW[buffer.runData.runArray[buffer.runIndex],
Jukebox.RunComponent[silence]].length
+(Jukebox.bytesPerChirp - buffer.bytesAccountedFor)]
];
buffer.bytesAccountedFor _ Jukebox.bytesPerChirp -- just for purity
};
CheckRunData[buffer];
FS.Write[file: buffer.window.file, to: buffer.window.base, nPages: buffer.chirpSpace.count, from: VM.AddressForPageNumber[buffer.chirpSpace.page]];
};


piece _ GetPiece[handle];
IF piece = NIL THEN LOOP;
buffer.keyIndex _ piece.intervalSpec.keyIndex;


IF piece.tune = NIL OR NOT (piece.playback OR piece.tune.writable) THEN ERROR; 


IF piece.intervalSpec.start < 0 THEN piece.intervalSpec.start _ Jukebox.TuneSize[piece.tune] * Jukebox.bytesPerChirp;

buffer.chirp _ piece.intervalSpec.start / Jukebox.bytesPerChirp;


skipLeading _ piece.intervalSpec.start MOD Jukebox.bytesPerChirp;
buffer.bytesAccountedFor _ skipLeading;
ourSize _ Jukebox.bytesPerChirp - skipLeading;
IF piece.intervalSpec.length < ourSize THEN {
IF piece.playback THEN ourSize _ piece.intervalSpec.length
ELSE piece.intervalSpec.length _ ourSize;
IF piece.playback THEN buffer.bytesAccountedFor _ Jukebox.bytesPerChirp - ourSize;
};

piece.intervalSpec.length _ piece.intervalSpec.length - ourSize;
piece.intervalSpec.start _ piece.intervalSpec.start + ourSize;


buffer.runIndex _ 0;
buffer.playedBytes _ 0;

IF (ourSize # Jukebox.bytesPerChirp) OR piece.playback THEN {
noChirp _ FALSE;
buffer.window _ Jukebox.FindChirp[self: handle.jukebox, tune: piece.tune,
chirp: buffer.chirp, signalEOF: piece.playback,
signalMissingChirp: TRUE
! Jukebox.MissingChirp => {noChirp _ TRUE; CONTINUE}];
IF noChirp THEN {
IF piece.playback THEN {
buffer.block.startIndex _ 0;
buffer.block.stopIndexPlusOne _ 0;
buffer.runData.runArray[0] _ [silence[ourSize]];
}
ELSE { -- build a fake chirp with the right structure
buffer.block.startIndex _ 0;
buffer.block.stopIndexPlusOne _ ourSize;
buffer.runData.runArray[0] _ [silence[skipLeading]];
};
}
ELSE {
FS.Read[file: buffer.window.file, from: buffer.window.base, nPages: buffer.chirpSpace.count, to: VM.AddressForPageNumber[buffer.chirpSpace.page]];
IF skipLeading > 0 THEN {
runSize: CARDINAL;
buffer.block.startIndex _ 0;
DO
WITH curr: buffer.runData.runArray[buffer.runIndex] SELECT FROM
silence => runSize _ curr.length;
singlePkt => runSize _ Jukebox.singlePktLength;
soundEnergy => runSize _ runSize _ NARROW[buffer.runData.runArray[buffer.runIndex+1], Jukebox.RunComponent[soundLength]].length;
ENDCASE => ERROR;

IF skipLeading >= runSize THEN {
skipLeading _ skipLeading - runSize;
IF buffer.runData.runArray[buffer.runIndex].elementType # silence THEN buffer.block.startIndex _ buffer.block.startIndex + runSize;
buffer.runIndex _ buffer.runIndex + (IF buffer.runData.runArray[buffer.runIndex].elementType=soundEnergy THEN 2 ELSE 1);
}
ELSE {  -- last run: 
WITH curr: buffer.runData.runArray[buffer.runIndex] SELECT FROM
silence => curr.length _ runSize - skipLeading; 
soundEnergy =>
buffer.runData.runArray[buffer.runIndex+1] _ [soundLength[IF piece.playback
THEN NARROW[buffer.runData.runArray[buffer.runIndex+1], Jukebox.RunComponent[soundLength]].length - skipLeading
ELSE skipLeading]]; -- but on record this is what is already there
singlePkt => IF piece.playback THEN buffer.playedBytes _ skipLeading
ELSE 
{buffer.runData.runArray[buffer.runIndex]  _ [soundEnergy[NARROW[buffer.runData.runArray[buffer.runIndex], Jukebox.RunComponent[soundEnergy]].energy]];
buffer.runData.runArray[buffer.runIndex+1] _ [soundLength[skipLeading]];
};
ENDCASE;
EXIT;
};
ENDLOOP;
buffer.block.stopIndexPlusOne _ buffer.block.startIndex + ourSize;
}
ELSE {
buffer.block.startIndex _ 0;
buffer.block.stopIndexPlusOne _ ourSize;
};
};
}
ELSE { -- whole chirp is involved and it is record
buffer.block.startIndex _ 0;
buffer.block.stopIndexPlusOne _ ourSize;
buffer.runData.runArray[0] _ [silence[0]]
};
buffer.toJukebox _ NOT piece.playback;
IF buffer.toJukebox THEN buffer.runData.ambientLevel _ piece.intervalSpec.ambientLevel;
GiveClientBuffer[handle];
ENDLOOP;
};


CheckRunData: PROC [buffer: REF VoiceStream.Buffer] = {
total: CARDINAL _ 0;
run: CARDINAL;
currElement: Jukebox.RunElementType _ silence; -- must simply start as ~soundEnergy

FOR ri: Jukebox.RunArrayRange IN [0..95) DO
	IF currElement = soundEnergy -- acutally it is prevElement is this context
	THEN IF buffer.runData.runArray[ri].elementType = soundLength THEN 
	{currElement _soundLength; LOOP} ELSE ERROR;
				
currElement _ buffer.runData.runArray[ri].elementType;
WITH curr: buffer.runData.runArray[ri] SELECT FROM
silence => run _ curr.length;
singlePkt => run _ Jukebox.singlePktLength;
soundEnergy => run _ NARROW[buffer.runData.runArray[ri+1],
	Jukebox.RunComponent[soundLength]].length;
ENDCASE => ERROR;

total _ total + run;

IF total > Jukebox.bytesPerChirp THEN {
WITH curr: buffer.runData.runArray[ri] SELECT FROM
silence => curr.length _ run - (total - Jukebox.bytesPerChirp);
soundEnergy => buffer.runData.runArray[ri+1] _ [soundLength[run - (total - 	Jukebox.bytesPerChirp)]];
singlePkt => { -- since this is last valid entry in chirp, okay to trample 'nextElement'
buffer.runData.runArray[buffer.runIndex]_ 		[soundEnergy[NARROW[buffer.runData.runArray[buffer.runIndex], 		Jukebox.RunComponent[singlePkt]].energy]];
buffer.runData.runArray[ri+1] _ [soundLength[Jukebox.singlePktLength - (total - 		Jukebox.bytesPerChirp)]]
};
ENDCASE;
IF debugRuns THEN SIGNAL Foo;
EXIT;
};

IF total = Jukebox.bytesPerChirp THEN EXIT;
ENDLOOP;
};

StartServer: PUBLIC PROC [stream: IO.STREAM] = { VoiceStream.ioStream _ stream; };

Init: PROC = {


p: PROCESS;

p _ FORK Server[];
Process.Detach[p];
};

Init[];

END.
1983, Stewart, run-encoded chirps
May 10, 1986 4:14:09 pm PDT, Stewart, Cedar 5, December


File: VoiceStreamServerImpl.mesa
Copyright c 1986 by Xerox Corporation.  All rights reserved.
This file contains part of the implementation of voicestreams.  The
routines in this file implement the voicestream server, a background
process that transfers information between disk and buffers in
voicestreams.
Ades, February 10, 1986 4:01:59 pm PST
Swinehart, June 17, 1986 11:56:14 pm PDT
Last Edited by: Ousterhout, March 8, 1983 11:39 am compile
Last Edited by: Stewart, January 3, 1984 11:47 am
This is a monitor procedure used by the server to wait for work to do.  For the server to have work to do, there must not be any errors associated with the stream.  Furthermore, either there must be a buffer waiting for the server, or there must be an idle buffer and there must be a valid piece waiting for the server.  If there is a server buffer waiting, this routine transfers the frontmost server buffer to the front of the idle list, from which position the server will process it.  Note:  it doesn't make any difference how the buffers on the idle list are ordered.
Notify anybody trying to close a stream that we've done all
the work we can, and are waiting.
This procedure just records error information in a voice
stream and wakes up waiting clients.  This is made a separate
procedure because exclusive access is needed on the voice
stream, which the server doesn't have.
This procedure is called only by the server.
It is made a separate procedure in order to guarantee exclusive access to the voice stream information.  Because of the high overheads in opening and closing tunes, we check the next piece and if it's the same tune, then don't bother closing the current one.  NIL is returned if either there are no pieces left, or if all the space of the frontmost piece is allocated to buffers but the buffers haven't been processed completely.  This means we can't buffer ahead across pieces, but the alternative results in messy synchronization problems.

Client notification of the start-of-transfer ($started) and end-of-transfer ($finished) for each piece is done here.
Piece in progress is now finished.
This procedure is responsible for buffering ahead and behind the client processes.  Be VERY careful with this code.  The procedure runs unmonitored, so that other processes can be getting and putting voice data while we do disk operations.  However, you must be extremely careful to make sure that the processes don't get in each others' way.
On EOF, just discard the rest of the current piece.
IO.PutRope[ioStream, "Unknown error in voice stream demon.\n"];
If this buffer is to be written, and the buffer is valid, then write
it out.
make sure that no partial chirps are recorded!
fill the rest of the chirp with silence
last thing placed in chirp was non-silent
IO.PutF[ioStream, "Wrote chirp %d to disk.\n", IO.int[buffer.chirp]];
Collect information for the next buffer's worth of voice.  First of all,
find a piece that isn't empty.
ioStream.PutF["Number of bytes left: %d\n", IO.int[piece.intervalSpec.length]];

Set up the encryption key index (copy over from piece).
Make sure that the tune is open.
Figure out which chirp this is.
Figure out which portion of the chirp we'll actually use.

Trim the tail if needed
disallow a recording that ends in the middle of a chirp
Account for the part of the piece in this chirp.
Read in the chirp, if necessary.  Note:  we don't look up the disk location until its time to actually transfer information.  This way, the jukebox routines won't allocate the space until it's actually needed.  Also, for playback we substitute a homemade all-silent chirp if there isn't a chirp on the disk.
Construct a chirp with a single run of silence
Read in the whole chirp, including its runData
The value of skipLeading is the amount to chase down the runData
skip the whole run
i.e. on playback this is what is left to be played back
since we are recording it is okay to rewrite this and the next runArray entries
Not all of this is needed, since some might be silence, but we don't know how much and don't want to spend the time analyzing the runData.
IO.PutF[ioStream, "Read chirp %d from disk.\n", IO.int[buffer.chirp]];
This procedure simply forks the stream buffer server and
initializes shared state.
Swinehart, May 10, 1986 4:13:59 pm PDT
Convert to new communications package
changes to: VoiceStreamServerImpl, EXPORTS, BEGIN, GetServerBuffer, GiveClientBuffer, SetError, GetPiece, Server, CheckRunData
Swinehart, June 9, 1986 9:52:06 am PDT
create option no longer supported.  Tunes must be open by arrival at server, GetServerBuffer, GetPiece


Κƒ˜š
œ ™ Icodešœ
Οm
œ1™<—Jš
œC™CJš
œD™DJš
œ>™>š
œ
™
K™&K™(—J˜Jš
œ:™:Jš
œ1™1J˜š
Οk	˜	Jšžœ
žœ˜Jšžœ
žœžœ˜Jšœžœžœz˜¦
Jšœžœ1˜>Jšœžœžœ˜Jšœ
žœžœ˜ Jšžœ
žœ˜ J˜J˜—Jšœžœ
žœ˜5Jšžœ
žœžœ"žœ
˜?šžœ˜J˜—Jš
ž˜Jšœžœžœ
˜Jšœžœžœ
˜J˜:J˜šœžœ
žœ
žœ!˜DJ˜Jš
œΌ™ΌJ˜Jšžœ
žœžœ
˜J˜Jšœžœ˜J˜šžœ
žœ
ž˜
J˜šžœ
žœ
ž˜šžœžœžœ˜"šžœžœžœ˜*J˜"J˜'J˜%J˜ Jšžœ
˜Jš
œ
˜
—š
ž˜šžœžœžœ˜Jšžœžœ
žœ
žœ
˜7šžœžœ˜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š
œ"˜"Jšžœ˜J˜
—šžœ˜J˜Jšžœžœ
žœžœ
˜,J˜Jš
œ˜—Jšž	œ˜Jš
œ˜J˜—š	œ
žœ
žœ
žœ)žœ"˜jJ˜Jš
œ8™8Jš
œ=™=Jš
œ9™9Jš
œ&™&J˜Jšžœ
žœžœ
˜J˜J˜Jšž	œ˜Jšž	œ˜$Jš
œ˜J˜—J˜Jšœ
žœ
žœžœ˜Q˜Jš
œ,™,J˜Jš
œ™J™J™tJ˜Jšžœ
žœžœ
˜J˜Jš
œ˜Jšœžœ
˜J˜šžœ
žœ
ž˜
J˜Jšžœ	žœ
žœžœžœžœ˜FJšžœ
žœ˜2šžœžœ˜ J˜$Jšžœžœ
žœ	˜5J™"J˜šžœžœ
˜#Jšžœžœžœ
žœžœΟc˜I—šžœ
žœ
žœ
Ÿ˜7Jš
œ1˜1—š
žœžœ
žœžœ
žœ5˜Tšžœ˜J˜(Jšœžœ
˜J˜——J˜"J˜—Jšœžœ
˜Jš
žœ	žœ
žœž	œžœ˜<šžœžœ
žœ˜Jš
œM˜M—J˜šžœ
žœ
žœ
Ÿ@˜XJš
œ7˜7—Jšžœ
˜—Jšžœžœ˜
Jš
œ˜J˜—J˜Jšœžœ˜˜Jš
œΦ™ΦJ˜J˜Jšœžœ˜Jšœ	žœ
˜
Jšœ
žœ
˜Jš
œ˜Jšœ	žœ
˜J˜J˜$J˜šžœ
žœ
ž˜
šžœ˜˜˜(šœžœE˜MJšžœ!žœ!˜F——Jšžœ
˜	Jš
œ˜J˜—Jš
œ3™3J˜šœžœ˜J˜Jšžœ
˜	Jš
œ˜J˜—šœ
žœ˜˜#J˜.—Jšžœ=™?Jšžœ
˜Jš
œ˜—Jš
œ˜—J˜J˜ J˜Jš
œD™DJš
œ™J˜šžœžœžœ˜+Jšœžœ
˜˜PJšœ)žœ
žœ˜B—J™.šžœ2žœ˜:J™'šžœAžœ˜IJ™)š
œ#˜#Jšœ
žœDžœžœ˜V—Jš
œ8˜8Jš
œ˜—š
œ*˜*š
œ˜šžœ*˜0Jš
œ%˜%—Jš
œ4˜4Jš
œ˜——Jš
œC˜CJš
œ˜—Jš
œ˜Jšžœ`žœ/˜“
Jš
œE™EJš
œ˜J˜—Jš
œH™HJš
œ™J˜J˜Jšžœ	žœ
žœ
žœ
˜Jš
œO™OJ™Jš
œ7™7Jš
œ.˜.J˜Jš
œ ™ J˜šžœžœ
žœ
ž
œžœžœ
žœ˜OJ˜—Jš
œ™J˜JšžœžœQ˜uJ˜Jš
œ@˜@J˜Jš
œ9™9J˜Jšœ'žœ˜AJš
œ'˜'Jš
œ.˜.J™J™šžœ%žœ˜-J™7Jšžœžœ$˜:Jšžœ%˜)Jšžœžœ<˜RJ˜—J˜J™0J˜@Jš
œ>˜>J˜Jš
œ³™³J˜Jš
œ˜J˜J˜šžœ#žœžœ˜=Jšœ
žœ
˜˜IJ˜/Jšœž˜Jšœ%žœžœ˜6—šžœ	žœ˜šžœžœ˜J™.J˜Jš
œ"˜"Jš
œ0˜0J˜
—šžœŸ.˜5J˜Jš
œ(˜(Jš
œ4˜4Jš
œ˜—Jš
œ
˜
—šžœ˜J™.Jšžœ_žœ/˜’
šžœžœ˜Jšœ	žœ
˜Jš
œ@™@Jš
œ˜š
ž˜Jšžœ0žœ
žœvžœXžœžœ˜₯šžœžœ˜ J™Jš
œ$˜$Jšžœ@žœ=˜ƒ
Jšœ%žœBžœžœ˜xJ˜
—šžœŸ
˜Jšžœ0žœ
ž˜?Jšœzžœžœ
žœd˜ϋ
Jš
œ7™7Jš
žœŸ/œ
žœžœ"žœ
˜
Jš
œO™OJšœ:žœ€
žœžœ
˜ς
J˜—Jšžœ
˜—Jš
œB˜BJ˜
—šžœ˜J˜J™Š
Jš
œ(˜(J˜—J˜—Jš
œF™FJš
œ
˜
—šžœŸ+˜2J˜Jš
œ(˜(Jš
œ)˜)J˜—Jšœžœ˜&J˜WJ˜Jšžœ
˜—Jš
œ˜—J˜J˜šΟnœžœ
žœ˜7Jšœžœ˜Jšœžœ1Ÿ%˜cšžœžœ	žœžœŸ.œ
žœ
žœ7žœžœžœ
žœ˜ο
Jš
œ7žœ#žœ
žœ`žœLžœžœ˜Γšžœž˜'šžœ#žœ
ž˜2Jš
œ?˜?Jš
œe˜ešœŸJ˜XJšœ9žœW˜–
Jš
œj˜jJš
œ˜—Jšžœ
˜Jšžœžœ
žœ˜Jšžœ
˜J˜——Jšžœžœ
žœ
˜+Jšžœ
˜—J˜—J˜Jš
 œžœ
žœ
žœ
žœ'˜RJ˜Jš œžœ˜˜Jš
œ8™8Jš
œ™J˜Jšœžœ
˜J˜Jšœžœ
˜J˜Jš
œ˜—J˜Jš
œ˜J˜Jšžœ
˜J˜!Jšœ-Οr
˜7J˜™&K™%Kšœ‘r™~—™&KšœK‘™f—K™K™—…—(’G/