//SinOsc m1 => SinOsc c1 => ADSR e1 => JCRev r1 =>LPF filt1 => Gain g10 => dac.chan(0); //voice 1 - chan 0
//filt1 => Gain g11 => dac.chan(1); // voice 1 - chan 1
//filt1 => Gain g12 => dac.chan(2); // voice 1 - chan 2
//filt1 => Gain g13 => dac.chan(3); // voice 1 - chan 3

//SinOsc m2 => SinOsc c2 =>  ADSR e2 => JCRev r2 => LPF filt2 => Gain g20 => dac.chan(0); //voice 2 - chan 0
//filt2 => Gain g21 => dac.chan(1); // voice 2 - chan 1
//filt2 => Gain g22 => dac.chan(2); // voice 2 - chan 2
//filt2 => Gain g23 => dac.chan(3); // voice 2 - chan 3

SinOsc m1 => SinOsc c1 => ADSR e1 => JCRev r1 =>LPF filt1 =>  Gain g10 => Gain t10 => Binaural.pssp[0]; //voice 1 - chan 0
filt1 => Gain g11 => Gain t11 => Binaural.pssp[1]; // voice 1 - chan 1
filt1 => Gain g12 => Gain t12 => Binaural.pssp[2]; // voice 1 - chan 2
filt1 => Gain g13 => Gain t13 => Binaural.pssp[3]; // voice 1 - chan 3

SinOsc m2 => SinOsc c2 =>  ADSR e2 => JCRev r2 => LPF filt2 => Gain g20 => Gain t20 => Binaural.pssp[0]; //voice 2 - chan 0
filt2 => Gain g21 => Gain t21 => Binaural.pssp[1]; // voice 2 - chan 1
filt2 => Gain g22 => Gain t22 => Binaural.pssp[2]; // voice 2 - chan 2
filt2 => Gain g23 => Gain t23 => Binaural.pssp[3]; // voice 2 - chan 3

.2 => t10.gain => t11.gain => t12.gain => t13.gain => t20.gain => t21.gain => t22.gain => t23.gain;

////// initialize uGen's /////////
    
    // modulator oscilators
    200 => float m1gain => m1.gain;
    500 => float m2gain => m2.gain;
    Std.mtof(60) => float m1freq => float m2freq => m1.freq => m2.freq;
    
    // carriers
    .5  => float c1gain => float c2gain => c1.gain => c2.gain;
    Std.mtof(60) => float c1freq => float c2freq => c1.freq => c2.freq;
    
    // gains for panning
    .5 => float g10gain => float g11gain => float g12gain => float g13gain;
    .5 => float g20gain => float g21gain => float g22gain => float g23gain;
    g10.gain(g10gain);
    g11.gain(g11gain);
    g12.gain(g12gain);
    g13.gain(g13gain);
    
    g20.gain(g20gain);
    g21.gain(g21gain);
    g22.gain(g22gain);
    g23.gain(g23gain);
        
    // filter vars
    5000 => float fcut1 => float fcut2;   
    filt1.freq(fcut1);
    filt2.freq(fcut2);
    
    // reverb vars
    0.5 => float r1mix => float r2mix => r1.gain => r2.gain => r1.mix => r2.mix;
    
    // init ADSR
    .2::second => e1.attackTime => e1.decayTime => e2.attackTime => e2.decayTime;
    e1.set(.2, .2, .5, .2);
    e2.set(.2, .2, .5, .2);  
    100::ms => e1.duration => e2.duration;
    0 => e1.target => e2.target;
    e2.gain(.5);
    e1.gain(.5);
   
    
    /////  Define beat lengths  /////
    2 => float four_beats;
    four_beats::second => dur whole;
    whole*.5 => dur half;
    half*.5 => dur quarter; 
    quarter*.5 => dur eighth;
    eighth*.5=> dur sixteenth;
    sixteenth*.5 => dur thrty;
    
//////////////////////////////   
///////  Functions  //////////    
//////////////////////////////   
 
// play sequence of 4 notes on voice 1
 fun void blah1(dur howmuch, float one, float two, float three, float four) 
     {
        <<<"blah">>>;
        howmuch+now => time blah_blurb;
        while( now < blah_blurb )
        {
           Std.mtof(one) => m1.freq;
            quarter => now;
            Std.mtof(two) => m1.freq;
            sixteenth => now;
            Std.mtof(three) => m1.freq;
            eighth => now;          
            Std.mtof(four) => m1.freq;
            quarter => now; 
        }
    }

//plays sequence of 3 notes with voice 2
fun void bleh2(dur howmuch, float one, float two, float three) 
{
    <<<"bleh">>>;
    howmuch+now => time blah_blurb;
    while( now < blah_blurb )
    {
       Std.mtof(one) => m2.freq;
        quarter => now;
        Std.mtof(two) => m2.freq;
        half => now;
        Std.mtof(three) => m2.freq; // => m2freq variable, etc.
        sixteenth => now;          
     }
}

// change the level voice 1 chan 0 over specified period 
fun void swell10(float length,  float end_level)
{
    g10gain => float temp ;
    
    temp - end_level => float span;
    length / .01 => float nsteps;
    span / nsteps => float step;
    <<<"swell 1", end_level, temp, length>>>;
    
    if(end_level > temp && end_level != temp)
        {while(temp < end_level)
        {//<<<temp, "up">>>;
            temp => g10gain => g10.gain;
            step -=> temp;
            10::ms => now;
        }
}

    else if(end_level < temp && end_level != temp)
    {while(temp > end_level)
        {//<<<temp, "down">>>;
        temp => g10gain => g10.gain;
        step -=> temp;
        10:: ms => now;
        }
    }
}

// change the level over specified period 
//when these are used there is a rather audible click for each
// gain change which makes a sweep like this add a lot of noise
fun void swell11(float length,  float end_level)
{
    g11gain=> float temp ;
    
    temp - end_level => float span;
    length / .01 => float nsteps;
    span / nsteps => float step;
    <<<"swell 2", end_level, temp, length>>>;
    
    if(end_level > temp && end_level != temp)
        {while(temp < end_level)
        {//<<<temp, "up">>>;
            temp => g11gain => g11.gain;
            step -=> temp;
            10::ms => now;
        }
    }

    else if(end_level < temp && end_level != temp)
    {while(temp > end_level)
        {//<<<temp, "down">>>;
        temp => g11gain => g11.gain;
        step -=> temp;
        10:: ms => now;
        }
    }
}


// change the level over specified period 
fun void swell12(float length,  float end_level)
{
    g12gain => float temp ;
    
    temp - end_level => float span;
    length / .01 => float nsteps;
    span / nsteps => float step;
    <<<"swell 1", end_level, temp, length>>>;
    
    if(end_level > temp && end_level != temp)
    {while(temp < end_level)
    {//<<<temp, "up">>>;
        temp => g12gain => g12.gain;
        step -=> temp;
        10::ms => now;
    }
}

else if(end_level < temp && end_level != temp)
     {while(temp > end_level)
     {//<<<temp, "down">>>;
         temp => g12gain => g12.gain;
         step -=> temp;
         10:: ms => now;
     }
 }
}

// change the level over specified period 
//voice 1 chan 3 
fun void swell13(float length,  float end_level)
{
    g13gain=> float temp ;
    
    temp - end_level => float span;
    length / .01 => float nsteps;
    span / nsteps => float step;
    <<<"swell 1,3", end_level, temp, length>>>;
    
    if(end_level > temp && end_level != temp)
    {while(temp < end_level)
    {//<<<temp, "up">>>;
        temp => g13gain => g13.gain;
        step -=> temp;
        10::ms => now;
    }
}

else if(end_level < temp && end_level != temp)
     {while(temp > end_level)
     {//<<<temp, "down">>>;
         temp => g13gain => g13.gain;
         step -=> temp;
         10:: ms => now;
     }
 }
}

// change the level voice 2 chan 0 over specified period 
fun void swell20(float length,  float end_level)
{
    g20gain => float temp ;
    
    temp - end_level => float span;
    length / .01 => float nsteps;
    span / nsteps => float step;
    <<<"swell 2, 0", end_level, temp, length>>>;
    
    if(end_level > temp && end_level != temp)
    {while(temp < end_level)
    {//<<<temp, "up">>>;
        temp => g20gain => g20.gain;
        step -=> temp;
        10::ms => now;
    }
}

else if(end_level < temp && end_level != temp)
     {while(temp > end_level)
     {//<<<temp, "down">>>;
         temp => g20gain => g20.gain;
         step -=> temp;
         10:: ms => now;
     }
 }
}

// change the level over specified period 
// voice 2 - chan 1
fun void swell21(float length,  float end_level)
{
    g21gain=> float temp ;
    
    temp - end_level => float span;
    length / .01 => float nsteps;
    span / nsteps => float step;
    <<<"swell 2, 1", end_level, temp, length>>>;
    
    if(end_level > temp && end_level != temp)
    {while(temp < end_level)
    {//<<<temp, "up">>>;
        temp => g21gain => g21.gain;
        step -=> temp;
        10::ms => now;
    }
}

else if(end_level < temp && end_level != temp)
     {while(temp > end_level)
     {//<<<temp, "down">>>;
         temp => g21gain => g21.gain;
         step -=> temp;
         10:: ms => now;
     }
 }
}


// change the level over specified period 
fun void swell22(float length,  float end_level)
{
    g22gain => float temp ;
    
    temp - end_level => float span;
    length / .01 => float nsteps;
    span / nsteps => float step;
    <<<"swell 2, 2", end_level, temp, length>>>;
    
    if(end_level > temp && end_level != temp)
    {while(temp < end_level)
    {//<<<temp, "up">>>;
        temp => g22gain => g22.gain;
        step -=> temp;
        10::ms => now;
    }
}

else if(end_level < temp && end_level != temp)
     {while(temp > end_level)
     {//<<<temp, "down">>>;
         temp => g22gain => g22.gain;
         step -=> temp;
         10:: ms => now;
     }
 }
}

// change the level over specified period 
// voice 2 - chan 3
fun void swell23(float length,  float end_level)
{
    g23gain=> float temp ;
    
    temp - end_level => float span;
    length / .01 => float nsteps;
    span / nsteps => float step;
    <<<"swell 2,3", end_level, temp, length>>>;
    
    if(end_level > temp && end_level != temp)
    {while(temp < end_level)
    {//<<<temp, "up">>>;
        temp => g23gain => g23.gain;
        step -=> temp;
        10::ms => now;
    }
}

else if(end_level < temp && end_level != temp)
     {while(temp > end_level)
     {//<<<temp, "down">>>;
         temp => g23gain => g23.gain;
         step -=> temp;
         10:: ms => now;
     }
 }
}



// sweep frequency of fm modulator1 frequency
fun void msweep1(float fstart, float fend, float length)
{
    fstart => float ftemp;
    fstart - fend => float fspan;
    length / .01 => float steps;
    fspan / steps => float fstep;
    <<<"msweep1", fstart, fend, ftemp, length>>>;
    
    if(fend > ftemp && fend != ftemp)
    {while(ftemp < fend)
        {//<<<ftemp, "up">>>;
            Std.mtof(ftemp) => m1.freq;
            fstep -=> ftemp => m1freq;
            10::ms => now;
        }
    }
    
    else if(fend < ftemp && fend != ftemp)
    {while(ftemp > fend)
        {//<<<ftemp, "down">>>;
        Std.mtof(ftemp) => m1.freq;
        fstep -=> ftemp => m1freq;
        10:: ms => now;
        }
    }
}

// sweep frequency of m2
fun void msweep2(float fstart, float fend, float length)
{
    
    fstart => float ftemp;
    fstart - fend => float fspan;
    length / .01 => float steps;
    fspan / steps => float fstep;
    <<<"m_frq_sweep", fstart, fend, ftemp, length>>>;
    
    if(fend > ftemp && fend != ftemp)
    {while(ftemp < fend)
         {//<<<ftemp, "up">>>;
         Std.mtof(ftemp) => m2.freq;
         fstep -=> ftemp => m2freq;
         //<<<fstep, ftemp>>>;
         10::ms => now;
         }
     }
     else if(fend < ftemp && fend != ftemp)
     {while(ftemp > fend)
     {//<<<ftemp, "down">>>;
          Std.mtof(ftemp) => m2.freq;
          fstep -=> ftemp => m2freq;;
          10:: ms => now;
      }
      }
 }

//  sweep fm mod oscillator gain
fun void mgain1(float gstart, float gend, float length)
{<<<"mgain1">>>;
    
    gstart => float gtemp;
    float gspan;
    
    if(gstart>gend)
    {gstart - gend => gspan;}
    if(gend>gstart)
        { gend -gstart => gspan;}
        length / .01 => float steps;
        gspan / steps => float gstep;
        //<<<"mod gsweep", gstart, gend, gtemp, length>>>;
    
    if(gend > gtemp && gend != gtemp)
    {while(gtemp < gend)
        {//<<<gtemp, "up">>>;
        gtemp => m1.gain;
        gstep +=> gtemp;
        10::ms => now;
    }
}
else if(gend < gtemp && gend != gtemp)
    {while(gtemp > gend)
        {//<<<gtemp, "down">>>;
            gtemp => m1.gain;
            gstep -=> gtemp;
            10:: ms => now;
        }
    }
}
 
//  sweep fm mod oscillator gain
fun void mgain2(float gstart, float gend, float length)
{
    
    gstart => float gtemp;
    float gspan;
    
    if(gstart>gend)
    {gstart - gend => gspan;}
    if(gend>gstart)
    { gend -gstart => gspan;}
    length / .01 => float steps;
    gspan / steps => float gstep;
    <<<"mod2 gain sweep", gstart, gend, gtemp, length>>>;
    
    if(gend > gtemp && gend != gtemp)
        {while(gtemp < gend)
        {//<<<gtemp, "up">>>;
            gtemp => m2.gain;
            gstep +=> gtemp;
            10::ms => now;
        }}
    else if(gend < gtemp && gend != gtemp)
        {while(gtemp > gend)
        {//<<<gtemp, "down">>>;
            gtemp => m2.gain;
            gstep -=> gtemp;
            10:: ms => now;
        }}
    }

// filtsweep() -- sweep the filter cutoff between the min and max over 
// the length of time specified (in seconds)
// midi note - start, max, min, rate, length (how many whole notes)
fun void filtsweep1(float filtfreq, float filtmin, float filtmax, float rate, float length)
{
    <<<"sweep1">>>;
   //Std.mtof(filtfreq) => float mfreq;
   filt2.freq(filtfreq);
 
    length::second+now=> time slow_blurb;
    filt1.freq(filtfreq);
    1 => int direction;
    
    filtmax-filtmin => float filt_width; //calculate slope
    rate / .01 => float steps;
    filt_width / steps =>float filt_step;
    
    while( now < slow_blurb )
    {
            if((direction==1) && filtfreq < filtmax)
            {   // <<<direction, filtfreq, filt_step>>>;
                filt_step + filtfreq => filtfreq;
                filtfreq => fcut1 => filt1.freq;
                10::ms=> now;
                if (filtfreq >= filtmax) {
                0=> direction;}
            }
            else if(direction==0 && filtfreq > filtmin)
            {   // <<<direction, filtfreq, filt_step>>>;
                filt_step -=> filtfreq;
                filtfreq => fcut1 => filt1.freq;
                10::ms => now;
                if (filtfreq<=filtmin)
                1=> direction;
            }             
    }
}



// filtsweep() -- sweep the filter cutoff between the min and max over 
// the length of time specified (in seconds)
// midi note - start, max, min, rate, length (how many whole notes)
fun void filtsweep2(float filtfreq, float filtmin, float filtmax, float rate, float length)
{
    <<<"sweep2">>>;
   //Std.mtof(filtfreq) => float mfreq;
   filt2.freq(filtfreq);
 
    length::second+now=> time slow_blurb;
    filt2.freq(filtfreq);
    1 => int direction;
    
    filtmax-filtmin => float filt_width; //calculate slope
    rate / .01 => float steps;
    filt_width / steps =>float filt_step;
    
    while( now < slow_blurb )
    {
            if((direction==1) && filtfreq < filtmax)
            {
                filt_step + filtfreq => filtfreq;
                filtfreq => fcut2 => filt2.freq;
                10::ms=> now;
                if (filtfreq >= filtmax) {
                0=> direction;}
            }
            else if(direction==0 && filtfreq > filtmin)
            {
                filt_step -=> filtfreq;
                filtfreq => fcut2 => filt2.freq;
                10::ms => now;
                if (filtfreq<=filtmin)
                1=> direction;
            }             
    }
}

1 => int sectionI; // set to 1 to play, 0 to skip;
1 => int sectionII;
1 => int sectionIII;
1 => int sectionIV;
1 => int sectionV;
1 => int sectionVI;


//////////////////////////////////
/////////   Main loop   //////////
//////////////////////////////////
while(true)
{ 
    //section I
    if(sectionI == 1)
    {<<<"sectionI">>>;
   <<<"hello...">>>;
   10::second => e2.attackTime => e1.attackTime;
   3::second => e1.releaseTime => e2.releaseTime;
   e1.keyOn(1);
   e2.keyOff(1);
   
   // voice one in chan 0
   0 => g10gain => g10.gain;
   0 => g11gain => g11.gain;
   0 => g11gain => g11.gain;
   .5 => g12gain => g12.gain;
   // voice two in chan 2,3
   0 => g20gain => g20.gain;
   0 => g21gain => g21.gain;
   .5 => g22gain => g22.gain;
   .5 => g23gain => g23.gain;
   

   whole*2 => now;
   spork~swell13(1,0);
   spork~swell10(1,.5);
      
   spork~blah1(whole*2, 80, 57, 62, 60.2);
   whole*3 => now;
   
   spork~swell10(1,.4);   
   spork~swell11(1,.4);
   spork~swell12(1,.4);
   spork~swell13(1,.4);

   spork~blah1(half, 78, 54, 57, 60.2);
   whole*4 => now;
   
   e2.keyOn(1);
   whole*2 => now;
   
   spork~bleh2(whole, 70, 47, 58);
   whole => now;
   spork ~ swell22(2, 0);
   spork ~ swell21(2, .5);
   spork~bleh2(whole, 69, 46, 57);
   whole*3 => now;   


   spork ~ msweep1(60, 40, 2); //sweep m2 freq from 40 to 39.6
   100::ms=>now;
   e2.keyOff(1);
   
   200::ms=> now;   
   e1.keyOff(1);
   spork ~ swell10(2, 0);
   spork ~ swell11(2, .5);
   500::ms=> now;
       
   } //end Sec I
   
   
   //section II
   if(sectionII == 1)
   {<<<"sectionII">>>;
   // pan
   swell21(1, .5);
   swell22(1, .5);
   swell23(1, 0);
   1::second => now;
   e2.keyOn(1);
   40 => m2freq;
   m2.freq(Std.mtof(m2freq));
   whole*4 => now;
   spork ~ mgain1(m1gain, 1000, 5); //change fm mod 1 gain (quickly)
   
   ///  sweep voice 2 up slightly 
   <<<"beat">>>;
   spork ~ msweep2(m2freq, 40.4, 3);
   e1.keyOn(1);
   whole*3 => now;
   // a bit more
   spork ~ msweep2(m2freq, 43.5, 5);
   whole*3 => now;

   
   e1.keyOff(1);
   whole*2 => now;
   
   spork ~ filtsweep1(fcut1, 200, 6000, .5, 3); //start sweeping voice 2 filter 
   half => now;
   
   e2.keyOff(1);   
   // voice 1 in all channels
   .5=>g10gain => g10.gain;
   .5=>g11gain => g11.gain;
   .5=>g12gain => g12.gain;
   .5=>g13gain => g13.gain;
   whole*2 => now;
   
   e1.set(1, 1, .6, 2);
   e2.set(1, 1, .6, 2);
   
   e1.keyOn(1);
   quarter => now;
   55 => m1freq;
   m1.freq(Std.mtof(m1freq));
   e1.keyOff(1);
   whole=>now;
   
   } //end section II;
   
   //section III
   if(sectionIII == 1)
   {<<<"sectionIII">>>;
   <<<"how about now?">>>;
   r1.mix(0);
   e1.set(.1, .1, .5, .01);
   e1.keyOn(1); 
   spork ~ mgain1(m1gain, 4000, .1);//change fm amount 
   spork ~ msweep1(m1freq, 30, 1);
   spork ~ swell10(1, .3);
   spork ~ swell11(1,.5);
   eighth => now;
   e1.keyOff(1);
   eighth => now;
   e1.keyOn(1);
   eighth => now;
   e1.keyOff(1);
   half => now;
   e1.keyOn(1);
   quarter => now;

   e1.keyOff(1);
   eighth => now;
   e1.keyOn(1);
   sixteenth=> now;
   e1.keyOff(1);
   eighth => now;
   e1.keyOn(1);
   eighth => now;
   e1.keyOff(1);
   sixteenth => now;
   e1.keyOn(1);
   eighth => now;

   
   r1.mix(.1);
   spork ~ msweep1(m1freq, 90, 3);
   eighth => now;
   e1.keyOff(1);
   eighth => now;
   e1.keyOn(1);
   quarter => now;
   e1.keyOff(1);
   
   spork ~ mgain1(m1gain, 1000, 3);
   spork ~ msweep1(m1freq, 20, .5);
   eighth => now;
   e1.keyOff(1);
   eighth => now;
   e1.keyOn(1);
   sixteenth => now;
   e1.keyOff(1);
   quarter => now;
   e1.keyOn(1);
   eighth => now;
   
   2::second => now;
   
   spork ~ swell10(1,.5);
   spork ~ swell11(1,.51);
   spork ~ msweep1(m1freq, 70, 3);
   half => now;
   e1.keyOff(1);
   eighth => now;
   e1.keyOn(1);
   quarter => now;
   e1.keyOff(1);
      
   spork ~ mgain1(m1gain, 600, .1);//change fm amount 
   half => now;
   
   <<<"ahhh...">>>;  
   e1.keyOn(1);
   r1.mix(.5);
   e1.set(.1, 1, .5, 1);
   spork ~ msweep1(m1freq, 44, 9);
   spork ~ filtsweep1(fcut1, 100, 6000, 2, 11); //start sweeping voice 2 filter 
   spork ~ swell10(3, .1);
   spork ~ swell12(3, .1);
   
   whole*1 => now;
   e2.attackTime(10::second);
   e2.keyOn(1);
   spork ~ filtsweep2(fcut2, 500, 10000, .25, 5);
   spork ~ bleh2(whole, 50, 53, 55);
    
   spork ~ mgain1(m1gain, 1000, 5);//change fm amount   
   whole*2 => now;
   
   e2.keyOn(1);
   mgain2(m2gain, 2000, 3);    
   whole*2=> now;
   
   }//end section III;
   
   //section IV
   if(sectionIV == 1 )
   {<<<"sectionIV">>>;
   <<<"you are here">>>;
   spork ~ msweep2(m2freq, 39.6, 3); //sweep m2 freq to 39.6 (MIDI note)
 
   spork ~ swell20(1, .1);
   spork ~ swell21(1, .6);
   spork ~ swell22(1, .01);
   spork ~ swell23(1, .2);
   1001::ms => now;
   
   spork ~ swell20(1, .2);
   spork ~ swell21(1, 0);
   spork ~ swell22(1, .6);
   spork ~ swell23(1, .01);
   1001::ms => now;
     
   whole*3 => now;
    
   //do some panning
   1 => e1.keyOn => e2.keyOn;
   spork ~ swell10(1, .4);
   spork ~ swell11(1, .7);
   spork ~ swell12(1, .1);
   spork ~ swell13(1, .3);
   1001::ms=>now;
   
   spork ~ swell20(1, .1);
   spork ~ swell21(1, .2);
   spork ~ swell22(1, .7);
   spork ~ swell23(1, .3);
   
   spork ~ swell10(1, .5);
   spork ~ swell11(1, .4);
   spork ~ swell12(1, .4);
   spork ~ swell13(1, .4);
   1001::ms=>now;
   
   spork ~ swell20(2, 0);
   spork ~ swell21(2, .5);
   spork ~ swell22(2, 0);
   spork ~ swell23(2, .5);
   
   spork ~ swell10(2, .4);
   spork ~ swell11(2, 0);
   spork ~ swell12(2, .5);
   spork ~ swell13(2, 0);
   2001::ms=>now;

   spork~bleh2(whole, 40, 47, 42);
   spork~blah1(whole, 60, 57, 62, 61);
   
   spork ~ swell20(2, .5);
   spork ~ swell21(2, .4);
   spork ~ swell22(2, 0);
   spork ~ swell23(2, 0);
   
   spork ~ swell10(2, 0);
   spork ~ swell11(2, 0);
   spork ~ swell12(2, .4);
   spork ~ swell13(2, .5);
   
   2*whole => now;
   <<<"where?">>>;
  
   spork ~ mgain1(m1gain, 700, 3);//change fm amount to 700
   spork ~ mgain2(m2gain, 500, 5);//change fm amount to 500
   whole*4 => now;
   
   spork ~msweep2(39.6, 40, 1);
   whole=> now;
   e1.keyOff(1);
   e2.keyOff(1);

   1::second => now;
   e1.keyOn(1);
   e2.keyOn(1);
   
   //// panning is fun
   spork ~ swell20(2, 0);
   spork ~ swell21(2, .5);
   spork ~ swell22(2, 0);
   spork ~ swell23(2, .5);
   
   spork ~ swell10(2, .5);
   spork ~ swell11(2, 0);
   spork ~ swell12(2, .5);
   spork ~ swell13(2, 0);
   2::second=>now;
   
   spork ~ swell20(2, .5);
   spork ~ swell21(2, .4);
   spork ~ swell22(2, 0);
   spork ~ swell23(2, 0);
   
   spork ~ swell10(2, 0);
   spork ~ swell11(2, 0);
   spork ~ swell12(2, .4);
   spork ~ swell13(2, .5);   
   2::second=> now;
   
   spork ~ swell20(2, .4);
   spork ~ swell21(2, .5);
   spork ~ swell22(2, .5);
   spork ~ swell23(2, .5);
   
   spork ~ swell10(2, .4);
   spork ~ swell11(2, .5);
   spork ~ swell12(2, .5);
   spork ~ swell13(2, .5);
   1::second=> now;
   e1.keyOff(1);
   e2.keyOff(1);
   
   half => now;   
   spork~bleh2(whole*4, 40, 37, 42);
   half => now;
   e1.keyOn(1);
   e2.keyOn(1);
   spork~blah1(whole*4, 50, 47, 52, 51);
   whole*4 => now;
   spork ~ mgain1(m1gain, 200, 1);
   spork ~ mgain2(m2gain, 300, 1);
   whole*3 => now;
   } //end secIV    
   
   // sec V
   if(sectionV == 1)
   {<<<"sectionV">>>;
   <<<"ok">>>;
   
   spork ~ filtsweep2(fcut2, 200, 9000, 2, 20); 
   spork ~ filtsweep1(fcut1, 200, 9000, 1.3, 20); 
   spork ~ msweep2(40, 20, 15);
   whole*2 => now;
   spork ~ mgain1(m1gain, 1000, 7);
   spork ~ mgain2(m2gain, 2000, 7);
   whole*10=> now;
   
   spork~bleh2(whole*4, 20, 27, 32);
   spork~blah1(whole*4, 50, 47, 52, 51);
   whole * 5 => now;
   <<<"almost">>>;
   
   spork ~ msweep2(m2freq, 60, 9);
   spork ~ filtsweep2(fcut2, 30, 9000, 3.3, 20); 
   spork ~ filtsweep1(fcut1, 30, 9000, 1.5, 20); 
   whole*2 => now;
   
   spork ~ mgain1(m1gain, 600, 11);
   spork ~ mgain2(m2gain, 300, 7);
   whole*10=> now;
   
   spork~bleh2(whole*4, 40, 47, 42);
   spork~blah1(whole*4, 60, 57, 62, 61);
   
   //// panning is fun
   spork ~ swell20(2, 0);
   spork ~ swell21(2, .7);
   spork ~ swell22(2, 0);
   spork ~ swell23(2, .7);
   
   spork ~ swell10(2, .7);
   spork ~ swell11(2, 0);
   spork ~ swell12(2, .7);
   spork ~ swell13(2, 0);
   2::second=>now;
   
   spork ~ swell20(2, .5);
   spork ~ swell21(2, .4);
   spork ~ swell22(2, 0);
   spork ~ swell23(2, 0);
   
   spork ~ swell10(2, 0);
   spork ~ swell11(2, 0);
   spork ~ swell12(2, .4);
   spork ~ swell13(2, .5);   
   2::second=> now;
   
   spork ~ swell20(2, .4);
   spork ~ swell21(2, .5);
   spork ~ swell22(2, .5);
   spork ~ swell23(2, .5);
   
   spork ~ swell10(2, .4);
   spork ~ swell11(2, .5);
   spork ~ swell12(2, .5);
   spork ~ swell13(2, .5);
   1::second=> now;
   
   whole * 5 => now;
   } // end secV
   
       //section VI
   if (sectionVI == 1)
   {<<<"sectionVI">>>;
   e1.releaseTime(20::second);
   e2.releaseTime(20::second);
   e2.keyOff(1);
   e1.keyOff(1);
   
   spork ~ filtsweep2(fcut2, 200, 9000, 2, 20); 
   spork ~ filtsweep1(fcut1, 200, 9000, 1.3, 20); 
   
   //// panning is fun
   spork ~ swell20(2, 0);
   spork ~ swell21(2, .7);
   spork ~ swell22(2, 0);
   spork ~ swell23(2, .7);
   
   spork ~ swell10(2, .7);
   spork ~ swell11(2, 0);
   spork ~ swell12(2, .7);
   spork ~ swell13(2, 0);
   2::second=>now;
   
   spork ~ swell20(2, .5);
   spork ~ swell21(2, .4);
   spork ~ swell22(2, 0);
   spork ~ swell23(2, 0);
   
   spork ~ swell10(2, 0);
   spork ~ swell11(2, 0);
   spork ~ swell12(2, .4);
   spork ~ swell13(2, .5);   
   2::second=> now;
   
   spork ~ swell20(2, .4);
   spork ~ swell21(2, .5);
   spork ~ swell22(2, .5);
   spork ~ swell23(2, .5);
   
   spork ~ swell10(2, .4);
   spork ~ swell11(2, .5);
   spork ~ swell12(2, .5);
   spork ~ swell13(2, .5);
   1::second=> now;
   
   } //end section VI;
   <<<"goodbye">>>;
   
   1::day => now;
}