(
// ===========================================================
// Ark/D, amorphic (2020)
// ===========================================================

Server.default.waitForBoot {
	"Init.scd".loadRelative;
	"init.scd".loadRelative;
}
);

// debug/meter
s.meter; s.scope(2); s.plotTree;

/*
ELEMENTS 
- two chord pad
- param/bebacklight (needs granulator?)
- s1 distorted drone
- shippo
- lcm noise
- gcdfeedmodsin + low rumble?
- klickyarj + lcm noise?
- lorenz pattern






*/


//
///////////////////////////////////////////////////////////////////////////////////////////////
// GCD SINMODFEED /////////////////////////////////////////////////////////////////////////////////////////
// feedback of modulated SinOsc

// low rumble 0 ------------------------------------
(
SynthDef(\dNoz, {
	arg out=0, gate=1, amp=0.1, envattackTime=0.001, release=0.001;
	var snd, env;
	env = Linen.kr(gate, envattackTime, 1, release, doneAction:2);
	snd = WhiteNoise.ar(1);
	snd = snd + SinOsc.ar(SinOsc.kr(10).range(40,60), mul:0.2);
	snd = snd + Pulse.ar(SinOsc.kr(12).range(40,60), mul:0.1);
	snd = snd.clip2(0.8);

	snd = LPF.ar(snd, LFNoise2.ar(0.4).range(60,100), mul:3);

	snd = snd.dup;
	snd[1] = DelayL.ar(snd[1], 0.05, SinOsc.kr(0.2).range(0.001,0.003));
	snd = snd * env * amp;
	Out.ar(out, snd);
	
}).add;
);
(
// "LFTri bass drum kick" - by luka@lukaprincic.si
SynthDef(\tribd, {
	arg out=0, gate=1, freq=77, amp=0.1;
	var snd,snd1, aenv, fenv, senv;

	fenv = Env(levels:[2, 1.2, 0], times: [0.1, 0.4]).kr;
	freq = [freq,freq*2] * fenv;
	freq = freq.max(10);

	snd = LFTri.ar(freq) + SinOsc.ar(freq) * [1,0.3];
	snd1 = SinOsc.ar(190, mul:3) * EnvGen.ar(Env.perc(releaseTime:0.1), gate) ;
	snd = snd.sum * 0.9;
	snd = LPF.ar(snd, freq * 4);

	snd = snd + RLPF.ar( BrownNoise.ar(1),
		Env(levels:[2000,500,90], times:[0.01,0.05]).kr, 0.3 );

	snd = snd + ( BPF.ar(WhiteNoise.ar(0.5), 3000) 
		* Env([1,1,0], [0.004,0.005]).kr );
	snd = snd + ( BPF.ar(WhiteNoise.ar(0.5), 7000) 
		* Env([1,1,0], [0.003,0.001]).kr );
	
	aenv = Env([1,1,0], [0.2,2], curve: -9).kr;
	snd = snd1 + snd * aenv;
	snd = Limiter.ar(snd, 8);
	
	senv = Linen.kr(releaseTime: 0.1, gate: gate, doneAction: Done.freeSelf);
	snd = LeakDC.ar(snd);
	snd = snd * amp * senv;
	snd = Pan2.ar(snd, pos:0);
	snd = snd.clip2;
	Out.ar(out, snd);
}).add;
);



////////////////////////////////////////////////////////////////////////////////////////////////////////
(
~clk3 = TempoClock.new(2.2);
//~myClock = TempoClock.new(2.2);

//~clk3 = TempoClock.tempo= 2.2 / 1;
{ // routine starts here
	1.wait;
	Ndef(\gcdmod).proxyspace.clock = ~clk3;
	Ndef(\gcdmod).proxyspace.quant = 1;	
	Ndef(\gcdmod, {
		var a = TDuty.ar(Dseq((0..3), inf) + 5 * SampleDur.ir);
		var b = TDuty.ar(Dseq((3..0), inf) + 5.01 * SampleDur.ir);
		var mod = 50;
		var t = PulseCount.ar(a) % mod;
		var u = PulseCount.ar(b) % mod;
		var n, j, d, e, c;

		d = LocalIn.ar(2);
		n = gcd(t, u + [0, 1]);
		e = n.linexp(0, mod, 70, 10000);
		j = SinOsc.ar(e);
		LocalOut.ar(j * d);
		c = CombC.ar(j, 1, [0.009,0.007,0.008, 0.006] * LFNoise1.ar([0.01,0.01]).range(1.3,0.7), 30, mul:0.05);
		j = j * LFNoise1.ar(0.2).range(0,0.5) + Splay.ar(c);
		j = Greyhole.ar(j, damp:0.5, diff:0.5 size:4);
		j = Limiter.ar(LPF.ar(HPF.ar(j, 100), LFNoise1.kr(0.1).exprange(200,18000)), 0.5, 0.55);
		j = j * LFPulse.ar([2.2,4.4]*2, 0.96, width:LFNoise1.ar(0.2).range(0.8,0.95)).range(LFNoise1.ar(0.1).range(0,1),1);
		j = j + LFPulse.ar([2.2,4.4], 0.96, mul: LFNoise1.kr(1/10).range(0,0.5) * Line.kr(0,1,30));
		j = LeakDC.ar(j);
		
		// Out.ar(0, j * EnvGate())
	});
	
	Ndef(\gcdkick).proxyspace.clock = ~clk3;
	Ndef(\gcdkick).proxyspace.quant = 1;
	Pdef(\gcdkick, {
		Pbind(*[
			instrument: \tribd,
			dur: Pseq([
				Rest(32),
				Pseq(
					[
						Prand( [ Pseq([1.5,1.5]), 3 ] ),
						3,
						Prand([
							4,
							Pn(1,3),
							Pn(Pseq([1/2,1,Prand([1/2,1.5])]),1)
						])
					] / 2, 32)
				],inf),
			//dur: 1,
			//dur: Pseq([1.5,1,1.5,1/2,2,1/2,1.5,1/2,1/4,1/2,1/4,3],inf),
			freq:77 + Prand((1..10)/5, inf),
			octave:2,
			amp:0.1
		])		
	};);
	Ndef(\gcdkick).mold(2, \audio, \elastic);
	Ndef(\gcdkick)[0] = Pdef(\gcdkick);


	Pbindef(\n1,
		\instrument, \dNoz,
		\dur, Pseq([20,Rest(10)],inf),
		\amp, 0.5,
		\legato, 1,
	);
	//Pdef(\n1).stop;
	//Pdef(\n1).clear;
	
	1.wait;

	s.makeBundle(0.25, {
		Pdef(\n1).play(~clk3, quant:1);
		Ndef(\gcdmod).play;
		Ndef(\gcdkick).play;
	});
	
}.fork(~clk3)
)
///////////////////////////////////////////////////////////////////////////////////////

// rumblw
Pdef(\n1).quant = 1;

Pdef(\n1).play(~clk3, quant:1);

q = Pbind(*[
	instrument: \tribd,
	// dur: Pseq([
	// 	Prand([
	// 		Pseq([1.5,1.5]),
	// 		3]),
	// 	3,4
	// ] / 4,inf),
	dur: 1,
	dur: Pseq([3,1/2,1/2],inf),
	freq:77,
	octave:2,
	amp:0.2
]).play(~clk3, quant:1);
//Pdef(\kicka2).play(quant:[8,0]);
)

{LFPulse.ar(iphase:0.99)}.plot

x.release

(
Pbindef(\n1,
	\instrument, \dNoz,
	\dur, Pseq([20,Rest(10)],inf),
	\amp, 0.5,
	\legato, 1,
)
)
Pdef(\n1).stop;
Pdef(\n1).clear;

(
Pbindef(\kicka2, *[
	instrument: \tribd,
	// dur: Pseq([
	// 	Prand([
	// 		Pseq([1.5,1.5]),
	// 		3]),
	// 	3,4
	// ] / 4,inf),
	dur: 4,
	//dur: Pseq([3,1/3,1/3,1/3],inf),
	freq:77,
	octave:2,
	amp:0.2
	
]);
)
Pdef(\kicka2).clear



// shippo ------------------------------------------------------
(
SynthDef(\shippo, {
	arg amp=0.1, gate=1, out=0, freq=100;
	var snd, env, rev;
	freq = [freq/2, freq * 0.99, freq * 1.51];
	snd = Pulse.ar(	freq	* LFNoise1.ar(1/10).range(1,1.03), mul:0.4 )
	; //* Lag.ar(LFPulse.ar(1/5, iphase:0.98, width:0.1));
	snd = Splay.ar(snd,spread:0.6);
	snd = LPF.ar(snd, LFNoise1.ar(1/4).exprange(500,10000));
	env = EnvGen.kr(Env.adsr(0.001,0,1, 0.1, 1), gate, doneAction:0);
	snd = snd * env;
	snd = snd;
	rev = Array.fill (16, {
		CombL.ar(
			snd,
			0.2,
			LFNoise1.ar(1/3).range(0.98,1.02) * rrand(0.01, 0.3),
			10)
	});
	rev = Splay.ar(rev);
	rev = LeakDC.ar(rev);
	rev = HPF.ar(rev, 100);
	snd = snd + rev;
	snd = Limiter.ar(snd, 0.8);
	snd = snd * amp;
	DetectSilence.ar(snd, doneAction:2);
	Out.ar(out, snd);
}).add;
)


~clksh = TempoClock.new(1);
Pdef(\shippoP).play(~clksh);
Pdef(\shippoP).stop;
(
Pbindef(\shippoP, *[
	instrument: \shippo,
	degree: 4,
	octave: 3,
	dur: Pseq([1,2,3], inf),
	legato:0.2,
	amp: 0.5
]);
)
Pdef(\shippoP).clear



// 4. dec. 2020 /////////////////////////////////////////////////////////////////

//AKJ to pattern femalemalenonbinary

(
SynthDef(\akj1, {
	arg freq=300, amp=0.1, out=0, gate=1;
	var snd, env;

	freq = [freq,freq*1.01];

	snd = LFPar.ar(freq) * 0.3
	+ (LFTri.ar(freq*16/19, mul:0.3))
	+ (Pulse.ar(freq*21/40, mul:0.1))
	+ (SinOsc.ar(freq/8.01, mul:4).clip2(0.3));
	

	env = Linen.kr(gate, attackTime:1, releaseTime:3, doneAction:2);
	snd = Splay.ar(snd);
	snd = snd * env * amp;
	Out.ar(out, snd);
}).add;
)

(
SynthDef(\akjbz, {
	arg freq=300, amp=0.1, out=0, gate=1;
	var snd, env;

	//freq = [freq, freq*2.02, freq*1.98, freq];
	snd = SinOsc.ar(freq/4, mul:0.7)!2;
	//snd = snd * [1, 0.1, 0.1, 1];
	snd = snd * Lag.ar(LFPulse.ar(freq/8.02, 0.5).range(1,0),0.005);
	snd = snd.softclip(0.5) * 1.5 ;
	
	env = Linen.kr(gate, 0,1,0, 2);
	//snd = (snd + (snd.wrap2 * 0.54)).softclip;

	snd = snd * env * amp;
	
	Splay.ar(snd);
	Out.ar(out, snd);
	//LFPulse.ar(0.275, width:0.25).range(0,1);

}).add
)

(
SynthDef(\click1, {
	arg out=0, gate=1, freq=440, amp=0.1, releaseTime=0.1;
	var snd, env;

	snd = LFPulse.ar([freq, freq * 2], width: LFNoise1.ar(0.1).exprange(0.001,0.004));
	snd = snd + (WhiteNoise.ar(1) * snd);
	snd = HPF.ar(snd, 200);
    //snd = Limiter.ar((snd * 5));

	env = EnvGen.ar(Env.perc(0,releaseTime));
	
	snd = snd * env * amp * Linen.kr(gate, 0, 1, releaseTime, 2);
	snd = Splay.ar(snd);
	Out.ar(out, snd);
}).add
)


// -- disonant chord + click + bazz -------------------------------
TempoClock.tempo=1
// disonchord
Pdef(\akj1p).play;
(
Pbindef(\akj1p, *[
	instrument: \akj1,
	freq:300,
	dur:5,
	legato: 1,
	amp: 1
]))
Pdef(\akj1p).stop;


// click
Pdef(\clickp).play(quant:4);
Pdef(\clickp).stop(quant:4);
(
Pbindef(\clickp, *[
	instrument: \click1,
	dur: Pseq([Pseq([1,2,3]/8, 2), Pseq([1,2,1,2,1,1]/8,3), Pseq([1]/8, 4), Pseq([1]/16, 2), ],inf),
	//dur: Pseq([Pn(1/8, 31), Rest(1/8)],inf),
	amp: Prand([5,7,8,9]/10, inf),
	releaseTime: 0.3,
	freq:1
	
])
)

// deep bass --
Pdef(\akjbp).play(quant:4)
(
Pbindef(\akjbp, *[
	instrument: \akjbz,
	freq: 300,
	dur: 8,
	amp: 0.5,
	legato: 0.20
])
)
Pdef(\akjbp).stop

// ----------------------------------------------------------------------------









// high pitched noise/pulse -------------------------------
(
SynthDef(\x44y, {
	arg out=0, gate=1, amp=0.9;
	var snd, env;
	env = Linen.kr(gate, releaseTime: 0.001, doneAction:2);
	snd = Pulse.ar([1234,2345,3456,4567,5678,8912,11023]
		* LFNoise0.ar(freq:Array.fill(7, {rrand(1,10)})).range(0.8,1.2), mul:0.2).sum;
	snd = snd + WhiteNoise.ar(0.2);
	snd = HPF.ar(snd, 8000);
	//snd = snd * LFSaw.kr(0.5,iphase:1).exprange(0.00001,1);
	snd = snd * amp * env;
	snd = snd.dup;
	Out.ar(out, snd);
}).add;
)

Pdef(\x44yp).play;
Pdef(\x44yp).quant = 4;
(
Pbindef(\x44yp,
	* [
		instrument: \x44y,
		dur: 1/8,
		legato: Prand([
			Pn(0.1,16),
			Pseq([Pn(0.1, 4), 0.5], 4),
			Pseq([Pn(0.1, 2), 0.5, Pn(0.1, 4), 0.5], 4)
		],inf),
		amp: 1,
	]
)
)
Pdef(\x44yp).stop
Pdef(\x44yp).clear



(
Pbindef(\x99,
	* [
		instrument: \tribd,
		octave:3,
		degree: Prand([1,2,3]/10,inf),
		//dur: Pseq([3,2,Prand([2,3]),3,2,2]/8, inf),
		dur: Pseq([3,2,Prand([4,3]),3,2,4]/4, inf),
		amp: 0.1
	]
).play
)




/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////
/////////////////////////////////////////////////////////////////////////////////



// kao bassline?
(
SynthDef(\bz2, {
	arg out=0, gate=1, freq=440, amp=0.1, releaseTime=0.1, cutoff=1, frq=1;
	var env,snd, ffreq;
	ffreq = freq * cutoff * 10;
	ffreq = ffreq.clip(50,18000);
	env = Linen.kr(gate, releaseTime: releaseTime, doneAction: Done.freeSelf);
	snd = Pulse.ar([freq,freq*1.01]);
	snd = snd + Saw.ar([freq*0.99, freq], mul:2);
	snd = RLPF.ar(in: snd,
		freq: ffreq,
		rq: frq);
	
	snd = Limiter.ar(snd, 0.7);
	snd = snd * env * amp;
	snd = Splay.ar(snd);
	snd = HPF.ar(snd, 50);
	Out.ar(out, snd);
	
}).add
)
// -- bassline pattern
Pdef(\bslp).play(quant:4)
Pdef(\bslp).stop
Pbindef(\bslp, *[ dur: Pseq([1,2,4] / [4,2,2,1]/4, inf),]).play(quant:4)
Pbindef(\bslp, *[ dur: Pseq([2,1,1]/4, inf),]).play(quant:8)
(
Pbindef(\bslp, *[
	instrument: \bz2,
	legato: Prand((1..5)*0.03, inf),
	cutoff: Prand([0.6,1,2,3,4,5,7,12]/2,inf),
	frq: Prand((4..7)/10, inf),
	degree: Pseq([0,2,3,Prand([8,4,2])] + 0,inf),
	octave: [3,3.3,4],
	amp:0.2,
	releaseTime:0.1
]).play(quant:4)
)

(  // klick?
SynthDef(\akjklik, {
	arg freq=2, amp=0.1, out=0, gate=1;
	var snd, env;

	snd = LFPulse.ar([freq, freq * 2], width: LFNoise1.ar(0.1).exprange(0.001,0.004));
	env = Linen.kr(gate, 0, 1, 0.01, doneAction:2);

	snd = snd * env * amp;
	Out.ar(out, snd);

}).add;
)



// -----------------------------------


////////////////////////////////////////////////////////////////////////////////////////////////


(

var clck1 = TempoClock.new(120/60);
var clck2 = TempoClock.new(70/60);

{
	
	x = Pbind( \degree, Pseq((0..12)) ).play(clck1);
	4.wait;
	x.stop;
	postln(Date.getDate.format("time: %H:%M:%S --------------------"));
	
}.fork(clck1);

{
	y = Pbind( \degree, Pseq((0..12)+7) ).play(clck2);
	4.wait;
	y.stop;
	postln(Date.getDate.format("time: %H:%M:%S --------------------"));

}.fork(clck2);

postln("end line out of forks");
)

(
/*var date  = Date.getDate;
date.format("%H%M%S").postln;
date.rawSeconds.postln;
		date.rawSeconds.postln;*/
~frames=(Date.getDate.rawSeconds).asString.reverse.at((0..3)).postln;
postln(Date.getDate.format("%H:%M:%S"));
"";
)
.stamp.postln

[1,2,3].asCompileString.postln;
s.freqscope

"this sentence has thirty-nine letters".reverse.at((0..3));
"this sentence has thirty-nine letters".padLeft(39, "-+");
"this sentence more than thirteen letters".padRight(13, "-+"); // nothing to pad.





//////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////
//////////////////////////////////////////////////////////////////////////////////////////////////





//////// EXPERIMENTS! //////////////////////////////////////////////////////////


// 24.nov 2020:

// clicky dissonance / akj ------------------------------------
Ndef(\akj).play
Ndef(\akj).stop
Ndef(\akj).fadeTime=5;
(
Ndef(\akj, {
	var freq=300, snd;
	freq = [freq,freq*1.01];
	snd = LFPar.ar(freq) * 0.3
	+ (LFTri.ar(freq*16/19, mul:0.3))
	+ (Pulse.ar(freq*21/40, mul:0.1))
	+ (SinOsc.ar(freq/8.01, mul:4).clip2(0.3))
	+ (LFPulse.ar([2.2,4.4]*2, width: LFNoise1.ar(0.1).exprange(0.001,0.004)))
	;
	
	snd = Splay.ar(snd);
	//snd = LeakDC.ar(snd);
	snd = snd + (Greyhole.ar(snd) * 0.1);
	snd = snd + (SinOsc.ar(freq/4, mul:0.7) * LFPulse.ar(0.275, width:0.25).range(0,1));

	//snd = Limiter.ar(snd, 0.5) * 1.5;
	
	(snd * 0.6 + (snd.wrap2 * 0.14)).softclip * 1;
	
	//(snd * 0.6).softclip;
	
})
)
















// -------------------------------------------------------

TempoClock.tempo = 120/120;

(
SynthDef(\h991, {
	arg out=0, freq=90, gate=1, amp;
	var snd, env;

	env = Linen.kr(gate, doneAction:2);

	freq = freq * XLine.ar(1,0.4, 5);
	snd = SinOsc.ar(freq);
	snd = BHiPass4.ar(snd, 40);
	snd = snd + LPF.ar(Pulse.ar([freq, freq*1.01], 0.01, mul:0.4), freq * 32);
	snd = snd + (LFTri.ar([freq*1.01,freq]) + SinOsc.ar(freq, mul:10).max(-0.5).min(0.5)).clip2(0.5);

	snd = snd + Pulse.ar(freq, mul:0.2);
	snd = snd + Impulse.ar(freq, mul:2);

	snd = BLowPass4.ar(snd, SinOsc.kr(LFNoise0.kr(8).range(1,8)).range(300,LFNoise1.kr(1).range(1000,10000)), rq:0.7);


	snd= snd * -6.dbamp;
	snd = snd * env * amp;
	snd = Splay.ar(snd);
	Out.ar(out,snd);
}).add;
)


Pdef(\h991p).play;
Pdef(\h991p).quant = 4;

(
Pbindef(\h991p, *[
	instrument: \h991,
	dur: 4,
	octave: 3,
	legato: 0.89,
	amp: 1
])
)
Pdef(\h991p).clear





////////////////////////////////////////////////////////////////////////////////
(
// SC808 drum snare
SynthDef.new(\sc808sn, {
	arg amp=2, tone=340, tone2=189, snappy=0.7, gate=1, amp2=1, out=0;
	var noiseEnv, atkEnv, sig, noise, osc1, osc2, sum;
	noiseEnv = EnvGen.kr(Env.perc(0.001, 4.2, 1, -115), doneAction:0);
	atkEnv = EnvGen.kr(Env.perc(0.001, 0.8,curve:-95), doneAction:2);
	noise = WhiteNoise.ar;
	noise = HPF.ar(noise, 1800);
	noise = LPF.ar(noise, 8850);
	noise = noise * noiseEnv * snappy;
	osc1 = SinOsc.ar(tone2, pi/2) * 0.6;
	osc2 = SinOsc.ar(tone, pi/2) * 0.7;
	sum = (osc1+osc2) * atkEnv * amp2;
	sig = Pan2.ar(((noise*1) + sum) * amp * 2.5, 0);
	sig = HPF.ar(sig, 340);
	Out.ar(out, sig);
}).add
)










~delay1 = Bus.audio(s, 2);

(
SynthDef(\dlywrangler, {
	arg out=0, in;
	var snd;
	snd = In.ar(in,2);
	snd = CombL.ar(snd, 1, Lag.ar(LFNoise0.ar(1).range(0.01,0.1),0.01), 3, mul:0.4) + snd;
	Out.ar(out, snd);
}).add;
)

~dlywrang1 = Synth(\dlywrangler, [\out, 0, \in, ~delay1]);
~dlywrang1.free

(
Pbindef(\hhp1,
	* [
		instrument: \sc808hh,
		//dur: Pseq([Rest(1/32), 3/32], inf),
		dur: 1/16,
		//amp: Prand([1,2,3]/3, inf),
		amp: Pseq([1, 0.2],inf),
		out: Pwrand([~delay1,0],[0.7,0.3],inf),
		pan: Pfunc({rrand(-0.6,0.6)})
	]
).play
)

(
Pbindef(\snp1,
	*[
		instrument: \sc808sn,
		dur: Pseq([Rest(1),Pxrand([1,1.5,0.5,Pn(0.5,4),Pn(0.25,2),Pn(0.25,2),Pn(0.25,2)])]/2,inf),
		amp: Prand([1,2,3]*0.05+0.8,inf),
		tone: 340,
		tone2: 189, //Pxrand([2,3,4,5,6,7] * 100, inf),
		snappy: 0.3,
		//out: Prand([0,~delay1],inf)
		out: 0
	]
).play
)

(
Pbindef(\sawp1,
	*[
		instrument: \softSaw,
		dur: 10,
		attackTime: 5,
		releaseTime:5,
		legato:1,
		degree: Pseq([ [-2,3,11,20], [-2,5,7,21] ],inf),
		octave: 3,
		amp: [1,0.5,0.2,0.1] * 0,
		out: ~delay2
	]
).play
)
~delay2 = Bus.audio(s,2);
(
SynthDef(\wiDel, {
	var snd = In.ar(\in.kr, 2);
	snd = CombL.ar(snd, 1, SinOsc.ar(0.02,[0,pi/2]).range(0.5,0.6), 10, mul:1) + snd;
	Out.ar(\out.kr(0), snd);
}).add;
)
~widel1.free
~widel1 = Synth(\wiDel, [\in, ~delay2, \out, 0]);



////////////////////////
s.meter










// BASSLINE + MELODIC LINES with buffer cycler

Pdef(\x32).play
Pdef(\x32).fadeTime = 0;
(
Pdef(\x32,
	Pbind(
		\instrument, 	\bufCyc,
		\bufnum, 		[~getSmp.value("0043"),~getSmp.value("0043")],
		\octave,		[3,2,4],
		\degree, 		Pseq([2,2,4,1], inf),
		\detune,		[0.1,0],
		\chanDetune,	20,
		\dur,			Pseq([0.20,0.40,0.60],inf),
		\legato,		1,
		\amp,			[0.3,0.5,0.1] * 0.5,
		\releaseTime,	0.01
	)).play.quant_(8);
)

Pdef(\x33).play
Pdef(\x33).fadeTime = 0;
(
Pdef(\x33,
	Pbind(
		\instrument, 	\bufCyc,
		\bufnum, 		[~getSmp.value("blended_0001"),~getSmp.value("0023")],
		//\bufnum, 		~getSmp.value("raw"),

		\degree, 		Pseq([[4,9],2,8,4,1], inf),

		\octave,		Prand([[6,5,7],[4,5,7],[7,5,4]]-0 ,inf),
		\mtranspose,	Pseq([Pn([1],10),Pn([0],10)],inf),
		\detune,		[0,0.3],
		\chanDetune,	Pseq([-10,0,5,10,-5],inf),
		\dur,			Pseq([1,2,3] * 0.2,inf),
		\legato,		0.1,
		\amp,			[0.3,0.5,0.1] * 0.1,
		\releaseTime,	Prand([1,2,3,4],inf)
	));
)