DIRECTORY
ImageDefs USING [AddCleanupProcedure, CleanupItem, CleanupProcedure, CleanupMask],
InlineDefs USING [BITSHIFT, HighHalf, LowHalf],
IODefs USING [WriteLine, WriteNumber, WriteString],
Mopcodes USING [zMISC],
MusicDefs,
MusicHardwareDefs,
Note USING [Duration, GetBackTie],      
Piece USING [AddSync, NearestSync],      
ProcessDefs USING [CV, DisableInterrupts, EnableInterrupts, GetPriority, InterruptLevel, Priority, SetPriority, SetTimeout],
Real USING [Fix],
Sync USING [AddNote],      
SystemDefs USING [AllocateSegment],      
Score USING [AddToPitch, GetKey, GetMetrenome],      
Screen USING [DisplayMessage, InvertListen, InvertPlay],      
Utility USING [NewNote, NewSync],      
Voice USING [ClearState, SetState, State, StatePTR];      


MusicProcess: CEDAR MONITOR 
IMPORTS ImageDefs, InlineDefs, IODefs, MusicDefs, Note, Piece, ProcessDefs, Real, Sync, SystemDefs, Score, Screen, Utility, Voice
EXPORTS MusicDefs, Score
= BEGIN OPEN MusicDefs, MusicHardwareDefs;

listen: CONDITION;  -- microcode signals whenever a buffer is ready for listenProcess
play: CONDITION;  -- microcode signals whenever it is through with a buffer
listenProcess, playProcess: PROCESS;

scoreIN: PiecePTR _ NIL;
scoreOUT: PiecePTR _ NIL;
playPhysical: BOOL _ FALSE;
offset: LONG CARDINAL;  -- since we can't set musicIO.time, we use an offset to start in the middle of a piece.
meter: INTEGER; -- speed of play (halftime, normal, doubletime). NOT metrenome!


cleanup: ImageDefs.CleanupItem;

InitializeSynthesizer: PUBLIC PROC = {
originalLevel: ProcessDefs.Priority _ ProcessDefs.GetPriority[];
cleanup _ [NIL, ImageDefs.CleanupMask[Finish]
+ImageDefs.CleanupMask[Save]
+ImageDefs.CleanupMask[Restore]
+ImageDefs.CleanupMask[Checkpoint]
+ImageDefs.CleanupMask[Restart],
CleanupMicrocode];
ImageDefs.AddCleanupProcedure[@cleanup];  
InitMicrocode[];
ProcessDefs.SetTimeout[@play, 1];
ProcessDefs.SetPriority[2];
listenProcess _ FORK ProcessBuffer;
playProcess _ FORK ProcessScore;
ProcessDefs.SetPriority[originalLevel];
};

StartListening: PUBLIC PROC[s: PiecePTR]= {
IF playing THEN RETURN;
meter _ 128; 
sync _ NIL;
offset _0;
IF debugInput THEN IODefs.WriteLine["offset reset--input"];
counter _ 0;
scoreIN _ s;
setOffset _ TRUE; 
partial _ ALL[[pressed, 0, 0]];
keyboardIN _ ALL[[0,[up, up, up, up, up, up]]];
StartMicrocode[listening];
};

StopListening: PUBLIC ENTRY PROC = {
StopMicrocode[listening];
NOTIFY listen;
};

StartPlaying: PUBLIC ENTRY PROC[s: PiecePTR, first: CARDINAL, physical: BOOL,
displayCursor: PROC[time: LONG CARDINAL]]= {
IF listening AND (scoreIN[0]#NIL OR ~Empty[INbuffer]) THEN RETURN;
IF ~physical THEN StopMicrocode[listening];
pendingArray _ ALL[[NIL, NIL, 0, up, FALSE, 0]];
pending _ NIL;
scoreOUT _ s;
in _ 0; -- in and out are used by the cursor displayer
out _ 1;
start _ first;
setOffset _ TRUE;
SELECT TRUE FROM
BlueBug[] => meter _ 256;
RedBug[] => meter _ 64;
ENDCASE => meter _ 128;
playPhysical _ physical;
DisplayCursor _ displayCursor;
StartMicrocode[playing];
IF ~microcode THEN  RealStopMicrocode[];
NOTIFY play; --you fool! you forgot to loadmb music.mb!
};

StopPlaying: PUBLIC PROC = {
StopMicrocode[playing];
IF listening AND scoreIN[0]=NIL AND Empty[INbuffer] 
THEN StopListening[];
};

Empty: PROC[b: EventBufferPTR] RETURNS[BOOL] =  {
IF b=NIL THEN RETURN[TRUE];
FOR i: CARDINAL IN [0..b.length) DO
IF b.data[i].htoc<100 THEN LOOP; -- transient garbage
RETURN[FALSE];
ENDLOOP;
RETURN[TRUE];
};

DisplayCursor: PROC[time: LONG CARDINAL];


setOffset: BOOL _ FALSE; -- so we know when to determine the offset  
counter: CARDINAL; -- number of times the microcode clock has wrapped around

ProcessBuffer: ENTRY PROC = {
c, channel: CARDINAL _ 0;
compare: ChannelWord;
event: MusicEvent;
DO --wait until a buffer is ready and then process it
WHILE ~listening AND INbuffer.length=0 DO WAIT listen; ENDLOOP;
WHILE INbuffer = musicIO.headOfInputList DO WAIT listen; ENDLOOP;
IF ~microcode THEN RealStopMicrocode[];
IF debugInput THEN WriteBuffer[INbuffer];
FOR c IN [0..INbuffer.length) DO
INbuffer.data[c].channelWord.channel _ --! hack to work around bug in the microcode  
SELECT INbuffer.data[c].channelWord.channel FROM 
12 => 0,
15 => 15,
ENDCASE => INbuffer.data[c].channelWord.channel + 1;
event _ INbuffer.data[c];
channel _ event.channelWord.channel;
IF channel = 15 THEN counter _ counter + 1;
IF channel > 12 THEN LOOP;
IF counter=0 AND event.htoc < 100 THEN LOOP; --transient garbage
compare _ keyboardIN[channel];
ExtractTransitions[compare, event.channelWord, event.htoc];
keyboardIN[channel] _ event.channelWord;
ENDLOOP;
IF ~listening THEN FOR i: CARDINAL IN [0..12] DO
IF keyboardIN[i].key = [up, up, up, up, up, up] THEN LOOP;
compare _ keyboardIN[i];
event.channelWord _ [i,[up, up, up, up, up, up]];
event.htoc _ MAX[event.htoc, InlineDefs.LowHalf[musicIO.time]];
ExtractTransitions[compare, event.channelWord, event.htoc];
keyboardIN[channel] _ event.channelWord;
ENDLOOP;
GetNextInputBuffer[];
ENDLOOP;
};

ExtractTransitions: INTERNAL PROC[x, y: ChannelWord, time: CARDINAL]= {
OPEN InlineDefs;
delta, pitch: INTEGER;
channel: CARDINAL=y.channel;
transition: RECORD[a, b, c: KeyState];
e: MusicEvent _ [LOOPHOLE[time], counter];
toc: LONG CARDINAL _ LOOPHOLE[e];
toc _ Scale[toc, meter, 128]+offset;
IF setOffset THEN {setOffset _ FALSE; offset _ 500-toc; toc _ 500;
IF debugInput THEN {WriteLong[offset]; IODefs.WriteLine[" (offset)"]}};
FOR i: CARDINAL IN [0..6) DO
IF x.key[i]=y.key[i] THEN LOOP;
pitch _ Pitch[channel, i];
delta _ InlineDefs.LowHalf[(toc-partial[pitch].toc)];
IF delta<0 THEN delta _ 32000;
transition _ [partial[pitch].last, x.key[i], y.key[i]];
SELECT transition FROM
[pressed, up, pressed] => partial[pitch].toc_ toc;
[up, pressed, up] => partial[pitch].toc_ 0; -- ignore transient bounce
[up, pressed, down] => NULL; --partial[pitch].loudness_ delta;
[down, pressed, down] => NULL;
[pressed, down, pressed] => partial[pitch].duration_ delta;
[pressed, down, up] => {partial[pitch].duration_ delta; AddNote[pitch]};
[down, pressed, up] => AddNote[pitch];
ENDCASE => Error[];
partial[pitch].last _ x.key[i];
ENDLOOP;
};

AddNote: INTERNAL PROC[pitch: CARDINAL] =  {
note: NotePTR;
IF partial[pitch].toc=0 THEN RETURN;
IF partial[pitch].duration=0 THEN Error[];
note _ Utility.NewNote[];
note^ _ []; --defaults to the values listed in MusicDefs
note.pitch _ pitch;
note.toc _ partial[pitch].toc;
note.duration _ partial[pitch].duration;
SELECT TRUE FROM
note.pitch IN [79..92] => { note.stemUp _ FALSE; note.staff _ 0; };
note.pitch IN [68..78] => { note.stemUp_ TRUE; note.staff _ 0; };
note.pitch IN [55..67] => { note.stemUp _ FALSE; note.staff _ 1; };
note.pitch IN [44..54] => { note.stemUp_ TRUE; note.staff _ 1; };
note.pitch IN [34..43] => { note.stemUp _ FALSE; note.staff _ 2; };
note.pitch IN [22..33] => { note.stemUp_ TRUE; note.staff _ 2; };
note.pitch IN [12..21] => { note.stemUp _ FALSE; note.staff _ 3; };
note.pitch IN [5..11]  => { note.stemUp_ TRUE; note.staff _ 3; };
ENDCASE;
IF sync=NIL OR ABS[note.toc - sync.time*MusicDefs.TF] > 200
THEN sync _ scoreIN[Piece.NearestSync[scoreIN, note.toc/MusicDefs.TF, TRUE]];
IF sync=NIL OR ABS[note.toc - sync.time*MusicDefs.TF] > 200 
THEN { 
sync _ Utility.NewSync[];
sync.type _ notes;
sync.time _ note.toc/MusicDefs.TF; 
Piece.AddSync[scoreIN, sync]; 
};
Sync.AddNote[sync, note];
partial[pitch].toc _ 0;
partial[pitch].duration _ 0;
};

sync: SyncPTR _ NIL;

Pitch: PROC[channel, note: CARDINAL] RETURNS[CARDINAL]=
INLINE { RETURN[channel*6 + note+12]; };

partial: ARRAY [0..100) OF RECORD[last: KeyState, toc: LONG CARDINAL, duration: CARDINAL--, loudness: CARDINAL--];
keyboardIN: ARRAY [0..12] OF ChannelWord; 


start: CARDINAL _ 0;

ProcessScore: PROC = {
endOfTime: LONG CARDINAL _ 0;
endOfTime _ endOfTime-1; -- wraps around to largest long cardinal
trill _InlineDefs.LowHalf[Scale[512, 128, 70]];  
trillDur _(3*trill)/4;  
grace _InlineDefs.LowHalf[Scale[300, 128, 70]];  
graceDur _(3*grace)/2;  
DO -- forever 
WHILE NOT playing DO WaitOnPlay[]; ENDLOOP;
musicIO.time _ 0;   
OUTbuffer.data[0] _ reStart;
OUTbuffer.length _ 1;
lastTOC _ 0;
InitKeyboardOUT[];
IF debugOutput THEN IODefs.WriteLine["processing score"];
IF playPhysical THEN TranslatePhysical[] ELSE TranslateLogical[]; 
IF debugOutput THEN IODefs.WriteLine["pending array"];
FlushPending[endOfTime];  -- flushes everything
GetNextOutputBuffer[]; -- has side effect of writing current buffer   
WHILE playing DO -- wait for microcode to finish 
IF musicIO.headOfOutputList=NIL 
THEN StopPlaying[] 
ELSE WaitOnPlay[]; 
ENDLOOP; 
ENDLOOP;
};

TranslatePhysical: PROC = {
n: NotePTR;
sync: SyncPTR;
time, maxTime, lastFlush, duration: LONG CARDINAL _ 0;
FOR i: CARDINAL IN [start..maxScoreLength) DO
IF NOT playing THEN EXIT;
IF (sync _ scoreOUT[i])=NIL THEN EXIT;
FOR j: CARDINAL IN [0..syncLength) DO
IF (n _ sync.event[j])=NIL THEN EXIT;
IF n.rest THEN LOOP;
IF n.tie#NIL AND n.tie.pitch=n.pitch THEN LOOP; -- skip the second note of a tied pair
IF voice AND n.voice#selectedVoice THEN LOOP;
IF n.toc=0 THEN time _ n.sync.time*TF ELSE time _ n.toc; 
IF n.duration=0 THEN duration _ Duration[n, 128] ELSE duration _ n.duration;
maxTime _ MAX[maxTime, time]; 
ProcessNote[MAX[time, lastFlush], duration, n.pitch, loudness]
ENDLOOP;
IF maxTime>1000 THEN lastFlush _ maxTime-1000;
FlushPending[lastFlush];
ENDLOOP;
};

TranslateLogical: PROC = {
i, j: CARDINAL;
n: NotePTR _ NIL;
vs: Voice.State;
sync: SyncPTR _ NIL;
now, delta, toc, max: Time _ 0;
lastDuration, lastNow, lastToc: Time _ 0;
pitch, metrenome, count: INTEGER _ 0;
isLogicalSync, wasLogicalSync, nonGraceSync: BOOL _ TRUE;
metrenome _ Score.GetMetrenome[scoreOUT[start].time];
index _ [0, 0];
Voice.ClearState[@vs];
FOR i: CARDINAL IN [0..maxVoice] DO vs[i].sum _ 10*trill; ENDLOOP;
FOR i IN [start..maxScoreLength) DO
IF NOT playing THEN EXIT;
IF (sync _ score[i])=NIL THEN LOOP;
IF sync.type=repeat1 THEN PushRepeat[i, stack1]; -- encountered a left-paren repeat 
IF sync.type=repeat2 THEN { -- encountered a right-paren repeat 
IF TopRepeat[stack2]=i THEN -- we've repeated once, don't repeat again. 
{ [] _ PopRepeat[stack2]; LOOP; };
IF NoRepeat[stack1] THEN LOOP;
PushRepeat[i, stack2]; -- save repeat so we won't repeat twice 
i _ PopRepeat[stack1]; -- go to beginning of the repeat
};
IF sync.type=metrenome THEN metrenome _ sync.value;
IF sync.type#notes THEN LOOP;
isLogicalSync _ FALSE; toc _ 0;
nonGraceSync _ FALSE;
FOR j IN [0..syncLength) DO
IF (n _ sync.event[j])=NIL THEN EXIT;
toc _ MAX[toc, sync.event[j].toc];
IF ~n.grace THEN nonGraceSync _ TRUE;
IF sync.event[j].value#unknown THEN isLogicalSync _ TRUE;
ENDLOOP;
max _ Voice.SetState[@vs, sync, metrenome];
IF wasLogicalSync AND isLogicalSync THEN 
IF max > now THEN now _ max ELSE now _ lastNow+lastDuration;
IF wasLogicalSync AND ~isLogicalSync THEN {
IF lastToc#0 THEN delta _ lastNow-lastToc ELSE delta_ (lastNow+lastDuration)-toc;
now_ toc+delta};
IF ~wasLogicalSync AND ~isLogicalSync THEN 
now _ toc+delta; 
IF ~wasLogicalSync AND isLogicalSync THEN
IF toc#0 AND toc+delta>now AND toc+delta<lastNow+lastDuration+4*trill 
THEN now _ toc+delta 
ELSE now_ lastNow+lastDuration;
SetSum[@vs, now];
IF nonGraceSync THEN PlayGraceNotes[now, i];
FOR j IN [0..syncLength) DO 
IF (n _ sync.event[j])=NIL THEN EXIT; 
IF voice AND n.voice#selectedVoice THEN LOOP; 
IF n.grace THEN LOOP; 
Associate[now, i];  -- so we can display the cursor later
PlayLogical[n, now, metrenome]; 
ENDLOOP;
wasLogicalSync _ isLogicalSync;
lastNow _ now; -- just to make it easier to understand
lastToc _ toc;
lastDuration _ 0;
IF isLogicalSync
THEN FOR j IN [0..maxVoice] DO
IF vs[j].found THEN lastDuration _ MAX[lastDuration, vs[j].duration];
ENDLOOP
ELSE FOR j IN [0..syncLength) DO
IF sync.event[j]=NIL THEN EXIT;
lastDuration _ MAX[lastDuration, sync.event[j].duration];
ENDLOOP;
lastDuration _ (4*lastDuration)/3;
IF nonGraceSync THEN FlushPending[now];
ENDLOOP;
};

PlayGraceNotes: PROC[now: Time, i: CARDINAL] =  {
n: NotePTR;
oldLoudness: CARDINAL;
nonGraceSync: BOOL;
count, start: CARDINAL _ 0;
FOR j: CARDINAL DECREASING IN [0..i) DO
IF score[j]=NIL THEN LOOP;
IF score[j].type#notes THEN LOOP;
count _ count+1; 
nonGraceSync _ FALSE;
FOR k: CARDINAL IN [0..syncLength) DO
IF (n _ score[j].event[k])=NIL THEN EXIT;
IF ~n.grace THEN nonGraceSync _ TRUE;
ENDLOOP;
IF nonGraceSync THEN {start _ j; EXIT};
ENDLOOP;
oldLoudness _ loudness;
loudness _ (7*loudness)/8;
FOR j: CARDINAL IN [start..i) DO
IF score[j]=NIL THEN LOOP;
IF score[j].type#notes THEN LOOP;
FOR k: CARDINAL IN [0..syncLength) DO
IF (n _ score[j].event[k])=NIL THEN EXIT;
IF ~n.grace THEN LOOP;
PlayLogical[n, now-count*grace, 128];
ENDLOOP;
count _ count-1;
ENDLOOP;
loudness _ oldLoudness;
};

SetSum: PROC[vs: Voice.StatePTR, sum: LONG CARDINAL] = {
FOR i: CARDINAL IN [0..maxVoice] DO
IF vs[i].found THEN vs[i].sum _ sum;
ENDLOOP;
};

trill, trillDur: INTEGER;
grace, graceDur: INTEGER;

PlayLogical: PROC[n: NotePTR, toc: LONG CARDINAL, metrenome: INTEGER] = {
key: INTEGER;
duration: LONG INTEGER;
IF n.rest THEN RETURN;
IF voice AND n.voice#selectedVoice THEN RETURN;
IF n.tie#NIL AND n.tie.pitch=n.pitch AND NOT Trilled[n] THEN RETURN; -- skip the second note of a tied pair
IF n.value#unknown THEN duration _ Duration[n, metrenome] ELSE duration _ n.duration;
IF n.embellish#none OR n.tie#NIL THEN key _ Score.GetKey[n.sync.time];
SELECT TRUE FROM
n.embellish=trill OR (n.tie#NIL AND n.tie.pitch=n.pitch) => {  -- n.tie is tied back to a trill
time: LONG CARDINAL _ toc;
duration _ Note.Duration[n, metrenome];
ProcessNote[time, trillDur, n.pitch, loudness];
ProcessNote[time+trill, trillDur, Score.AddToPitch[key, n.pitch, 1], loudness];
time _ time+2*trill;
duration _ duration-2*trill;
WHILE duration>=2*trill DO 
ProcessNote[time, trillDur, n.pitch, loudness];
ProcessNote[time+trill, trillDur, Score.AddToPitch[key, n.pitch, 1], loudness];
time _ time+2*trill;
duration _ duration-2*trill;
ENDLOOP;
};
n.embellish=mordent1 => { 
ProcessNote[toc-2*trill, trillDur, n.pitch, loudness];
ProcessNote[toc-trill, trillDur, Score.AddToPitch[key, n.pitch, 1], loudness];
ProcessNote[toc, duration, n.pitch, loudness];
};
n.embellish=mordent2 => { 
ProcessNote[toc-2*trill, trillDur, n.pitch, loudness];
ProcessNote[toc-trill, trillDur, Score.AddToPitch[key, n.pitch,-1], loudness];
ProcessNote[toc, duration, n.pitch, loudness];
};
n.grace => ProcessNote[toc, graceDur, n.pitch, loudness];
ENDCASE => ProcessNote[toc, duration, n.pitch, loudness];
};

Trilled: PROC[n: NotePTR] RETURNS[BOOL] = {
WHILE n.tie#NIL DO
IF n.tie.pitch#n.pitch THEN RETURN[FALSE];
IF (n _ n.tie).embellish=trill THEN RETURN[TRUE];
IF n.embellish#none THEN RETURN[FALSE];
ENDLOOP;
RETURN[FALSE];
}; 

Duration: PROC[n: NotePTR, metrenome: INTEGER] RETURNS[INTEGER] = {
l: REAL _ 1;
tie: NotePTR;
d: Time _ Note.Duration[n, metrenome];
IF n.grace THEN d _ grace;
WHILE n.tied DO
IF n.embellish=trill THEN EXIT;
tie _ Note.GetBackTie[n];
IF n.pitch#tie.pitch THEN EXIT;
d _ d + Note.Duration[tie, metrenome];
n _ tie;
ENDLOOP;
RETURN[InlineDefs.LowHalf[MIN[7*(d/8), 32000]]];
};


Scale: PROC[time, top, bottom: LONG CARDINAL] RETURNS[LONG CARDINAL] = {
l: REAL _ 1;
RETURN[Real.Fix[l*top*time/bottom]];
};

loudness: INTEGER _ 90;


PushRepeat: PROC[i, s: CARDINAL] =
{ stack[s][index[s]] _ i; index[s] _ index[s] + 1; };

PopRepeat: PROC[s: CARDINAL] RETURNS[CARDINAL] =
{ IF NoRepeat[s] THEN Error; index[s] _ index[s] - 1; RETURN[stack[s][index[s]]]; };

TopRepeat: PROC[s: CARDINAL] RETURNS[CARDINAL] =
{ RETURN[IF NoRepeat[s] THEN 10000 ELSE stack[s][index[s]-1]]; };

NoRepeat: PROC[s: CARDINAL] RETURNS[BOOL] =
{ RETURN[index[s]=0] };

stack: ARRAY [1..2] OF ARRAY [0..10] OF CARDINAL;
index: ARRAY [1..2] OF CARDINAL _ [0, 0]; 
stack1: CARDINAL = 1;
stack2: CARDINAL = 2;


WaitOnPlay: ENTRY PROC = {
time: Time;
sync: SyncPTR;
WAIT play;
WHILE dataStructureInFlux DO WAIT play; ENDLOOP;
IF musicIO.headOfOutputList=NIL THEN RETURN;
time _ Scale[musicIO.time, meter, 128]+offset;
IF playPhysical 
THEN DisplayCursor[time]
ELSE IF (sync _ GetSync[time])#NIL THEN DisplayCursor[sync.time];
};

Associate: PROC[time: LONG CARDINAL, sync: CARDINAL] = {
IF list[in] = [time, sync] THEN RETURN;
in _ (in+1) MOD listLength;
list[in] _ [time, sync];
};

GetSync: PROC[time: LONG CARDINAL] RETURNS[SyncPTR] = {
IF out = (in+1) MOD listLength THEN RETURN[NIL];
WHILE list[(out+1) MOD listLength].time<time+520 DO
out _ (out+1) MOD listLength;
IF out = (in+1) MOD listLength THEN RETURN[NIL];
ENDLOOP;
RETURN[scoreOUT[list[out].sync]];
};

list: ARRAY [0..listLength) OF 
RECORD[time: LONG CARDINAL, sync: CARDINAL];
listLength: CARDINAL = 70;
in, out: CARDINAL;



lastTOC: LONG CARDINAL; -- all future events must occur AFTER this time.
pending: POINTER TO PendingEvent _ NIL; -- list of events produced that we don't want to put in the buffer yet because events to come may actually occur before these events.

ProcessNote: PROC[time, duration: LONG CARDINAL, pitch: INTEGER, loudness: CARDINAL] = {
merge: BOOL _ FALSE;
temp: POINTER TO PendingEvent;
WHILE pitch<12 DO pitch _ pitch+12; ENDLOOP; -- make the note fall on the keyboard
WHILE pitch>87 DO pitch _ pitch-12; ENDLOOP; -- ditto
IF pitch>72 THEN loudness _ (2*loudness)/3; -- adjust for dynamics of keyboard
IF setOffset THEN {offset _ (IF time>500 THEN time-500 ELSE 0); setOffset _ FALSE;
IF debugOutput THEN {WriteLong[offset]; IODefs.WriteLine[" (offset)"]}};
time _ Scale[(time-offset), 128, meter]; -- adjust for tempo (not metrenome!)
duration _ Scale[duration, 128, meter];
duration _ MAX[duration, 2*loudness];
time _ MAX[time, lastTOC];
FOR temp _ pending, temp.next WHILE temp#NIL DO
IF temp.pitch#pitch THEN LOOP;
IF temp.toc<time THEN LOOP; 
IF temp.state=illegal THEN LOOP; 
IF temp.state=up THEN { -- separate the two notes 
temp.state _ illegal;
AddPending[pitch, up, time-2];
duration _ MAX[duration, temp.toc-time]; 
EXIT};
IF temp.state=pressed AND temp.toc>time+loudness THEN { -- separate them
temp.state _ illegal;
AddPending[pitch, up, MAX[temp.toc, time+duration]];
duration _ MIN[duration, temp.toc-time-2]; 
EXIT};
merge _ TRUE;
EXIT; ENDLOOP;
IF merge THEN FOR temp _ pending, temp.next WHILE temp#NIL DO
IF temp.pitch#pitch THEN LOOP;
IF temp.toc<time THEN LOOP;
IF temp.state=illegal THEN LOOP;
IF temp.state=pressed AND time<temp.toc THEN -- make it as early as possible
{temp.state _ illegal; AddPending[pitch, pressed, time]};
IF temp.state=down AND time+loudness<temp.toc THEN -- make it as loud as possible
{temp.state _ illegal; AddPending[pitch, down, time+loudness]};
IF temp.state=up AND time+duration>temp.toc THEN -- make it as long as possible
{temp.state _ illegal; AddPending[pitch, up, time+duration]};
IF temp.state=up THEN RETURN;
ENDLOOP;
AddPending[pitch, pressed, time];
AddPending[pitch, down, time+loudness];
AddPending[pitch, up, time+duration];
};

AddPending: PROC[pitch: INTEGER, state: KeyState, toc: LONG CARDINAL] =
i: CARDINAL _ 0;
p: POINTER TO PendingEvent;
IF toc<lastTOC THEN Error[]; -- runtime check of invariant
IF LOOPHOLE[toc, LONG INTEGER]<0 THEN Error[];
UNTIL pendingArray[i].used = FALSE DO i _ i + 1; ENDLOOP;
IF i >= pendingLength THEN Error[];
pendingArray[i] _ [NIL, NIL, pitch, state, TRUE, toc];
IF pending = NIL OR toc < pending.toc 
THEN {
pendingArray[i].next _ pending;
pending _ @pendingArray[i]}
ELSE FOR p _ pending, p.next DO 
IF p.next = NIL OR toc < p.next.toc THEN { 
pendingArray[i].next _ p.next;
pendingArray[i].back _ p;
IF p.next#NIL THEN p.next.back _ @pendingArray[i];
p.next _ @pendingArray[i];
EXIT};
ENDLOOP;
};

FlushPending: PROC[time: LONG CARDINAL] = {
temp: POINTER TO PendingEvent;
IF time<offset THEN time _ offset;
time _ Scale[(time-offset), 128, meter]; -- adjust for metrenome
WHILE pending#NIL AND time> pending.toc DO  
AddEvent[pending.pitch, pending.state, pending.toc];
temp _ pending;
pending _ pending.next;
temp.used _ FALSE;
ENDLOOP;
};

AddEvent: PROC[pitch: CARDINAL, state: KeyState, toc: LONG CARDINAL] = {
OPEN InlineDefs;
i, lastEvent: CARDINAL;
IF state=illegal THEN RETURN;
pitch _ pitch-12;
SetPitchOUTState[pitch, state];
IF toc<lastTOC THEN Error[]; -- runtime check of invariant
FOR i IN [0..(InlineDefs.HighHalf[toc]-InlineDefs.HighHalf[lastTOC])) DO
lastEvent _ OUTbuffer.length;
IF lastEvent>=OUTbuffer.maxLength THEN {lastEvent _ 0; GetNextOutputBuffer[]};
OUTbuffer.data[lastEvent] _ nullEvent;
OUTbuffer.length _ lastEvent + 1;
ENDLOOP;
lastEvent _ OUTbuffer.length;
IF lastEvent >= OUTbuffer.maxLength THEN {lastEvent _ 0; GetNextOutputBuffer[]};
OUTbuffer.data[lastEvent].channelWord _ keyboardOUT[Channel[pitch]];
OUTbuffer.data[lastEvent].htoc _ InlineDefs.LowHalf[toc];
OUTbuffer.length _ lastEvent + 1;
lastTOC _ toc;
};

SetPitchOUTState: PROC[pitch: INTEGER, state: KeyState] = {
channel: CARDINAL _ Channel[pitch];
index: CARDINAL _ pitch MOD 6;
IF debugOutput THEN {
IF keyboardOUT[channel].key[index]=pressed AND state=up THEN Error[];
IF keyboardOUT[channel].key[index]=up AND state=down THEN Error[]};
keyboardOUT[channel].key[index] _ state;
};

InitKeyboardOUT: PROC = INLINE {
FOR i: CARDINAL IN [0..12] DO
keyboardOUT[i] _ [i,[up, up, up, up, up, up]];
ENDLOOP};

Channel: PROC[pitch: CARDINAL] RETURNS[CARDINAL] =
INLINE {RETURN[IF pitch<6 THEN 12 ELSE pitch/6 -1]};

keyboardOUT: ARRAY [0..12] OF ChannelWord;
nullEvent: MusicEvent = [[15,[up, up, up, up, up, up]], 0];
reStart: MusicEvent = [[14,[up, up, up, up, up, up]], 0];
pendingArray: ARRAY [0..pendingLength) OF PendingEvent;
pendingLength: CARDINAL=140;
PendingEvent: TYPE = RECORD[next, back: POINTER TO PendingEvent,
pitch: [-100..300],
state: KeyState,
used: BOOL,
toc: LONG CARDINAL];


musicIO: MusicIODescriptor;
INbuffer: EventBufferPTR; -- pointer to current input buffer
unprocessedBuffers: EventBufferPTR;--buffers that haven't been processed by ProcessBuffer
OUTbuffer: EventBufferPTR;  -- pointer to current output buffer
temporaryRegisters: ARRAY [0..26) OF CARDINAL;
started: BOOL _ FALSE;
playing: PUBLIC BOOL _ FALSE;
listening: PUBLIC BOOL _ FALSE;
playChannel: ProcessDefs.InterruptLevel;
listenChannel: ProcessDefs.InterruptLevel;
microcode: BOOL _ TRUE; -- debugging switch

Error: PROC =
{ RealStopMicrocode[]; ERROR; };

InitMicrocode: PROC = {
playBit, listenBit: CARDINAL;
playBit _ FindBit[0];
playChannel _ GetLevel[playBit];
listenBit _ FindBit[playChannel];
listenChannel _ GetLevel[listenBit];
IF playBit=listenBit THEN ERROR;
musicIO _ [NIL, NIL,, listenBit, playBit,@temporaryRegisters, 75145B, 0];
INbuffer _ unprocessedBuffers _ LinkBuffer[];
OUTbuffer _ LinkBuffer[];
};

FindBit: PROC[i: CARDINAL] RETURNS[bit: CARDINAL] = { 
x, channel: ProcessDefs.InterruptLevel;
FOR x IN ProcessDefs.InterruptLevel DO
IF ProcessDefs.CV[x]#NIL THEN LOOP; 
IF x=i THEN LOOP;
channel _ x; 
EXIT; ENDLOOP;
bit _ InlineDefs.BITSHIFT[1, LOOPHOLE[channel, CARDINAL]];
};

GetLevel: PROC[bit: CARDINAL] RETURNS[lvl: ProcessDefs.InterruptLevel] = {
cursor: CARDINAL _ 1;
lvl _ 0;
IF bit=0 THEN ERROR;
UNTIL bit=1 DO
bit _ InlineDefs.BITSHIFT[bit, -1];
lvl _ lvl+1;
ENDLOOP;
};

StartMicrocode: PROC[mode: {playing, listening}] = {
IF mode=listening AND listening THEN RETURN;
IF mode=playing AND playing THEN RETURN;
ProcessDefs.DisableInterrupts[];
IF mode=listening 
THEN ProcessDefs.CV[listenChannel] _ @listen 
ELSE ProcessDefs.CV[playChannel] _ @play;
IF mode=listening THEN
{
musicIO.headOfInputList _ unprocessedBuffers;
INbuffer _ unprocessedBuffers;
listening _ TRUE;
};
IF mode=playing THEN playing _ TRUE;
ProcessDefs.EnableInterrupts[];
IF mode=listening THEN Screen.InvertListen[];
IF mode=playing THEN Screen.InvertPlay[];
IF started THEN RETURN;
RegisterInit[];
MainMusicPTR^ _ @musicIO;
started _ TRUE;
RealStartMicrocode[! ANY => {
IF mode=listening THEN Screen.InvertListen[];
IF mode=playing THEN Screen.InvertPlay[];
Screen.DisplayMessage["Please load microcode!!! (loadmb music.mb)"];
listening _ playing _ FALSE;
started _ FALSE; 
flash _ TRUE;
CONTINUE}];
IF debugOutput THEN IODefs.WriteLine["music started"];
};

RegisterInit: PROC = {
i: CARDINAL;
FOR i IN [0..25) DO musicIO.microcodeTemps[i] _ 0; ENDLOOP;
musicIO.microcodeTemps[25] _ 100000B;
};

StopMicrocode: PROC[mode: {playing, listening}]  = {
IF mode=playing THEN {
IF ~playing THEN RETURN;
ProcessDefs.DisableInterrupts[];
ProcessDefs.CV[playChannel] _ NIL;
musicIO.headOfOutputList _ NIL;
playing _ FALSE;
ProcessDefs.EnableInterrupts[];
Screen.InvertPlay[];
IF listening THEN RETURN};
IF mode=listening THEN {
IF ~listening THEN RETURN;
ProcessDefs.DisableInterrupts[];
ProcessDefs.CV[listenChannel] _ NIL;
musicIO.headOfInputList _ NIL;
listening _ FALSE;
ProcessDefs.EnableInterrupts[];
Screen.InvertListen[];
IF playing THEN RETURN};
IF ~started THEN RETURN;
MainMusicPTR^ _ NIL;
RealStopMicrocode[];
started _ FALSE;
};

CleanupMicrocode: ImageDefs.CleanupProcedure =
{
RealStopMicrocode[];
};

RealStartMicrocode: PROC = 
MACHINE CODE { Mopcodes.zMISC, 244B };

RealStopMicrocode: PROC = 
MACHINE CODE { Mopcodes.zMISC, 245B };

LinkBuffer: PROC RETURNS[b: EventBufferPTR] = {
j: EventBufferPTR;
j _ SystemDefs.AllocateSegment[2*bufferLength+7];
j^ _ [NIL, bufferLength, 0,, ALL[[LOOPHOLE[0], 0]] ];
b _ SystemDefs.AllocateSegment[2*bufferLength+7];
b^ _ [j, bufferLength, 0,, ALL[[LOOPHOLE[0], 0]] ];
RETURN;
};

length: CARDINAL; -- debugging aid

GetNextInputBuffer: PROC = {
length _ INbuffer.length; 
INbuffer.length _ 0;
unprocessedBuffers _ INbuffer.chainPTR;
INbuffer.chainPTR _ NIL;
Append[unprocessedBuffers, INbuffer];
INbuffer _ unprocessedBuffers;
IF musicIO.headOfInputList=NIL AND listening THEN { 
musicIO.headOfInputList _ unprocessedBuffers;
IF debugInput THEN IODefs.WriteLine["add to musicIO input."]};
IF debugInput THEN WriteList[musicIO.headOfInputList,"headOfInputList= "];
IF debugInput THEN WriteList[INbuffer,"INbuffer list= "];
};

GetNextOutputBuffer: PROC = {
WriteCurrentOutputBuffer[];
IF OUTbuffer = NIL THEN Error[]; 
WHILE OUTbuffer = musicIO.headOfOutputList DO WaitOnPlay[]; ENDLOOP;
OUTbuffer.length _ 0;
};

WriteCurrentOutputBuffer: PROC = {
l: EventBufferPTR;
IF debugOutput THEN WriteBuffer[OUTbuffer];
l _ OUTbuffer.chainPTR;
OUTbuffer.chainPTR _ NIL;
Append[l, OUTbuffer]; -- l is most likely already on musicIO.headOfOutputList
IF musicIO.headOfOutputList = NIL AND playing
THEN { -- but if it isn't, then put OUTbuffer on
musicIO.headOfOutputList _ OUTbuffer;
IF debugOutput THEN IODefs.WriteLine["add to musicIO output."];
};
OUTbuffer _ l;
IF debugOutput THEN WriteList[musicIO.headOfOutputList,"headOfOutputList= "];
IF debugOutput THEN WriteList[OUTbuffer,"OUTbuffer list= "];
};

Append: PROC[list, buffer: EventBufferPTR] = INLINE {
p: EventBufferPTR;
IF list = NIL THEN RETURN;
FOR p _ list, p.chainPTR DO
IF p.chainPTR = NIL THEN { p.chainPTR _ buffer; EXIT; };
ENDLOOP;
};


debugInput, debugOutput: BOOL _ FALSE;

WriteList: PROC[b: EventBufferPTR, header: STRING] = {
OPEN IODefs;
p: EventBufferPTR;
WriteString[header];
IF b=NIL THEN { WriteLine["NIL"]; RETURN; };
FOR p _ b, p.chainPTR DO
IF p=NIL THEN { WriteLine[";"]; EXIT; };
WriteNumber[LOOPHOLE[InlineDefs.LowHalf[p], CARDINAL],[8, FALSE, TRUE, 7]];
ENDLOOP;
};

WriteBuffer: PROC[b: EventBufferPTR] =  {
OPEN IODefs;
i, oldtoc: CARDINAL _ 0;
e: MusicEvent;
WriteLine[""];
WriteString["buffer="];
WriteNumber[b.length,[10, FALSE, TRUE, 4]];
WriteLine[""];
WriteLong[musicIO.time];
WriteLine[""];
FOR i IN [0..b.length) DO
{
e _ b.data[i];
IF e.channelWord.channel = 15 THEN 
{ WriteLine["wrap around"]; LOOP; };
IF e.channelWord.channel = 14 THEN 
{ WriteLine["reset clock to 0"]; LOOP; };
WriteString["channelword="];
WriteNumber[e.channelWord.channel,[10, FALSE, TRUE, 3]];
FOR i: CARDINAL IN [0..6) DO
WriteNumber[e.channelWord.key[i],[10, FALSE, TRUE, 2]];
ENDLOOP;
WriteString["   htoc="];
WriteNumber[e.htoc,[10, FALSE, TRUE, 6]];
IF e.htoc < oldtoc  
THEN WriteLine["!!!!!"]
ELSE WriteLine[";"];
oldtoc _ e.htoc;
}; ENDLOOP;
};

WriteLong: PROC[lc: LONG CARDINAL] = INLINE {
IODefs.WriteNumber[InlineDefs.HighHalf[lc],[10, FALSE, TRUE, 4]];
IODefs.WriteNumber[InlineDefs.LowHalf[lc],[10, FALSE, TRUE, 4]];
};

END.
MusicProcess.mesa
Copyright (C) 1981, 1984 Xerox Corporation. All rights reserved.
Author: John Maxwell
last modified: December 18, 1981  8: 47 AM
Edited by Doug Wyatt, June 14, 1984 3:44:56 pm PDT
******************************************************************
code necessary to initialize the processes
******************************************************************
******************************************************************
this submodule is responsible for translating from events to notes
******************************************************************
the microcode passes us a buffer of keystates and their times.
we must compare successive keystates to see where changes occur.
the keystates may include spurious "bounce".
channel=15 means that the microcode's clock wrapped around (it's only 16 bits).
each channel has 6 keys, and there might be more than one transition
note.loudness _ partial[pitch].loudness;
******************************************************************
this submodule is responsible for translating from notes to events
******************************************************************
done with the main score, clean out pending
handle all of the syncs that don't contain notes 
handle syncs that contain notes
is this a logical sync?  what is its toc?
determine the time to play for the whole sync.
handle boundarys between physical and logical sections
play all non-grace notes
set up wasLogicalSync, lastNow, lastToc and lastDuration for the next iteration
how many grace syncs? where do they start?
now we can play them
grace notes and trills are played at a constant rate independent of metrenome
******************************************************************
procedures needed to handle repeats correctly
******************************************************************
******************************************************************
Waiting and displaying cursor
******************************************************************
We want to display the cursor near the note that the microcode is playing, not the one we are processing.
All we know about the microcode is its current time.  (musicIO.time)
We save the actual times we said to play syncs long enough to guess what sync is being played.
******************************************************************
Adding a physical note (pitch, time, duration, loudness) to a buffer
******************************************************************
Each note must be converted into three events: key pressed, key down, and key up.
The time between pressed and down is LOUDNESS
The time between pressed and up is DURATION
Because of multiple voices, the same pitch may be played twice in an overlapping manner.
IF the second pitch is pressed after the first becomes down, then separate the notes, else merge them.
To separate the notes: stop the first note just before the second begins.
To merge the notes: use the earlier start time, the longer duration, and the greater loudness.  
Events in the buffer must be in order by their time of occurrance.
Once you put an event in the buffer, there is no turning back.
find out if there is another note pending at this pitch and time
ENDCASE: merge the two notes
nullify incorrect entries.  (don't want to resort pending list)
keeps pending list sorted by toc {
enter pending events
insert any spacers necessary
add the event
******************************************************************
Microcode and buffers
******************************************************************
the microcode gets all of its information through musicIO
musicIO has two queues of buffers: one for input, and one for output.
The microcode only listens if there is an empty buffer on the input queue.
When a buffer gets full, it NOTIFY's listen.  The full buffer is found on the input queue.
The microcode will play any buffer on the ouput queue.
There are two pools of buffers.  When a buffer has been processed, we put it at the end of its queue. 
Gene's procedures for getting a process level
initialize the EventBuffers
i: EventBufferPTR;
i _ SystemDefs.AllocateSegment[2*bufferLength+7];
i^ _ [j, bufferLength, 0,, ALL[[LOOPHOLE[0], 0]] ];
******************************************************************
testing procedures
******************************************************************
�Ê%²˜š
œ™Jš
œ@™@Jš
œ™Jš
œ*™*J™2J˜—š
Ïk	˜	Jšœ
�œC˜RJšœ�œ�œ˜/Jšœ�œ'˜3Jšœ	�œ	˜J˜
J˜Jšœ�œ˜(Jšœ�œ˜)Jšœ�œ�œg˜|Jšœ�œ˜Jšœ�œ˜Jšœ�œ˜)Jšœ�œ*˜5Jšœ�œ2˜>Jšœ�œ˜'Jšœ�œ/˜:J˜J˜—Jšœ�œ
�œ
˜Jš�œz˜�
Jš�œ˜Jšœ�œ
�œ˜*J˜Jšœ�	œÏcA˜UJšœ�	œž9˜KJšœ�œ
˜$J˜Jšœ�œ
˜Jšœ�œ
˜Jšœ�œ�œ
˜Jšœ�œ
�œžW˜oJšœ�œž?˜OJ˜Jš
œB™BJš
œ*™*Jš
œB™BJ˜J˜J˜šÏnœ�œ
�œ˜&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˜šŸœ�œ
�œ
�œ�œ�œ
˜MJšœ�œ�œ
�œ˜,Jš�œ�œ
�œ
�œ�œ
�œ
˜BJš�œ�œ˜+Jš	œ�œ�œ�œ	�œ˜0Jšœ
�œ
˜J˜
Jšœž.˜6J˜J˜Jšœ�œ
˜š�œ
�œ
�˜J˜J˜Jš�œ˜—J˜J˜J˜Jš�œ�œ˜(Jš�œž*˜7Jš
œ˜—J˜šŸœ�œ
�œ˜J˜š�œ�œ�œ
�œ˜4Jš�œ˜—Jš
œ˜—J˜šŸœ�œ�œ
�œ˜1Jš
�œ�œ
�œ
�œ
�œ˜š�œ�œ
�œ�˜#Jš�œ�œ
�œž˜5Jš�œ
�œ˜Jš�œ
˜—Jš�œ
�œ˜
Jš
œ˜—J˜JšŸ
œ�œ�œ
�œ˜)J˜Jš
œB™BJš
œB™BJš
œB™BJš
œ>™>Jš
œ@™@Jš
œ,™,Jš
œO™OJ˜Jšœ�œ�œž,˜EJšœ	�œž9˜LJ˜šŸ
œ�œ
�œ˜Jšœ�œ˜J˜J˜Jš�œ
ž2˜5Jš
�œ�œ�œ
�œ	�œ
˜?Jš�œ$�œ
�œ	�œ
˜AJš�œ�œ˜'Jš�œ�œ˜)š�œ�œ�˜ šœ'ž.˜Uš�œ&�œ
˜1J˜J˜	Jš�œ-˜4——J˜J˜$Jš�œ�œ˜+Jš�œ�œ
�œ
˜Jš	�œ�œ�œ
�œž˜@J˜J˜;J˜(Jš�œ
˜—š�œ�œ
�œ�œ
�œ	�˜0Jš�œ.�œ
�œ
˜:J˜J˜1Jšœ
�œ/˜?J˜;J˜(Jš�œ
˜—J˜Jš�œ
˜Jš
œ˜—J˜šŸœ�œ
�œ�œ˜GJš�œ˜Jšœ�œ
˜Jšœ	�œ˜Jšœ�œ˜&Jšœ�œ˜*Jšœ�œ
�œ�œ˜!J˜$š�œ�œ�œ˜BJš�œ�œ5˜G—Jš
œD™Dš�œ�œ
�œ�˜Jš�œ�œ
�œ
˜J˜J˜5Jš�œ	�œ˜J˜7š�œ�˜J˜2Jšœ,ž˜FJšœ�œž!˜>Jšœ�œ
˜J˜;J˜HJ˜&Jš�œ˜—J˜Jš�œ
˜—Jš
œ˜—J˜šŸœ�œ
�œ�œ˜,J˜Jš�œ�œ
�œ
˜$Jš�œ�œ	˜*J˜Jšœž,˜8J˜J˜J˜(Jš
œ(™(š�œ
�œ
�˜Jšœ�œ�œ˜CJšœ�œ�œ˜AJšœ�œ�œ˜CJšœ�œ�œ˜AJšœ�œ�œ˜CJšœ�œ�œ˜AJšœ�œ�œ˜CJšœ�œ�œ˜AJš�œ
˜—š
�œ�œ
�œ
�œ �œ˜;Jš�œ>�œ�œ˜M—š
�œ�œ
�œ
�œ �œ˜<š�œ˜J˜J˜Jšœ�œ˜#J˜Jš
œ˜——J˜J˜J˜Jš
œ˜—J˜Jšœ�œ
˜J˜Jš
Ÿœ�œ�œ�œ
�œ˜7Jš�œ�œ˜(J˜Jšœ	�œ
�œ
�œ�œ
�œ�žœ˜rJšœ�œ	�œ˜*J˜Jš
œB™BJš
œB™BJš
œB™BJ˜Jšœ�œ˜J˜šŸœ�œ˜Jšœ�œ
�œ˜Jšœž(˜AJ˜1J˜J˜1J˜š�œ
ž˜Jš�œ
�œ	�œ�œ
˜+J˜J˜J˜J˜J˜Jš�œ
�œ&˜9Jš�œ�œ�œ˜BJš
œ+™+Jš�œ
�œ#˜6Jšœž˜/Jšœž/˜Fš�œ	�œ
ž ˜1š�œ�œ
˜ Jš�œ˜Jš�œ˜—Jš�œ˜	—Jš�œ
˜—Jš
œ˜—J˜šŸœ�œ˜J˜J˜Jšœ$�œ
�œ˜6š�œ�œ
�œ�˜-Jš�œ
�œ	�œ
�œ
˜Jš�œ�œ
�œ
�œ
˜&š�œ�œ
�œ�˜%Jš�œ�œ
�œ
�œ
˜%Jš�œ�œ
�œ
˜Jš�œ�œ
�œ�œ
�œž&˜VJš�œ�œ�œ
�œ
˜-Jš�œ	�œ�œ
�œ˜9Jš�œ�œ�œ˜LJšœ
�œ˜Jšœ�œ/˜>Jš�œ
˜—Jš�œ�œ˜.J˜Jš�œ
˜—Jš
œ˜—J˜šŸœ�œ˜Jšœ�œ
˜Jšœ
�œ
˜J˜Jšœ�œ
˜J˜J˜)Jšœ�œ˜%Jšœ-�œ�œ
˜9J˜5J˜J˜Jš
�œ�œ
�œ�œ�œ
˜Bš�œ�œ�˜#Jš�œ
�œ	�œ
�œ
˜Jš�œ�œ
�œ
�œ
˜#Jš
œ1™1Jš�œ�œž#˜Tš�œ�œž$˜@š�œ�œ
ž,˜HJšœ�œ˜"—Jš�œ�œ
�œ
˜Jšœž(˜?Jšœž ˜7Jš
œ˜—Jš�œ�œ˜3Jš�œ�œ
�œ
˜Jš
œ™Jš
œ)™)Jšœ�œ
˜Jšœ�œ
˜š�œ�œ�˜Jš�œ�œ
�œ
�œ
˜%Jšœ�œ˜"Jš�œ
�œ�œ
˜%Jš�œ�œ�œ
˜9Jš�œ
˜—Jš
œ.™.Jš
œ6™6J˜+š�œ�œ�œ
˜)Jš�œ�œ�œ˜<—š�œ�œ�œ˜+Jš�œ�œ�œ#˜QJ˜—š�œ�œ�œ
˜+J˜—š�œ�œ�˜)š�œ�œ�œ(˜FJš�œ˜Jš�œ˜——J˜Jš�œ�œ˜,Jš
œ™š�œ�œ�œ
˜Jš�œ�œ
�œ
�œ˜&Jš�œ�œ�œ
�œ˜.Jš�œ	�œ
�œ˜Jšœž%˜9J˜ Jš�œ
˜—Jš
œO™OJ˜Jšœž'˜6J˜J˜š�œ˜š�œ
�œ�œ�˜Jš�œ
�œ�œ˜EJš
�˜—š�œ
�œ�œ�˜ Jš�œ�œ
�œ
�œ
˜Jšœ�œ'˜9Jš�œ
˜——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˜Jš�œ
˜—J˜Jš
œ˜—J˜šŸœ�œ�œ
�œ˜8š�œ�œ
�œ�˜#Jš�œ
�œ˜$Jš�œ
˜—Jš
œ˜—J˜Jšœ�œ
˜Jšœ�œ
˜Jš
œM™MJ˜š
Ÿœ�œ�œ
�œ
�œ˜IJšœ�œ
˜
Jšœ
�œ
�œ
˜Jš�œ�œ
�œ
˜Jš�œ�œ�œ
�œ
˜/Jš�œ�œ
�œ�œ
�œ�œ
�œž&˜kJš�œ�œ#�œ˜UJš�œ�œ�œ
�œ!˜Fš�œ
�œ
�˜šœ�œ�œ
�œž ˜_Jšœ�œ
�œ˜J˜'J˜/J˜OJ˜J˜š�œ�œ
˜J˜/J˜OJ˜J˜Jš�œ
˜—Jš
œ˜—š
œ˜J˜6J˜NJ˜.Jš
œ˜—š
œ˜J˜6J˜NJ˜.Jš
œ˜—J˜9Jš�œ2˜9—Jš
œ˜—J˜šŸœ�œ
�œ
�œ˜+š�œ�œ
�˜Jš�œ�œ
�œ
�œ˜*Jš�œ�œ
�œ
�œ˜1Jš�œ�œ
�œ
�œ˜'Jš�œ
˜—Jš�œ
�œ˜Jš
œ˜—J˜š
Ÿœ�œ�œ�œ
�œ˜CJšœ�œ˜J˜
J˜&Jš�œ	�œ˜š�œ�˜Jš�œ�œ
�œ
˜J˜Jš�œ�œ
�œ
˜J˜&J˜Jš�œ
˜—Jš�œ�œ˜0Jš
œ˜—J˜J˜šŸœ�œ�œ
�œ�œ
�œ
�œ˜HJšœ�œ˜Jš�œ˜$Jš
œ˜—J˜Jšœ
�œ˜J˜Jš
œB™BJš
œ-™-Jš
œB™BJ˜JšŸ
œ�œ�œ˜"Jš
œ5˜5J˜Jš
Ÿ	œ�œ�œ�œ
�œ˜0Jšœ�œ
�œ!�œ˜TJ˜Jš
Ÿ	œ�œ�œ�œ
�œ˜0Jš	œ�œ
�œ
�œ�œ˜AJ˜Jš
Ÿœ�œ�œ�œ
�œ˜+Jšœ�œ˜J˜Jšœ�œ�œ
�œ	�œ
�œ
˜1Jšœ�œ�œ
�œ˜*Jšœ�œ˜Jšœ�œ˜J˜Jš
œB™BJš
œ™Jš
œB™BJš
œi™iJš
œD™DJš
œ^™^J˜šŸ
œ�œ
�œ˜J˜J˜Jš�œ˜
Jš�œ�œ
�œ�œ
˜0Jš�œ�œ
�œ
�œ
˜,J˜.š�œ˜Jš�œ˜Jš�œ
�œ�œ
�œ˜A—Jš
œ˜—J˜š
Ÿ	œ�œ�œ
�œ�œ˜8Jš�œ�œ
�œ
˜'Jšœ�œ˜J˜Jš
œ˜—J˜š
Ÿœ�œ�œ
�œ�œ
˜7Jš
�œ�œ�œ
�œ
�œ˜0š�œ�œ�˜3Jšœ�œ˜Jš
�œ�œ�œ
�œ
�œ˜0Jš�œ
˜—Jš�œ˜!Jš
œ˜—J˜šœ�œ�œ
˜Jš�œ�œ
�œ�œ˜,—Jšœ�œ˜Jšœ	�œ
˜J˜Jš
œB™BJš
œD™DJš
œB™BJš
œQ™QJš
œ-™-Jš
œ+™+Jš
œX™XJš
œf™fJš
œI™IJš
œ`™`Jš
œB™BJš
œ>™>J˜J˜Jšœ	�œ
�œž0˜HJšœ	�œ
�œ�œž…
˜­
J˜šŸœ�œ�œ
�œ	�œ�œ˜XJšœ�œ�œ
˜Jšœ�œ
�œ˜Jš�œ
�œ�œž%˜RJš�œ
�œ�œž˜5Jš�œ
�œž"˜Nš�œ�œ�œ
�œ
�œ�œ
˜RJš�œ
�œ5˜H—Jšœ)ž$˜MJ˜'Jšœ�œ˜%Jšœ�œ˜š�œ�œ�œ
�˜/Jš
œ@™@Jš�œ�œ
�œ
˜Jš�œ�œ
�œ˜Jš�œ�œ
�œ˜!š�œ�œž˜2J˜J˜Jšœ�œ˜)Jš�œ˜—š�œ�œ�œž˜HJ˜Jšœ�œ˜4Jšœ�œ˜+Jš�œ˜—Jš
œ™Jšœ�œ
˜
Jš�œ�œ
˜—š�œ�œ
�œ�œ�œ
�˜=Jš
œ?™?Jš�œ�œ
�œ
˜Jš�œ�œ
�œ
˜Jš�œ�œ
�œ
˜ š�œ�œ�œ
ž˜LJ˜9—š�œ�œ�œ
ž˜QJ˜?—š�œ�œ�œ
ž˜OJ˜=—Jš�œ�œ
�œ
˜Jš�œ
˜—J˜!J˜'J˜%Jš
œ˜—J˜Jš
Ÿ
œ�œ�œ�œ
�œ˜Gš
œ"™"Jšœ�œ˜Jšœ�œ
�œ˜Jš�œ
�œ
ž˜:Jš
�œ
�œ�œ
�œ�œ	˜.Jš�œ�œ
�œ�œ
˜9Jš�œ�œ	˜#Jšœ�œ�œ�œ˜6š�œ�œ
�œ˜&š�œ˜J˜J˜—š�œ
�œ�œ
˜ š�œ
�œ
�œ�œ˜+J˜J˜Jš�œ�œ
�œ ˜2J˜Jš�œ˜—Jš�œ
˜——Jš
œ˜—J˜šŸœ�œ�œ
�œ˜+Jšœ�œ
�œ˜Jš�œ
�œ˜"Jšœ)ž˜@š�œ	�œ
�œ�œ˜,Jš
œ™J˜4J˜J˜Jšœ�œ
˜Jš�œ
˜—Jš
œ˜—J˜š
Ÿœ�œ�œ�œ
�œ˜HJš�œ˜Jšœ�œ
˜Jš�œ�œ
�œ
˜J˜J˜Jš�œ
�œ
ž˜:Jš
œ™š�œ�œ>�˜HJ˜Jš�œ �œ(˜NJ˜&J˜!Jš�œ
˜—Jš
œ
™
J˜Jš�œ"�œ(˜PJ˜DJ˜9J˜!J˜Jš
œ˜—J˜šŸœ�œ�œ˜;Jšœ	�œ˜#Jšœ�œ	�œ˜š�œ
�œ˜Jš�œ)�œ
�œ	˜EJš�œ$�œ�œ
˜C—J˜(Jš
œ˜—J˜JšŸœ�œ�œ˜ š�œ�œ
�œ	�˜J˜.Jš�œ˜	J˜—Jš
Ÿœ�œ�œ�œ
�œ˜2Jš
�œ�œ
�œ	�œ�œ˜4J˜Jšœ
�œ	�œ
˜*J˜;J˜9Jšœ�œ�œ˜7Jšœ�œ˜š	œ�œ�œ
�œ
�œ˜@J˜J˜šœ�œ
˜Jšœ�œ
�œ˜J˜——Jš
œB™BJš
œ™Jš
œB™BJš
œ9™9Jš
œE™EJš
œJ™JJš
œZ™ZJš
œ6™6Jš
œf™fJ˜J˜Jšœž"˜<Jšœ#ž6˜YJšœž#˜?Jšœ�œ	�œ
�œ
˜.Jšœ	�œ�œ
˜Jšœ	�œ
�œ�œ
˜Jšœ�œ
�œ�œ
˜J˜(J˜*Jšœ�œ�œž˜+J˜JšŸœ�œ˜
Jšœ�œ˜ J˜šŸ
œ�œ˜Jšœ�œ
˜J˜J˜ J˜!J˜$Jš�œ�œ
�œ
˜ Jšœ�œ�œ6˜IJ˜-J˜Jš
œ˜—J˜Jš
œ-™-š
Ÿœ�œ�œ�œ�œ˜6J˜'š�œ�œ�˜&Jš
�œ
�œ�œ
�œ
�œ˜$Jš�œ�œ
�œ
˜J˜
Jš�œ�œ
˜—Jšœ�œ�œ
�œ˜:Jš
œ˜—J˜šŸœ�œ�œ�œ%˜JJšœ�œ˜J˜Jš�œ�œ
�œ
˜š�œ�˜Jšœ�œ
˜#J˜Jš�œ
˜—Jš
œ˜—J˜šŸœ�œ ˜4Jš�œ�œ�œ
�œ
˜,Jš�œ�œ	�œ
�œ
˜(J˜ š�œ˜Jš�œ
�œ˜-Jš�œ
�œ˜)—š�œ�˜Jš
œ
˜
J˜-J˜Jšœ�œ
˜Jš
œ˜—Jš�œ�œ�œ
˜$J˜Jš�œ�œ˜-Jš�œ�œ˜)Jš�œ	�œ
�œ
˜J˜J˜Jšœ
�œ
˜šœ�œ˜Jš�œ�œ˜-Jš�œ�œ˜)J˜DJšœ�œ
˜Jšœ
�œ˜Jšœ�œ
˜
Jš�œ˜—Jš�œ
�œ#˜6Jš
œ˜—J˜šŸœ�œ˜Jšœ�œ
˜Jš�œ�œ	�œ �œ
˜;J˜%Jš
œ˜—J˜šŸ
œ�œ!˜4š�œ�œ˜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˜Jš
œ™J˜1Jšœ�œ�œ�œ˜5Jš
œ1™1Jš
œ3™3J˜1Jšœ�œ�œ˜3Jš�œ
˜Jš
œ˜—J˜Jšœ�œž˜"J˜šŸœ�œ˜J˜J˜J˜'Jšœ�œ
˜J˜%J˜š�œ�œ
�œ�œ˜4J˜-Jš�œ�œ,˜>—Jš�œ�œ8˜JJš�œ�œ'˜9Jš
œ˜—J˜šŸœ�œ˜J˜Jš�œ
�œ
�œ
˜!Jš�œ&�œ�œ
˜DJ˜Jš
œ˜—J˜šŸœ�œ˜"J˜Jš�œ
�œ˜+J˜Jšœ�œ
˜Jšœž7˜Mš�œ�œ
�œ˜-š�œž)˜0J˜%Jš�œ
�œ,˜?Jš
œ˜——J˜Jš�œ
�œ:˜MJš�œ
�œ)˜<Jš
œ˜—J˜šŸœ�œ!�œ˜5J˜Jš�œ�œ
�œ
�œ
˜š�œ�˜Jš�œ�œ
�œ�œ˜8Jš�œ
˜—Jš
œ˜—J˜Jš
œB™BJš
œ™Jš
œB™BJ˜Jšœ�œ�œ
˜&J˜šŸ	œ�œ�œ˜6Jš�œ˜J˜J˜Jš�œ�œ
�œ�œ˜,š�œ�˜Jš�œ�œ
�œ�œ˜(Jš	œ�œ�œ�œ�œ˜KJš�œ
˜—Jš
œ˜—J˜šŸœ�œ˜)Jš�œ˜Jšœ�œ˜J˜J˜J˜Jšœ�œ�œ˜+J˜J˜J˜š�œ�œ�˜Jš
œ
˜
J˜š�œ�œ
˜#Jšœ�œ˜$—š�œ�œ
˜#Jšœ!�œ˜)—J˜Jšœ'�œ�œ˜8š�œ�œ
�œ�˜Jšœ&�œ�œ˜7Jš�œ
˜—J˜Jšœ�œ�œ˜)š�œ˜Jš�œ˜Jš�œ˜—J˜Jšœ�œ
˜—Jš
œ˜—J˜š
Ÿ	œ�œ�œ
�œ�œ˜-Jšœ0�œ�œ˜AJšœ/�œ�œ˜@Jš
œ˜—J˜Jš�œ
˜—…—mघ