PocketVerbs

10 files changed, 19259 insertions, 0 deletions

diff --git a/plugins/WinVST/PocketVerbs/.vs/Console4Channel64/v14/.suo b/plugins/WinVST/PocketVerbs/.vs/Console4Channel64/v14/.suo
new file mode 100755
index 0000000..777b846
--- /dev/null
+++ b/plugins/WinVST/PocketVerbs/.vs/Console4Channel64/v14/.suo
diff --git a/plugins/WinVST/PocketVerbs/.vs/VSTProject/v14/.suo b/plugins/WinVST/PocketVerbs/.vs/VSTProject/v14/.suo
new file mode 100755
index 0000000..9bbdfac
--- /dev/null
+++ b/plugins/WinVST/PocketVerbs/.vs/VSTProject/v14/.suo
diff --git a/plugins/WinVST/PocketVerbs/PocketVerbs.cpp b/plugins/WinVST/PocketVerbs/PocketVerbs.cpp
new file mode 100755
index 0000000..4426e4b
--- /dev/null
+++ b/plugins/WinVST/PocketVerbs/PocketVerbs.cpp
@@ -0,0 +1,325 @@
+/* ========================================
+ *  PocketVerbs - PocketVerbs.h
+ *  Copyright (c) 2016 airwindows, All rights reserved
+ * ======================================== */
+
+#ifndef __PocketVerbs_H
+#include "PocketVerbs.h"
+#endif
+
+AudioEffect* createEffectInstance(audioMasterCallback audioMaster) {return new PocketVerbs(audioMaster);}
+
+PocketVerbs::PocketVerbs(audioMasterCallback audioMaster) :
+    AudioEffectX(audioMaster, kNumPrograms, kNumParameters)
+{
+	A = 0.0;
+	B = 0.5;
+	C = 0.0;
+	D = 0.5;
+	
+	for(count = 0; count < 6; count++) {dAL[count] = 0.0; dBL[count] = 0.0; dCL[count] = 0.0; dDL[count] = 0.0; dEL[count] = 0.0;
+		dFL[count] = 0.0; dGL[count] = 0.0; dHL[count] = 0.0; dIL[count] = 0.0; dJL[count] = 0.0; dKL[count] = 0.0; dLL[count] = 0.0;
+		dML[count] = 0.0; dNL[count] = 0.0; dOL[count] = 0.0; dPL[count] = 0.0; dQL[count] = 0.0; dRL[count] = 0.0; dSL[count] = 0.0;
+		dTL[count] = 0.0; dUL[count] = 0.0; dVL[count] = 0.0; dWL[count] = 0.0; dXL[count] = 0.0; dYL[count] = 0.0; dZL[count] = 0.0;}
+	
+	for(count = 0; count < 15149; count++) {aAL[count] = 0.0;}
+	for(count = 0; count < 15149; count++) {oAL[count] = 0.0;}
+	for(count = 0; count < 14617; count++) {aBL[count] = 0.0;}
+	for(count = 0; count < 14617; count++) {oBL[count] = 0.0;}
+	for(count = 0; count < 14357; count++) {aCL[count] = 0.0;}
+	for(count = 0; count < 14357; count++) {oCL[count] = 0.0;}
+	for(count = 0; count < 13817; count++) {aDL[count] = 0.0;}
+	for(count = 0; count < 13817; count++) {oDL[count] = 0.0;}
+	for(count = 0; count < 13561; count++) {aEL[count] = 0.0;}
+	for(count = 0; count < 13561; count++) {oEL[count] = 0.0;}
+	for(count = 0; count < 13045; count++) {aFL[count] = 0.0;}
+	for(count = 0; count < 13045; count++) {oFL[count] = 0.0;}
+	for(count = 0; count < 11965; count++) {aGL[count] = 0.0;}
+	for(count = 0; count < 11965; count++) {oGL[count] = 0.0;}
+	for(count = 0; count < 11129; count++) {aHL[count] = 0.0;}
+	for(count = 0; count < 11129; count++) {oHL[count] = 0.0;}
+	for(count = 0; count < 10597; count++) {aIL[count] = 0.0;}
+	for(count = 0; count < 10597; count++) {oIL[count] = 0.0;}
+	for(count = 0; count < 9809; count++) {aJL[count] = 0.0;}
+	for(count = 0; count < 9809; count++) {oJL[count] = 0.0;}
+	for(count = 0; count < 9521; count++) {aKL[count] = 0.0;}
+	for(count = 0; count < 9521; count++) {oKL[count] = 0.0;}
+	for(count = 0; count < 8981; count++) {aLL[count] = 0.0;}
+	for(count = 0; count < 8981; count++) {oLL[count] = 0.0;}
+	for(count = 0; count < 8785; count++) {aML[count] = 0.0;}
+	for(count = 0; count < 8785; count++) {oML[count] = 0.0;}
+	for(count = 0; count < 8461; count++) {aNL[count] = 0.0;}
+	for(count = 0; count < 8461; count++) {oNL[count] = 0.0;}
+	for(count = 0; count < 8309; count++) {aOL[count] = 0.0;}
+	for(count = 0; count < 8309; count++) {oOL[count] = 0.0;}
+	for(count = 0; count < 7981; count++) {aPL[count] = 0.0;}
+	for(count = 0; count < 7981; count++) {oPL[count] = 0.0;}
+	for(count = 0; count < 7321; count++) {aQL[count] = 0.0;}
+	for(count = 0; count < 7321; count++) {oQL[count] = 0.0;}
+	for(count = 0; count < 6817; count++) {aRL[count] = 0.0;}
+	for(count = 0; count < 6817; count++) {oRL[count] = 0.0;}
+	for(count = 0; count < 6505; count++) {aSL[count] = 0.0;}
+	for(count = 0; count < 6505; count++) {oSL[count] = 0.0;}
+	for(count = 0; count < 6001; count++) {aTL[count] = 0.0;}
+	for(count = 0; count < 6001; count++) {oTL[count] = 0.0;}
+	for(count = 0; count < 5837; count++) {aUL[count] = 0.0;}
+	for(count = 0; count < 5837; count++) {oUL[count] = 0.0;}
+	for(count = 0; count < 5501; count++) {aVL[count] = 0.0;}
+	for(count = 0; count < 5501; count++) {oVL[count] = 0.0;}
+	for(count = 0; count < 5009; count++) {aWL[count] = 0.0;}
+	for(count = 0; count < 5009; count++) {oWL[count] = 0.0;}
+	for(count = 0; count < 4849; count++) {aXL[count] = 0.0;}
+	for(count = 0; count < 4849; count++) {oXL[count] = 0.0;}
+	for(count = 0; count < 4295; count++) {aYL[count] = 0.0;}
+	for(count = 0; count < 4295; count++) {oYL[count] = 0.0;}
+	for(count = 0; count < 4179; count++) {aZL[count] = 0.0;}	
+	for(count = 0; count < 4179; count++) {oZL[count] = 0.0;}
+	
+	for(count = 0; count < 6; count++) {dAR[count] = 0.0; dBR[count] = 0.0; dCR[count] = 0.0; dDR[count] = 0.0; dER[count] = 0.0;
+		dFR[count] = 0.0; dGR[count] = 0.0; dHR[count] = 0.0; dIR[count] = 0.0; dJR[count] = 0.0; dKR[count] = 0.0; dLR[count] = 0.0;
+		dMR[count] = 0.0; dNR[count] = 0.0; dOR[count] = 0.0; dPR[count] = 0.0; dQR[count] = 0.0; dRR[count] = 0.0; dSR[count] = 0.0;
+		dTR[count] = 0.0; dUR[count] = 0.0; dVR[count] = 0.0; dWR[count] = 0.0; dXR[count] = 0.0; dYR[count] = 0.0; dZR[count] = 0.0;}
+	
+	for(count = 0; count < 15149; count++) {aAR[count] = 0.0;}
+	for(count = 0; count < 15149; count++) {oAR[count] = 0.0;}
+	for(count = 0; count < 14617; count++) {aBR[count] = 0.0;}
+	for(count = 0; count < 14617; count++) {oBR[count] = 0.0;}
+	for(count = 0; count < 14357; count++) {aCR[count] = 0.0;}
+	for(count = 0; count < 14357; count++) {oCR[count] = 0.0;}
+	for(count = 0; count < 13817; count++) {aDR[count] = 0.0;}
+	for(count = 0; count < 13817; count++) {oDR[count] = 0.0;}
+	for(count = 0; count < 13561; count++) {aER[count] = 0.0;}
+	for(count = 0; count < 13561; count++) {oER[count] = 0.0;}
+	for(count = 0; count < 13045; count++) {aFR[count] = 0.0;}
+	for(count = 0; count < 13045; count++) {oFR[count] = 0.0;}
+	for(count = 0; count < 11965; count++) {aGR[count] = 0.0;}
+	for(count = 0; count < 11965; count++) {oGR[count] = 0.0;}
+	for(count = 0; count < 11129; count++) {aHR[count] = 0.0;}
+	for(count = 0; count < 11129; count++) {oHR[count] = 0.0;}
+	for(count = 0; count < 10597; count++) {aIR[count] = 0.0;}
+	for(count = 0; count < 10597; count++) {oIR[count] = 0.0;}
+	for(count = 0; count < 9809; count++) {aJR[count] = 0.0;}
+	for(count = 0; count < 9809; count++) {oJR[count] = 0.0;}
+	for(count = 0; count < 9521; count++) {aKR[count] = 0.0;}
+	for(count = 0; count < 9521; count++) {oKR[count] = 0.0;}
+	for(count = 0; count < 8981; count++) {aLR[count] = 0.0;}
+	for(count = 0; count < 8981; count++) {oLR[count] = 0.0;}
+	for(count = 0; count < 8785; count++) {aMR[count] = 0.0;}
+	for(count = 0; count < 8785; count++) {oMR[count] = 0.0;}
+	for(count = 0; count < 8461; count++) {aNR[count] = 0.0;}
+	for(count = 0; count < 8461; count++) {oNR[count] = 0.0;}
+	for(count = 0; count < 8309; count++) {aOR[count] = 0.0;}
+	for(count = 0; count < 8309; count++) {oOR[count] = 0.0;}
+	for(count = 0; count < 7981; count++) {aPR[count] = 0.0;}
+	for(count = 0; count < 7981; count++) {oPR[count] = 0.0;}
+	for(count = 0; count < 7321; count++) {aQR[count] = 0.0;}
+	for(count = 0; count < 7321; count++) {oQR[count] = 0.0;}
+	for(count = 0; count < 6817; count++) {aRR[count] = 0.0;}
+	for(count = 0; count < 6817; count++) {oRR[count] = 0.0;}
+	for(count = 0; count < 6505; count++) {aSR[count] = 0.0;}
+	for(count = 0; count < 6505; count++) {oSR[count] = 0.0;}
+	for(count = 0; count < 6001; count++) {aTR[count] = 0.0;}
+	for(count = 0; count < 6001; count++) {oTR[count] = 0.0;}
+	for(count = 0; count < 5837; count++) {aUR[count] = 0.0;}
+	for(count = 0; count < 5837; count++) {oUR[count] = 0.0;}
+	for(count = 0; count < 5501; count++) {aVR[count] = 0.0;}
+	for(count = 0; count < 5501; count++) {oVR[count] = 0.0;}
+	for(count = 0; count < 5009; count++) {aWR[count] = 0.0;}
+	for(count = 0; count < 5009; count++) {oWR[count] = 0.0;}
+	for(count = 0; count < 4849; count++) {aXR[count] = 0.0;}
+	for(count = 0; count < 4849; count++) {oXR[count] = 0.0;}
+	for(count = 0; count < 4295; count++) {aYR[count] = 0.0;}
+	for(count = 0; count < 4295; count++) {oYR[count] = 0.0;}
+	for(count = 0; count < 4179; count++) {aZR[count] = 0.0;}	
+	for(count = 0; count < 4179; count++) {oZR[count] = 0.0;}
+	
+	outAL = 1; alpAL = 1;
+	outBL = 1; alpBL = 1;
+	outCL = 1; alpCL = 1;
+	outDL = 1; alpDL = 1;
+	outEL = 1; alpEL = 1;
+	outFL = 1; alpFL = 1;
+	outGL = 1; alpGL = 1;
+	outHL = 1; alpHL = 1;
+	outIL = 1; alpIL = 1;
+	outJL = 1; alpJL = 1;
+	outKL = 1; alpKL = 1;
+	outLL = 1; alpLL = 1;
+	outML = 1; alpML = 1;
+	outNL = 1; alpNL = 1;
+	outOL = 1; alpOL = 1;
+	outPL = 1; alpPL = 1;
+	outQL = 1; alpQL = 1;
+	outRL = 1; alpRL = 1;
+	outSL = 1; alpSL = 1;
+	outTL = 1; alpTL = 1;
+	outUL = 1; alpUL = 1;
+	outVL = 1; alpVL = 1;
+	outWL = 1; alpWL = 1;
+	outXL = 1; alpXL = 1;
+	outYL = 1; alpYL = 1;
+	outZL = 1; alpZL = 1;
+	
+	outAR = 1; alpAR = 1; delayA = 4; maxdelayA = 7573;
+	outBR = 1; alpBR = 1; delayB = 4; maxdelayB = 7307;
+	outCR = 1; alpCR = 1; delayC = 4; maxdelayC = 7177;
+	outDR = 1; alpDR = 1; delayD = 4; maxdelayD = 6907;
+	outER = 1; alpER = 1; delayE = 4; maxdelayE = 6779;
+	outFR = 1; alpFR = 1; delayF = 4; maxdelayF = 6521;
+	outGR = 1; alpGR = 1; delayG = 4; maxdelayG = 5981;
+	outHR = 1; alpHR = 1; delayH = 4; maxdelayH = 5563;
+	outIR = 1; alpIR = 1; delayI = 4; maxdelayI = 5297;
+	outJR = 1; alpJR = 1; delayJ = 4; maxdelayJ = 4903;
+	outKR = 1; alpKR = 1; delayK = 4; maxdelayK = 4759;
+	outLR = 1; alpLR = 1; delayL = 4; maxdelayL = 4489;
+	outMR = 1; alpMR = 1; delayM = 4; maxdelayM = 4391;
+	outNR = 1; alpNR = 1; delayN = 4; maxdelayN = 4229;
+	outOR = 1; alpOR = 1; delayO = 4; maxdelayO = 4153;
+	outPR = 1; alpPR = 1; delayP = 4; maxdelayP = 3989;
+	outQR = 1; alpQR = 1; delayQ = 4; maxdelayQ = 3659;
+	outRR = 1; alpRR = 1; delayR = 4; maxdelayR = 3407;
+	outSR = 1; alpSR = 1; delayS = 4; maxdelayS = 3251;
+	outTR = 1; alpTR = 1; delayT = 4; maxdelayT = 2999;
+	outUR = 1; alpUR = 1; delayU = 4; maxdelayU = 2917;
+	outVR = 1; alpVR = 1; delayV = 4; maxdelayV = 2749;
+	outWR = 1; alpWR = 1; delayW = 4; maxdelayW = 2503;
+	outXR = 1; alpXR = 1; delayX = 4; maxdelayX = 2423;
+	outYR = 1; alpYR = 1; delayY = 4; maxdelayY = 2146;
+	outZR = 1; alpZR = 1; delayZ = 4; maxdelayZ = 2088;
+	
+	savedRoomsize = -1.0; //force update to begin
+	countdown = -1;
+	peakL = 1.0;
+	peakR = 1.0;
+	fpd = 17;
+	//this is reset: values being initialized only once. Startup values, whatever they are.
+	
+    _canDo.insert("plugAsChannelInsert"); // plug-in can be used as a channel insert effect.
+    _canDo.insert("plugAsSend"); // plug-in can be used as a send effect.
+    _canDo.insert("x2in2out"); 
+    setNumInputs(kNumInputs);
+    setNumOutputs(kNumOutputs);
+    setUniqueID(kUniqueId);
+    canProcessReplacing();     // supports output replacing
+    canDoubleReplacing();      // supports double precision processing
+	programsAreChunks(true);
+    vst_strncpy (_programName, "Default", kVstMaxProgNameLen); // default program name
+}
+
+PocketVerbs::~PocketVerbs() {}
+VstInt32 PocketVerbs::getVendorVersion () {return 1000;}
+void PocketVerbs::setProgramName(char *name) {vst_strncpy (_programName, name, kVstMaxProgNameLen);}
+void PocketVerbs::getProgramName(char *name) {vst_strncpy (name, _programName, kVstMaxProgNameLen);}
+//airwindows likes to ignore this stuff. Make your own programs, and make a different plugin rather than
+//trying to do versioning and preventing people from using older versions. Maybe they like the old one!
+
+static float pinParameter(float data)
+{
+	if (data < 0.0f) return 0.0f;
+	if (data > 1.0f) return 1.0f;
+	return data;
+}
+
+VstInt32 PocketVerbs::getChunk (void** data, bool isPreset)
+{
+	float *chunkData = (float *)calloc(kNumParameters, sizeof(float));
+	chunkData[0] = A;
+	chunkData[1] = B;
+	chunkData[2] = C;
+	chunkData[3] = D;
+	/* Note: The way this is set up, it will break if you manage to save settings on an Intel
+	 machine and load them on a PPC Mac. However, it's fine if you stick to the machine you 
+	 started with. */
+	
+	*data = chunkData;
+	return kNumParameters * sizeof(float);
+}
+
+VstInt32 PocketVerbs::setChunk (void* data, VstInt32 byteSize, bool isPreset)
+{	
+	float *chunkData = (float *)data;
+	A = pinParameter(chunkData[0]);
+	B = pinParameter(chunkData[1]);
+	C = pinParameter(chunkData[2]);
+	D = pinParameter(chunkData[3]);
+	/* We're ignoring byteSize as we found it to be a filthy liar */
+	
+	/* calculate any other fields you need here - you could copy in 
+	 code from setParameter() here. */
+	return 0;
+}
+
+void PocketVerbs::setParameter(VstInt32 index, float value) {
+    switch (index) {
+        case kParamA: A = value; break;
+        case kParamB: B = value; break;
+        case kParamC: C = value; break;
+        case kParamD: D = value; break;
+        default: throw; // unknown parameter, shouldn't happen!
+    }
+}
+
+float PocketVerbs::getParameter(VstInt32 index) {
+    switch (index) {
+        case kParamA: return A; break;
+        case kParamB: return B; break;
+        case kParamC: return C; break;
+        case kParamD: return D; break;
+        default: break; // unknown parameter, shouldn't happen!
+    } return 0.0; //we only need to update the relevant name, this is simple to manage
+}
+
+void PocketVerbs::getParameterName(VstInt32 index, char *text) {
+    switch (index) {
+        case kParamA: vst_strncpy (text, "Type", kVstMaxParamStrLen); break;
+		case kParamB: vst_strncpy (text, "Size", kVstMaxParamStrLen); break;
+		case kParamC: vst_strncpy (text, "Gating", kVstMaxParamStrLen); break;
+		case kParamD: vst_strncpy (text, "Dry/Wet", kVstMaxParamStrLen); break;
+        default: break; // unknown parameter, shouldn't happen!
+    } //this is our labels for displaying in the VST host
+}
+
+void PocketVerbs::getParameterDisplay(VstInt32 index, char *text) {
+    switch (index) {
+        case kParamA: switch((VstInt32)( A * 5.999 )) //0 to almost edge of # of params
+		{	case 0: vst_strncpy (text, "Chamber", kVstMaxParamStrLen); break;
+			case 1: vst_strncpy (text, "Spring", kVstMaxParamStrLen); break;
+			case 2: vst_strncpy (text, "Tiled", kVstMaxParamStrLen); break;
+			case 3: vst_strncpy (text, "Room", kVstMaxParamStrLen); break;
+			case 4: vst_strncpy (text, "Stretch", kVstMaxParamStrLen); break;
+			case 5: vst_strncpy (text, "Zarathu", kVstMaxParamStrLen); break;
+			default: break; // unknown parameter, shouldn't happen!
+		} break;			
+        case kParamB: float2string (B, text, kVstMaxParamStrLen); break;
+        case kParamC: float2string (C, text, kVstMaxParamStrLen); break;
+        case kParamD: float2string (D, text, kVstMaxParamStrLen); break;
+        default: break; // unknown parameter, shouldn't happen!
+	} //this displays the values and handles 'popups' where it's discrete choices
+}
+
+void PocketVerbs::getParameterLabel(VstInt32 index, char *text) {
+    switch (index) {
+        case kParamA: vst_strncpy (text, "", kVstMaxParamStrLen); break;
+        case kParamB: vst_strncpy (text, "", kVstMaxParamStrLen); break;
+        case kParamC: vst_strncpy (text, "", kVstMaxParamStrLen); break;
+        case kParamD: vst_strncpy (text, "", kVstMaxParamStrLen); break;
+		default: break; // unknown parameter, shouldn't happen!
+    }
+}
+
+VstInt32 PocketVerbs::canDo(char *text) 
+{ return (_canDo.find(text) == _canDo.end()) ? -1: 1; } // 1 = yes, -1 = no, 0 = don't know
+
+bool PocketVerbs::getEffectName(char* name) {
+    vst_strncpy(name, "PocketVerbs", kVstMaxProductStrLen); return true;
+}
+
+VstPlugCategory PocketVerbs::getPlugCategory() {return kPlugCategEffect;}
+
+bool PocketVerbs::getProductString(char* text) {
+  	vst_strncpy (text, "airwindows PocketVerbs", kVstMaxProductStrLen); return true;
+}
+
+bool PocketVerbs::getVendorString(char* text) {
+  	vst_strncpy (text, "airwindows", kVstMaxVendorStrLen); return true;
+}
diff --git a/plugins/WinVST/PocketVerbs/PocketVerbs.h b/plugins/WinVST/PocketVerbs/PocketVerbs.h
new file mode 100755
index 0000000..7feaf8e
--- /dev/null
+++ b/plugins/WinVST/PocketVerbs/PocketVerbs.h
@@ -0,0 +1,295 @@
+/* ========================================
+ *  PocketVerbs - PocketVerbs.h
+ *  Created 8/12/11 by SPIAdmin 
+ *  Copyright (c) 2011 __MyCompanyName__, All rights reserved
+ * ======================================== */
+
+#ifndef __PocketVerbs_H
+#define __PocketVerbs_H
+
+#ifndef __audioeffect__
+#include "audioeffectx.h"
+#endif
+
+#include <set>
+#include <string>
+#include <math.h>
+
+enum {
+	kParamA = 0,
+	kParamB = 1,
+	kParamC = 2,
+	kParamD = 3,
+  kNumParameters = 4
+}; //
+
+const int kNumPrograms = 0;
+const int kNumInputs = 2;
+const int kNumOutputs = 2;
+const unsigned long kUniqueId = 'pkvb';    //Change this to what the AU identity is!
+
+class PocketVerbs : 
+    public AudioEffectX 
+{
+public:
+    PocketVerbs(audioMasterCallback audioMaster);
+    ~PocketVerbs();
+    virtual bool getEffectName(char* name);                       // The plug-in name
+    virtual VstPlugCategory getPlugCategory();                    // The general category for the plug-in
+    virtual bool getProductString(char* text);                    // This is a unique plug-in string provided by Steinberg
+    virtual bool getVendorString(char* text);                     // Vendor info
+    virtual VstInt32 getVendorVersion();                          // Version number
+    virtual void processReplacing (float** inputs, float** outputs, VstInt32 sampleFrames);
+    virtual void processDoubleReplacing (double** inputs, double** outputs, VstInt32 sampleFrames);
+    virtual void getProgramName(char *name);                      // read the name from the host
+    virtual void setProgramName(char *name);                      // changes the name of the preset displayed in the host
+	virtual VstInt32 getChunk (void** data, bool isPreset);
+	virtual VstInt32 setChunk (void* data, VstInt32 byteSize, bool isPreset);
+    virtual float getParameter(VstInt32 index);                   // get the parameter value at the specified index
+    virtual void setParameter(VstInt32 index, float value);       // set the parameter at index to value
+    virtual void getParameterLabel(VstInt32 index, char *text);  // label for the parameter (eg dB)
+    virtual void getParameterName(VstInt32 index, char *text);    // name of the parameter
+    virtual void getParameterDisplay(VstInt32 index, char *text); // text description of the current value    
+    virtual VstInt32 canDo(char *text);
+private:
+    char _programName[kVstMaxProgNameLen + 1];
+    std::set< std::string > _canDo;
+    
+	int count;
+	
+	
+	
+	double dAR[7];
+	double dBR[7];
+	double dCR[7];
+	double dDR[7];		
+	double dER[7];
+	double dFR[7];
+	double dGR[7];
+	double dHR[7];
+	double dIR[7];
+	double dJR[7];
+	double dKR[7];
+	double dLR[7];
+	double dMR[7];
+	double dNR[7];
+	double dOR[7];
+	double dPR[7];
+	double dQR[7];
+	double dRR[7];
+	double dSR[7];
+	double dTR[7];
+	double dUR[7];
+	double dVR[7];
+	double dWR[7];
+	double dXR[7];
+	double dYR[7];
+	double dZR[7];
+	
+	double aAR[15150];
+	double aBR[14618];
+	double aCR[14358];
+	double aDR[13818];		
+	double aER[13562];
+	double aFR[13046];
+	double aGR[11966];
+	double aHR[11130];
+	double aIR[10598];
+	double aJR[9810];
+	double aKR[9522];
+	double aLR[8982];
+	double aMR[8786];
+	double aNR[8462];
+	double aOR[8310];
+	double aPR[7982];
+	double aQR[7322];
+	double aRR[6818];
+	double aSR[6506];
+	double aTR[6002];
+	double aUR[5838];
+	double aVR[5502];
+	double aWR[5010];
+	double aXR[4850];
+	double aYR[4296];
+	double aZR[4180];
+	
+	double oAR[15150];
+	double oBR[14618];
+	double oCR[14358];
+	double oDR[13818];		
+	double oER[13562];
+	double oFR[13046];
+	double oGR[11966];
+	double oHR[11130];
+	double oIR[10598];
+	double oJR[9810];
+	double oKR[9522];
+	double oLR[8982];
+	double oMR[8786];
+	double oNR[8462];
+	double oOR[8310];
+	double oPR[7982];
+	double oQR[7322];
+	double oRR[6818];
+	double oSR[6506];
+	double oTR[6002];
+	double oUR[5838];
+	double oVR[5502];
+	double oWR[5010];
+	double oXR[4850];
+	double oYR[4296];
+	double oZR[4180];
+	
+	double dAL[7];
+	double dBL[7];
+	double dCL[7];
+	double dDL[7];		
+	double dEL[7];
+	double dFL[7];
+	double dGL[7];
+	double dHL[7];
+	double dIL[7];
+	double dJL[7];
+	double dKL[7];
+	double dLL[7];
+	double dML[7];
+	double dNL[7];
+	double dOL[7];
+	double dPL[7];
+	double dQL[7];
+	double dRL[7];
+	double dSL[7];
+	double dTL[7];
+	double dUL[7];
+	double dVL[7];
+	double dWL[7];
+	double dXL[7];
+	double dYL[7];
+	double dZL[7];
+	
+	double aAL[15150];
+	double aBL[14618];
+	double aCL[14358];
+	double aDL[13818];		
+	double aEL[13562];
+	double aFL[13046];
+	double aGL[11966];
+	double aHL[11130];
+	double aIL[10598];
+	double aJL[9810];
+	double aKL[9522];
+	double aLL[8982];
+	double aML[8786];
+	double aNL[8462];
+	double aOL[8310];
+	double aPL[7982];
+	double aQL[7322];
+	double aRL[6818];
+	double aSL[6506];
+	double aTL[6002];
+	double aUL[5838];
+	double aVL[5502];
+	double aWL[5010];
+	double aXL[4850];
+	double aYL[4296];
+	double aZL[4180];
+	
+	double oAL[15150];
+	double oBL[14618];
+	double oCL[14358];
+	double oDL[13818];		
+	double oEL[13562];
+	double oFL[13046];
+	double oGL[11966];
+	double oHL[11130];
+	double oIL[10598];
+	double oJL[9810];
+	double oKL[9522];
+	double oLL[8982];
+	double oML[8786];
+	double oNL[8462];
+	double oOL[8310];
+	double oPL[7982];
+	double oQL[7322];
+	double oRL[6818];
+	double oSL[6506];
+	double oTL[6002];
+	double oUL[5838];
+	double oVL[5502];
+	double oWL[5010];
+	double oXL[4850];
+	double oYL[4296];
+	double oZL[4180];
+	
+	
+	
+	int outAL, alpAL;
+	int outBL, alpBL;
+	int outCL, alpCL;
+	int outDL, alpDL;
+	int outEL, alpEL;
+	int outFL, alpFL;
+	int outGL, alpGL;
+	int outHL, alpHL;
+	int outIL, alpIL;
+	int outJL, alpJL;
+	int outKL, alpKL;
+	int outLL, alpLL;
+	int outML, alpML;
+	int outNL, alpNL;
+	int outOL, alpOL;
+	int outPL, alpPL;
+	int outQL, alpQL;
+	int outRL, alpRL;
+	int outSL, alpSL;
+	int outTL, alpTL;
+	int outUL, alpUL;
+	int outVL, alpVL;
+	int outWL, alpWL;
+	int outXL, alpXL;
+	int outYL, alpYL;
+	int outZL, alpZL;
+	
+	int outAR, alpAR, maxdelayA, delayA;
+	int outBR, alpBR, maxdelayB, delayB;
+	int outCR, alpCR, maxdelayC, delayC;
+	int outDR, alpDR, maxdelayD, delayD;
+	int outER, alpER, maxdelayE, delayE;
+	int outFR, alpFR, maxdelayF, delayF;
+	int outGR, alpGR, maxdelayG, delayG;
+	int outHR, alpHR, maxdelayH, delayH;
+	int outIR, alpIR, maxdelayI, delayI;
+	int outJR, alpJR, maxdelayJ, delayJ;
+	int outKR, alpKR, maxdelayK, delayK;
+	int outLR, alpLR, maxdelayL, delayL;
+	int outMR, alpMR, maxdelayM, delayM;
+	int outNR, alpNR, maxdelayN, delayN;
+	int outOR, alpOR, maxdelayO, delayO;
+	int outPR, alpPR, maxdelayP, delayP;
+	int outQR, alpQR, maxdelayQ, delayQ;
+	int outRR, alpRR, maxdelayR, delayR;
+	int outSR, alpSR, maxdelayS, delayS;
+	int outTR, alpTR, maxdelayT, delayT;
+	int outUR, alpUR, maxdelayU, delayU;
+	int outVR, alpVR, maxdelayV, delayV;
+	int outWR, alpWR, maxdelayW, delayW;
+	int outXR, alpXR, maxdelayX, delayX;
+	int outYR, alpYR, maxdelayY, delayY;
+	int outZR, alpZR, maxdelayZ, delayZ;
+	
+	double savedRoomsize;
+	int countdown;
+	double peakL;
+	double peakR;
+	
+	uint32_t fpd;
+	//default stuff
+
+    float A;
+    float B;
+    float C;
+    float D;
+
+};
+
+#endif
diff --git a/plugins/WinVST/PocketVerbs/PocketVerbsProc.cpp b/plugins/WinVST/PocketVerbs/PocketVerbsProc.cpp
new file mode 100755
index 0000000..4ea8f51
--- /dev/null
+++ b/plugins/WinVST/PocketVerbs/PocketVerbsProc.cpp
@@ -0,0 +1,18358 @@
+/* ========================================
+ *  PocketVerbs - PocketVerbs.h
+ *  Copyright (c) 2016 airwindows, All rights reserved
+ * ======================================== */
+
+#ifndef __PocketVerbs_H
+#include "PocketVerbs.h"
+#endif
+
+void PocketVerbs::processReplacing(float **inputs, float **outputs, VstInt32 sampleFrames) 
+{
+    float* in1  =  inputs[0];
+    float* in2  =  inputs[1];
+    float* out1 = outputs[0];
+    float* out2 = outputs[1];
+	
+	int verbtype = (VstInt32)( A * 5.999 )+1;
+	
+	double roomsize = (pow(B,2)*1.9)+0.1;
+	
+	double release = 0.00008 * pow(C,3);
+	if (release == 0.0) {peakL = 1.0; peakR = 1.0;}
+	double wetnesstarget = D;
+	double dryness = (1.0 - wetnesstarget);
+	//verbs use base wetness value internally
+	double wetness = wetnesstarget;
+	double constallpass = 0.618033988749894848204586; //golden ratio!
+	int allpasstemp;
+	int count;
+	int max = 70; //biggest divisor to test primes against
+	double bridgerectifier;
+	double gain = 0.5+(wetnesstarget*0.5); //dryer for less verb drive
+	//used as an aux, saturates when fed high levels
+	
+	//remap values to primes input number in question is 'i'
+	//max is the largest prime we care about- HF interactions more interesting than the big numbers
+	//pushing values larger and larger until we have a result
+	//for (primetest=2; primetest <= max; primetest++) {if ( i!=primetest && i % primetest == 0 ) {i += 1; primetest=2;}}
+	
+	if (savedRoomsize != roomsize) {savedRoomsize = roomsize; countdown = 26;} //kick off the adjustment which will take 26 zippernoise refreshes to complete
+    
+	if (countdown > 0) {switch (countdown)
+		{
+			case 1:
+				delayA = (int(maxdelayA * roomsize));
+				for (count=2; count <= max; count++) {if ( delayA != count && delayA % count == 0 ) {delayA += 1; count=2;}} //try for primeish As
+				if (delayA > maxdelayA) delayA = maxdelayA; //insanitycheck
+				for(count = alpAL; count < 15149; count++) {aAL[count] = 0.0;}
+				for(count = outAL; count < 15149; count++) {oAL[count] = 0.0;}
+				break;
+				
+			case 2:
+				delayB = (int(maxdelayB * roomsize));
+				for (count=2; count <= max; count++) {if ( delayB != count && delayB % count == 0 ) {delayB += 1; count=2;}} //try for primeish Bs
+				if (delayB > maxdelayB) delayB = maxdelayB; //insanitycheck
+				for(count = alpBL; count < 14617; count++) {aBL[count] = 0.0;}
+				for(count = outBL; count < 14617; count++) {oBL[count] = 0.0;}
+				break;
+				
+			case 3:
+				delayC = (int(maxdelayC * roomsize));
+				for (count=2; count <= max; count++) {if ( delayC != count && delayC % count == 0 ) {delayC += 1; count=2;}} //try for primeish Cs
+				if (delayC > maxdelayC) delayC = maxdelayC; //insanitycheck
+				for(count = alpCL; count < 14357; count++) {aCL[count] = 0.0;}
+				for(count = outCL; count < 14357; count++) {oCL[count] = 0.0;}
+				break;
+				
+			case 4:
+				delayD = (int(maxdelayD * roomsize));
+				for (count=2; count <= max; count++) {if ( delayD != count && delayD % count == 0 ) {delayD += 1; count=2;}} //try for primeish Ds
+				if (delayD > maxdelayD) delayD = maxdelayD; //insanitycheck
+				for(count = alpDL; count < 13817; count++) {aDL[count] = 0.0;}
+				for(count = outDL; count < 13817; count++) {oDL[count] = 0.0;}
+				break;
+				
+			case 5:
+				delayE = (int(maxdelayE * roomsize));
+				for (count=2; count <= max; count++) {if ( delayE != count && delayE % count == 0 ) {delayE += 1; count=2;}} //try for primeish Es
+				if (delayE > maxdelayE) delayE = maxdelayE; //insanitycheck
+				for(count = alpEL; count < 13561; count++) {aEL[count] = 0.0;}
+				for(count = outEL; count < 13561; count++) {oEL[count] = 0.0;}
+				break;
+				
+			case 6:
+				delayF = (int(maxdelayF * roomsize));
+				for (count=2; count <= max; count++) {if ( delayF != count && delayF % count == 0 ) {delayF += 1; count=2;}} //try for primeish Fs
+				if (delayF > maxdelayF) delayF = maxdelayF; //insanitycheck
+				for(count = alpFL; count < 13045; count++) {aFL[count] = 0.0;}
+				for(count = outFL; count < 13045; count++) {oFL[count] = 0.0;}
+				break;
+				
+			case 7:
+				delayG = (int(maxdelayG * roomsize));
+				for (count=2; count <= max; count++) {if ( delayG != count && delayG % count == 0 ) {delayG += 1; count=2;}} //try for primeish Gs
+				if (delayG > maxdelayG) delayG = maxdelayG; //insanitycheck
+				for(count = alpGL; count < 11965; count++) {aGL[count] = 0.0;}
+				for(count = outGL; count < 11965; count++) {oGL[count] = 0.0;}
+				break;
+				
+			case 8:
+				delayH = (int(maxdelayH * roomsize));
+				for (count=2; count <= max; count++) {if ( delayH != count && delayH % count == 0 ) {delayH += 1; count=2;}} //try for primeish Hs
+				if (delayH > maxdelayH) delayH = maxdelayH; //insanitycheck
+				for(count = alpHL; count < 11129; count++) {aHL[count] = 0.0;}
+				for(count = outHL; count < 11129; count++) {oHL[count] = 0.0;}
+				break;
+				
+			case 9:
+				delayI = (int(maxdelayI * roomsize));
+				for (count=2; count <= max; count++) {if ( delayI != count && delayI % count == 0 ) {delayI += 1; count=2;}} //try for primeish Is
+				if (delayI > maxdelayI) delayI = maxdelayI; //insanitycheck
+				for(count = alpIL; count < 10597; count++) {aIL[count] = 0.0;}
+				for(count = outIL; count < 10597; count++) {oIL[count] = 0.0;}
+				break;
+				
+			case 10:
+				delayJ = (int(maxdelayJ * roomsize));
+				for (count=2; count <= max; count++) {if ( delayJ != count && delayJ % count == 0 ) {delayJ += 1; count=2;}} //try for primeish Js
+				if (delayJ > maxdelayJ) delayJ = maxdelayJ; //insanitycheck
+				for(count = alpJL; count < 9809; count++) {aJL[count] = 0.0;}
+				for(count = outJL; count < 9809; count++) {oJL[count] = 0.0;}
+				break;
+				
+			case 11:
+				delayK = (int(maxdelayK * roomsize));
+				for (count=2; count <= max; count++) {if ( delayK != count && delayK % count == 0 ) {delayK += 1; count=2;}} //try for primeish Ks
+				if (delayK > maxdelayK) delayK = maxdelayK; //insanitycheck
+				for(count = alpKL; count < 9521; count++) {aKL[count] = 0.0;}
+				for(count = outKL; count < 9521; count++) {oKL[count] = 0.0;}
+				break;
+				
+			case 12:
+				delayL = (int(maxdelayL * roomsize));
+				for (count=2; count <= max; count++) {if ( delayL != count && delayL % count == 0 ) {delayL += 1; count=2;}} //try for primeish Ls
+				if (delayL > maxdelayL) delayL = maxdelayL; //insanitycheck
+				for(count = alpLL; count < 8981; count++) {aLL[count] = 0.0;}
+				for(count = outLL; count < 8981; count++) {oLL[count] = 0.0;}
+				break;
+				
+			case 13:
+				delayM = (int(maxdelayM * roomsize));
+				for (count=2; count <= max; count++) {if ( delayM != count && delayM % count == 0 ) {delayM += 1; count=2;}} //try for primeish Ms
+				if (delayM > maxdelayM) delayM = maxdelayM; //insanitycheck
+				for(count = alpML; count < 8785; count++) {aML[count] = 0.0;}
+				for(count = outML; count < 8785; count++) {oML[count] = 0.0;}
+				break;
+				
+			case 14:
+				delayN = (int(maxdelayN * roomsize));
+				for (count=2; count <= max; count++) {if ( delayN != count && delayN % count == 0 ) {delayN += 1; count=2;}} //try for primeish Ns
+				if (delayN > maxdelayN) delayN = maxdelayN; //insanitycheck
+				for(count = alpNL; count < 8461; count++) {aNL[count] = 0.0;}
+				for(count = outNL; count < 8461; count++) {oNL[count] = 0.0;}
+				break;
+				
+			case 15:
+				delayO = (int(maxdelayO * roomsize));
+				for (count=2; count <= max; count++) {if ( delayO != count && delayO % count == 0 ) {delayO += 1; count=2;}} //try for primeish Os
+				if (delayO > maxdelayO) delayO = maxdelayO; //insanitycheck
+				for(count = alpOL; count < 8309; count++) {aOL[count] = 0.0;}
+				for(count = outOL; count < 8309; count++) {oOL[count] = 0.0;}
+				break;
+				
+			case 16:
+				delayP = (int(maxdelayP * roomsize));
+				for (count=2; count <= max; count++) {if ( delayP != count && delayP % count == 0 ) {delayP += 1; count=2;}} //try for primeish Ps
+				if (delayP > maxdelayP) delayP = maxdelayP; //insanitycheck
+				for(count = alpPL; count < 7981; count++) {aPL[count] = 0.0;}
+				for(count = outPL; count < 7981; count++) {oPL[count] = 0.0;}
+				break;
+				
+			case 17:
+				delayQ = (int(maxdelayQ * roomsize));
+				for (count=2; count <= max; count++) {if ( delayQ != count && delayQ % count == 0 ) {delayQ += 1; count=2;}} //try for primeish Qs
+				if (delayQ > maxdelayQ) delayQ = maxdelayQ; //insanitycheck
+				for(count = alpQL; count < 7321; count++) {aQL[count] = 0.0;}
+				for(count = outQL; count < 7321; count++) {oQL[count] = 0.0;}
+				break;
+				
+			case 18:
+				delayR = (int(maxdelayR * roomsize));
+				for (count=2; count <= max; count++) {if ( delayR != count && delayR % count == 0 ) {delayR += 1; count=2;}} //try for primeish Rs
+				if (delayR > maxdelayR) delayR = maxdelayR; //insanitycheck
+				for(count = alpRL; count < 6817; count++) {aRL[count] = 0.0;}
+				for(count = outRL; count < 6817; count++) {oRL[count] = 0.0;}
+				break;
+				
+			case 19:
+				delayS = (int(maxdelayS * roomsize));
+				for (count=2; count <= max; count++) {if ( delayS != count && delayS % count == 0 ) {delayS += 1; count=2;}} //try for primeish Ss
+				if (delayS > maxdelayS) delayS = maxdelayS; //insanitycheck
+				for(count = alpSL; count < 6505; count++) {aSL[count] = 0.0;}
+				for(count = outSL; count < 6505; count++) {oSL[count] = 0.0;}
+				break;
+				
+			case 20:
+				delayT = (int(maxdelayT * roomsize));
+				for (count=2; count <= max; count++) {if ( delayT != count && delayT % count == 0 ) {delayT += 1; count=2;}} //try for primeish Ts
+				if (delayT > maxdelayT) delayT = maxdelayT; //insanitycheck
+				for(count = alpTL; count < 6001; count++) {aTL[count] = 0.0;}
+				for(count = outTL; count < 6001; count++) {oTL[count] = 0.0;}
+				break;
+				
+			case 21:
+				delayU = (int(maxdelayU * roomsize));
+				for (count=2; count <= max; count++) {if ( delayU != count && delayU % count == 0 ) {delayU += 1; count=2;}} //try for primeish Us
+				if (delayU > maxdelayU) delayU = maxdelayU; //insanitycheck
+				for(count = alpUL; count < 5837; count++) {aUL[count] = 0.0;}
+				for(count = outUL; count < 5837; count++) {oUL[count] = 0.0;}
+				break;
+				
+			case 22:
+				delayV = (int(maxdelayV * roomsize));
+				for (count=2; count <= max; count++) {if ( delayV != count && delayV % count == 0 ) {delayV += 1; count=2;}} //try for primeish Vs
+				if (delayV > maxdelayV) delayV = maxdelayV; //insanitycheck
+				for(count = alpVL; count < 5501; count++) {aVL[count] = 0.0;}
+				for(count = outVL; count < 5501; count++) {oVL[count] = 0.0;}
+				break;
+				
+			case 23:
+				delayW = (int(maxdelayW * roomsize));
+				for (count=2; count <= max; count++) {if ( delayW != count && delayW % count == 0 ) {delayW += 1; count=2;}} //try for primeish Ws
+				if (delayW > maxdelayW) delayW = maxdelayW; //insanitycheck
+				for(count = alpWL; count < 5009; count++) {aWL[count] = 0.0;}
+				for(count = outWL; count < 5009; count++) {oWL[count] = 0.0;}
+				break;
+				
+			case 24:
+				delayX = (int(maxdelayX * roomsize));
+				for (count=2; count <= max; count++) {if ( delayX != count && delayX % count == 0 ) {delayX += 1; count=2;}} //try for primeish Xs
+				if (delayX > maxdelayX) delayX = maxdelayX; //insanitycheck
+				for(count = alpXL; count < 4849; count++) {aXL[count] = 0.0;}
+				for(count = outXL; count < 4849; count++) {oXL[count] = 0.0;}
+				break;
+				
+			case 25:
+				delayY = (int(maxdelayY * roomsize));
+				for (count=2; count <= max; count++) {if ( delayY != count && delayY % count == 0 ) {delayY += 1; count=2;}} //try for primeish Ys
+				if (delayY > maxdelayY) delayY = maxdelayY; //insanitycheck
+				for(count = alpYL; count < 4295; count++) {aYL[count] = 0.0;}
+				for(count = outYL; count < 4295; count++) {oYL[count] = 0.0;}
+				break;
+				
+			case 26:
+				delayZ = (int(maxdelayZ * roomsize));
+				for (count=2; count <= max; count++) {if ( delayZ != count && delayZ % count == 0 ) {delayZ += 1; count=2;}} //try for primeish Zs
+				if (delayZ > maxdelayZ) delayZ = maxdelayZ; //insanitycheck
+				for(count = alpZL; count < 4179; count++) {aZL[count] = 0.0;}	
+				for(count = outZL; count < 4179; count++) {oZL[count] = 0.0;}
+				break;
+		} //end of switch statement
+		//countdown--; we are doing this after the second one
+	}
+	
+	if (countdown > 0) {switch (countdown)
+		{
+			case 1:
+				delayA = (int(maxdelayA * roomsize));
+				for (count=2; count <= max; count++) {if ( delayA != count && delayA % count == 0 ) {delayA += 1; count=2;}} //try for primeish As
+				if (delayA > maxdelayA) delayA = maxdelayA; //insanitycheck
+				for(count = alpAR; count < 15149; count++) {aAR[count] = 0.0;}
+				for(count = outAR; count < 15149; count++) {oAR[count] = 0.0;}
+				break;
+				
+			case 2:
+				delayB = (int(maxdelayB * roomsize));
+				for (count=2; count <= max; count++) {if ( delayB != count && delayB % count == 0 ) {delayB += 1; count=2;}} //try for primeish Bs
+				if (delayB > maxdelayB) delayB = maxdelayB; //insanitycheck
+				for(count = alpBR; count < 14617; count++) {aBR[count] = 0.0;}
+				for(count = outBR; count < 14617; count++) {oBR[count] = 0.0;}
+				break;
+				
+			case 3:
+				delayC = (int(maxdelayC * roomsize));
+				for (count=2; count <= max; count++) {if ( delayC != count && delayC % count == 0 ) {delayC += 1; count=2;}} //try for primeish Cs
+				if (delayC > maxdelayC) delayC = maxdelayC; //insanitycheck
+				for(count = alpCR; count < 14357; count++) {aCR[count] = 0.0;}
+				for(count = outCR; count < 14357; count++) {oCR[count] = 0.0;}
+				break;
+				
+			case 4:
+				delayD = (int(maxdelayD * roomsize));
+				for (count=2; count <= max; count++) {if ( delayD != count && delayD % count == 0 ) {delayD += 1; count=2;}} //try for primeish Ds
+				if (delayD > maxdelayD) delayD = maxdelayD; //insanitycheck
+				for(count = alpDR; count < 13817; count++) {aDR[count] = 0.0;}
+				for(count = outDR; count < 13817; count++) {oDR[count] = 0.0;}
+				break;
+				
+			case 5:
+				delayE = (int(maxdelayE * roomsize));
+				for (count=2; count <= max; count++) {if ( delayE != count && delayE % count == 0 ) {delayE += 1; count=2;}} //try for primeish Es
+				if (delayE > maxdelayE) delayE = maxdelayE; //insanitycheck
+				for(count = alpER; count < 13561; count++) {aER[count] = 0.0;}
+				for(count = outER; count < 13561; count++) {oER[count] = 0.0;}
+				break;
+				
+			case 6:
+				delayF = (int(maxdelayF * roomsize));
+				for (count=2; count <= max; count++) {if ( delayF != count && delayF % count == 0 ) {delayF += 1; count=2;}} //try for primeish Fs
+				if (delayF > maxdelayF) delayF = maxdelayF; //insanitycheck
+				for(count = alpFR; count < 13045; count++) {aFR[count] = 0.0;}
+				for(count = outFR; count < 13045; count++) {oFR[count] = 0.0;}
+				break;
+				
+			case 7:
+				delayG = (int(maxdelayG * roomsize));
+				for (count=2; count <= max; count++) {if ( delayG != count && delayG % count == 0 ) {delayG += 1; count=2;}} //try for primeish Gs
+				if (delayG > maxdelayG) delayG = maxdelayG; //insanitycheck
+				for(count = alpGR; count < 11965; count++) {aGR[count] = 0.0;}
+				for(count = outGR; count < 11965; count++) {oGR[count] = 0.0;}
+				break;
+				
+			case 8:
+				delayH = (int(maxdelayH * roomsize));
+				for (count=2; count <= max; count++) {if ( delayH != count && delayH % count == 0 ) {delayH += 1; count=2;}} //try for primeish Hs
+				if (delayH > maxdelayH) delayH = maxdelayH; //insanitycheck
+				for(count = alpHR; count < 11129; count++) {aHR[count] = 0.0;}
+				for(count = outHR; count < 11129; count++) {oHR[count] = 0.0;}
+				break;
+				
+			case 9:
+				delayI = (int(maxdelayI * roomsize));
+				for (count=2; count <= max; count++) {if ( delayI != count && delayI % count == 0 ) {delayI += 1; count=2;}} //try for primeish Is
+				if (delayI > maxdelayI) delayI = maxdelayI; //insanitycheck
+				for(count = alpIR; count < 10597; count++) {aIR[count] = 0.0;}
+				for(count = outIR; count < 10597; count++) {oIR[count] = 0.0;}
+				break;
+				
+			case 10:
+				delayJ = (int(maxdelayJ * roomsize));
+				for (count=2; count <= max; count++) {if ( delayJ != count && delayJ % count == 0 ) {delayJ += 1; count=2;}} //try for primeish Js
+				if (delayJ > maxdelayJ) delayJ = maxdelayJ; //insanitycheck
+				for(count = alpJR; count < 9809; count++) {aJR[count] = 0.0;}
+				for(count = outJR; count < 9809; count++) {oJR[count] = 0.0;}
+				break;
+				
+			case 11:
+				delayK = (int(maxdelayK * roomsize));
+				for (count=2; count <= max; count++) {if ( delayK != count && delayK % count == 0 ) {delayK += 1; count=2;}} //try for primeish Ks
+				if (delayK > maxdelayK) delayK = maxdelayK; //insanitycheck
+				for(count = alpKR; count < 9521; count++) {aKR[count] = 0.0;}
+				for(count = outKR; count < 9521; count++) {oKR[count] = 0.0;}
+				break;
+				
+			case 12:
+				delayL = (int(maxdelayL * roomsize));
+				for (count=2; count <= max; count++) {if ( delayL != count && delayL % count == 0 ) {delayL += 1; count=2;}} //try for primeish Ls
+				if (delayL > maxdelayL) delayL = maxdelayL; //insanitycheck
+				for(count = alpLR; count < 8981; count++) {aLR[count] = 0.0;}
+				for(count = outLR; count < 8981; count++) {oLR[count] = 0.0;}
+				break;
+				
+			case 13:
+				delayM = (int(maxdelayM * roomsize));
+				for (count=2; count <= max; count++) {if ( delayM != count && delayM % count == 0 ) {delayM += 1; count=2;}} //try for primeish Ms
+				if (delayM > maxdelayM) delayM = maxdelayM; //insanitycheck
+				for(count = alpMR; count < 8785; count++) {aMR[count] = 0.0;}
+				for(count = outMR; count < 8785; count++) {oMR[count] = 0.0;}
+				break;
+				
+			case 14:
+				delayN = (int(maxdelayN * roomsize));
+				for (count=2; count <= max; count++) {if ( delayN != count && delayN % count == 0 ) {delayN += 1; count=2;}} //try for primeish Ns
+				if (delayN > maxdelayN) delayN = maxdelayN; //insanitycheck
+				for(count = alpNR; count < 8461; count++) {aNR[count] = 0.0;}
+				for(count = outNR; count < 8461; count++) {oNR[count] = 0.0;}
+				break;
+				
+			case 15:
+				delayO = (int(maxdelayO * roomsize));
+				for (count=2; count <= max; count++) {if ( delayO != count && delayO % count == 0 ) {delayO += 1; count=2;}} //try for primeish Os
+				if (delayO > maxdelayO) delayO = maxdelayO; //insanitycheck
+				for(count = alpOR; count < 8309; count++) {aOR[count] = 0.0;}
+				for(count = outOR; count < 8309; count++) {oOR[count] = 0.0;}
+				break;
+				
+			case 16:
+				delayP = (int(maxdelayP * roomsize));
+				for (count=2; count <= max; count++) {if ( delayP != count && delayP % count == 0 ) {delayP += 1; count=2;}} //try for primeish Ps
+				if (delayP > maxdelayP) delayP = maxdelayP; //insanitycheck
+				for(count = alpPR; count < 7981; count++) {aPR[count] = 0.0;}
+				for(count = outPR; count < 7981; count++) {oPR[count] = 0.0;}
+				break;
+				
+			case 17:
+				delayQ = (int(maxdelayQ * roomsize));
+				for (count=2; count <= max; count++) {if ( delayQ != count && delayQ % count == 0 ) {delayQ += 1; count=2;}} //try for primeish Qs
+				if (delayQ > maxdelayQ) delayQ = maxdelayQ; //insanitycheck
+				for(count = alpQR; count < 7321; count++) {aQR[count] = 0.0;}
+				for(count = outQR; count < 7321; count++) {oQR[count] = 0.0;}
+				break;
+				
+			case 18:
+				delayR = (int(maxdelayR * roomsize));
+				for (count=2; count <= max; count++) {if ( delayR != count && delayR % count == 0 ) {delayR += 1; count=2;}} //try for primeish Rs
+				if (delayR > maxdelayR) delayR = maxdelayR; //insanitycheck
+				for(count = alpRR; count < 6817; count++) {aRR[count] = 0.0;}
+				for(count = outRR; count < 6817; count++) {oRR[count] = 0.0;}
+				break;
+				
+			case 19:
+				delayS = (int(maxdelayS * roomsize));
+				for (count=2; count <= max; count++) {if ( delayS != count && delayS % count == 0 ) {delayS += 1; count=2;}} //try for primeish Ss
+				if (delayS > maxdelayS) delayS = maxdelayS; //insanitycheck
+				for(count = alpSR; count < 6505; count++) {aSR[count] = 0.0;}
+				for(count = outSR; count < 6505; count++) {oSR[count] = 0.0;}
+				break;
+				
+			case 20:
+				delayT = (int(maxdelayT * roomsize));
+				for (count=2; count <= max; count++) {if ( delayT != count && delayT % count == 0 ) {delayT += 1; count=2;}} //try for primeish Ts
+				if (delayT > maxdelayT) delayT = maxdelayT; //insanitycheck
+				for(count = alpTR; count < 6001; count++) {aTR[count] = 0.0;}
+				for(count = outTR; count < 6001; count++) {oTR[count] = 0.0;}
+				break;
+				
+			case 21:
+				delayU = (int(maxdelayU * roomsize));
+				for (count=2; count <= max; count++) {if ( delayU != count && delayU % count == 0 ) {delayU += 1; count=2;}} //try for primeish Us
+				if (delayU > maxdelayU) delayU = maxdelayU; //insanitycheck
+				for(count = alpUR; count < 5837; count++) {aUR[count] = 0.0;}
+				for(count = outUR; count < 5837; count++) {oUR[count] = 0.0;}
+				break;
+				
+			case 22:
+				delayV = (int(maxdelayV * roomsize));
+				for (count=2; count <= max; count++) {if ( delayV != count && delayV % count == 0 ) {delayV += 1; count=2;}} //try for primeish Vs
+				if (delayV > maxdelayV) delayV = maxdelayV; //insanitycheck
+				for(count = alpVR; count < 5501; count++) {aVR[count] = 0.0;}
+				for(count = outVR; count < 5501; count++) {oVR[count] = 0.0;}
+				break;
+				
+			case 23:
+				delayW = (int(maxdelayW * roomsize));
+				for (count=2; count <= max; count++) {if ( delayW != count && delayW % count == 0 ) {delayW += 1; count=2;}} //try for primeish Ws
+				if (delayW > maxdelayW) delayW = maxdelayW; //insanitycheck
+				for(count = alpWR; count < 5009; count++) {aWR[count] = 0.0;}
+				for(count = outWR; count < 5009; count++) {oWR[count] = 0.0;}
+				break;
+				
+			case 24:
+				delayX = (int(maxdelayX * roomsize));
+				for (count=2; count <= max; count++) {if ( delayX != count && delayX % count == 0 ) {delayX += 1; count=2;}} //try for primeish Xs
+				if (delayX > maxdelayX) delayX = maxdelayX; //insanitycheck
+				for(count = alpXR; count < 4849; count++) {aXR[count] = 0.0;}
+				for(count = outXR; count < 4849; count++) {oXR[count] = 0.0;}
+				break;
+				
+			case 25:
+				delayY = (int(maxdelayY * roomsize));
+				for (count=2; count <= max; count++) {if ( delayY != count && delayY % count == 0 ) {delayY += 1; count=2;}} //try for primeish Ys
+				if (delayY > maxdelayY) delayY = maxdelayY; //insanitycheck
+				for(count = alpYR; count < 4295; count++) {aYR[count] = 0.0;}
+				for(count = outYR; count < 4295; count++) {oYR[count] = 0.0;}
+				break;
+				
+			case 26:
+				delayZ = (int(maxdelayZ * roomsize));
+				for (count=2; count <= max; count++) {if ( delayZ != count && delayZ % count == 0 ) {delayZ += 1; count=2;}} //try for primeish Zs
+				if (delayZ > maxdelayZ) delayZ = maxdelayZ; //insanitycheck
+				for(count = alpZR; count < 4179; count++) {aZR[count] = 0.0;}	
+				for(count = outZR; count < 4179; count++) {oZR[count] = 0.0;}
+				break;
+		} //end of switch statement
+		countdown--; //every buffer we'll do one of the recalculations for prime buffer sizes
+	}
+	
+	
+	
+    while (--sampleFrames >= 0)
+    {
+		long double inputSampleL = *in1;
+		long double inputSampleR = *in2;
+		
+		if (fabs(inputSampleL)<1.18e-37) inputSampleL = fpd * 1.18e-37;
+		if (fabs(inputSampleR)<1.18e-37) inputSampleR = fpd * 1.18e-37;
+		
+		long double drySampleL = inputSampleL;
+		long double drySampleR = inputSampleR;
+		
+		peakL -= release;
+		if (peakL < fabs(inputSampleL*2.0)) peakL = fabs(inputSampleL*2.0);
+		if (peakL > 1.0) peakL = 1.0;
+		peakR -= release;
+		if (peakR < fabs(inputSampleR*2.0)) peakR = fabs(inputSampleR*2.0);
+		if (peakR > 1.0) peakR = 1.0;
+		//chase the maximum signal to incorporate the wetter/louder behavior
+		//boost for more extreme effect when in use, cap it
+		
+		inputSampleL *= gain;
+		bridgerectifier = fabs(inputSampleL);
+		bridgerectifier = sin(bridgerectifier);
+		if (inputSampleL > 0) inputSampleL = bridgerectifier;
+		else inputSampleL = -bridgerectifier;
+		inputSampleR *= gain;
+		bridgerectifier = fabs(inputSampleR);
+		bridgerectifier = sin(bridgerectifier);
+		if (inputSampleR > 0) inputSampleR = bridgerectifier;
+		else inputSampleR = -bridgerectifier;
+		//here we apply the ADT2 console-on-steroids trick		
+		
+		
+		
+		
+		
+		switch (verbtype)
+		{
+				
+				
+			case 1://Chamber
+				allpasstemp = alpAL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;}
+				inputSampleL -= aAL[allpasstemp]*constallpass;
+				aAL[alpAL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpAL--; if (alpAL < 0 || alpAL > delayA) {alpAL = delayA;}
+				inputSampleL += (aAL[alpAL]);
+				//allpass filter A		
+				
+				dAL[3] = dAL[2];
+				dAL[2] = dAL[1];
+				dAL[1] = inputSampleL;
+				inputSampleL = (dAL[1] + dAL[2] + dAL[3])/3.0;
+				
+				allpasstemp = alpBL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;}
+				inputSampleL -= aBL[allpasstemp]*constallpass;
+				aBL[alpBL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpBL--; if (alpBL < 0 || alpBL > delayB) {alpBL = delayB;}
+				inputSampleL += (aBL[alpBL]);
+				//allpass filter B
+				
+				dBL[3] = dBL[2];
+				dBL[2] = dBL[1];
+				dBL[1] = inputSampleL;
+				inputSampleL = (dBL[1] + dBL[2] + dBL[3])/3.0;
+				
+				allpasstemp = alpCL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;}
+				inputSampleL -= aCL[allpasstemp]*constallpass;
+				aCL[alpCL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpCL--; if (alpCL < 0 || alpCL > delayC) {alpCL = delayC;}
+				inputSampleL += (aCL[alpCL]);
+				//allpass filter C
+				
+				dCL[3] = dCL[2];
+				dCL[2] = dCL[1];
+				dCL[1] = inputSampleL;
+				inputSampleL = (dAL[1] + dCL[2] + dCL[3])/3.0;
+				
+				allpasstemp = alpDL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;}
+				inputSampleL -= aDL[allpasstemp]*constallpass;
+				aDL[alpDL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpDL--; if (alpDL < 0 || alpDL > delayD) {alpDL = delayD;}
+				inputSampleL += (aDL[alpDL]);
+				//allpass filter D
+				
+				dDL[3] = dDL[2];
+				dDL[2] = dDL[1];
+				dDL[1] = inputSampleL;
+				inputSampleL = (dDL[1] + dDL[2] + dDL[3])/3.0;
+				
+				allpasstemp = alpEL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;}
+				inputSampleL -= aEL[allpasstemp]*constallpass;
+				aEL[alpEL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpEL--; if (alpEL < 0 || alpEL > delayE) {alpEL = delayE;}
+				inputSampleL += (aEL[alpEL]);
+				//allpass filter E
+				
+				dEL[3] = dEL[2];
+				dEL[2] = dEL[1];
+				dEL[1] = inputSampleL;
+				inputSampleL = (dAL[1] + dEL[2] + dEL[3])/3.0;
+				
+				allpasstemp = alpFL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;}
+				inputSampleL -= aFL[allpasstemp]*constallpass;
+				aFL[alpFL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpFL--; if (alpFL < 0 || alpFL > delayF) {alpFL = delayF;}
+				inputSampleL += (aFL[alpFL]);
+				//allpass filter F
+				
+				dFL[3] = dFL[2];
+				dFL[2] = dFL[1];
+				dFL[1] = inputSampleL;
+				inputSampleL = (dFL[1] + dFL[2] + dFL[3])/3.0;
+				
+				allpasstemp = alpGL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;}
+				inputSampleL -= aGL[allpasstemp]*constallpass;
+				aGL[alpGL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpGL--; if (alpGL < 0 || alpGL > delayG) {alpGL = delayG;}
+				inputSampleL += (aGL[alpGL]);
+				//allpass filter G
+				
+				dGL[3] = dGL[2];
+				dGL[2] = dGL[1];
+				dGL[1] = inputSampleL;
+				inputSampleL = (dAL[1] + dGL[2] + dGL[3])/3.0;
+				
+				allpasstemp = alpHL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;}
+				inputSampleL -= aHL[allpasstemp]*constallpass;
+				aHL[alpHL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpHL--; if (alpHL < 0 || alpHL > delayH) {alpHL = delayH;}
+				inputSampleL += (aHL[alpHL]);
+				//allpass filter H
+				
+				dHL[3] = dHL[2];
+				dHL[2] = dHL[1];
+				dHL[1] = inputSampleL;
+				inputSampleL = (dHL[1] + dHL[2] + dHL[3])/3.0;
+				
+				allpasstemp = alpIL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;}
+				inputSampleL -= aIL[allpasstemp]*constallpass;
+				aIL[alpIL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpIL--; if (alpIL < 0 || alpIL > delayI) {alpIL = delayI;}
+				inputSampleL += (aIL[alpIL]);
+				//allpass filter I
+				
+				dIL[3] = dIL[2];
+				dIL[2] = dIL[1];
+				dIL[1] = inputSampleL;
+				inputSampleL = (dIL[1] + dIL[2] + dIL[3])/3.0;
+				
+				allpasstemp = alpJL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;}
+				inputSampleL -= aJL[allpasstemp]*constallpass;
+				aJL[alpJL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpJL--; if (alpJL < 0 || alpJL > delayJ) {alpJL = delayJ;}
+				inputSampleL += (aJL[alpJL]);
+				//allpass filter J
+				
+				dJL[3] = dJL[2];
+				dJL[2] = dJL[1];
+				dJL[1] = inputSampleL;
+				inputSampleL = (dJL[1] + dJL[2] + dJL[3])/3.0;
+				
+				allpasstemp = alpKL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;}
+				inputSampleL -= aKL[allpasstemp]*constallpass;
+				aKL[alpKL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpKL--; if (alpKL < 0 || alpKL > delayK) {alpKL = delayK;}
+				inputSampleL += (aKL[alpKL]);
+				//allpass filter K
+				
+				dKL[3] = dKL[2];
+				dKL[2] = dKL[1];
+				dKL[1] = inputSampleL;
+				inputSampleL = (dAL[1] + dKL[2] + dKL[3])/3.0;
+				
+				allpasstemp = alpLL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;}
+				inputSampleL -= aLL[allpasstemp]*constallpass;
+				aLL[alpLL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpLL--; if (alpLL < 0 || alpLL > delayL) {alpLL = delayL;}
+				inputSampleL += (aLL[alpLL]);
+				//allpass filter L
+				
+				dLL[3] = dLL[2];
+				dLL[2] = dLL[1];
+				dLL[1] = inputSampleL;
+				inputSampleL = (dLL[1] + dLL[2] + dLL[3])/3.0;
+				
+				allpasstemp = alpML - 1;
+				if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;}
+				inputSampleL -= aML[allpasstemp]*constallpass;
+				aML[alpML] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpML--; if (alpML < 0 || alpML > delayM) {alpML = delayM;}
+				inputSampleL += (aML[alpML]);
+				//allpass filter M
+				
+				dML[3] = dML[2];
+				dML[2] = dML[1];
+				dML[1] = inputSampleL;
+				inputSampleL = (dAL[1] + dML[2] + dML[3])/3.0;
+				
+				allpasstemp = alpNL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;}
+				inputSampleL -= aNL[allpasstemp]*constallpass;
+				aNL[alpNL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpNL--; if (alpNL < 0 || alpNL > delayN) {alpNL = delayN;}
+				inputSampleL += (aNL[alpNL]);
+				//allpass filter N
+				
+				dNL[3] = dNL[2];
+				dNL[2] = dNL[1];
+				dNL[1] = inputSampleL;
+				inputSampleL = (dNL[1] + dNL[2] + dNL[3])/3.0;
+				
+				allpasstemp = alpOL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;}
+				inputSampleL -= aOL[allpasstemp]*constallpass;
+				aOL[alpOL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpOL--; if (alpOL < 0 || alpOL > delayO) {alpOL = delayO;}
+				inputSampleL += (aOL[alpOL]);
+				//allpass filter O
+				
+				dOL[3] = dOL[2];
+				dOL[2] = dOL[1];
+				dOL[1] = inputSampleL;
+				inputSampleL = (dOL[1] + dOL[2] + dOL[3])/3.0;
+				
+				allpasstemp = alpPL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;}
+				inputSampleL -= aPL[allpasstemp]*constallpass;
+				aPL[alpPL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpPL--; if (alpPL < 0 || alpPL > delayP) {alpPL = delayP;}
+				inputSampleL += (aPL[alpPL]);
+				//allpass filter P
+				
+				dPL[3] = dPL[2];
+				dPL[2] = dPL[1];
+				dPL[1] = inputSampleL;
+				inputSampleL = (dPL[1] + dPL[2] + dPL[3])/3.0;
+				
+				allpasstemp = alpQL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;}
+				inputSampleL -= aQL[allpasstemp]*constallpass;
+				aQL[alpQL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpQL--; if (alpQL < 0 || alpQL > delayQ) {alpQL = delayQ;}
+				inputSampleL += (aQL[alpQL]);
+				//allpass filter Q
+				
+				dQL[3] = dQL[2];
+				dQL[2] = dQL[1];
+				dQL[1] = inputSampleL;
+				inputSampleL = (dAL[1] + dQL[2] + dQL[3])/3.0;
+				
+				allpasstemp = alpRL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;}
+				inputSampleL -= aRL[allpasstemp]*constallpass;
+				aRL[alpRL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpRL--; if (alpRL < 0 || alpRL > delayR) {alpRL = delayR;}
+				inputSampleL += (aRL[alpRL]);
+				//allpass filter R
+				
+				dRL[3] = dRL[2];
+				dRL[2] = dRL[1];
+				dRL[1] = inputSampleL;
+				inputSampleL = (dRL[1] + dRL[2] + dRL[3])/3.0;
+				
+				allpasstemp = alpSL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;}
+				inputSampleL -= aSL[allpasstemp]*constallpass;
+				aSL[alpSL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpSL--; if (alpSL < 0 || alpSL > delayS) {alpSL = delayS;}
+				inputSampleL += (aSL[alpSL]);
+				//allpass filter S
+				
+				dSL[3] = dSL[2];
+				dSL[2] = dSL[1];
+				dSL[1] = inputSampleL;
+				inputSampleL = (dAL[1] + dSL[2] + dSL[3])/3.0;
+				
+				allpasstemp = alpTL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;}
+				inputSampleL -= aTL[allpasstemp]*constallpass;
+				aTL[alpTL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpTL--; if (alpTL < 0 || alpTL > delayT) {alpTL = delayT;}
+				inputSampleL += (aTL[alpTL]);
+				//allpass filter T
+				
+				dTL[3] = dTL[2];
+				dTL[2] = dTL[1];
+				dTL[1] = inputSampleL;
+				inputSampleL = (dTL[1] + dTL[2] + dTL[3])/3.0;
+				
+				allpasstemp = alpUL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;}
+				inputSampleL -= aUL[allpasstemp]*constallpass;
+				aUL[alpUL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpUL--; if (alpUL < 0 || alpUL > delayU) {alpUL = delayU;}
+				inputSampleL += (aUL[alpUL]);
+				//allpass filter U
+				
+				dUL[3] = dUL[2];
+				dUL[2] = dUL[1];
+				dUL[1] = inputSampleL;
+				inputSampleL = (dUL[1] + dUL[2] + dUL[3])/3.0;
+				
+				allpasstemp = alpVL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;}
+				inputSampleL -= aVL[allpasstemp]*constallpass;
+				aVL[alpVL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpVL--; if (alpVL < 0 || alpVL > delayV) {alpVL = delayV;}
+				inputSampleL += (aVL[alpVL]);
+				//allpass filter V
+				
+				dVL[3] = dVL[2];
+				dVL[2] = dVL[1];
+				dVL[1] = inputSampleL;
+				inputSampleL = (dVL[1] + dVL[2] + dVL[3])/3.0;
+				
+				allpasstemp = alpWL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;}
+				inputSampleL -= aWL[allpasstemp]*constallpass;
+				aWL[alpWL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpWL--; if (alpWL < 0 || alpWL > delayW) {alpWL = delayW;}
+				inputSampleL += (aWL[alpWL]);
+				//allpass filter W
+				
+				dWL[3] = dWL[2];
+				dWL[2] = dWL[1];
+				dWL[1] = inputSampleL;
+				inputSampleL = (dAL[1] + dWL[2] + dWL[3])/3.0;
+				
+				allpasstemp = alpXL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;}
+				inputSampleL -= aXL[allpasstemp]*constallpass;
+				aXL[alpXL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpXL--; if (alpXL < 0 || alpXL > delayX) {alpXL = delayX;}
+				inputSampleL += (aXL[alpXL]);
+				//allpass filter X
+				
+				dXL[3] = dXL[2];
+				dXL[2] = dXL[1];
+				dXL[1] = inputSampleL;
+				inputSampleL = (dXL[1] + dXL[2] + dXL[3])/3.0;
+				
+				allpasstemp = alpYL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;}
+				inputSampleL -= aYL[allpasstemp]*constallpass;
+				aYL[alpYL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpYL--; if (alpYL < 0 || alpYL > delayY) {alpYL = delayY;}
+				inputSampleL += (aYL[alpYL]);
+				//allpass filter Y
+				
+				dYL[3] = dYL[2];
+				dYL[2] = dYL[1];
+				dYL[1] = inputSampleL;
+				inputSampleL = (dYL[1] + dYL[2] + dYL[3])/3.0;
+				
+				allpasstemp = alpZL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;}
+				inputSampleL -= aZL[allpasstemp]*constallpass;
+				aZL[alpZL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpZL--; if (alpZL < 0 || alpZL > delayZ) {alpZL = delayZ;}
+				inputSampleL += (aZL[alpZL]);
+				//allpass filter Z
+				
+				dZL[3] = dZL[2];
+				dZL[2] = dZL[1];
+				dZL[1] = inputSampleL;
+				inputSampleL = (dZL[1] + dZL[2] + dZL[3])/3.0;
+				
+				// now the second stage using the 'out' bank of allpasses		
+				
+				allpasstemp = outAL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;}
+				inputSampleL -= oAL[allpasstemp]*constallpass;
+				oAL[outAL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outAL--; if (outAL < 0 || outAL > delayA) {outAL = delayA;}
+				inputSampleL += (oAL[outAL]);
+				//allpass filter A		
+				
+				dAL[6] = dAL[5];
+				dAL[5] = dAL[4];
+				dAL[4] = inputSampleL;
+				inputSampleL = (dAL[4] + dAL[5] + dAL[6])/3.0;
+				
+				allpasstemp = outBL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;}
+				inputSampleL -= oBL[allpasstemp]*constallpass;
+				oBL[outBL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outBL--; if (outBL < 0 || outBL > delayB) {outBL = delayB;}
+				inputSampleL += (oBL[outBL]);
+				//allpass filter B
+				
+				dBL[6] = dBL[5];
+				dBL[5] = dBL[4];
+				dBL[4] = inputSampleL;
+				inputSampleL = (dBL[4] + dBL[5] + dBL[6])/3.0;
+				
+				allpasstemp = outCL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;}
+				inputSampleL -= oCL[allpasstemp]*constallpass;
+				oCL[outCL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outCL--; if (outCL < 0 || outCL > delayC) {outCL = delayC;}
+				inputSampleL += (oCL[outCL]);
+				//allpass filter C
+				
+				dCL[6] = dCL[5];
+				dCL[5] = dCL[4];
+				dCL[4] = inputSampleL;
+				inputSampleL = (dAL[1] + dCL[5] + dCL[6])/3.0;
+				
+				allpasstemp = outDL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;}
+				inputSampleL -= oDL[allpasstemp]*constallpass;
+				oDL[outDL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outDL--; if (outDL < 0 || outDL > delayD) {outDL = delayD;}
+				inputSampleL += (oDL[outDL]);
+				//allpass filter D
+				
+				dDL[6] = dDL[5];
+				dDL[5] = dDL[4];
+				dDL[4] = inputSampleL;
+				inputSampleL = (dDL[4] + dDL[5] + dDL[6])/3.0;
+				
+				allpasstemp = outEL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;}
+				inputSampleL -= oEL[allpasstemp]*constallpass;
+				oEL[outEL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outEL--; if (outEL < 0 || outEL > delayE) {outEL = delayE;}
+				inputSampleL += (oEL[outEL]);
+				//allpass filter E
+				
+				dEL[6] = dEL[5];
+				dEL[5] = dEL[4];
+				dEL[4] = inputSampleL;
+				inputSampleL = (dAL[1] + dEL[5] + dEL[6])/3.0;
+				
+				allpasstemp = outFL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;}
+				inputSampleL -= oFL[allpasstemp]*constallpass;
+				oFL[outFL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outFL--; if (outFL < 0 || outFL > delayF) {outFL = delayF;}
+				inputSampleL += (oFL[outFL]);
+				//allpass filter F
+				
+				dFL[6] = dFL[5];
+				dFL[5] = dFL[4];
+				dFL[4] = inputSampleL;
+				inputSampleL = (dFL[4] + dFL[5] + dFL[6])/3.0;
+				
+				allpasstemp = outGL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;}
+				inputSampleL -= oGL[allpasstemp]*constallpass;
+				oGL[outGL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outGL--; if (outGL < 0 || outGL > delayG) {outGL = delayG;}
+				inputSampleL += (oGL[outGL]);
+				//allpass filter G
+				
+				dGL[6] = dGL[5];
+				dGL[5] = dGL[4];
+				dGL[4] = inputSampleL;
+				inputSampleL = (dGL[4] + dGL[5] + dGL[6])/3.0;
+				
+				allpasstemp = outHL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;}
+				inputSampleL -= oHL[allpasstemp]*constallpass;
+				oHL[outHL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outHL--; if (outHL < 0 || outHL > delayH) {outHL = delayH;}
+				inputSampleL += (oHL[outHL]);
+				//allpass filter H
+				
+				dHL[6] = dHL[5];
+				dHL[5] = dHL[4];
+				dHL[4] = inputSampleL;
+				inputSampleL = (dHL[4] + dHL[5] + dHL[6])/3.0;
+				
+				allpasstemp = outIL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;}
+				inputSampleL -= oIL[allpasstemp]*constallpass;
+				oIL[outIL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outIL--; if (outIL < 0 || outIL > delayI) {outIL = delayI;}
+				inputSampleL += (oIL[outIL]);
+				//allpass filter I
+				
+				dIL[6] = dIL[5];
+				dIL[5] = dIL[4];
+				dIL[4] = inputSampleL;
+				inputSampleL = (dIL[4] + dIL[5] + dIL[6])/3.0;
+				
+				allpasstemp = outJL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;}
+				inputSampleL -= oJL[allpasstemp]*constallpass;
+				oJL[outJL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outJL--; if (outJL < 0 || outJL > delayJ) {outJL = delayJ;}
+				inputSampleL += (oJL[outJL]);
+				//allpass filter J
+				
+				dJL[6] = dJL[5];
+				dJL[5] = dJL[4];
+				dJL[4] = inputSampleL;
+				inputSampleL = (dJL[4] + dJL[5] + dJL[6])/3.0;
+				
+				allpasstemp = outKL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;}
+				inputSampleL -= oKL[allpasstemp]*constallpass;
+				oKL[outKL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outKL--; if (outKL < 0 || outKL > delayK) {outKL = delayK;}
+				inputSampleL += (oKL[outKL]);
+				//allpass filter K
+				
+				dKL[6] = dKL[5];
+				dKL[5] = dKL[4];
+				dKL[4] = inputSampleL;
+				inputSampleL = (dAL[1] + dKL[5] + dKL[6])/3.0;
+				
+				allpasstemp = outLL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;}
+				inputSampleL -= oLL[allpasstemp]*constallpass;
+				oLL[outLL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outLL--; if (outLL < 0 || outLL > delayL) {outLL = delayL;}
+				inputSampleL += (oLL[outLL]);
+				//allpass filter L
+				
+				dLL[6] = dLL[5];
+				dLL[5] = dLL[4];
+				dLL[4] = inputSampleL;
+				inputSampleL = (dLL[4] + dLL[5] + dLL[6])/3.0;
+				
+				allpasstemp = outML - 1;
+				if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;}
+				inputSampleL -= oML[allpasstemp]*constallpass;
+				oML[outML] = inputSampleL;
+				inputSampleL *= constallpass;
+				outML--; if (outML < 0 || outML > delayM) {outML = delayM;}
+				inputSampleL += (oML[outML]);
+				//allpass filter M
+				
+				dML[6] = dML[5];
+				dML[5] = dML[4];
+				dML[4] = inputSampleL;
+				inputSampleL = (dML[4] + dML[5] + dML[6])/3.0;
+				
+				allpasstemp = outNL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;}
+				inputSampleL -= oNL[allpasstemp]*constallpass;
+				oNL[outNL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outNL--; if (outNL < 0 || outNL > delayN) {outNL = delayN;}
+				inputSampleL += (oNL[outNL]);
+				//allpass filter N
+				
+				dNL[6] = dNL[5];
+				dNL[5] = dNL[4];
+				dNL[4] = inputSampleL;
+				inputSampleL = (dNL[4] + dNL[5] + dNL[6])/3.0;
+				
+				allpasstemp = outOL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;}
+				inputSampleL -= oOL[allpasstemp]*constallpass;
+				oOL[outOL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outOL--; if (outOL < 0 || outOL > delayO) {outOL = delayO;}
+				inputSampleL += (oOL[outOL]);
+				//allpass filter O
+				
+				dOL[6] = dOL[5];
+				dOL[5] = dOL[4];
+				dOL[4] = inputSampleL;
+				inputSampleL = (dAL[1] + dOL[5] + dOL[6])/3.0;
+				
+				allpasstemp = outPL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;}
+				inputSampleL -= oPL[allpasstemp]*constallpass;
+				oPL[outPL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outPL--; if (outPL < 0 || outPL > delayP) {outPL = delayP;}
+				inputSampleL += (oPL[outPL]);
+				//allpass filter P
+				
+				dPL[6] = dPL[5];
+				dPL[5] = dPL[4];
+				dPL[4] = inputSampleL;
+				inputSampleL = (dPL[4] + dPL[5] + dPL[6])/3.0;
+				
+				allpasstemp = outQL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;}
+				inputSampleL -= oQL[allpasstemp]*constallpass;
+				oQL[outQL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outQL--; if (outQL < 0 || outQL > delayQ) {outQL = delayQ;}
+				inputSampleL += (oQL[outQL]);
+				//allpass filter Q
+				
+				dQL[6] = dQL[5];
+				dQL[5] = dQL[4];
+				dQL[4] = inputSampleL;
+				inputSampleL = (dAL[1] + dQL[5] + dQL[6])/3.0;
+				
+				allpasstemp = outRL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;}
+				inputSampleL -= oRL[allpasstemp]*constallpass;
+				oRL[outRL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outRL--; if (outRL < 0 || outRL > delayR) {outRL = delayR;}
+				inputSampleL += (oRL[outRL]);
+				//allpass filter R
+				
+				dRL[6] = dRL[5];
+				dRL[5] = dRL[4];
+				dRL[4] = inputSampleL;
+				inputSampleL = (dRL[4] + dRL[5] + dRL[6])/3.0;
+				
+				allpasstemp = outSL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;}
+				inputSampleL -= oSL[allpasstemp]*constallpass;
+				oSL[outSL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outSL--; if (outSL < 0 || outSL > delayS) {outSL = delayS;}
+				inputSampleL += (oSL[outSL]);
+				//allpass filter S
+				
+				dSL[6] = dSL[5];
+				dSL[5] = dSL[4];
+				dSL[4] = inputSampleL;
+				inputSampleL = (dSL[4] + dSL[5] + dSL[6])/3.0;
+				
+				allpasstemp = outTL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;}
+				inputSampleL -= oTL[allpasstemp]*constallpass;
+				oTL[outTL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outTL--; if (outTL < 0 || outTL > delayT) {outTL = delayT;}
+				inputSampleL += (oTL[outTL]);
+				//allpass filter T
+				
+				dTL[6] = dTL[5];
+				dTL[5] = dTL[4];
+				dTL[4] = inputSampleL;
+				inputSampleL = (dTL[4] + dTL[5] + dTL[6])/3.0;
+				
+				allpasstemp = outUL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;}
+				inputSampleL -= oUL[allpasstemp]*constallpass;
+				oUL[outUL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outUL--; if (outUL < 0 || outUL > delayU) {outUL = delayU;}
+				inputSampleL += (oUL[outUL]);
+				//allpass filter U
+				
+				dUL[6] = dUL[5];
+				dUL[5] = dUL[4];
+				dUL[4] = inputSampleL;
+				inputSampleL = (dAL[1] + dUL[5] + dUL[6])/3.0;
+				
+				allpasstemp = outVL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;}
+				inputSampleL -= oVL[allpasstemp]*constallpass;
+				oVL[outVL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outVL--; if (outVL < 0 || outVL > delayV) {outVL = delayV;}
+				inputSampleL += (oVL[outVL]);
+				//allpass filter V
+				
+				dVL[6] = dVL[5];
+				dVL[5] = dVL[4];
+				dVL[4] = inputSampleL;
+				inputSampleL = (dVL[4] + dVL[5] + dVL[6])/3.0;
+				
+				allpasstemp = outWL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;}
+				inputSampleL -= oWL[allpasstemp]*constallpass;
+				oWL[outWL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outWL--; if (outWL < 0 || outWL > delayW) {outWL = delayW;}
+				inputSampleL += (oWL[outWL]);
+				//allpass filter W
+				
+				dWL[6] = dWL[5];
+				dWL[5] = dWL[4];
+				dWL[4] = inputSampleL;
+				inputSampleL = (dWL[4] + dWL[5] + dWL[6])/3.0;
+				
+				allpasstemp = outXL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;}
+				inputSampleL -= oXL[allpasstemp]*constallpass;
+				oXL[outXL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outXL--; if (outXL < 0 || outXL > delayX) {outXL = delayX;}
+				inputSampleL += (oXL[outXL]);
+				//allpass filter X
+				
+				dXL[6] = dXL[5];
+				dXL[5] = dXL[4];
+				dXL[4] = inputSampleL;
+				inputSampleL = (dXL[4] + dXL[5] + dXL[6])/3.0;
+				
+				allpasstemp = outYL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;}
+				inputSampleL -= oYL[allpasstemp]*constallpass;
+				oYL[outYL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outYL--; if (outYL < 0 || outYL > delayY) {outYL = delayY;}
+				inputSampleL += (oYL[outYL]);
+				//allpass filter Y
+				
+				dYL[6] = dYL[5];
+				dYL[5] = dYL[4];
+				dYL[4] = inputSampleL;
+				inputSampleL = (dYL[4] + dYL[5] + dYL[6])/3.0;
+				
+				allpasstemp = outZL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;}
+				inputSampleL -= oZL[allpasstemp]*constallpass;
+				oZL[outZL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outZL--; if (outZL < 0 || outZL > delayZ) {outZL = delayZ;}
+				inputSampleL += (oZL[outZL]);
+				//allpass filter Z
+				
+				dZL[6] = dZL[5];
+				dZL[5] = dZL[4];
+				dZL[4] = inputSampleL;
+				inputSampleL = (dZL[4] + dZL[5] + dZL[6]);		
+				//output Chamber
+				break;
+				
+				
+				
+				
+				
+			case 2:	//Spring
+				
+				allpasstemp = alpAL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;}
+				inputSampleL -= aAL[allpasstemp]*constallpass;
+				aAL[alpAL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpAL--; if (alpAL < 0 || alpAL > delayA) {alpAL = delayA;}
+				inputSampleL += (aAL[alpAL]);
+				//allpass filter A		
+				
+				dAL[3] = dAL[2];
+				dAL[2] = dAL[1];
+				dAL[1] = inputSampleL;
+				inputSampleL = (dAL[1] + dAL[2] + dAL[3])/3.0;
+				
+				allpasstemp = alpBL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;}
+				inputSampleL -= aBL[allpasstemp]*constallpass;
+				aBL[alpBL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpBL--; if (alpBL < 0 || alpBL > delayB) {alpBL = delayB;}
+				inputSampleL += (aBL[alpBL]);
+				//allpass filter B
+				
+				dBL[3] = dBL[2];
+				dBL[2] = dBL[1];
+				dBL[1] = inputSampleL;
+				inputSampleL = (dBL[1] + dBL[2] + dBL[3])/3.0;
+				
+				allpasstemp = alpCL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;}
+				inputSampleL -= aCL[allpasstemp]*constallpass;
+				aCL[alpCL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpCL--; if (alpCL < 0 || alpCL > delayC) {alpCL = delayC;}
+				inputSampleL += (aCL[alpCL]);
+				//allpass filter C
+				
+				dCL[3] = dCL[2];
+				dCL[2] = dCL[1];
+				dCL[1] = inputSampleL;
+				inputSampleL = (dCL[1] + dCL[2] + dCL[3])/3.0;
+				
+				allpasstemp = alpDL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;}
+				inputSampleL -= aDL[allpasstemp]*constallpass;
+				aDL[alpDL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpDL--; if (alpDL < 0 || alpDL > delayD) {alpDL = delayD;}
+				inputSampleL += (aDL[alpDL]);
+				//allpass filter D
+				
+				dDL[3] = dDL[2];
+				dDL[2] = dDL[1];
+				dDL[1] = inputSampleL;
+				inputSampleL = (dDL[1] + dDL[2] + dDL[3])/3.0;
+				
+				allpasstemp = alpEL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;}
+				inputSampleL -= aEL[allpasstemp]*constallpass;
+				aEL[alpEL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpEL--; if (alpEL < 0 || alpEL > delayE) {alpEL = delayE;}
+				inputSampleL += (aEL[alpEL]);
+				//allpass filter E
+				
+				dEL[3] = dEL[2];
+				dEL[2] = dEL[1];
+				dEL[1] = inputSampleL;
+				inputSampleL = (dEL[1] + dEL[2] + dEL[3])/3.0;
+				
+				allpasstemp = alpFL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;}
+				inputSampleL -= aFL[allpasstemp]*constallpass;
+				aFL[alpFL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpFL--; if (alpFL < 0 || alpFL > delayF) {alpFL = delayF;}
+				inputSampleL += (aFL[alpFL]);
+				//allpass filter F
+				
+				dFL[3] = dFL[2];
+				dFL[2] = dFL[1];
+				dFL[1] = inputSampleL;
+				inputSampleL = (dFL[1] + dFL[2] + dFL[3])/3.0;
+				
+				allpasstemp = alpGL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;}
+				inputSampleL -= aGL[allpasstemp]*constallpass;
+				aGL[alpGL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpGL--; if (alpGL < 0 || alpGL > delayG) {alpGL = delayG;}
+				inputSampleL += (aGL[alpGL]);
+				//allpass filter G
+				
+				dGL[3] = dGL[2];
+				dGL[2] = dGL[1];
+				dGL[1] = inputSampleL;
+				inputSampleL = (dGL[1] + dGL[2] + dGL[3])/3.0;
+				
+				allpasstemp = alpHL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;}
+				inputSampleL -= aHL[allpasstemp]*constallpass;
+				aHL[alpHL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpHL--; if (alpHL < 0 || alpHL > delayH) {alpHL = delayH;}
+				inputSampleL += (aHL[alpHL]);
+				//allpass filter H
+				
+				dHL[3] = dHL[2];
+				dHL[2] = dHL[1];
+				dHL[1] = inputSampleL;
+				inputSampleL = (dHL[1] + dHL[2] + dHL[3])/3.0;
+				
+				allpasstemp = alpIL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;}
+				inputSampleL -= aIL[allpasstemp]*constallpass;
+				aIL[alpIL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpIL--; if (alpIL < 0 || alpIL > delayI) {alpIL = delayI;}
+				inputSampleL += (aIL[alpIL]);
+				//allpass filter I
+				
+				dIL[3] = dIL[2];
+				dIL[2] = dIL[1];
+				dIL[1] = inputSampleL;
+				inputSampleL = (dIL[1] + dIL[2] + dIL[3])/3.0;
+				
+				allpasstemp = alpJL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;}
+				inputSampleL -= aJL[allpasstemp]*constallpass;
+				aJL[alpJL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpJL--; if (alpJL < 0 || alpJL > delayJ) {alpJL = delayJ;}
+				inputSampleL += (aJL[alpJL]);
+				//allpass filter J
+				
+				dJL[3] = dJL[2];
+				dJL[2] = dJL[1];
+				dJL[1] = inputSampleL;
+				inputSampleL = (dJL[1] + dJL[2] + dJL[3])/3.0;
+				
+				allpasstemp = alpKL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;}
+				inputSampleL -= aKL[allpasstemp]*constallpass;
+				aKL[alpKL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpKL--; if (alpKL < 0 || alpKL > delayK) {alpKL = delayK;}
+				inputSampleL += (aKL[alpKL]);
+				//allpass filter K
+				
+				dKL[3] = dKL[2];
+				dKL[2] = dKL[1];
+				dKL[1] = inputSampleL;
+				inputSampleL = (dKL[1] + dKL[2] + dKL[3])/3.0;
+				
+				allpasstemp = alpLL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;}
+				inputSampleL -= aLL[allpasstemp]*constallpass;
+				aLL[alpLL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpLL--; if (alpLL < 0 || alpLL > delayL) {alpLL = delayL;}
+				inputSampleL += (aLL[alpLL]);
+				//allpass filter L
+				
+				dLL[3] = dLL[2];
+				dLL[2] = dLL[1];
+				dLL[1] = inputSampleL;
+				inputSampleL = (dLL[1] + dLL[2] + dLL[3])/3.0;
+				
+				allpasstemp = alpML - 1;
+				if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;}
+				inputSampleL -= aML[allpasstemp]*constallpass;
+				aML[alpML] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpML--; if (alpML < 0 || alpML > delayM) {alpML = delayM;}
+				inputSampleL += (aML[alpML]);
+				//allpass filter M
+				
+				dML[3] = dML[2];
+				dML[2] = dML[1];
+				dML[1] = inputSampleL;
+				inputSampleL = (dML[1] + dML[2] + dML[3])/3.0;
+				
+				allpasstemp = alpNL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;}
+				inputSampleL -= aNL[allpasstemp]*constallpass;
+				aNL[alpNL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpNL--; if (alpNL < 0 || alpNL > delayN) {alpNL = delayN;}
+				inputSampleL += (aNL[alpNL]);
+				//allpass filter N
+				
+				dNL[3] = dNL[2];
+				dNL[2] = dNL[1];
+				dNL[1] = inputSampleL;
+				inputSampleL = (dNL[1] + dNL[2] + dNL[3])/3.0;
+				
+				allpasstemp = alpOL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;}
+				inputSampleL -= aOL[allpasstemp]*constallpass;
+				aOL[alpOL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpOL--; if (alpOL < 0 || alpOL > delayO) {alpOL = delayO;}
+				inputSampleL += (aOL[alpOL]);
+				//allpass filter O
+				
+				dOL[3] = dOL[2];
+				dOL[2] = dOL[1];
+				dOL[1] = inputSampleL;
+				inputSampleL = (dOL[1] + dOL[2] + dOL[3])/3.0;
+				
+				allpasstemp = alpPL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;}
+				inputSampleL -= aPL[allpasstemp]*constallpass;
+				aPL[alpPL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpPL--; if (alpPL < 0 || alpPL > delayP) {alpPL = delayP;}
+				inputSampleL += (aPL[alpPL]);
+				//allpass filter P
+				
+				dPL[3] = dPL[2];
+				dPL[2] = dPL[1];
+				dPL[1] = inputSampleL;
+				inputSampleL = (dPL[1] + dPL[2] + dPL[3])/3.0;
+				
+				allpasstemp = alpQL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;}
+				inputSampleL -= aQL[allpasstemp]*constallpass;
+				aQL[alpQL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpQL--; if (alpQL < 0 || alpQL > delayQ) {alpQL = delayQ;}
+				inputSampleL += (aQL[alpQL]);
+				//allpass filter Q
+				
+				dQL[3] = dQL[2];
+				dQL[2] = dQL[1];
+				dQL[1] = inputSampleL;
+				inputSampleL = (dQL[1] + dQL[2] + dQL[3])/3.0;
+				
+				allpasstemp = alpRL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;}
+				inputSampleL -= aRL[allpasstemp]*constallpass;
+				aRL[alpRL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpRL--; if (alpRL < 0 || alpRL > delayR) {alpRL = delayR;}
+				inputSampleL += (aRL[alpRL]);
+				//allpass filter R
+				
+				dRL[3] = dRL[2];
+				dRL[2] = dRL[1];
+				dRL[1] = inputSampleL;
+				inputSampleL = (dRL[1] + dRL[2] + dRL[3])/3.0;
+				
+				allpasstemp = alpSL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;}
+				inputSampleL -= aSL[allpasstemp]*constallpass;
+				aSL[alpSL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpSL--; if (alpSL < 0 || alpSL > delayS) {alpSL = delayS;}
+				inputSampleL += (aSL[alpSL]);
+				//allpass filter S
+				
+				dSL[3] = dSL[2];
+				dSL[2] = dSL[1];
+				dSL[1] = inputSampleL;
+				inputSampleL = (dSL[1] + dSL[2] + dSL[3])/3.0;
+				
+				allpasstemp = alpTL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;}
+				inputSampleL -= aTL[allpasstemp]*constallpass;
+				aTL[alpTL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpTL--; if (alpTL < 0 || alpTL > delayT) {alpTL = delayT;}
+				inputSampleL += (aTL[alpTL]);
+				//allpass filter T
+				
+				dTL[3] = dTL[2];
+				dTL[2] = dTL[1];
+				dTL[1] = inputSampleL;
+				inputSampleL = (dTL[1] + dTL[2] + dTL[3])/3.0;
+				
+				allpasstemp = alpUL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;}
+				inputSampleL -= aUL[allpasstemp]*constallpass;
+				aUL[alpUL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpUL--; if (alpUL < 0 || alpUL > delayU) {alpUL = delayU;}
+				inputSampleL += (aUL[alpUL]);
+				//allpass filter U
+				
+				dUL[3] = dUL[2];
+				dUL[2] = dUL[1];
+				dUL[1] = inputSampleL;
+				inputSampleL = (dUL[1] + dUL[2] + dUL[3])/3.0;
+				
+				allpasstemp = alpVL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;}
+				inputSampleL -= aVL[allpasstemp]*constallpass;
+				aVL[alpVL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpVL--; if (alpVL < 0 || alpVL > delayV) {alpVL = delayV;}
+				inputSampleL += (aVL[alpVL]);
+				//allpass filter V
+				
+				dVL[3] = dVL[2];
+				dVL[2] = dVL[1];
+				dVL[1] = inputSampleL;
+				inputSampleL = (dVL[1] + dVL[2] + dVL[3])/3.0;
+				
+				allpasstemp = alpWL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;}
+				inputSampleL -= aWL[allpasstemp]*constallpass;
+				aWL[alpWL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpWL--; if (alpWL < 0 || alpWL > delayW) {alpWL = delayW;}
+				inputSampleL += (aWL[alpWL]);
+				//allpass filter W
+				
+				dWL[3] = dWL[2];
+				dWL[2] = dWL[1];
+				dWL[1] = inputSampleL;
+				inputSampleL = (dWL[1] + dWL[2] + dWL[3])/3.0;
+				
+				allpasstemp = alpXL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;}
+				inputSampleL -= aXL[allpasstemp]*constallpass;
+				aXL[alpXL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpXL--; if (alpXL < 0 || alpXL > delayX) {alpXL = delayX;}
+				inputSampleL += (aXL[alpXL]);
+				//allpass filter X
+				
+				dXL[3] = dXL[2];
+				dXL[2] = dXL[1];
+				dXL[1] = inputSampleL;
+				inputSampleL = (dXL[1] + dXL[2] + dXL[3])/3.0;
+				
+				allpasstemp = alpYL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;}
+				inputSampleL -= aYL[allpasstemp]*constallpass;
+				aYL[alpYL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpYL--; if (alpYL < 0 || alpYL > delayY) {alpYL = delayY;}
+				inputSampleL += (aYL[alpYL]);
+				//allpass filter Y
+				
+				dYL[3] = dYL[2];
+				dYL[2] = dYL[1];
+				dYL[1] = inputSampleL;
+				inputSampleL = (dYL[1] + dYL[2] + dYL[3])/3.0;
+				
+				allpasstemp = alpZL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;}
+				inputSampleL -= aZL[allpasstemp]*constallpass;
+				aZL[alpZL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpZL--; if (alpZL < 0 || alpZL > delayZ) {alpZL = delayZ;}
+				inputSampleL += (aZL[alpZL]);
+				//allpass filter Z
+				
+				dZL[3] = dZL[2];
+				dZL[2] = dZL[1];
+				dZL[1] = inputSampleL;
+				inputSampleL = (dZL[1] + dZL[2] + dZL[3])/3.0;
+				
+				// now the second stage using the 'out' bank of allpasses		
+				
+				allpasstemp = outAL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;}
+				inputSampleL -= oAL[allpasstemp]*constallpass;
+				oAL[outAL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outAL--; if (outAL < 0 || outAL > delayA) {outAL = delayA;}
+				inputSampleL += (oAL[outAL]);
+				//allpass filter A		
+				
+				dAL[6] = dAL[5];
+				dAL[5] = dAL[4];
+				dAL[4] = inputSampleL;
+				inputSampleL = (dYL[1] + dAL[5] + dAL[6])/3.0;
+				
+				allpasstemp = outBL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;}
+				inputSampleL -= oBL[allpasstemp]*constallpass;
+				oBL[outBL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outBL--; if (outBL < 0 || outBL > delayB) {outBL = delayB;}
+				inputSampleL += (oBL[outBL]);
+				//allpass filter B
+				
+				dBL[6] = dBL[5];
+				dBL[5] = dBL[4];
+				dBL[4] = inputSampleL;
+				inputSampleL = (dXL[1] + dBL[5] + dBL[6])/3.0;
+				
+				allpasstemp = outCL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;}
+				inputSampleL -= oCL[allpasstemp]*constallpass;
+				oCL[outCL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outCL--; if (outCL < 0 || outCL > delayC) {outCL = delayC;}
+				inputSampleL += (oCL[outCL]);
+				//allpass filter C
+				
+				dCL[6] = dCL[5];
+				dCL[5] = dCL[4];
+				dCL[4] = inputSampleL;
+				inputSampleL = (dWL[1] + dCL[5] + dCL[6])/3.0;
+				
+				allpasstemp = outDL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;}
+				inputSampleL -= oDL[allpasstemp]*constallpass;
+				oDL[outDL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outDL--; if (outDL < 0 || outDL > delayD) {outDL = delayD;}
+				inputSampleL += (oDL[outDL]);
+				//allpass filter D
+				
+				dDL[6] = dDL[5];
+				dDL[5] = dDL[4];
+				dDL[4] = inputSampleL;
+				inputSampleL = (dVL[1] + dDL[5] + dDL[6])/3.0;
+				
+				allpasstemp = outEL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;}
+				inputSampleL -= oEL[allpasstemp]*constallpass;
+				oEL[outEL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outEL--; if (outEL < 0 || outEL > delayE) {outEL = delayE;}
+				inputSampleL += (oEL[outEL]);
+				//allpass filter E
+				
+				dEL[6] = dEL[5];
+				dEL[5] = dEL[4];
+				dEL[4] = inputSampleL;
+				inputSampleL = (dUL[1] + dEL[5] + dEL[6])/3.0;
+				
+				allpasstemp = outFL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;}
+				inputSampleL -= oFL[allpasstemp]*constallpass;
+				oFL[outFL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outFL--; if (outFL < 0 || outFL > delayF) {outFL = delayF;}
+				inputSampleL += (oFL[outFL]);
+				//allpass filter F
+				
+				dFL[6] = dFL[5];
+				dFL[5] = dFL[4];
+				dFL[4] = inputSampleL;
+				inputSampleL = (dTL[1] + dFL[5] + dFL[6])/3.0;
+				
+				allpasstemp = outGL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;}
+				inputSampleL -= oGL[allpasstemp]*constallpass;
+				oGL[outGL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outGL--; if (outGL < 0 || outGL > delayG) {outGL = delayG;}
+				inputSampleL += (oGL[outGL]);
+				//allpass filter G
+				
+				dGL[6] = dGL[5];
+				dGL[5] = dGL[4];
+				dGL[4] = inputSampleL;
+				inputSampleL = (dSL[1] + dGL[5] + dGL[6])/3.0;
+				
+				allpasstemp = outHL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;}
+				inputSampleL -= oHL[allpasstemp]*constallpass;
+				oHL[outHL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outHL--; if (outHL < 0 || outHL > delayH) {outHL = delayH;}
+				inputSampleL += (oHL[outHL]);
+				//allpass filter H
+				
+				dHL[6] = dHL[5];
+				dHL[5] = dHL[4];
+				dHL[4] = inputSampleL;
+				inputSampleL = (dRL[1] + dHL[5] + dHL[6])/3.0;
+				
+				allpasstemp = outIL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;}
+				inputSampleL -= oIL[allpasstemp]*constallpass;
+				oIL[outIL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outIL--; if (outIL < 0 || outIL > delayI) {outIL = delayI;}
+				inputSampleL += (oIL[outIL]);
+				//allpass filter I
+				
+				dIL[6] = dIL[5];
+				dIL[5] = dIL[4];
+				dIL[4] = inputSampleL;
+				inputSampleL = (dQL[1] + dIL[5] + dIL[6])/3.0;
+				
+				allpasstemp = outJL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;}
+				inputSampleL -= oJL[allpasstemp]*constallpass;
+				oJL[outJL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outJL--; if (outJL < 0 || outJL > delayJ) {outJL = delayJ;}
+				inputSampleL += (oJL[outJL]);
+				//allpass filter J
+				
+				dJL[6] = dJL[5];
+				dJL[5] = dJL[4];
+				dJL[4] = inputSampleL;
+				inputSampleL = (dPL[1] + dJL[5] + dJL[6])/3.0;
+				
+				allpasstemp = outKL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;}
+				inputSampleL -= oKL[allpasstemp]*constallpass;
+				oKL[outKL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outKL--; if (outKL < 0 || outKL > delayK) {outKL = delayK;}
+				inputSampleL += (oKL[outKL]);
+				//allpass filter K
+				
+				dKL[6] = dKL[5];
+				dKL[5] = dKL[4];
+				dKL[4] = inputSampleL;
+				inputSampleL = (dOL[1] + dKL[5] + dKL[6])/3.0;
+				
+				allpasstemp = outLL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;}
+				inputSampleL -= oLL[allpasstemp]*constallpass;
+				oLL[outLL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outLL--; if (outLL < 0 || outLL > delayL) {outLL = delayL;}
+				inputSampleL += (oLL[outLL]);
+				//allpass filter L
+				
+				dLL[6] = dLL[5];
+				dLL[5] = dLL[4];
+				dLL[4] = inputSampleL;
+				inputSampleL = (dNL[1] + dLL[5] + dLL[6])/3.0;
+				
+				allpasstemp = outML - 1;
+				if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;}
+				inputSampleL -= oML[allpasstemp]*constallpass;
+				oML[outML] = inputSampleL;
+				inputSampleL *= constallpass;
+				outML--; if (outML < 0 || outML > delayM) {outML = delayM;}
+				inputSampleL += (oML[outML]);
+				//allpass filter M
+				
+				dML[6] = dML[5];
+				dML[5] = dML[4];
+				dML[4] = inputSampleL;
+				inputSampleL = (dML[1] + dML[5] + dML[6])/3.0;
+				
+				allpasstemp = outNL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;}
+				inputSampleL -= oNL[allpasstemp]*constallpass;
+				oNL[outNL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outNL--; if (outNL < 0 || outNL > delayN) {outNL = delayN;}
+				inputSampleL += (oNL[outNL]);
+				//allpass filter N
+				
+				dNL[6] = dNL[5];
+				dNL[5] = dNL[4];
+				dNL[4] = inputSampleL;
+				inputSampleL = (dLL[1] + dNL[5] + dNL[6])/3.0;
+				
+				allpasstemp = outOL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;}
+				inputSampleL -= oOL[allpasstemp]*constallpass;
+				oOL[outOL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outOL--; if (outOL < 0 || outOL > delayO) {outOL = delayO;}
+				inputSampleL += (oOL[outOL]);
+				//allpass filter O
+				
+				dOL[6] = dOL[5];
+				dOL[5] = dOL[4];
+				dOL[4] = inputSampleL;
+				inputSampleL = (dKL[1] + dOL[5] + dOL[6])/3.0;
+				
+				allpasstemp = outPL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;}
+				inputSampleL -= oPL[allpasstemp]*constallpass;
+				oPL[outPL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outPL--; if (outPL < 0 || outPL > delayP) {outPL = delayP;}
+				inputSampleL += (oPL[outPL]);
+				//allpass filter P
+				
+				dPL[6] = dPL[5];
+				dPL[5] = dPL[4];
+				dPL[4] = inputSampleL;
+				inputSampleL = (dJL[1] + dPL[5] + dPL[6])/3.0;
+				
+				allpasstemp = outQL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;}
+				inputSampleL -= oQL[allpasstemp]*constallpass;
+				oQL[outQL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outQL--; if (outQL < 0 || outQL > delayQ) {outQL = delayQ;}
+				inputSampleL += (oQL[outQL]);
+				//allpass filter Q
+				
+				dQL[6] = dQL[5];
+				dQL[5] = dQL[4];
+				dQL[4] = inputSampleL;
+				inputSampleL = (dIL[1] + dQL[5] + dQL[6])/3.0;
+				
+				allpasstemp = outRL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;}
+				inputSampleL -= oRL[allpasstemp]*constallpass;
+				oRL[outRL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outRL--; if (outRL < 0 || outRL > delayR) {outRL = delayR;}
+				inputSampleL += (oRL[outRL]);
+				//allpass filter R
+				
+				dRL[6] = dRL[5];
+				dRL[5] = dRL[4];
+				dRL[4] = inputSampleL;
+				inputSampleL = (dHL[1] + dRL[5] + dRL[6])/3.0;
+				
+				allpasstemp = outSL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;}
+				inputSampleL -= oSL[allpasstemp]*constallpass;
+				oSL[outSL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outSL--; if (outSL < 0 || outSL > delayS) {outSL = delayS;}
+				inputSampleL += (oSL[outSL]);
+				//allpass filter S
+				
+				dSL[6] = dSL[5];
+				dSL[5] = dSL[4];
+				dSL[4] = inputSampleL;
+				inputSampleL = (dGL[1] + dSL[5] + dSL[6])/3.0;
+				
+				allpasstemp = outTL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;}
+				inputSampleL -= oTL[allpasstemp]*constallpass;
+				oTL[outTL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outTL--; if (outTL < 0 || outTL > delayT) {outTL = delayT;}
+				inputSampleL += (oTL[outTL]);
+				//allpass filter T
+				
+				dTL[6] = dTL[5];
+				dTL[5] = dTL[4];
+				dTL[4] = inputSampleL;
+				inputSampleL = (dFL[1] + dTL[5] + dTL[6])/3.0;
+				
+				allpasstemp = outUL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;}
+				inputSampleL -= oUL[allpasstemp]*constallpass;
+				oUL[outUL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outUL--; if (outUL < 0 || outUL > delayU) {outUL = delayU;}
+				inputSampleL += (oUL[outUL]);
+				//allpass filter U
+				
+				dUL[6] = dUL[5];
+				dUL[5] = dUL[4];
+				dUL[4] = inputSampleL;
+				inputSampleL = (dEL[1] + dUL[5] + dUL[6])/3.0;
+				
+				allpasstemp = outVL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;}
+				inputSampleL -= oVL[allpasstemp]*constallpass;
+				oVL[outVL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outVL--; if (outVL < 0 || outVL > delayV) {outVL = delayV;}
+				inputSampleL += (oVL[outVL]);
+				//allpass filter V
+				
+				dVL[6] = dVL[5];
+				dVL[5] = dVL[4];
+				dVL[4] = inputSampleL;
+				inputSampleL = (dDL[1] + dVL[5] + dVL[6])/3.0;
+				
+				allpasstemp = outWL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;}
+				inputSampleL -= oWL[allpasstemp]*constallpass;
+				oWL[outWL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outWL--; if (outWL < 0 || outWL > delayW) {outWL = delayW;}
+				inputSampleL += (oWL[outWL]);
+				//allpass filter W
+				
+				dWL[6] = dWL[5];
+				dWL[5] = dWL[4];
+				dWL[4] = inputSampleL;
+				inputSampleL = (dCL[1] + dWL[5] + dWL[6])/3.0;
+				
+				allpasstemp = outXL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;}
+				inputSampleL -= oXL[allpasstemp]*constallpass;
+				oXL[outXL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outXL--; if (outXL < 0 || outXL > delayX) {outXL = delayX;}
+				inputSampleL += (oXL[outXL]);
+				//allpass filter X
+				
+				dXL[6] = dXL[5];
+				dXL[5] = dXL[4];
+				dXL[4] = inputSampleL;
+				inputSampleL = (dAL[1] + dXL[5] + dXL[6])/3.0;
+				
+				allpasstemp = outYL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;}
+				inputSampleL -= oYL[allpasstemp]*constallpass;
+				oYL[outYL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outYL--; if (outYL < 0 || outYL > delayY) {outYL = delayY;}
+				inputSampleL += (oYL[outYL]);
+				//allpass filter Y
+				
+				dYL[6] = dYL[5];
+				dYL[5] = dYL[4];
+				dYL[4] = inputSampleL;
+				inputSampleL = (dBL[1] + dYL[5] + dYL[6])/3.0;
+				
+				allpasstemp = outZL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;}
+				inputSampleL -= oZL[allpasstemp]*constallpass;
+				oZL[outZL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outZL--; if (outZL < 0 || outZL > delayZ) {outZL = delayZ;}
+				inputSampleL += (oZL[outZL]);
+				//allpass filter Z
+				
+				dZL[6] = dZL[5];
+				dZL[5] = dZL[4];
+				dZL[4] = inputSampleL;
+				inputSampleL = (dZL[5] + dZL[6]);
+				//output Spring
+				break;
+				
+				
+			case 3:	//Tiled
+				allpasstemp = alpAL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;}
+				inputSampleL -= aAL[allpasstemp]*constallpass;
+				aAL[alpAL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpAL--; if (alpAL < 0 || alpAL > delayA) {alpAL = delayA;}
+				inputSampleL += (aAL[alpAL]);
+				//allpass filter A		
+				
+				dAL[2] = dAL[1];
+				dAL[1] = inputSampleL;
+				inputSampleL = (dAL[1] + dAL[2])/2.0;
+				
+				allpasstemp = alpBL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;}
+				inputSampleL -= aBL[allpasstemp]*constallpass;
+				aBL[alpBL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpBL--; if (alpBL < 0 || alpBL > delayB) {alpBL = delayB;}
+				inputSampleL += (aBL[alpBL]);
+				//allpass filter B
+				
+				dBL[2] = dBL[1];
+				dBL[1] = inputSampleL;
+				inputSampleL = (dBL[1] + dBL[2])/2.0;
+				
+				allpasstemp = alpCL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;}
+				inputSampleL -= aCL[allpasstemp]*constallpass;
+				aCL[alpCL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpCL--; if (alpCL < 0 || alpCL > delayC) {alpCL = delayC;}
+				inputSampleL += (aCL[alpCL]);
+				//allpass filter C
+				
+				dCL[2] = dCL[1];
+				dCL[1] = inputSampleL;
+				inputSampleL = (dAL[1] + dCL[2])/2.0;
+				
+				allpasstemp = alpDL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;}
+				inputSampleL -= aDL[allpasstemp]*constallpass;
+				aDL[alpDL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpDL--; if (alpDL < 0 || alpDL > delayD) {alpDL = delayD;}
+				inputSampleL += (aDL[alpDL]);
+				//allpass filter D
+				
+				dDL[2] = dDL[1];
+				dDL[1] = inputSampleL;
+				inputSampleL = (dDL[1] + dDL[2])/2.0;
+				
+				allpasstemp = alpEL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;}
+				inputSampleL -= aEL[allpasstemp]*constallpass;
+				aEL[alpEL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpEL--; if (alpEL < 0 || alpEL > delayE) {alpEL = delayE;}
+				inputSampleL += (aEL[alpEL]);
+				//allpass filter E
+				
+				dEL[2] = dEL[1];
+				dEL[1] = inputSampleL;
+				inputSampleL = (dAL[1] + dEL[2])/2.0;
+				
+				allpasstemp = alpFL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;}
+				inputSampleL -= aFL[allpasstemp]*constallpass;
+				aFL[alpFL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpFL--; if (alpFL < 0 || alpFL > delayF) {alpFL = delayF;}
+				inputSampleL += (aFL[alpFL]);
+				//allpass filter F
+				
+				dFL[2] = dFL[1];
+				dFL[1] = inputSampleL;
+				inputSampleL = (dFL[1] + dFL[2])/2.0;
+				
+				allpasstemp = alpGL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;}
+				inputSampleL -= aGL[allpasstemp]*constallpass;
+				aGL[alpGL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpGL--; if (alpGL < 0 || alpGL > delayG) {alpGL = delayG;}
+				inputSampleL += (aGL[alpGL]);
+				//allpass filter G
+				
+				dGL[2] = dGL[1];
+				dGL[1] = inputSampleL;
+				inputSampleL = (dAL[1] + dGL[2])/2.0;
+				
+				allpasstemp = alpHL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;}
+				inputSampleL -= aHL[allpasstemp]*constallpass;
+				aHL[alpHL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpHL--; if (alpHL < 0 || alpHL > delayH) {alpHL = delayH;}
+				inputSampleL += (aHL[alpHL]);
+				//allpass filter H
+				
+				dHL[2] = dHL[1];
+				dHL[1] = inputSampleL;
+				inputSampleL = (dHL[1] + dHL[2])/2.0;
+				
+				allpasstemp = alpIL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;}
+				inputSampleL -= aIL[allpasstemp]*constallpass;
+				aIL[alpIL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpIL--; if (alpIL < 0 || alpIL > delayI) {alpIL = delayI;}
+				inputSampleL += (aIL[alpIL]);
+				//allpass filter I
+				
+				dIL[2] = dIL[1];
+				dIL[1] = inputSampleL;
+				inputSampleL = (dIL[1] + dIL[2])/2.0;
+				
+				allpasstemp = alpJL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;}
+				inputSampleL -= aJL[allpasstemp]*constallpass;
+				aJL[alpJL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpJL--; if (alpJL < 0 || alpJL > delayJ) {alpJL = delayJ;}
+				inputSampleL += (aJL[alpJL]);
+				//allpass filter J
+				
+				dJL[2] = dJL[1];
+				dJL[1] = inputSampleL;
+				inputSampleL = (dJL[1] + dJL[2])/2.0;
+				
+				allpasstemp = alpKL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;}
+				inputSampleL -= aKL[allpasstemp]*constallpass;
+				aKL[alpKL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpKL--; if (alpKL < 0 || alpKL > delayK) {alpKL = delayK;}
+				inputSampleL += (aKL[alpKL]);
+				//allpass filter K
+				
+				dKL[2] = dKL[1];
+				dKL[1] = inputSampleL;
+				inputSampleL = (dAL[1] + dKL[2])/2.0;
+				
+				allpasstemp = alpLL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;}
+				inputSampleL -= aLL[allpasstemp]*constallpass;
+				aLL[alpLL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpLL--; if (alpLL < 0 || alpLL > delayL) {alpLL = delayL;}
+				inputSampleL += (aLL[alpLL]);
+				//allpass filter L
+				
+				dLL[2] = dLL[1];
+				dLL[1] = inputSampleL;
+				inputSampleL = (dLL[1] + dLL[2])/2.0;
+				
+				allpasstemp = alpML - 1;
+				if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;}
+				inputSampleL -= aML[allpasstemp]*constallpass;
+				aML[alpML] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpML--; if (alpML < 0 || alpML > delayM) {alpML = delayM;}
+				inputSampleL += (aML[alpML]);
+				//allpass filter M
+				
+				dML[2] = dML[1];
+				dML[1] = inputSampleL;
+				inputSampleL = (dAL[1] + dML[2])/2.0;
+				
+				allpasstemp = alpNL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;}
+				inputSampleL -= aNL[allpasstemp]*constallpass;
+				aNL[alpNL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpNL--; if (alpNL < 0 || alpNL > delayN) {alpNL = delayN;}
+				inputSampleL += (aNL[alpNL]);
+				//allpass filter N
+				
+				dNL[2] = dNL[1];
+				dNL[1] = inputSampleL;
+				inputSampleL = (dNL[1] + dNL[2])/2.0;
+				
+				allpasstemp = alpOL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;}
+				inputSampleL -= aOL[allpasstemp]*constallpass;
+				aOL[alpOL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpOL--; if (alpOL < 0 || alpOL > delayO) {alpOL = delayO;}
+				inputSampleL += (aOL[alpOL]);
+				//allpass filter O
+				
+				dOL[2] = dOL[1];
+				dOL[1] = inputSampleL;
+				inputSampleL = (dOL[1] + dOL[2])/2.0;
+				
+				allpasstemp = alpPL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;}
+				inputSampleL -= aPL[allpasstemp]*constallpass;
+				aPL[alpPL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpPL--; if (alpPL < 0 || alpPL > delayP) {alpPL = delayP;}
+				inputSampleL += (aPL[alpPL]);
+				//allpass filter P
+				
+				dPL[2] = dPL[1];
+				dPL[1] = inputSampleL;
+				inputSampleL = (dPL[1] + dPL[2])/2.0;
+				
+				allpasstemp = alpQL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;}
+				inputSampleL -= aQL[allpasstemp]*constallpass;
+				aQL[alpQL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpQL--; if (alpQL < 0 || alpQL > delayQ) {alpQL = delayQ;}
+				inputSampleL += (aQL[alpQL]);
+				//allpass filter Q
+				
+				dQL[2] = dQL[1];
+				dQL[1] = inputSampleL;
+				inputSampleL = (dAL[1] + dQL[2])/2.0;
+				
+				allpasstemp = alpRL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;}
+				inputSampleL -= aRL[allpasstemp]*constallpass;
+				aRL[alpRL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpRL--; if (alpRL < 0 || alpRL > delayR) {alpRL = delayR;}
+				inputSampleL += (aRL[alpRL]);
+				//allpass filter R
+				
+				dRL[2] = dRL[1];
+				dRL[1] = inputSampleL;
+				inputSampleL = (dRL[1] + dRL[2])/2.0;
+				
+				allpasstemp = alpSL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;}
+				inputSampleL -= aSL[allpasstemp]*constallpass;
+				aSL[alpSL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpSL--; if (alpSL < 0 || alpSL > delayS) {alpSL = delayS;}
+				inputSampleL += (aSL[alpSL]);
+				//allpass filter S
+				
+				dSL[2] = dSL[1];
+				dSL[1] = inputSampleL;
+				inputSampleL = (dAL[1] + dSL[2])/2.0;
+				
+				allpasstemp = alpTL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;}
+				inputSampleL -= aTL[allpasstemp]*constallpass;
+				aTL[alpTL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpTL--; if (alpTL < 0 || alpTL > delayT) {alpTL = delayT;}
+				inputSampleL += (aTL[alpTL]);
+				//allpass filter T
+				
+				dTL[2] = dTL[1];
+				dTL[1] = inputSampleL;
+				inputSampleL = (dTL[1] + dTL[2])/2.0;
+				
+				allpasstemp = alpUL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;}
+				inputSampleL -= aUL[allpasstemp]*constallpass;
+				aUL[alpUL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpUL--; if (alpUL < 0 || alpUL > delayU) {alpUL = delayU;}
+				inputSampleL += (aUL[alpUL]);
+				//allpass filter U
+				
+				dUL[2] = dUL[1];
+				dUL[1] = inputSampleL;
+				inputSampleL = (dUL[1] + dUL[2])/2.0;
+				
+				allpasstemp = alpVL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;}
+				inputSampleL -= aVL[allpasstemp]*constallpass;
+				aVL[alpVL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpVL--; if (alpVL < 0 || alpVL > delayV) {alpVL = delayV;}
+				inputSampleL += (aVL[alpVL]);
+				//allpass filter V
+				
+				dVL[2] = dVL[1];
+				dVL[1] = inputSampleL;
+				inputSampleL = (dVL[1] + dVL[2])/2.0;
+				
+				allpasstemp = alpWL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;}
+				inputSampleL -= aWL[allpasstemp]*constallpass;
+				aWL[alpWL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpWL--; if (alpWL < 0 || alpWL > delayW) {alpWL = delayW;}
+				inputSampleL += (aWL[alpWL]);
+				//allpass filter W
+				
+				dWL[2] = dWL[1];
+				dWL[1] = inputSampleL;
+				inputSampleL = (dAL[1] + dWL[2])/2.0;
+				
+				allpasstemp = alpXL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;}
+				inputSampleL -= aXL[allpasstemp]*constallpass;
+				aXL[alpXL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpXL--; if (alpXL < 0 || alpXL > delayX) {alpXL = delayX;}
+				inputSampleL += (aXL[alpXL]);
+				//allpass filter X
+				
+				dXL[2] = dXL[1];
+				dXL[1] = inputSampleL;
+				inputSampleL = (dXL[1] + dXL[2])/2.0;
+				
+				allpasstemp = alpYL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;}
+				inputSampleL -= aYL[allpasstemp]*constallpass;
+				aYL[alpYL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpYL--; if (alpYL < 0 || alpYL > delayY) {alpYL = delayY;}
+				inputSampleL += (aYL[alpYL]);
+				//allpass filter Y
+				
+				dYL[2] = dYL[1];
+				dYL[1] = inputSampleL;
+				inputSampleL = (dYL[1] + dYL[2])/2.0;
+				
+				allpasstemp = alpZL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;}
+				inputSampleL -= aZL[allpasstemp]*constallpass;
+				aZL[alpZL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpZL--; if (alpZL < 0 || alpZL > delayZ) {alpZL = delayZ;}
+				inputSampleL += (aZL[alpZL]);
+				//allpass filter Z
+				
+				dZL[2] = dZL[1];
+				dZL[1] = inputSampleL;
+				inputSampleL = (dZL[1] + dZL[2])/2.0;
+				
+				// now the second stage using the 'out' bank of allpasses		
+				
+				allpasstemp = outAL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;}
+				inputSampleL -= oAL[allpasstemp]*constallpass;
+				oAL[outAL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outAL--; if (outAL < 0 || outAL > delayA) {outAL = delayA;}
+				inputSampleL += (oAL[outAL]);
+				//allpass filter A		
+				
+				dAL[5] = dAL[4];
+				dAL[4] = inputSampleL;
+				inputSampleL = (dAL[4] + dAL[5])/2.0;
+				
+				allpasstemp = outBL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;}
+				inputSampleL -= oBL[allpasstemp]*constallpass;
+				oBL[outBL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outBL--; if (outBL < 0 || outBL > delayB) {outBL = delayB;}
+				inputSampleL += (oBL[outBL]);
+				//allpass filter B
+				
+				dBL[5] = dBL[4];
+				dBL[4] = inputSampleL;
+				inputSampleL = (dBL[4] + dBL[5])/2.0;
+				
+				allpasstemp = outCL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;}
+				inputSampleL -= oCL[allpasstemp]*constallpass;
+				oCL[outCL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outCL--; if (outCL < 0 || outCL > delayC) {outCL = delayC;}
+				inputSampleL += (oCL[outCL]);
+				//allpass filter C
+				
+				dCL[5] = dCL[4];
+				dCL[4] = inputSampleL;
+				inputSampleL = (dAL[1] + dCL[5])/2.0;
+				
+				allpasstemp = outDL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;}
+				inputSampleL -= oDL[allpasstemp]*constallpass;
+				oDL[outDL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outDL--; if (outDL < 0 || outDL > delayD) {outDL = delayD;}
+				inputSampleL += (oDL[outDL]);
+				//allpass filter D
+				
+				dDL[5] = dDL[4];
+				dDL[4] = inputSampleL;
+				inputSampleL = (dDL[4] + dDL[5])/2.0;
+				
+				allpasstemp = outEL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;}
+				inputSampleL -= oEL[allpasstemp]*constallpass;
+				oEL[outEL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outEL--; if (outEL < 0 || outEL > delayE) {outEL = delayE;}
+				inputSampleL += (oEL[outEL]);
+				//allpass filter E
+				
+				dEL[5] = dEL[4];
+				dEL[4] = inputSampleL;
+				inputSampleL = (dAL[1] + dEL[5])/2.0;
+				
+				allpasstemp = outFL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;}
+				inputSampleL -= oFL[allpasstemp]*constallpass;
+				oFL[outFL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outFL--; if (outFL < 0 || outFL > delayF) {outFL = delayF;}
+				inputSampleL += (oFL[outFL]);
+				//allpass filter F
+				
+				dFL[5] = dFL[4];
+				dFL[4] = inputSampleL;
+				inputSampleL = (dFL[4] + dFL[5])/2.0;
+				
+				allpasstemp = outGL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;}
+				inputSampleL -= oGL[allpasstemp]*constallpass;
+				oGL[outGL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outGL--; if (outGL < 0 || outGL > delayG) {outGL = delayG;}
+				inputSampleL += (oGL[outGL]);
+				//allpass filter G
+				
+				dGL[5] = dGL[4];
+				dGL[4] = inputSampleL;
+				inputSampleL = (dGL[4] + dGL[5])/2.0;
+				
+				allpasstemp = outHL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;}
+				inputSampleL -= oHL[allpasstemp]*constallpass;
+				oHL[outHL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outHL--; if (outHL < 0 || outHL > delayH) {outHL = delayH;}
+				inputSampleL += (oHL[outHL]);
+				//allpass filter H
+				
+				dHL[5] = dHL[4];
+				dHL[4] = inputSampleL;
+				inputSampleL = (dHL[4] + dHL[5])/2.0;
+				
+				allpasstemp = outIL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;}
+				inputSampleL -= oIL[allpasstemp]*constallpass;
+				oIL[outIL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outIL--; if (outIL < 0 || outIL > delayI) {outIL = delayI;}
+				inputSampleL += (oIL[outIL]);
+				//allpass filter I
+				
+				dIL[5] = dIL[4];
+				dIL[4] = inputSampleL;
+				inputSampleL = (dIL[4] + dIL[5])/2.0;
+				
+				allpasstemp = outJL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;}
+				inputSampleL -= oJL[allpasstemp]*constallpass;
+				oJL[outJL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outJL--; if (outJL < 0 || outJL > delayJ) {outJL = delayJ;}
+				inputSampleL += (oJL[outJL]);
+				//allpass filter J
+				
+				dJL[5] = dJL[4];
+				dJL[4] = inputSampleL;
+				inputSampleL = (dJL[4] + dJL[5])/2.0;
+				
+				allpasstemp = outKL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;}
+				inputSampleL -= oKL[allpasstemp]*constallpass;
+				oKL[outKL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outKL--; if (outKL < 0 || outKL > delayK) {outKL = delayK;}
+				inputSampleL += (oKL[outKL]);
+				//allpass filter K
+				
+				dKL[5] = dKL[4];
+				dKL[4] = inputSampleL;
+				inputSampleL = (dAL[1] + dKL[5])/2.0;
+				
+				allpasstemp = outLL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;}
+				inputSampleL -= oLL[allpasstemp]*constallpass;
+				oLL[outLL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outLL--; if (outLL < 0 || outLL > delayL) {outLL = delayL;}
+				inputSampleL += (oLL[outLL]);
+				//allpass filter L
+				
+				dLL[5] = dLL[4];
+				dLL[4] = inputSampleL;
+				inputSampleL = (dLL[4] + dLL[5])/2.0;
+				
+				allpasstemp = outML - 1;
+				if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;}
+				inputSampleL -= oML[allpasstemp]*constallpass;
+				oML[outML] = inputSampleL;
+				inputSampleL *= constallpass;
+				outML--; if (outML < 0 || outML > delayM) {outML = delayM;}
+				inputSampleL += (oML[outML]);
+				//allpass filter M
+				
+				dML[5] = dML[4];
+				dML[4] = inputSampleL;
+				inputSampleL = (dML[4] + dML[5])/2.0;
+				
+				allpasstemp = outNL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;}
+				inputSampleL -= oNL[allpasstemp]*constallpass;
+				oNL[outNL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outNL--; if (outNL < 0 || outNL > delayN) {outNL = delayN;}
+				inputSampleL += (oNL[outNL]);
+				//allpass filter N
+				
+				dNL[5] = dNL[4];
+				dNL[4] = inputSampleL;
+				inputSampleL = (dNL[4] + dNL[5])/2.0;
+				
+				allpasstemp = outOL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;}
+				inputSampleL -= oOL[allpasstemp]*constallpass;
+				oOL[outOL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outOL--; if (outOL < 0 || outOL > delayO) {outOL = delayO;}
+				inputSampleL += (oOL[outOL]);
+				//allpass filter O
+				
+				dOL[5] = dOL[4];
+				dOL[4] = inputSampleL;
+				inputSampleL = (dAL[1] + dOL[5])/2.0;
+				
+				allpasstemp = outPL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;}
+				inputSampleL -= oPL[allpasstemp]*constallpass;
+				oPL[outPL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outPL--; if (outPL < 0 || outPL > delayP) {outPL = delayP;}
+				inputSampleL += (oPL[outPL]);
+				//allpass filter P
+				
+				dPL[5] = dPL[4];
+				dPL[4] = inputSampleL;
+				inputSampleL = (dPL[4] + dPL[5])/2.0;
+				
+				allpasstemp = outQL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;}
+				inputSampleL -= oQL[allpasstemp]*constallpass;
+				oQL[outQL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outQL--; if (outQL < 0 || outQL > delayQ) {outQL = delayQ;}
+				inputSampleL += (oQL[outQL]);
+				//allpass filter Q
+				
+				dQL[5] = dQL[4];
+				dQL[4] = inputSampleL;
+				inputSampleL = (dAL[1] + dQL[5])/2.0;
+				
+				allpasstemp = outRL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;}
+				inputSampleL -= oRL[allpasstemp]*constallpass;
+				oRL[outRL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outRL--; if (outRL < 0 || outRL > delayR) {outRL = delayR;}
+				inputSampleL += (oRL[outRL]);
+				//allpass filter R
+				
+				dRL[5] = dRL[4];
+				dRL[4] = inputSampleL;
+				inputSampleL = (dRL[4] + dRL[5])/2.0;
+				
+				allpasstemp = outSL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;}
+				inputSampleL -= oSL[allpasstemp]*constallpass;
+				oSL[outSL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outSL--; if (outSL < 0 || outSL > delayS) {outSL = delayS;}
+				inputSampleL += (oSL[outSL]);
+				//allpass filter S
+				
+				dSL[5] = dSL[4];
+				dSL[4] = inputSampleL;
+				inputSampleL = (dSL[4] + dSL[5])/2.0;
+				
+				allpasstemp = outTL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;}
+				inputSampleL -= oTL[allpasstemp]*constallpass;
+				oTL[outTL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outTL--; if (outTL < 0 || outTL > delayT) {outTL = delayT;}
+				inputSampleL += (oTL[outTL]);
+				//allpass filter T
+				
+				dTL[5] = dTL[4];
+				dTL[4] = inputSampleL;
+				inputSampleL = (dTL[4] + dTL[5])/2.0;
+				
+				allpasstemp = outUL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;}
+				inputSampleL -= oUL[allpasstemp]*constallpass;
+				oUL[outUL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outUL--; if (outUL < 0 || outUL > delayU) {outUL = delayU;}
+				inputSampleL += (oUL[outUL]);
+				//allpass filter U
+				
+				dUL[5] = dUL[4];
+				dUL[4] = inputSampleL;
+				inputSampleL = (dAL[1] + dUL[5])/2.0;
+				
+				allpasstemp = outVL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;}
+				inputSampleL -= oVL[allpasstemp]*constallpass;
+				oVL[outVL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outVL--; if (outVL < 0 || outVL > delayV) {outVL = delayV;}
+				inputSampleL += (oVL[outVL]);
+				//allpass filter V
+				
+				dVL[5] = dVL[4];
+				dVL[4] = inputSampleL;
+				inputSampleL = (dVL[4] + dVL[5])/2.0;
+				
+				allpasstemp = outWL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;}
+				inputSampleL -= oWL[allpasstemp]*constallpass;
+				oWL[outWL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outWL--; if (outWL < 0 || outWL > delayW) {outWL = delayW;}
+				inputSampleL += (oWL[outWL]);
+				//allpass filter W
+				
+				dWL[5] = dWL[4];
+				dWL[4] = inputSampleL;
+				inputSampleL = (dWL[4] + dWL[5])/2.0;
+				
+				allpasstemp = outXL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;}
+				inputSampleL -= oXL[allpasstemp]*constallpass;
+				oXL[outXL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outXL--; if (outXL < 0 || outXL > delayX) {outXL = delayX;}
+				inputSampleL += (oXL[outXL]);
+				//allpass filter X
+				
+				dXL[5] = dXL[4];
+				dXL[4] = inputSampleL;
+				inputSampleL = (dXL[4] + dXL[5])/2.0;
+				
+				allpasstemp = outYL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;}
+				inputSampleL -= oYL[allpasstemp]*constallpass;
+				oYL[outYL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outYL--; if (outYL < 0 || outYL > delayY) {outYL = delayY;}
+				inputSampleL += (oYL[outYL]);
+				//allpass filter Y
+				
+				dYL[5] = dYL[4];
+				dYL[4] = inputSampleL;
+				inputSampleL = (dYL[4] + dYL[5])/2.0;
+				
+				allpasstemp = outZL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;}
+				inputSampleL -= oZL[allpasstemp]*constallpass;
+				oZL[outZL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outZL--; if (outZL < 0 || outZL > delayZ) {outZL = delayZ;}
+				inputSampleL += (oZL[outZL]);
+				//allpass filter Z
+				
+				dZL[5] = dZL[4];
+				dZL[4] = inputSampleL;
+				inputSampleL = (dZL[4] + dZL[5]);		
+				//output Tiled
+				break;
+				
+				
+			case 4://Room
+				allpasstemp = alpAL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;}
+				inputSampleL -= aAL[allpasstemp]*constallpass;
+				aAL[alpAL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpAL--; if (alpAL < 0 || alpAL > delayA) {alpAL = delayA;}
+				inputSampleL += (aAL[alpAL]);
+				//allpass filter A		
+				
+				dAL[2] = dAL[1];
+				dAL[1] = inputSampleL;
+				inputSampleL = drySampleL;
+				
+				allpasstemp = alpBL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;}
+				inputSampleL -= aBL[allpasstemp]*constallpass;
+				aBL[alpBL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpBL--; if (alpBL < 0 || alpBL > delayB) {alpBL = delayB;}
+				inputSampleL += (aBL[alpBL]);
+				//allpass filter B
+				
+				dBL[2] = dBL[1];
+				dBL[1] = inputSampleL;
+				inputSampleL = drySampleL;
+				
+				allpasstemp = alpCL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;}
+				inputSampleL -= aCL[allpasstemp]*constallpass;
+				aCL[alpCL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpCL--; if (alpCL < 0 || alpCL > delayC) {alpCL = delayC;}
+				inputSampleL += (aCL[alpCL]);
+				//allpass filter C
+				
+				dCL[2] = dCL[1];
+				dCL[1] = inputSampleL;
+				inputSampleL = drySampleL;
+				
+				allpasstemp = alpDL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;}
+				inputSampleL -= aDL[allpasstemp]*constallpass;
+				aDL[alpDL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpDL--; if (alpDL < 0 || alpDL > delayD) {alpDL = delayD;}
+				inputSampleL += (aDL[alpDL]);
+				//allpass filter D
+				
+				dDL[2] = dDL[1];
+				dDL[1] = inputSampleL;
+				inputSampleL = drySampleL;
+				
+				allpasstemp = alpEL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;}
+				inputSampleL -= aEL[allpasstemp]*constallpass;
+				aEL[alpEL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpEL--; if (alpEL < 0 || alpEL > delayE) {alpEL = delayE;}
+				inputSampleL += (aEL[alpEL]);
+				//allpass filter E
+				
+				dEL[2] = dEL[1];
+				dEL[1] = inputSampleL;
+				inputSampleL = drySampleL;
+				
+				allpasstemp = alpFL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;}
+				inputSampleL -= aFL[allpasstemp]*constallpass;
+				aFL[alpFL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpFL--; if (alpFL < 0 || alpFL > delayF) {alpFL = delayF;}
+				inputSampleL += (aFL[alpFL]);
+				//allpass filter F
+				
+				dFL[2] = dFL[1];
+				dFL[1] = inputSampleL;
+				inputSampleL = drySampleL;
+				
+				allpasstemp = alpGL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;}
+				inputSampleL -= aGL[allpasstemp]*constallpass;
+				aGL[alpGL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpGL--; if (alpGL < 0 || alpGL > delayG) {alpGL = delayG;}
+				inputSampleL += (aGL[alpGL]);
+				//allpass filter G
+				
+				dGL[2] = dGL[1];
+				dGL[1] = inputSampleL;
+				inputSampleL = drySampleL;
+				
+				allpasstemp = alpHL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;}
+				inputSampleL -= aHL[allpasstemp]*constallpass;
+				aHL[alpHL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpHL--; if (alpHL < 0 || alpHL > delayH) {alpHL = delayH;}
+				inputSampleL += (aHL[alpHL]);
+				//allpass filter H
+				
+				dHL[2] = dHL[1];
+				dHL[1] = inputSampleL;
+				inputSampleL = drySampleL;
+				
+				allpasstemp = alpIL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;}
+				inputSampleL -= aIL[allpasstemp]*constallpass;
+				aIL[alpIL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpIL--; if (alpIL < 0 || alpIL > delayI) {alpIL = delayI;}
+				inputSampleL += (aIL[alpIL]);
+				//allpass filter I
+				
+				dIL[2] = dIL[1];
+				dIL[1] = inputSampleL;
+				inputSampleL = drySampleL;
+				
+				allpasstemp = alpJL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;}
+				inputSampleL -= aJL[allpasstemp]*constallpass;
+				aJL[alpJL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpJL--; if (alpJL < 0 || alpJL > delayJ) {alpJL = delayJ;}
+				inputSampleL += (aJL[alpJL]);
+				//allpass filter J
+				
+				dJL[2] = dJL[1];
+				dJL[1] = inputSampleL;
+				inputSampleL = drySampleL;
+				
+				allpasstemp = alpKL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;}
+				inputSampleL -= aKL[allpasstemp]*constallpass;
+				aKL[alpKL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpKL--; if (alpKL < 0 || alpKL > delayK) {alpKL = delayK;}
+				inputSampleL += (aKL[alpKL]);
+				//allpass filter K
+				
+				dKL[2] = dKL[1];
+				dKL[1] = inputSampleL;
+				inputSampleL = drySampleL;
+				
+				allpasstemp = alpLL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;}
+				inputSampleL -= aLL[allpasstemp]*constallpass;
+				aLL[alpLL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpLL--; if (alpLL < 0 || alpLL > delayL) {alpLL = delayL;}
+				inputSampleL += (aLL[alpLL]);
+				//allpass filter L
+				
+				dLL[2] = dLL[1];
+				dLL[1] = inputSampleL;
+				inputSampleL = drySampleL;
+				
+				allpasstemp = alpML - 1;
+				if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;}
+				inputSampleL -= aML[allpasstemp]*constallpass;
+				aML[alpML] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpML--; if (alpML < 0 || alpML > delayM) {alpML = delayM;}
+				inputSampleL += (aML[alpML]);
+				//allpass filter M
+				
+				dML[2] = dML[1];
+				dML[1] = inputSampleL;
+				inputSampleL = drySampleL;
+				
+				allpasstemp = alpNL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;}
+				inputSampleL -= aNL[allpasstemp]*constallpass;
+				aNL[alpNL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpNL--; if (alpNL < 0 || alpNL > delayN) {alpNL = delayN;}
+				inputSampleL += (aNL[alpNL]);
+				//allpass filter N
+				
+				dNL[2] = dNL[1];
+				dNL[1] = inputSampleL;
+				inputSampleL = drySampleL;
+				
+				allpasstemp = alpOL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;}
+				inputSampleL -= aOL[allpasstemp]*constallpass;
+				aOL[alpOL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpOL--; if (alpOL < 0 || alpOL > delayO) {alpOL = delayO;}
+				inputSampleL += (aOL[alpOL]);
+				//allpass filter O
+				
+				dOL[2] = dOL[1];
+				dOL[1] = inputSampleL;
+				inputSampleL = drySampleL;
+				
+				allpasstemp = alpPL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;}
+				inputSampleL -= aPL[allpasstemp]*constallpass;
+				aPL[alpPL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpPL--; if (alpPL < 0 || alpPL > delayP) {alpPL = delayP;}
+				inputSampleL += (aPL[alpPL]);
+				//allpass filter P
+				
+				dPL[2] = dPL[1];
+				dPL[1] = inputSampleL;
+				inputSampleL = drySampleL;
+				
+				allpasstemp = alpQL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;}
+				inputSampleL -= aQL[allpasstemp]*constallpass;
+				aQL[alpQL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpQL--; if (alpQL < 0 || alpQL > delayQ) {alpQL = delayQ;}
+				inputSampleL += (aQL[alpQL]);
+				//allpass filter Q
+				
+				dQL[2] = dQL[1];
+				dQL[1] = inputSampleL;
+				inputSampleL = drySampleL;
+				
+				allpasstemp = alpRL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;}
+				inputSampleL -= aRL[allpasstemp]*constallpass;
+				aRL[alpRL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpRL--; if (alpRL < 0 || alpRL > delayR) {alpRL = delayR;}
+				inputSampleL += (aRL[alpRL]);
+				//allpass filter R
+				
+				dRL[2] = dRL[1];
+				dRL[1] = inputSampleL;
+				inputSampleL = drySampleL;
+				
+				allpasstemp = alpSL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;}
+				inputSampleL -= aSL[allpasstemp]*constallpass;
+				aSL[alpSL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpSL--; if (alpSL < 0 || alpSL > delayS) {alpSL = delayS;}
+				inputSampleL += (aSL[alpSL]);
+				//allpass filter S
+				
+				dSL[2] = dSL[1];
+				dSL[1] = inputSampleL;
+				inputSampleL = drySampleL;
+				
+				allpasstemp = alpTL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;}
+				inputSampleL -= aTL[allpasstemp]*constallpass;
+				aTL[alpTL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpTL--; if (alpTL < 0 || alpTL > delayT) {alpTL = delayT;}
+				inputSampleL += (aTL[alpTL]);
+				//allpass filter T
+				
+				dTL[2] = dTL[1];
+				dTL[1] = inputSampleL;
+				inputSampleL = drySampleL;
+				
+				allpasstemp = alpUL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;}
+				inputSampleL -= aUL[allpasstemp]*constallpass;
+				aUL[alpUL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpUL--; if (alpUL < 0 || alpUL > delayU) {alpUL = delayU;}
+				inputSampleL += (aUL[alpUL]);
+				//allpass filter U
+				
+				dUL[2] = dUL[1];
+				dUL[1] = inputSampleL;
+				inputSampleL = drySampleL;
+				
+				allpasstemp = alpVL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;}
+				inputSampleL -= aVL[allpasstemp]*constallpass;
+				aVL[alpVL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpVL--; if (alpVL < 0 || alpVL > delayV) {alpVL = delayV;}
+				inputSampleL += (aVL[alpVL]);
+				//allpass filter V
+				
+				dVL[2] = dVL[1];
+				dVL[1] = inputSampleL;
+				inputSampleL = drySampleL;
+				
+				allpasstemp = alpWL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;}
+				inputSampleL -= aWL[allpasstemp]*constallpass;
+				aWL[alpWL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpWL--; if (alpWL < 0 || alpWL > delayW) {alpWL = delayW;}
+				inputSampleL += (aWL[alpWL]);
+				//allpass filter W
+				
+				dWL[2] = dWL[1];
+				dWL[1] = inputSampleL;
+				inputSampleL = drySampleL;
+				
+				allpasstemp = alpXL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;}
+				inputSampleL -= aXL[allpasstemp]*constallpass;
+				aXL[alpXL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpXL--; if (alpXL < 0 || alpXL > delayX) {alpXL = delayX;}
+				inputSampleL += (aXL[alpXL]);
+				//allpass filter X
+				
+				dXL[2] = dXL[1];
+				dXL[1] = inputSampleL;
+				inputSampleL = drySampleL;
+				
+				allpasstemp = alpYL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;}
+				inputSampleL -= aYL[allpasstemp]*constallpass;
+				aYL[alpYL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpYL--; if (alpYL < 0 || alpYL > delayY) {alpYL = delayY;}
+				inputSampleL += (aYL[alpYL]);
+				//allpass filter Y
+				
+				dYL[2] = dYL[1];
+				dYL[1] = inputSampleL;
+				inputSampleL = drySampleL;
+				
+				allpasstemp = alpZL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;}
+				inputSampleL -= aZL[allpasstemp]*constallpass;
+				aZL[alpZL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpZL--; if (alpZL < 0 || alpZL > delayZ) {alpZL = delayZ;}
+				inputSampleL += (aZL[alpZL]);
+				//allpass filter Z
+				
+				dZL[2] = dZL[1];
+				dZL[1] = inputSampleL;
+				inputSampleL = drySampleL;
+				
+				// now the second stage using the 'out' bank of allpasses		
+				
+				allpasstemp = outAL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;}
+				inputSampleL -= oAL[allpasstemp]*constallpass;
+				oAL[outAL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outAL--; if (outAL < 0 || outAL > delayA) {outAL = delayA;}
+				inputSampleL += (oAL[outAL]);
+				//allpass filter A		
+				
+				dAL[5] = dAL[4];
+				dAL[4] = inputSampleL;
+				inputSampleL = (dAL[1]+dAL[2])/2.0;
+				
+				allpasstemp = outBL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;}
+				inputSampleL -= oBL[allpasstemp]*constallpass;
+				oBL[outBL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outBL--; if (outBL < 0 || outBL > delayB) {outBL = delayB;}
+				inputSampleL += (oBL[outBL]);
+				//allpass filter B
+				
+				dBL[5] = dBL[4];
+				dBL[4] = inputSampleL;
+				inputSampleL = (dBL[1]+dBL[2])/2.0;
+				
+				allpasstemp = outCL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;}
+				inputSampleL -= oCL[allpasstemp]*constallpass;
+				oCL[outCL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outCL--; if (outCL < 0 || outCL > delayC) {outCL = delayC;}
+				inputSampleL += (oCL[outCL]);
+				//allpass filter C
+				
+				dCL[5] = dCL[4];
+				dCL[4] = inputSampleL;
+				inputSampleL = (dCL[1]+dCL[2])/2.0;
+				
+				allpasstemp = outDL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;}
+				inputSampleL -= oDL[allpasstemp]*constallpass;
+				oDL[outDL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outDL--; if (outDL < 0 || outDL > delayD) {outDL = delayD;}
+				inputSampleL += (oDL[outDL]);
+				//allpass filter D
+				
+				dDL[5] = dDL[4];
+				dDL[4] = inputSampleL;
+				inputSampleL = (dDL[1]+dDL[2])/2.0;
+				
+				allpasstemp = outEL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;}
+				inputSampleL -= oEL[allpasstemp]*constallpass;
+				oEL[outEL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outEL--; if (outEL < 0 || outEL > delayE) {outEL = delayE;}
+				inputSampleL += (oEL[outEL]);
+				//allpass filter E
+				
+				dEL[5] = dEL[4];
+				dEL[4] = inputSampleL;
+				inputSampleL = (dEL[1]+dEL[2])/2.0;
+				
+				allpasstemp = outFL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;}
+				inputSampleL -= oFL[allpasstemp]*constallpass;
+				oFL[outFL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outFL--; if (outFL < 0 || outFL > delayF) {outFL = delayF;}
+				inputSampleL += (oFL[outFL]);
+				//allpass filter F
+				
+				dFL[5] = dFL[4];
+				dFL[4] = inputSampleL;
+				inputSampleL = (dFL[1]+dFL[2])/2.0;
+				
+				allpasstemp = outGL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;}
+				inputSampleL -= oGL[allpasstemp]*constallpass;
+				oGL[outGL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outGL--; if (outGL < 0 || outGL > delayG) {outGL = delayG;}
+				inputSampleL += (oGL[outGL]);
+				//allpass filter G
+				
+				dGL[5] = dGL[4];
+				dGL[4] = inputSampleL;
+				inputSampleL = (dGL[1]+dGL[2])/2.0;
+				
+				allpasstemp = outHL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;}
+				inputSampleL -= oHL[allpasstemp]*constallpass;
+				oHL[outHL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outHL--; if (outHL < 0 || outHL > delayH) {outHL = delayH;}
+				inputSampleL += (oHL[outHL]);
+				//allpass filter H
+				
+				dHL[5] = dHL[4];
+				dHL[4] = inputSampleL;
+				inputSampleL = (dHL[1]+dHL[2])/2.0;
+				
+				allpasstemp = outIL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;}
+				inputSampleL -= oIL[allpasstemp]*constallpass;
+				oIL[outIL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outIL--; if (outIL < 0 || outIL > delayI) {outIL = delayI;}
+				inputSampleL += (oIL[outIL]);
+				//allpass filter I
+				
+				dIL[5] = dIL[4];
+				dIL[4] = inputSampleL;
+				inputSampleL = (dIL[1]+dIL[2])/2.0;
+				
+				allpasstemp = outJL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;}
+				inputSampleL -= oJL[allpasstemp]*constallpass;
+				oJL[outJL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outJL--; if (outJL < 0 || outJL > delayJ) {outJL = delayJ;}
+				inputSampleL += (oJL[outJL]);
+				//allpass filter J
+				
+				dJL[5] = dJL[4];
+				dJL[4] = inputSampleL;
+				inputSampleL = (dJL[1]+dJL[2])/2.0;
+				
+				allpasstemp = outKL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;}
+				inputSampleL -= oKL[allpasstemp]*constallpass;
+				oKL[outKL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outKL--; if (outKL < 0 || outKL > delayK) {outKL = delayK;}
+				inputSampleL += (oKL[outKL]);
+				//allpass filter K
+				
+				dKL[5] = dKL[4];
+				dKL[4] = inputSampleL;
+				inputSampleL = (dKL[1]+dKL[2])/2.0;
+				
+				allpasstemp = outLL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;}
+				inputSampleL -= oLL[allpasstemp]*constallpass;
+				oLL[outLL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outLL--; if (outLL < 0 || outLL > delayL) {outLL = delayL;}
+				inputSampleL += (oLL[outLL]);
+				//allpass filter L
+				
+				dLL[5] = dLL[4];
+				dLL[4] = inputSampleL;
+				inputSampleL = (dLL[1]+dLL[2])/2.0;
+				
+				allpasstemp = outML - 1;
+				if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;}
+				inputSampleL -= oML[allpasstemp]*constallpass;
+				oML[outML] = inputSampleL;
+				inputSampleL *= constallpass;
+				outML--; if (outML < 0 || outML > delayM) {outML = delayM;}
+				inputSampleL += (oML[outML]);
+				//allpass filter M
+				
+				dML[5] = dML[4];
+				dML[4] = inputSampleL;
+				inputSampleL = (dML[1]+dML[2])/2.0;
+				
+				allpasstemp = outNL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;}
+				inputSampleL -= oNL[allpasstemp]*constallpass;
+				oNL[outNL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outNL--; if (outNL < 0 || outNL > delayN) {outNL = delayN;}
+				inputSampleL += (oNL[outNL]);
+				//allpass filter N
+				
+				dNL[5] = dNL[4];
+				dNL[4] = inputSampleL;
+				inputSampleL = (dNL[1]+dNL[2])/2.0;
+				
+				allpasstemp = outOL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;}
+				inputSampleL -= oOL[allpasstemp]*constallpass;
+				oOL[outOL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outOL--; if (outOL < 0 || outOL > delayO) {outOL = delayO;}
+				inputSampleL += (oOL[outOL]);
+				//allpass filter O
+				
+				dOL[5] = dOL[4];
+				dOL[4] = inputSampleL;
+				inputSampleL = (dOL[1]+dOL[2])/2.0;
+				
+				allpasstemp = outPL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;}
+				inputSampleL -= oPL[allpasstemp]*constallpass;
+				oPL[outPL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outPL--; if (outPL < 0 || outPL > delayP) {outPL = delayP;}
+				inputSampleL += (oPL[outPL]);
+				//allpass filter P
+				
+				dPL[5] = dPL[4];
+				dPL[4] = inputSampleL;
+				inputSampleL = (dPL[1]+dPL[2])/2.0;
+				
+				allpasstemp = outQL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;}
+				inputSampleL -= oQL[allpasstemp]*constallpass;
+				oQL[outQL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outQL--; if (outQL < 0 || outQL > delayQ) {outQL = delayQ;}
+				inputSampleL += (oQL[outQL]);
+				//allpass filter Q
+				
+				dQL[5] = dQL[4];
+				dQL[4] = inputSampleL;
+				inputSampleL = (dQL[1]+dQL[2])/2.0;
+				
+				allpasstemp = outRL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;}
+				inputSampleL -= oRL[allpasstemp]*constallpass;
+				oRL[outRL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outRL--; if (outRL < 0 || outRL > delayR) {outRL = delayR;}
+				inputSampleL += (oRL[outRL]);
+				//allpass filter R
+				
+				dRL[5] = dRL[4];
+				dRL[4] = inputSampleL;
+				inputSampleL = (dRL[1]+dRL[2])/2.0;
+				
+				allpasstemp = outSL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;}
+				inputSampleL -= oSL[allpasstemp]*constallpass;
+				oSL[outSL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outSL--; if (outSL < 0 || outSL > delayS) {outSL = delayS;}
+				inputSampleL += (oSL[outSL]);
+				//allpass filter S
+				
+				dSL[5] = dSL[4];
+				dSL[4] = inputSampleL;
+				inputSampleL = (dSL[1]+dSL[2])/2.0;
+				
+				allpasstemp = outTL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;}
+				inputSampleL -= oTL[allpasstemp]*constallpass;
+				oTL[outTL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outTL--; if (outTL < 0 || outTL > delayT) {outTL = delayT;}
+				inputSampleL += (oTL[outTL]);
+				//allpass filter T
+				
+				dTL[5] = dTL[4];
+				dTL[4] = inputSampleL;
+				inputSampleL = (dTL[1]+dTL[2])/2.0;
+				
+				allpasstemp = outUL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;}
+				inputSampleL -= oUL[allpasstemp]*constallpass;
+				oUL[outUL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outUL--; if (outUL < 0 || outUL > delayU) {outUL = delayU;}
+				inputSampleL += (oUL[outUL]);
+				//allpass filter U
+				
+				dUL[5] = dUL[4];
+				dUL[4] = inputSampleL;
+				inputSampleL = (dUL[1]+dUL[2])/2.0;
+				
+				allpasstemp = outVL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;}
+				inputSampleL -= oVL[allpasstemp]*constallpass;
+				oVL[outVL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outVL--; if (outVL < 0 || outVL > delayV) {outVL = delayV;}
+				inputSampleL += (oVL[outVL]);
+				//allpass filter V
+				
+				dVL[5] = dVL[4];
+				dVL[4] = inputSampleL;
+				inputSampleL = (dVL[1]+dVL[2])/2.0;
+				
+				allpasstemp = outWL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;}
+				inputSampleL -= oWL[allpasstemp]*constallpass;
+				oWL[outWL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outWL--; if (outWL < 0 || outWL > delayW) {outWL = delayW;}
+				inputSampleL += (oWL[outWL]);
+				//allpass filter W
+				
+				dWL[5] = dWL[4];
+				dWL[4] = inputSampleL;
+				inputSampleL = (dWL[1]+dWL[2])/2.0;
+				
+				allpasstemp = outXL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;}
+				inputSampleL -= oXL[allpasstemp]*constallpass;
+				oXL[outXL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outXL--; if (outXL < 0 || outXL > delayX) {outXL = delayX;}
+				inputSampleL += (oXL[outXL]);
+				//allpass filter X
+				
+				dXL[5] = dXL[4];
+				dXL[4] = inputSampleL;
+				inputSampleL = (dXL[1]+dXL[2])/2.0;
+				
+				allpasstemp = outYL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;}
+				inputSampleL -= oYL[allpasstemp]*constallpass;
+				oYL[outYL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outYL--; if (outYL < 0 || outYL > delayY) {outYL = delayY;}
+				inputSampleL += (oYL[outYL]);
+				//allpass filter Y
+				
+				dYL[5] = dYL[4];
+				dYL[4] = inputSampleL;
+				inputSampleL = (dYL[1]+dYL[2])/2.0;
+				
+				allpasstemp = outZL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;}
+				inputSampleL -= oZL[allpasstemp]*constallpass;
+				oZL[outZL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outZL--; if (outZL < 0 || outZL > delayZ) {outZL = delayZ;}
+				inputSampleL += (oZL[outZL]);
+				//allpass filter Z
+				
+				dZL[5] = dZL[4];
+				dZL[4] = inputSampleL;
+				inputSampleL = (dBL[4] * dryness);		
+				inputSampleL += (dCL[4] * dryness);		
+				inputSampleL += dDL[4];		
+				inputSampleL += dEL[4];		
+				inputSampleL += dFL[4];		
+				inputSampleL += dGL[4];		
+				inputSampleL += dHL[4];		
+				inputSampleL += dIL[4];		
+				inputSampleL += dJL[4];		
+				inputSampleL += dKL[4];		
+				inputSampleL += dLL[4];		
+				inputSampleL += dML[4];		
+				inputSampleL += dNL[4];		
+				inputSampleL += dOL[4];		
+				inputSampleL += dPL[4];		
+				inputSampleL += dQL[4];		
+				inputSampleL += dRL[4];		
+				inputSampleL += dSL[4];		
+				inputSampleL += dTL[4];		
+				inputSampleL += dUL[4];		
+				inputSampleL += dVL[4];		
+				inputSampleL += dWL[4];		
+				inputSampleL += dXL[4];		
+				inputSampleL += dYL[4];		
+				inputSampleL += (dZL[4] * wetness);
+				
+				inputSampleL += (dBL[5] * dryness);		
+				inputSampleL += (dCL[5] * dryness);		
+				inputSampleL += dDL[5];		
+				inputSampleL += dEL[5];		
+				inputSampleL += dFL[5];		
+				inputSampleL += dGL[5];		
+				inputSampleL += dHL[5];		
+				inputSampleL += dIL[5];		
+				inputSampleL += dJL[5];		
+				inputSampleL += dKL[5];		
+				inputSampleL += dLL[5];		
+				inputSampleL += dML[5];		
+				inputSampleL += dNL[5];		
+				inputSampleL += dOL[5];		
+				inputSampleL += dPL[5];		
+				inputSampleL += dQL[5];		
+				inputSampleL += dRL[5];		
+				inputSampleL += dSL[5];		
+				inputSampleL += dTL[5];		
+				inputSampleL += dUL[5];		
+				inputSampleL += dVL[5];		
+				inputSampleL += dWL[5];		
+				inputSampleL += dXL[5];		
+				inputSampleL += dYL[5];		
+				inputSampleL += (dZL[5] * wetness);
+				
+				inputSampleL /= (26.0 + (wetness * 4.0));
+				//output Room effect
+				break;
+				
+				
+				
+				
+				
+				
+			case 5:	//Stretch	
+				allpasstemp = alpAL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;}
+				inputSampleL -= aAL[allpasstemp]*constallpass;
+				aAL[alpAL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpAL--; if (alpAL < 0 || alpAL > delayA) {alpAL = delayA;}
+				inputSampleL += (aAL[alpAL]);
+				//allpass filter A		
+				
+				dAL[2] = dAL[1];
+				dAL[1] = inputSampleL;
+				inputSampleL = (dAL[1] + dAL[2])/2.0;
+				
+				allpasstemp = alpBL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;}
+				inputSampleL -= aBL[allpasstemp]*constallpass;
+				aBL[alpBL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpBL--; if (alpBL < 0 || alpBL > delayB) {alpBL = delayB;}
+				inputSampleL += (aBL[alpBL]);
+				//allpass filter B
+				
+				dBL[2] = dBL[1];
+				dBL[1] = inputSampleL;
+				inputSampleL = (dBL[1] + dBL[2])/2.0;
+				
+				allpasstemp = alpCL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;}
+				inputSampleL -= aCL[allpasstemp]*constallpass;
+				aCL[alpCL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpCL--; if (alpCL < 0 || alpCL > delayC) {alpCL = delayC;}
+				inputSampleL += (aCL[alpCL]);
+				//allpass filter C
+				
+				dCL[2] = dCL[1];
+				dCL[1] = inputSampleL;
+				inputSampleL = (dCL[1] + dCL[2])/2.0;
+				
+				allpasstemp = alpDL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;}
+				inputSampleL -= aDL[allpasstemp]*constallpass;
+				aDL[alpDL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpDL--; if (alpDL < 0 || alpDL > delayD) {alpDL = delayD;}
+				inputSampleL += (aDL[alpDL]);
+				//allpass filter D
+				
+				dDL[2] = dDL[1];
+				dDL[1] = inputSampleL;
+				inputSampleL = (dDL[1] + dDL[2])/2.0;
+				
+				allpasstemp = alpEL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;}
+				inputSampleL -= aEL[allpasstemp]*constallpass;
+				aEL[alpEL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpEL--; if (alpEL < 0 || alpEL > delayE) {alpEL = delayE;}
+				inputSampleL += (aEL[alpEL]);
+				//allpass filter E
+				
+				dEL[2] = dEL[1];
+				dEL[1] = inputSampleL;
+				inputSampleL = (dEL[1] + dEL[2])/2.0;
+				
+				allpasstemp = alpFL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;}
+				inputSampleL -= aFL[allpasstemp]*constallpass;
+				aFL[alpFL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpFL--; if (alpFL < 0 || alpFL > delayF) {alpFL = delayF;}
+				inputSampleL += (aFL[alpFL]);
+				//allpass filter F
+				
+				dFL[2] = dFL[1];
+				dFL[1] = inputSampleL;
+				inputSampleL = (dFL[1] + dFL[2])/2.0;
+				
+				allpasstemp = alpGL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;}
+				inputSampleL -= aGL[allpasstemp]*constallpass;
+				aGL[alpGL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpGL--; if (alpGL < 0 || alpGL > delayG) {alpGL = delayG;}
+				inputSampleL += (aGL[alpGL]);
+				//allpass filter G
+				
+				dGL[2] = dGL[1];
+				dGL[1] = inputSampleL;
+				inputSampleL = (dGL[1] + dGL[2])/2.0;
+				
+				allpasstemp = alpHL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;}
+				inputSampleL -= aHL[allpasstemp]*constallpass;
+				aHL[alpHL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpHL--; if (alpHL < 0 || alpHL > delayH) {alpHL = delayH;}
+				inputSampleL += (aHL[alpHL]);
+				//allpass filter H
+				
+				dHL[2] = dHL[1];
+				dHL[1] = inputSampleL;
+				inputSampleL = (dHL[1] + dHL[2])/2.0;
+				
+				allpasstemp = alpIL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;}
+				inputSampleL -= aIL[allpasstemp]*constallpass;
+				aIL[alpIL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpIL--; if (alpIL < 0 || alpIL > delayI) {alpIL = delayI;}
+				inputSampleL += (aIL[alpIL]);
+				//allpass filter I
+				
+				dIL[2] = dIL[1];
+				dIL[1] = inputSampleL;
+				inputSampleL = (dIL[1] + dIL[2])/2.0;
+				
+				allpasstemp = alpJL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;}
+				inputSampleL -= aJL[allpasstemp]*constallpass;
+				aJL[alpJL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpJL--; if (alpJL < 0 || alpJL > delayJ) {alpJL = delayJ;}
+				inputSampleL += (aJL[alpJL]);
+				//allpass filter J
+				
+				dJL[2] = dJL[1];
+				dJL[1] = inputSampleL;
+				inputSampleL = (dJL[1] + dJL[2])/2.0;
+				
+				allpasstemp = alpKL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;}
+				inputSampleL -= aKL[allpasstemp]*constallpass;
+				aKL[alpKL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpKL--; if (alpKL < 0 || alpKL > delayK) {alpKL = delayK;}
+				inputSampleL += (aKL[alpKL]);
+				//allpass filter K
+				
+				dKL[2] = dKL[1];
+				dKL[1] = inputSampleL;
+				inputSampleL = (dKL[1] + dKL[2])/2.0;
+				
+				allpasstemp = alpLL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;}
+				inputSampleL -= aLL[allpasstemp]*constallpass;
+				aLL[alpLL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpLL--; if (alpLL < 0 || alpLL > delayL) {alpLL = delayL;}
+				inputSampleL += (aLL[alpLL]);
+				//allpass filter L
+				
+				dLL[2] = dLL[1];
+				dLL[1] = inputSampleL;
+				inputSampleL = (dLL[1] + dLL[2])/2.0;
+				
+				allpasstemp = alpML - 1;
+				if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;}
+				inputSampleL -= aML[allpasstemp]*constallpass;
+				aML[alpML] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpML--; if (alpML < 0 || alpML > delayM) {alpML = delayM;}
+				inputSampleL += (aML[alpML]);
+				//allpass filter M
+				
+				dML[2] = dML[1];
+				dML[1] = inputSampleL;
+				inputSampleL = (dML[1] + dML[2])/2.0;
+				
+				allpasstemp = alpNL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;}
+				inputSampleL -= aNL[allpasstemp]*constallpass;
+				aNL[alpNL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpNL--; if (alpNL < 0 || alpNL > delayN) {alpNL = delayN;}
+				inputSampleL += (aNL[alpNL]);
+				//allpass filter N
+				
+				dNL[2] = dNL[1];
+				dNL[1] = inputSampleL;
+				inputSampleL = (dNL[1] + dNL[2])/2.0;
+				
+				allpasstemp = alpOL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;}
+				inputSampleL -= aOL[allpasstemp]*constallpass;
+				aOL[alpOL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpOL--; if (alpOL < 0 || alpOL > delayO) {alpOL = delayO;}
+				inputSampleL += (aOL[alpOL]);
+				//allpass filter O
+				
+				dOL[2] = dOL[1];
+				dOL[1] = inputSampleL;
+				inputSampleL = (dOL[1] + dOL[2])/2.0;
+				
+				allpasstemp = alpPL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;}
+				inputSampleL -= aPL[allpasstemp]*constallpass;
+				aPL[alpPL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpPL--; if (alpPL < 0 || alpPL > delayP) {alpPL = delayP;}
+				inputSampleL += (aPL[alpPL]);
+				//allpass filter P
+				
+				dPL[2] = dPL[1];
+				dPL[1] = inputSampleL;
+				inputSampleL = (dPL[1] + dPL[2])/2.0;
+				
+				allpasstemp = alpQL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;}
+				inputSampleL -= aQL[allpasstemp]*constallpass;
+				aQL[alpQL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpQL--; if (alpQL < 0 || alpQL > delayQ) {alpQL = delayQ;}
+				inputSampleL += (aQL[alpQL]);
+				//allpass filter Q
+				
+				dQL[2] = dQL[1];
+				dQL[1] = inputSampleL;
+				inputSampleL = (dQL[1] + dQL[2])/2.0;
+				
+				allpasstemp = alpRL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;}
+				inputSampleL -= aRL[allpasstemp]*constallpass;
+				aRL[alpRL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpRL--; if (alpRL < 0 || alpRL > delayR) {alpRL = delayR;}
+				inputSampleL += (aRL[alpRL]);
+				//allpass filter R
+				
+				dRL[2] = dRL[1];
+				dRL[1] = inputSampleL;
+				inputSampleL = (dRL[1] + dRL[2])/2.0;
+				
+				allpasstemp = alpSL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;}
+				inputSampleL -= aSL[allpasstemp]*constallpass;
+				aSL[alpSL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpSL--; if (alpSL < 0 || alpSL > delayS) {alpSL = delayS;}
+				inputSampleL += (aSL[alpSL]);
+				//allpass filter S
+				
+				dSL[2] = dSL[1];
+				dSL[1] = inputSampleL;
+				inputSampleL = (dSL[1] + dSL[2])/2.0;
+				
+				allpasstemp = alpTL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;}
+				inputSampleL -= aTL[allpasstemp]*constallpass;
+				aTL[alpTL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpTL--; if (alpTL < 0 || alpTL > delayT) {alpTL = delayT;}
+				inputSampleL += (aTL[alpTL]);
+				//allpass filter T
+				
+				dTL[2] = dTL[1];
+				dTL[1] = inputSampleL;
+				inputSampleL = (dTL[1] + dTL[2])/2.0;
+				
+				allpasstemp = alpUL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;}
+				inputSampleL -= aUL[allpasstemp]*constallpass;
+				aUL[alpUL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpUL--; if (alpUL < 0 || alpUL > delayU) {alpUL = delayU;}
+				inputSampleL += (aUL[alpUL]);
+				//allpass filter U
+				
+				dUL[2] = dUL[1];
+				dUL[1] = inputSampleL;
+				inputSampleL = (dUL[1] + dUL[2])/2.0;
+				
+				allpasstemp = alpVL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;}
+				inputSampleL -= aVL[allpasstemp]*constallpass;
+				aVL[alpVL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpVL--; if (alpVL < 0 || alpVL > delayV) {alpVL = delayV;}
+				inputSampleL += (aVL[alpVL]);
+				//allpass filter V
+				
+				dVL[2] = dVL[1];
+				dVL[1] = inputSampleL;
+				inputSampleL = (dVL[1] + dVL[2])/2.0;
+				
+				allpasstemp = alpWL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;}
+				inputSampleL -= aWL[allpasstemp]*constallpass;
+				aWL[alpWL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpWL--; if (alpWL < 0 || alpWL > delayW) {alpWL = delayW;}
+				inputSampleL += (aWL[alpWL]);
+				//allpass filter W
+				
+				dWL[2] = dWL[1];
+				dWL[1] = inputSampleL;
+				inputSampleL = (dWL[1] + dWL[2])/2.0;
+				
+				allpasstemp = alpXL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;}
+				inputSampleL -= aXL[allpasstemp]*constallpass;
+				aXL[alpXL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpXL--; if (alpXL < 0 || alpXL > delayX) {alpXL = delayX;}
+				inputSampleL += (aXL[alpXL]);
+				//allpass filter X
+				
+				dXL[2] = dXL[1];
+				dXL[1] = inputSampleL;
+				inputSampleL = (dXL[1] + dXL[2])/2.0;
+				
+				allpasstemp = alpYL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;}
+				inputSampleL -= aYL[allpasstemp]*constallpass;
+				aYL[alpYL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpYL--; if (alpYL < 0 || alpYL > delayY) {alpYL = delayY;}
+				inputSampleL += (aYL[alpYL]);
+				//allpass filter Y
+				
+				dYL[2] = dYL[1];
+				dYL[1] = inputSampleL;
+				inputSampleL = (dYL[1] + dYL[2])/2.0;
+				
+				allpasstemp = alpZL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;}
+				inputSampleL -= aZL[allpasstemp]*constallpass;
+				aZL[alpZL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpZL--; if (alpZL < 0 || alpZL > delayZ) {alpZL = delayZ;}
+				inputSampleL += (aZL[alpZL]);
+				//allpass filter Z
+				
+				dZL[2] = dZL[1];
+				dZL[1] = inputSampleL;
+				inputSampleL = (dZL[1] + dZL[2])/2.0;
+				
+				// now the second stage using the 'out' bank of allpasses		
+				
+				allpasstemp = outAL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;}
+				inputSampleL -= oAL[allpasstemp]*constallpass;
+				oAL[outAL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outAL--; if (outAL < 0 || outAL > delayA) {outAL = delayA;}
+				inputSampleL += (oAL[outAL]);
+				//allpass filter A		
+				
+				dAL[5] = dAL[4];
+				dAL[4] = inputSampleL;
+				inputSampleL = (dAL[4] + dAL[5])/2.0;
+				
+				allpasstemp = outBL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;}
+				inputSampleL -= oBL[allpasstemp]*constallpass;
+				oBL[outBL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outBL--; if (outBL < 0 || outBL > delayB) {outBL = delayB;}
+				inputSampleL += (oBL[outBL]);
+				//allpass filter B
+				
+				dBL[5] = dBL[4];
+				dBL[4] = inputSampleL;
+				inputSampleL = (dBL[4] + dBL[5])/2.0;
+				
+				allpasstemp = outCL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;}
+				inputSampleL -= oCL[allpasstemp]*constallpass;
+				oCL[outCL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outCL--; if (outCL < 0 || outCL > delayC) {outCL = delayC;}
+				inputSampleL += (oCL[outCL]);
+				//allpass filter C
+				
+				dCL[5] = dCL[4];
+				dCL[4] = inputSampleL;
+				inputSampleL = (dCL[4] + dCL[5])/2.0;
+				
+				allpasstemp = outDL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;}
+				inputSampleL -= oDL[allpasstemp]*constallpass;
+				oDL[outDL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outDL--; if (outDL < 0 || outDL > delayD) {outDL = delayD;}
+				inputSampleL += (oDL[outDL]);
+				//allpass filter D
+				
+				dDL[5] = dDL[4];
+				dDL[4] = inputSampleL;
+				inputSampleL = (dDL[4] + dDL[5])/2.0;
+				
+				allpasstemp = outEL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;}
+				inputSampleL -= oEL[allpasstemp]*constallpass;
+				oEL[outEL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outEL--; if (outEL < 0 || outEL > delayE) {outEL = delayE;}
+				inputSampleL += (oEL[outEL]);
+				//allpass filter E
+				
+				dEL[5] = dEL[4];
+				dEL[4] = inputSampleL;
+				inputSampleL = (dEL[4] + dEL[5])/2.0;
+				
+				allpasstemp = outFL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;}
+				inputSampleL -= oFL[allpasstemp]*constallpass;
+				oFL[outFL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outFL--; if (outFL < 0 || outFL > delayF) {outFL = delayF;}
+				inputSampleL += (oFL[outFL]);
+				//allpass filter F
+				
+				dFL[5] = dFL[4];
+				dFL[4] = inputSampleL;
+				inputSampleL = (dFL[4] + dFL[5])/2.0;
+				
+				allpasstemp = outGL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;}
+				inputSampleL -= oGL[allpasstemp]*constallpass;
+				oGL[outGL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outGL--; if (outGL < 0 || outGL > delayG) {outGL = delayG;}
+				inputSampleL += (oGL[outGL]);
+				//allpass filter G
+				
+				dGL[5] = dGL[4];
+				dGL[4] = inputSampleL;
+				inputSampleL = (dGL[4] + dGL[5])/2.0;
+				
+				allpasstemp = outHL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;}
+				inputSampleL -= oHL[allpasstemp]*constallpass;
+				oHL[outHL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outHL--; if (outHL < 0 || outHL > delayH) {outHL = delayH;}
+				inputSampleL += (oHL[outHL]);
+				//allpass filter H
+				
+				dHL[5] = dHL[4];
+				dHL[4] = inputSampleL;
+				inputSampleL = (dHL[4] + dHL[5])/2.0;
+				
+				allpasstemp = outIL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;}
+				inputSampleL -= oIL[allpasstemp]*constallpass;
+				oIL[outIL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outIL--; if (outIL < 0 || outIL > delayI) {outIL = delayI;}
+				inputSampleL += (oIL[outIL]);
+				//allpass filter I
+				
+				dIL[5] = dIL[4];
+				dIL[4] = inputSampleL;
+				inputSampleL = (dIL[4] + dIL[5])/2.0;
+				
+				allpasstemp = outJL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;}
+				inputSampleL -= oJL[allpasstemp]*constallpass;
+				oJL[outJL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outJL--; if (outJL < 0 || outJL > delayJ) {outJL = delayJ;}
+				inputSampleL += (oJL[outJL]);
+				//allpass filter J
+				
+				dJL[5] = dJL[4];
+				dJL[4] = inputSampleL;
+				inputSampleL = (dJL[4] + dJL[5])/2.0;
+				
+				allpasstemp = outKL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;}
+				inputSampleL -= oKL[allpasstemp]*constallpass;
+				oKL[outKL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outKL--; if (outKL < 0 || outKL > delayK) {outKL = delayK;}
+				inputSampleL += (oKL[outKL]);
+				//allpass filter K
+				
+				dKL[5] = dKL[4];
+				dKL[4] = inputSampleL;
+				inputSampleL = (dKL[4] + dKL[5])/2.0;
+				
+				allpasstemp = outLL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;}
+				inputSampleL -= oLL[allpasstemp]*constallpass;
+				oLL[outLL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outLL--; if (outLL < 0 || outLL > delayL) {outLL = delayL;}
+				inputSampleL += (oLL[outLL]);
+				//allpass filter L
+				
+				dLL[5] = dLL[4];
+				dLL[4] = inputSampleL;
+				inputSampleL = (dLL[4] + dLL[5])/2.0;
+				
+				allpasstemp = outML - 1;
+				if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;}
+				inputSampleL -= oML[allpasstemp]*constallpass;
+				oML[outML] = inputSampleL;
+				inputSampleL *= constallpass;
+				outML--; if (outML < 0 || outML > delayM) {outML = delayM;}
+				inputSampleL += (oML[outML]);
+				//allpass filter M
+				
+				dML[5] = dML[4];
+				dML[4] = inputSampleL;
+				inputSampleL = (dML[4] + dML[5])/2.0;
+				
+				allpasstemp = outNL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;}
+				inputSampleL -= oNL[allpasstemp]*constallpass;
+				oNL[outNL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outNL--; if (outNL < 0 || outNL > delayN) {outNL = delayN;}
+				inputSampleL += (oNL[outNL]);
+				//allpass filter N
+				
+				dNL[5] = dNL[4];
+				dNL[4] = inputSampleL;
+				inputSampleL = (dNL[4] + dNL[5])/2.0;
+				
+				allpasstemp = outOL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;}
+				inputSampleL -= oOL[allpasstemp]*constallpass;
+				oOL[outOL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outOL--; if (outOL < 0 || outOL > delayO) {outOL = delayO;}
+				inputSampleL += (oOL[outOL]);
+				//allpass filter O
+				
+				dOL[5] = dOL[4];
+				dOL[4] = inputSampleL;
+				inputSampleL = (dOL[4] + dOL[5])/2.0;
+				
+				allpasstemp = outPL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;}
+				inputSampleL -= oPL[allpasstemp]*constallpass;
+				oPL[outPL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outPL--; if (outPL < 0 || outPL > delayP) {outPL = delayP;}
+				inputSampleL += (oPL[outPL]);
+				//allpass filter P
+				
+				dPL[5] = dPL[4];
+				dPL[4] = inputSampleL;
+				inputSampleL = (dPL[4] + dPL[5])/2.0;
+				
+				allpasstemp = outQL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;}
+				inputSampleL -= oQL[allpasstemp]*constallpass;
+				oQL[outQL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outQL--; if (outQL < 0 || outQL > delayQ) {outQL = delayQ;}
+				inputSampleL += (oQL[outQL]);
+				//allpass filter Q
+				
+				dQL[5] = dQL[4];
+				dQL[4] = inputSampleL;
+				inputSampleL = (dQL[4] + dQL[5])/2.0;
+				
+				allpasstemp = outRL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;}
+				inputSampleL -= oRL[allpasstemp]*constallpass;
+				oRL[outRL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outRL--; if (outRL < 0 || outRL > delayR) {outRL = delayR;}
+				inputSampleL += (oRL[outRL]);
+				//allpass filter R
+				
+				dRL[5] = dRL[4];
+				dRL[4] = inputSampleL;
+				inputSampleL = (dRL[4] + dRL[5])/2.0;
+				
+				allpasstemp = outSL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;}
+				inputSampleL -= oSL[allpasstemp]*constallpass;
+				oSL[outSL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outSL--; if (outSL < 0 || outSL > delayS) {outSL = delayS;}
+				inputSampleL += (oSL[outSL]);
+				//allpass filter S
+				
+				dSL[5] = dSL[4];
+				dSL[4] = inputSampleL;
+				inputSampleL = (dSL[4] + dSL[5])/2.0;
+				
+				allpasstemp = outTL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;}
+				inputSampleL -= oTL[allpasstemp]*constallpass;
+				oTL[outTL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outTL--; if (outTL < 0 || outTL > delayT) {outTL = delayT;}
+				inputSampleL += (oTL[outTL]);
+				//allpass filter T
+				
+				dTL[5] = dTL[4];
+				dTL[4] = inputSampleL;
+				inputSampleL = (dTL[4] + dTL[5])/2.0;
+				
+				allpasstemp = outUL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;}
+				inputSampleL -= oUL[allpasstemp]*constallpass;
+				oUL[outUL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outUL--; if (outUL < 0 || outUL > delayU) {outUL = delayU;}
+				inputSampleL += (oUL[outUL]);
+				//allpass filter U
+				
+				dUL[5] = dUL[4];
+				dUL[4] = inputSampleL;
+				inputSampleL = (dUL[4] + dUL[5])/2.0;
+				
+				allpasstemp = outVL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;}
+				inputSampleL -= oVL[allpasstemp]*constallpass;
+				oVL[outVL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outVL--; if (outVL < 0 || outVL > delayV) {outVL = delayV;}
+				inputSampleL += (oVL[outVL]);
+				//allpass filter V
+				
+				dVL[5] = dVL[4];
+				dVL[4] = inputSampleL;
+				inputSampleL = (dVL[4] + dVL[5])/2.0;
+				
+				allpasstemp = outWL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;}
+				inputSampleL -= oWL[allpasstemp]*constallpass;
+				oWL[outWL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outWL--; if (outWL < 0 || outWL > delayW) {outWL = delayW;}
+				inputSampleL += (oWL[outWL]);
+				//allpass filter W
+				
+				dWL[5] = dWL[4];
+				dWL[4] = inputSampleL;
+				inputSampleL = (dWL[4] + dWL[5])/2.0;
+				
+				allpasstemp = outXL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;}
+				inputSampleL -= oXL[allpasstemp]*constallpass;
+				oXL[outXL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outXL--; if (outXL < 0 || outXL > delayX) {outXL = delayX;}
+				inputSampleL += (oXL[outXL]);
+				//allpass filter X
+				
+				dXL[5] = dXL[4];
+				dXL[4] = inputSampleL;
+				inputSampleL = (dXL[4] + dXL[5])/2.0;
+				
+				allpasstemp = outYL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;}
+				inputSampleL -= oYL[allpasstemp]*constallpass;
+				oYL[outYL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outYL--; if (outYL < 0 || outYL > delayY) {outYL = delayY;}
+				inputSampleL += (oYL[outYL]);
+				//allpass filter Y
+				
+				dYL[5] = dYL[4];
+				dYL[4] = inputSampleL;
+				inputSampleL = (dYL[4] + dYL[5])/2.0;
+				
+				allpasstemp = outZL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;}
+				inputSampleL -= oZL[allpasstemp]*constallpass;
+				oZL[outZL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outZL--; if (outZL < 0 || outZL > delayZ) {outZL = delayZ;}
+				inputSampleL += (oZL[outZL]);
+				//allpass filter Z
+				
+				dZL[5] = dZL[4];
+				dZL[4] = inputSampleL;
+				inputSampleL = (dZL[4] + dZL[5])/2.0;		
+				//output Stretch unrealistic but smooth fake Paulstretch
+				break;				
+				
+				
+			case 6:	//Zarathustra	
+				allpasstemp = alpAL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;}
+				inputSampleL -= aAL[allpasstemp]*constallpass;
+				aAL[alpAL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpAL--; if (alpAL < 0 || alpAL > delayA) {alpAL = delayA;}
+				inputSampleL += (aAL[alpAL]);
+				//allpass filter A		
+				
+				dAL[3] = dAL[2];
+				dAL[2] = dAL[1];
+				dAL[1] = inputSampleL;
+				inputSampleL = (dAL[1] + dAL[2] + dZL[3])/3.0; //add feedback
+				
+				allpasstemp = alpBL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;}
+				inputSampleL -= aBL[allpasstemp]*constallpass;
+				aBL[alpBL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpBL--; if (alpBL < 0 || alpBL > delayB) {alpBL = delayB;}
+				inputSampleL += (aBL[alpBL]);
+				//allpass filter B
+				
+				dBL[3] = dBL[2];
+				dBL[2] = dBL[1];
+				dBL[1] = inputSampleL;
+				inputSampleL = (dBL[1] + dBL[2] + dBL[3])/3.0;
+				
+				allpasstemp = alpCL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;}
+				inputSampleL -= aCL[allpasstemp]*constallpass;
+				aCL[alpCL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpCL--; if (alpCL < 0 || alpCL > delayC) {alpCL = delayC;}
+				inputSampleL += (aCL[alpCL]);
+				//allpass filter C
+				
+				dCL[3] = dCL[2];
+				dCL[2] = dCL[1];
+				dCL[1] = inputSampleL;
+				inputSampleL = (dCL[1] + dCL[2] + dCL[3])/3.0;
+				
+				allpasstemp = alpDL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;}
+				inputSampleL -= aDL[allpasstemp]*constallpass;
+				aDL[alpDL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpDL--; if (alpDL < 0 || alpDL > delayD) {alpDL = delayD;}
+				inputSampleL += (aDL[alpDL]);
+				//allpass filter D
+				
+				dDL[3] = dDL[2];
+				dDL[2] = dDL[1];
+				dDL[1] = inputSampleL;
+				inputSampleL = (dDL[1] + dDL[2] + dDL[3])/3.0;
+				
+				allpasstemp = alpEL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;}
+				inputSampleL -= aEL[allpasstemp]*constallpass;
+				aEL[alpEL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpEL--; if (alpEL < 0 || alpEL > delayE) {alpEL = delayE;}
+				inputSampleL += (aEL[alpEL]);
+				//allpass filter E
+				
+				dEL[3] = dEL[2];
+				dEL[2] = dEL[1];
+				dEL[1] = inputSampleL;
+				inputSampleL = (dEL[1] + dEL[2] + dEL[3])/3.0;
+				
+				allpasstemp = alpFL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;}
+				inputSampleL -= aFL[allpasstemp]*constallpass;
+				aFL[alpFL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpFL--; if (alpFL < 0 || alpFL > delayF) {alpFL = delayF;}
+				inputSampleL += (aFL[alpFL]);
+				//allpass filter F
+				
+				dFL[3] = dFL[2];
+				dFL[2] = dFL[1];
+				dFL[1] = inputSampleL;
+				inputSampleL = (dFL[1] + dFL[2] + dFL[3])/3.0;
+				
+				allpasstemp = alpGL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;}
+				inputSampleL -= aGL[allpasstemp]*constallpass;
+				aGL[alpGL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpGL--; if (alpGL < 0 || alpGL > delayG) {alpGL = delayG;}
+				inputSampleL += (aGL[alpGL]);
+				//allpass filter G
+				
+				dGL[3] = dGL[2];
+				dGL[2] = dGL[1];
+				dGL[1] = inputSampleL;
+				inputSampleL = (dGL[1] + dGL[2] + dGL[3])/3.0;
+				
+				allpasstemp = alpHL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;}
+				inputSampleL -= aHL[allpasstemp]*constallpass;
+				aHL[alpHL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpHL--; if (alpHL < 0 || alpHL > delayH) {alpHL = delayH;}
+				inputSampleL += (aHL[alpHL]);
+				//allpass filter H
+				
+				dHL[3] = dHL[2];
+				dHL[2] = dHL[1];
+				dHL[1] = inputSampleL;
+				inputSampleL = (dHL[1] + dHL[2] + dHL[3])/3.0;
+				
+				allpasstemp = alpIL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;}
+				inputSampleL -= aIL[allpasstemp]*constallpass;
+				aIL[alpIL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpIL--; if (alpIL < 0 || alpIL > delayI) {alpIL = delayI;}
+				inputSampleL += (aIL[alpIL]);
+				//allpass filter I
+				
+				dIL[3] = dIL[2];
+				dIL[2] = dIL[1];
+				dIL[1] = inputSampleL;
+				inputSampleL = (dIL[1] + dIL[2] + dIL[3])/3.0;
+				
+				allpasstemp = alpJL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;}
+				inputSampleL -= aJL[allpasstemp]*constallpass;
+				aJL[alpJL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpJL--; if (alpJL < 0 || alpJL > delayJ) {alpJL = delayJ;}
+				inputSampleL += (aJL[alpJL]);
+				//allpass filter J
+				
+				dJL[3] = dJL[2];
+				dJL[2] = dJL[1];
+				dJL[1] = inputSampleL;
+				inputSampleL = (dJL[1] + dJL[2] + dJL[3])/3.0;
+				
+				allpasstemp = alpKL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;}
+				inputSampleL -= aKL[allpasstemp]*constallpass;
+				aKL[alpKL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpKL--; if (alpKL < 0 || alpKL > delayK) {alpKL = delayK;}
+				inputSampleL += (aKL[alpKL]);
+				//allpass filter K
+				
+				dKL[3] = dKL[2];
+				dKL[2] = dKL[1];
+				dKL[1] = inputSampleL;
+				inputSampleL = (dKL[1] + dKL[2] + dKL[3])/3.0;
+				
+				allpasstemp = alpLL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;}
+				inputSampleL -= aLL[allpasstemp]*constallpass;
+				aLL[alpLL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpLL--; if (alpLL < 0 || alpLL > delayL) {alpLL = delayL;}
+				inputSampleL += (aLL[alpLL]);
+				//allpass filter L
+				
+				dLL[3] = dLL[2];
+				dLL[2] = dLL[1];
+				dLL[1] = inputSampleL;
+				inputSampleL = (dLL[1] + dLL[2] + dLL[3])/3.0;
+				
+				allpasstemp = alpML - 1;
+				if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;}
+				inputSampleL -= aML[allpasstemp]*constallpass;
+				aML[alpML] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpML--; if (alpML < 0 || alpML > delayM) {alpML = delayM;}
+				inputSampleL += (aML[alpML]);
+				//allpass filter M
+				
+				dML[3] = dML[2];
+				dML[2] = dML[1];
+				dML[1] = inputSampleL;
+				inputSampleL = (dML[1] + dML[2] + dML[3])/3.0;
+				
+				allpasstemp = alpNL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;}
+				inputSampleL -= aNL[allpasstemp]*constallpass;
+				aNL[alpNL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpNL--; if (alpNL < 0 || alpNL > delayN) {alpNL = delayN;}
+				inputSampleL += (aNL[alpNL]);
+				//allpass filter N
+				
+				dNL[3] = dNL[2];
+				dNL[2] = dNL[1];
+				dNL[1] = inputSampleL;
+				inputSampleL = (dNL[1] + dNL[2] + dNL[3])/3.0;
+				
+				allpasstemp = alpOL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;}
+				inputSampleL -= aOL[allpasstemp]*constallpass;
+				aOL[alpOL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpOL--; if (alpOL < 0 || alpOL > delayO) {alpOL = delayO;}
+				inputSampleL += (aOL[alpOL]);
+				//allpass filter O
+				
+				dOL[3] = dOL[2];
+				dOL[2] = dOL[1];
+				dOL[1] = inputSampleL;
+				inputSampleL = (dOL[1] + dOL[2] + dOL[3])/3.0;
+				
+				allpasstemp = alpPL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;}
+				inputSampleL -= aPL[allpasstemp]*constallpass;
+				aPL[alpPL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpPL--; if (alpPL < 0 || alpPL > delayP) {alpPL = delayP;}
+				inputSampleL += (aPL[alpPL]);
+				//allpass filter P
+				
+				dPL[3] = dPL[2];
+				dPL[2] = dPL[1];
+				dPL[1] = inputSampleL;
+				inputSampleL = (dPL[1] + dPL[2] + dPL[3])/3.0;
+				
+				allpasstemp = alpQL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;}
+				inputSampleL -= aQL[allpasstemp]*constallpass;
+				aQL[alpQL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpQL--; if (alpQL < 0 || alpQL > delayQ) {alpQL = delayQ;}
+				inputSampleL += (aQL[alpQL]);
+				//allpass filter Q
+				
+				dQL[3] = dQL[2];
+				dQL[2] = dQL[1];
+				dQL[1] = inputSampleL;
+				inputSampleL = (dQL[1] + dQL[2] + dQL[3])/3.0;
+				
+				allpasstemp = alpRL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;}
+				inputSampleL -= aRL[allpasstemp]*constallpass;
+				aRL[alpRL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpRL--; if (alpRL < 0 || alpRL > delayR) {alpRL = delayR;}
+				inputSampleL += (aRL[alpRL]);
+				//allpass filter R
+				
+				dRL[3] = dRL[2];
+				dRL[2] = dRL[1];
+				dRL[1] = inputSampleL;
+				inputSampleL = (dRL[1] + dRL[2] + dRL[3])/3.0;
+				
+				allpasstemp = alpSL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;}
+				inputSampleL -= aSL[allpasstemp]*constallpass;
+				aSL[alpSL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpSL--; if (alpSL < 0 || alpSL > delayS) {alpSL = delayS;}
+				inputSampleL += (aSL[alpSL]);
+				//allpass filter S
+				
+				dSL[3] = dSL[2];
+				dSL[2] = dSL[1];
+				dSL[1] = inputSampleL;
+				inputSampleL = (dSL[1] + dSL[2] + dSL[3])/3.0;
+				
+				allpasstemp = alpTL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;}
+				inputSampleL -= aTL[allpasstemp]*constallpass;
+				aTL[alpTL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpTL--; if (alpTL < 0 || alpTL > delayT) {alpTL = delayT;}
+				inputSampleL += (aTL[alpTL]);
+				//allpass filter T
+				
+				dTL[3] = dTL[2];
+				dTL[2] = dTL[1];
+				dTL[1] = inputSampleL;
+				inputSampleL = (dTL[1] + dTL[2] + dTL[3])/3.0;
+				
+				allpasstemp = alpUL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;}
+				inputSampleL -= aUL[allpasstemp]*constallpass;
+				aUL[alpUL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpUL--; if (alpUL < 0 || alpUL > delayU) {alpUL = delayU;}
+				inputSampleL += (aUL[alpUL]);
+				//allpass filter U
+				
+				dUL[3] = dUL[2];
+				dUL[2] = dUL[1];
+				dUL[1] = inputSampleL;
+				inputSampleL = (dUL[1] + dUL[2] + dUL[3])/3.0;
+				
+				allpasstemp = alpVL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;}
+				inputSampleL -= aVL[allpasstemp]*constallpass;
+				aVL[alpVL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpVL--; if (alpVL < 0 || alpVL > delayV) {alpVL = delayV;}
+				inputSampleL += (aVL[alpVL]);
+				//allpass filter V
+				
+				dVL[3] = dVL[2];
+				dVL[2] = dVL[1];
+				dVL[1] = inputSampleL;
+				inputSampleL = (dVL[1] + dVL[2] + dVL[3])/3.0;
+				
+				allpasstemp = alpWL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;}
+				inputSampleL -= aWL[allpasstemp]*constallpass;
+				aWL[alpWL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpWL--; if (alpWL < 0 || alpWL > delayW) {alpWL = delayW;}
+				inputSampleL += (aWL[alpWL]);
+				//allpass filter W
+				
+				dWL[3] = dWL[2];
+				dWL[2] = dWL[1];
+				dWL[1] = inputSampleL;
+				inputSampleL = (dWL[1] + dWL[2] + dWL[3])/3.0;
+				
+				allpasstemp = alpXL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;}
+				inputSampleL -= aXL[allpasstemp]*constallpass;
+				aXL[alpXL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpXL--; if (alpXL < 0 || alpXL > delayX) {alpXL = delayX;}
+				inputSampleL += (aXL[alpXL]);
+				//allpass filter X
+				
+				dXL[3] = dXL[2];
+				dXL[2] = dXL[1];
+				dXL[1] = inputSampleL;
+				inputSampleL = (dXL[1] + dXL[2] + dXL[3])/3.0;
+				
+				allpasstemp = alpYL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;}
+				inputSampleL -= aYL[allpasstemp]*constallpass;
+				aYL[alpYL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpYL--; if (alpYL < 0 || alpYL > delayY) {alpYL = delayY;}
+				inputSampleL += (aYL[alpYL]);
+				//allpass filter Y
+				
+				dYL[3] = dYL[2];
+				dYL[2] = dYL[1];
+				dYL[1] = inputSampleL;
+				inputSampleL = (dYL[1] + dYL[2] + dYL[3])/3.0;
+				
+				allpasstemp = alpZL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;}
+				inputSampleL -= aZL[allpasstemp]*constallpass;
+				aZL[alpZL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpZL--; if (alpZL < 0 || alpZL > delayZ) {alpZL = delayZ;}
+				inputSampleL += (aZL[alpZL]);
+				//allpass filter Z
+				
+				dZL[3] = dZL[2];
+				dZL[2] = dZL[1];
+				dZL[1] = inputSampleL;
+				inputSampleL = (dZL[1] + dZL[2] + dZL[3])/3.0;
+				
+				// now the second stage using the 'out' bank of allpasses		
+				
+				allpasstemp = outAL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;}
+				inputSampleL -= oAL[allpasstemp]*constallpass;
+				oAL[outAL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outAL--; if (outAL < 0 || outAL > delayA) {outAL = delayA;}
+				inputSampleL += (oAL[outAL]);
+				//allpass filter A		
+				
+				dAL[6] = dAL[5];
+				dAL[5] = dAL[4];
+				dAL[4] = inputSampleL;
+				inputSampleL = (dCL[1] + dAL[5] + dAL[6])/3.0;  //note, feeding in dry again for a little more clarity!
+				
+				allpasstemp = outBL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;}
+				inputSampleL -= oBL[allpasstemp]*constallpass;
+				oBL[outBL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outBL--; if (outBL < 0 || outBL > delayB) {outBL = delayB;}
+				inputSampleL += (oBL[outBL]);
+				//allpass filter B
+				
+				dBL[6] = dBL[5];
+				dBL[5] = dBL[4];
+				dBL[4] = inputSampleL;
+				inputSampleL = (dBL[4] + dBL[5] + dBL[6])/3.0;
+				
+				allpasstemp = outCL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;}
+				inputSampleL -= oCL[allpasstemp]*constallpass;
+				oCL[outCL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outCL--; if (outCL < 0 || outCL > delayC) {outCL = delayC;}
+				inputSampleL += (oCL[outCL]);
+				//allpass filter C
+				
+				dCL[6] = dCL[5];
+				dCL[5] = dCL[4];
+				dCL[4] = inputSampleL;
+				inputSampleL = (dCL[4] + dCL[5] + dCL[6])/3.0;
+				
+				allpasstemp = outDL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;}
+				inputSampleL -= oDL[allpasstemp]*constallpass;
+				oDL[outDL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outDL--; if (outDL < 0 || outDL > delayD) {outDL = delayD;}
+				inputSampleL += (oDL[outDL]);
+				//allpass filter D
+				
+				dDL[6] = dDL[5];
+				dDL[5] = dDL[4];
+				dDL[4] = inputSampleL;
+				inputSampleL = (dDL[4] + dDL[5] + dDL[6])/3.0;
+				
+				allpasstemp = outEL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;}
+				inputSampleL -= oEL[allpasstemp]*constallpass;
+				oEL[outEL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outEL--; if (outEL < 0 || outEL > delayE) {outEL = delayE;}
+				inputSampleL += (oEL[outEL]);
+				//allpass filter E
+				
+				dEL[6] = dEL[5];
+				dEL[5] = dEL[4];
+				dEL[4] = inputSampleL;
+				inputSampleL = (dEL[4] + dEL[5] + dEL[6])/3.0;
+				
+				allpasstemp = outFL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;}
+				inputSampleL -= oFL[allpasstemp]*constallpass;
+				oFL[outFL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outFL--; if (outFL < 0 || outFL > delayF) {outFL = delayF;}
+				inputSampleL += (oFL[outFL]);
+				//allpass filter F
+				
+				dFL[6] = dFL[5];
+				dFL[5] = dFL[4];
+				dFL[4] = inputSampleL;
+				inputSampleL = (dFL[4] + dFL[5] + dFL[6])/3.0;
+				
+				allpasstemp = outGL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;}
+				inputSampleL -= oGL[allpasstemp]*constallpass;
+				oGL[outGL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outGL--; if (outGL < 0 || outGL > delayG) {outGL = delayG;}
+				inputSampleL += (oGL[outGL]);
+				//allpass filter G
+				
+				dGL[6] = dGL[5];
+				dGL[5] = dGL[4];
+				dGL[4] = inputSampleL;
+				inputSampleL = (dGL[4] + dGL[5] + dGL[6])/3.0;
+				
+				allpasstemp = outHL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;}
+				inputSampleL -= oHL[allpasstemp]*constallpass;
+				oHL[outHL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outHL--; if (outHL < 0 || outHL > delayH) {outHL = delayH;}
+				inputSampleL += (oHL[outHL]);
+				//allpass filter H
+				
+				dHL[6] = dHL[5];
+				dHL[5] = dHL[4];
+				dHL[4] = inputSampleL;
+				inputSampleL = (dHL[4] + dHL[5] + dHL[6])/3.0;
+				
+				allpasstemp = outIL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;}
+				inputSampleL -= oIL[allpasstemp]*constallpass;
+				oIL[outIL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outIL--; if (outIL < 0 || outIL > delayI) {outIL = delayI;}
+				inputSampleL += (oIL[outIL]);
+				//allpass filter I
+				
+				dIL[6] = dIL[5];
+				dIL[5] = dIL[4];
+				dIL[4] = inputSampleL;
+				inputSampleL = (dIL[4] + dIL[5] + dIL[6])/3.0;
+				
+				allpasstemp = outJL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;}
+				inputSampleL -= oJL[allpasstemp]*constallpass;
+				oJL[outJL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outJL--; if (outJL < 0 || outJL > delayJ) {outJL = delayJ;}
+				inputSampleL += (oJL[outJL]);
+				//allpass filter J
+				
+				dJL[6] = dJL[5];
+				dJL[5] = dJL[4];
+				dJL[4] = inputSampleL;
+				inputSampleL = (dJL[4] + dJL[5] + dJL[6])/3.0;
+				
+				allpasstemp = outKL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;}
+				inputSampleL -= oKL[allpasstemp]*constallpass;
+				oKL[outKL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outKL--; if (outKL < 0 || outKL > delayK) {outKL = delayK;}
+				inputSampleL += (oKL[outKL]);
+				//allpass filter K
+				
+				dKL[6] = dKL[5];
+				dKL[5] = dKL[4];
+				dKL[4] = inputSampleL;
+				inputSampleL = (dKL[4] + dKL[5] + dKL[6])/3.0;
+				
+				allpasstemp = outLL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;}
+				inputSampleL -= oLL[allpasstemp]*constallpass;
+				oLL[outLL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outLL--; if (outLL < 0 || outLL > delayL) {outLL = delayL;}
+				inputSampleL += (oLL[outLL]);
+				//allpass filter L
+				
+				dLL[6] = dLL[5];
+				dLL[5] = dLL[4];
+				dLL[4] = inputSampleL;
+				inputSampleL = (dLL[4] + dLL[5] + dLL[6])/3.0;
+				
+				allpasstemp = outML - 1;
+				if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;}
+				inputSampleL -= oML[allpasstemp]*constallpass;
+				oML[outML] = inputSampleL;
+				inputSampleL *= constallpass;
+				outML--; if (outML < 0 || outML > delayM) {outML = delayM;}
+				inputSampleL += (oML[outML]);
+				//allpass filter M
+				
+				dML[6] = dML[5];
+				dML[5] = dML[4];
+				dML[4] = inputSampleL;
+				inputSampleL = (dML[4] + dML[5] + dML[6])/3.0;
+				
+				allpasstemp = outNL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;}
+				inputSampleL -= oNL[allpasstemp]*constallpass;
+				oNL[outNL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outNL--; if (outNL < 0 || outNL > delayN) {outNL = delayN;}
+				inputSampleL += (oNL[outNL]);
+				//allpass filter N
+				
+				dNL[6] = dNL[5];
+				dNL[5] = dNL[4];
+				dNL[4] = inputSampleL;
+				inputSampleL = (dNL[4] + dNL[5] + dNL[6])/3.0;
+				
+				allpasstemp = outOL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;}
+				inputSampleL -= oOL[allpasstemp]*constallpass;
+				oOL[outOL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outOL--; if (outOL < 0 || outOL > delayO) {outOL = delayO;}
+				inputSampleL += (oOL[outOL]);
+				//allpass filter O
+				
+				dOL[6] = dOL[5];
+				dOL[5] = dOL[4];
+				dOL[4] = inputSampleL;
+				inputSampleL = (dOL[4] + dOL[5] + dOL[6])/3.0;
+				
+				allpasstemp = outPL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;}
+				inputSampleL -= oPL[allpasstemp]*constallpass;
+				oPL[outPL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outPL--; if (outPL < 0 || outPL > delayP) {outPL = delayP;}
+				inputSampleL += (oPL[outPL]);
+				//allpass filter P
+				
+				dPL[6] = dPL[5];
+				dPL[5] = dPL[4];
+				dPL[4] = inputSampleL;
+				inputSampleL = (dPL[4] + dPL[5] + dPL[6])/3.0;
+				
+				allpasstemp = outQL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;}
+				inputSampleL -= oQL[allpasstemp]*constallpass;
+				oQL[outQL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outQL--; if (outQL < 0 || outQL > delayQ) {outQL = delayQ;}
+				inputSampleL += (oQL[outQL]);
+				//allpass filter Q
+				
+				dQL[6] = dQL[5];
+				dQL[5] = dQL[4];
+				dQL[4] = inputSampleL;
+				inputSampleL = (dQL[4] + dQL[5] + dQL[6])/3.0;
+				
+				allpasstemp = outRL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;}
+				inputSampleL -= oRL[allpasstemp]*constallpass;
+				oRL[outRL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outRL--; if (outRL < 0 || outRL > delayR) {outRL = delayR;}
+				inputSampleL += (oRL[outRL]);
+				//allpass filter R
+				
+				dRL[6] = dRL[5];
+				dRL[5] = dRL[4];
+				dRL[4] = inputSampleL;
+				inputSampleL = (dRL[4] + dRL[5] + dRL[6])/3.0;
+				
+				allpasstemp = outSL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;}
+				inputSampleL -= oSL[allpasstemp]*constallpass;
+				oSL[outSL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outSL--; if (outSL < 0 || outSL > delayS) {outSL = delayS;}
+				inputSampleL += (oSL[outSL]);
+				//allpass filter S
+				
+				dSL[6] = dSL[5];
+				dSL[5] = dSL[4];
+				dSL[4] = inputSampleL;
+				inputSampleL = (dSL[4] + dSL[5] + dSL[6])/3.0;
+				
+				allpasstemp = outTL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;}
+				inputSampleL -= oTL[allpasstemp]*constallpass;
+				oTL[outTL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outTL--; if (outTL < 0 || outTL > delayT) {outTL = delayT;}
+				inputSampleL += (oTL[outTL]);
+				//allpass filter T
+				
+				dTL[6] = dTL[5];
+				dTL[5] = dTL[4];
+				dTL[4] = inputSampleL;
+				inputSampleL = (dTL[4] + dTL[5] + dTL[6])/3.0;
+				
+				allpasstemp = outUL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;}
+				inputSampleL -= oUL[allpasstemp]*constallpass;
+				oUL[outUL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outUL--; if (outUL < 0 || outUL > delayU) {outUL = delayU;}
+				inputSampleL += (oUL[outUL]);
+				//allpass filter U
+				
+				dUL[6] = dUL[5];
+				dUL[5] = dUL[4];
+				dUL[4] = inputSampleL;
+				inputSampleL = (dUL[4] + dUL[5] + dUL[6])/3.0;
+				
+				allpasstemp = outVL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;}
+				inputSampleL -= oVL[allpasstemp]*constallpass;
+				oVL[outVL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outVL--; if (outVL < 0 || outVL > delayV) {outVL = delayV;}
+				inputSampleL += (oVL[outVL]);
+				//allpass filter V
+				
+				dVL[6] = dVL[5];
+				dVL[5] = dVL[4];
+				dVL[4] = inputSampleL;
+				inputSampleL = (dVL[4] + dVL[5] + dVL[6])/3.0;
+				
+				allpasstemp = outWL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;}
+				inputSampleL -= oWL[allpasstemp]*constallpass;
+				oWL[outWL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outWL--; if (outWL < 0 || outWL > delayW) {outWL = delayW;}
+				inputSampleL += (oWL[outWL]);
+				//allpass filter W
+				
+				dWL[6] = dWL[5];
+				dWL[5] = dWL[4];
+				dWL[4] = inputSampleL;
+				inputSampleL = (dWL[4] + dWL[5] + dWL[6])/3.0;
+				
+				allpasstemp = outXL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;}
+				inputSampleL -= oXL[allpasstemp]*constallpass;
+				oXL[outXL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outXL--; if (outXL < 0 || outXL > delayX) {outXL = delayX;}
+				inputSampleL += (oXL[outXL]);
+				//allpass filter X
+				
+				dXL[6] = dXL[5];
+				dXL[5] = dXL[4];
+				dXL[4] = inputSampleL;
+				inputSampleL = (dXL[4] + dXL[5] + dXL[6])/3.0;
+				
+				allpasstemp = outYL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;}
+				inputSampleL -= oYL[allpasstemp]*constallpass;
+				oYL[outYL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outYL--; if (outYL < 0 || outYL > delayY) {outYL = delayY;}
+				inputSampleL += (oYL[outYL]);
+				//allpass filter Y
+				
+				dYL[6] = dYL[5];
+				dYL[5] = dYL[4];
+				dYL[4] = inputSampleL;
+				inputSampleL = (dYL[4] + dYL[5] + dYL[6])/3.0;
+				
+				allpasstemp = outZL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;}
+				inputSampleL -= oZL[allpasstemp]*constallpass;
+				oZL[outZL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outZL--; if (outZL < 0 || outZL > delayZ) {outZL = delayZ;}
+				inputSampleL += (oZL[outZL]);
+				//allpass filter Z
+				
+				dZL[6] = dZL[5];
+				dZL[5] = dZL[4];
+				dZL[4] = inputSampleL;
+				inputSampleL = (dZL[4] + dZL[5] + dZL[6]);		
+				//output Zarathustra infinite space verb
+				break;
+				
+		}
+		//end big switch for verb type
+		
+		switch (verbtype)
+		{
+				
+				
+			case 1://Chamber
+				allpasstemp = alpAR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;}
+				inputSampleR -= aAR[allpasstemp]*constallpass;
+				aAR[alpAR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpAR--; if (alpAR < 0 || alpAR > delayA) {alpAR = delayA;}
+				inputSampleR += (aAR[alpAR]);
+				//allpass filter A		
+				
+				dAR[3] = dAR[2];
+				dAR[2] = dAR[1];
+				dAR[1] = inputSampleR;
+				inputSampleR = (dAR[1] + dAR[2] + dAR[3])/3.0;
+				
+				allpasstemp = alpBR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;}
+				inputSampleR -= aBR[allpasstemp]*constallpass;
+				aBR[alpBR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpBR--; if (alpBR < 0 || alpBR > delayB) {alpBR = delayB;}
+				inputSampleR += (aBR[alpBR]);
+				//allpass filter B
+				
+				dBR[3] = dBR[2];
+				dBR[2] = dBR[1];
+				dBR[1] = inputSampleR;
+				inputSampleR = (dBR[1] + dBR[2] + dBR[3])/3.0;
+				
+				allpasstemp = alpCR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;}
+				inputSampleR -= aCR[allpasstemp]*constallpass;
+				aCR[alpCR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpCR--; if (alpCR < 0 || alpCR > delayC) {alpCR = delayC;}
+				inputSampleR += (aCR[alpCR]);
+				//allpass filter C
+				
+				dCR[3] = dCR[2];
+				dCR[2] = dCR[1];
+				dCR[1] = inputSampleR;
+				inputSampleR = (dAR[1] + dCR[2] + dCR[3])/3.0;
+				
+				allpasstemp = alpDR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;}
+				inputSampleR -= aDR[allpasstemp]*constallpass;
+				aDR[alpDR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpDR--; if (alpDR < 0 || alpDR > delayD) {alpDR = delayD;}
+				inputSampleR += (aDR[alpDR]);
+				//allpass filter D
+				
+				dDR[3] = dDR[2];
+				dDR[2] = dDR[1];
+				dDR[1] = inputSampleR;
+				inputSampleR = (dDR[1] + dDR[2] + dDR[3])/3.0;
+				
+				allpasstemp = alpER - 1;
+				if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;}
+				inputSampleR -= aER[allpasstemp]*constallpass;
+				aER[alpER] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpER--; if (alpER < 0 || alpER > delayE) {alpER = delayE;}
+				inputSampleR += (aER[alpER]);
+				//allpass filter E
+				
+				dER[3] = dER[2];
+				dER[2] = dER[1];
+				dER[1] = inputSampleR;
+				inputSampleR = (dAR[1] + dER[2] + dER[3])/3.0;
+				
+				allpasstemp = alpFR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;}
+				inputSampleR -= aFR[allpasstemp]*constallpass;
+				aFR[alpFR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpFR--; if (alpFR < 0 || alpFR > delayF) {alpFR = delayF;}
+				inputSampleR += (aFR[alpFR]);
+				//allpass filter F
+				
+				dFR[3] = dFR[2];
+				dFR[2] = dFR[1];
+				dFR[1] = inputSampleR;
+				inputSampleR = (dFR[1] + dFR[2] + dFR[3])/3.0;
+				
+				allpasstemp = alpGR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;}
+				inputSampleR -= aGR[allpasstemp]*constallpass;
+				aGR[alpGR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpGR--; if (alpGR < 0 || alpGR > delayG) {alpGR = delayG;}
+				inputSampleR += (aGR[alpGR]);
+				//allpass filter G
+				
+				dGR[3] = dGR[2];
+				dGR[2] = dGR[1];
+				dGR[1] = inputSampleR;
+				inputSampleR = (dAR[1] + dGR[2] + dGR[3])/3.0;
+				
+				allpasstemp = alpHR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;}
+				inputSampleR -= aHR[allpasstemp]*constallpass;
+				aHR[alpHR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpHR--; if (alpHR < 0 || alpHR > delayH) {alpHR = delayH;}
+				inputSampleR += (aHR[alpHR]);
+				//allpass filter H
+				
+				dHR[3] = dHR[2];
+				dHR[2] = dHR[1];
+				dHR[1] = inputSampleR;
+				inputSampleR = (dHR[1] + dHR[2] + dHR[3])/3.0;
+				
+				allpasstemp = alpIR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;}
+				inputSampleR -= aIR[allpasstemp]*constallpass;
+				aIR[alpIR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpIR--; if (alpIR < 0 || alpIR > delayI) {alpIR = delayI;}
+				inputSampleR += (aIR[alpIR]);
+				//allpass filter I
+				
+				dIR[3] = dIR[2];
+				dIR[2] = dIR[1];
+				dIR[1] = inputSampleR;
+				inputSampleR = (dIR[1] + dIR[2] + dIR[3])/3.0;
+				
+				allpasstemp = alpJR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;}
+				inputSampleR -= aJR[allpasstemp]*constallpass;
+				aJR[alpJR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpJR--; if (alpJR < 0 || alpJR > delayJ) {alpJR = delayJ;}
+				inputSampleR += (aJR[alpJR]);
+				//allpass filter J
+				
+				dJR[3] = dJR[2];
+				dJR[2] = dJR[1];
+				dJR[1] = inputSampleR;
+				inputSampleR = (dJR[1] + dJR[2] + dJR[3])/3.0;
+				
+				allpasstemp = alpKR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;}
+				inputSampleR -= aKR[allpasstemp]*constallpass;
+				aKR[alpKR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpKR--; if (alpKR < 0 || alpKR > delayK) {alpKR = delayK;}
+				inputSampleR += (aKR[alpKR]);
+				//allpass filter K
+				
+				dKR[3] = dKR[2];
+				dKR[2] = dKR[1];
+				dKR[1] = inputSampleR;
+				inputSampleR = (dAR[1] + dKR[2] + dKR[3])/3.0;
+				
+				allpasstemp = alpLR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;}
+				inputSampleR -= aLR[allpasstemp]*constallpass;
+				aLR[alpLR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpLR--; if (alpLR < 0 || alpLR > delayL) {alpLR = delayL;}
+				inputSampleR += (aLR[alpLR]);
+				//allpass filter L
+				
+				dLR[3] = dLR[2];
+				dLR[2] = dLR[1];
+				dLR[1] = inputSampleR;
+				inputSampleR = (dLR[1] + dLR[2] + dLR[3])/3.0;
+				
+				allpasstemp = alpMR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;}
+				inputSampleR -= aMR[allpasstemp]*constallpass;
+				aMR[alpMR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpMR--; if (alpMR < 0 || alpMR > delayM) {alpMR = delayM;}
+				inputSampleR += (aMR[alpMR]);
+				//allpass filter M
+				
+				dMR[3] = dMR[2];
+				dMR[2] = dMR[1];
+				dMR[1] = inputSampleR;
+				inputSampleR = (dAR[1] + dMR[2] + dMR[3])/3.0;
+				
+				allpasstemp = alpNR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;}
+				inputSampleR -= aNR[allpasstemp]*constallpass;
+				aNR[alpNR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpNR--; if (alpNR < 0 || alpNR > delayN) {alpNR = delayN;}
+				inputSampleR += (aNR[alpNR]);
+				//allpass filter N
+				
+				dNR[3] = dNR[2];
+				dNR[2] = dNR[1];
+				dNR[1] = inputSampleR;
+				inputSampleR = (dNR[1] + dNR[2] + dNR[3])/3.0;
+				
+				allpasstemp = alpOR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;}
+				inputSampleR -= aOR[allpasstemp]*constallpass;
+				aOR[alpOR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpOR--; if (alpOR < 0 || alpOR > delayO) {alpOR = delayO;}
+				inputSampleR += (aOR[alpOR]);
+				//allpass filter O
+				
+				dOR[3] = dOR[2];
+				dOR[2] = dOR[1];
+				dOR[1] = inputSampleR;
+				inputSampleR = (dOR[1] + dOR[2] + dOR[3])/3.0;
+				
+				allpasstemp = alpPR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;}
+				inputSampleR -= aPR[allpasstemp]*constallpass;
+				aPR[alpPR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpPR--; if (alpPR < 0 || alpPR > delayP) {alpPR = delayP;}
+				inputSampleR += (aPR[alpPR]);
+				//allpass filter P
+				
+				dPR[3] = dPR[2];
+				dPR[2] = dPR[1];
+				dPR[1] = inputSampleR;
+				inputSampleR = (dPR[1] + dPR[2] + dPR[3])/3.0;
+				
+				allpasstemp = alpQR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;}
+				inputSampleR -= aQR[allpasstemp]*constallpass;
+				aQR[alpQR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpQR--; if (alpQR < 0 || alpQR > delayQ) {alpQR = delayQ;}
+				inputSampleR += (aQR[alpQR]);
+				//allpass filter Q
+				
+				dQR[3] = dQR[2];
+				dQR[2] = dQR[1];
+				dQR[1] = inputSampleR;
+				inputSampleR = (dAR[1] + dQR[2] + dQR[3])/3.0;
+				
+				allpasstemp = alpRR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;}
+				inputSampleR -= aRR[allpasstemp]*constallpass;
+				aRR[alpRR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpRR--; if (alpRR < 0 || alpRR > delayR) {alpRR = delayR;}
+				inputSampleR += (aRR[alpRR]);
+				//allpass filter R
+				
+				dRR[3] = dRR[2];
+				dRR[2] = dRR[1];
+				dRR[1] = inputSampleR;
+				inputSampleR = (dRR[1] + dRR[2] + dRR[3])/3.0;
+				
+				allpasstemp = alpSR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;}
+				inputSampleR -= aSR[allpasstemp]*constallpass;
+				aSR[alpSR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpSR--; if (alpSR < 0 || alpSR > delayS) {alpSR = delayS;}
+				inputSampleR += (aSR[alpSR]);
+				//allpass filter S
+				
+				dSR[3] = dSR[2];
+				dSR[2] = dSR[1];
+				dSR[1] = inputSampleR;
+				inputSampleR = (dAR[1] + dSR[2] + dSR[3])/3.0;
+				
+				allpasstemp = alpTR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;}
+				inputSampleR -= aTR[allpasstemp]*constallpass;
+				aTR[alpTR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpTR--; if (alpTR < 0 || alpTR > delayT) {alpTR = delayT;}
+				inputSampleR += (aTR[alpTR]);
+				//allpass filter T
+				
+				dTR[3] = dTR[2];
+				dTR[2] = dTR[1];
+				dTR[1] = inputSampleR;
+				inputSampleR = (dTR[1] + dTR[2] + dTR[3])/3.0;
+				
+				allpasstemp = alpUR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;}
+				inputSampleR -= aUR[allpasstemp]*constallpass;
+				aUR[alpUR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpUR--; if (alpUR < 0 || alpUR > delayU) {alpUR = delayU;}
+				inputSampleR += (aUR[alpUR]);
+				//allpass filter U
+				
+				dUR[3] = dUR[2];
+				dUR[2] = dUR[1];
+				dUR[1] = inputSampleR;
+				inputSampleR = (dUR[1] + dUR[2] + dUR[3])/3.0;
+				
+				allpasstemp = alpVR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;}
+				inputSampleR -= aVR[allpasstemp]*constallpass;
+				aVR[alpVR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpVR--; if (alpVR < 0 || alpVR > delayV) {alpVR = delayV;}
+				inputSampleR += (aVR[alpVR]);
+				//allpass filter V
+				
+				dVR[3] = dVR[2];
+				dVR[2] = dVR[1];
+				dVR[1] = inputSampleR;
+				inputSampleR = (dVR[1] + dVR[2] + dVR[3])/3.0;
+				
+				allpasstemp = alpWR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;}
+				inputSampleR -= aWR[allpasstemp]*constallpass;
+				aWR[alpWR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpWR--; if (alpWR < 0 || alpWR > delayW) {alpWR = delayW;}
+				inputSampleR += (aWR[alpWR]);
+				//allpass filter W
+				
+				dWR[3] = dWR[2];
+				dWR[2] = dWR[1];
+				dWR[1] = inputSampleR;
+				inputSampleR = (dAR[1] + dWR[2] + dWR[3])/3.0;
+				
+				allpasstemp = alpXR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;}
+				inputSampleR -= aXR[allpasstemp]*constallpass;
+				aXR[alpXR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpXR--; if (alpXR < 0 || alpXR > delayX) {alpXR = delayX;}
+				inputSampleR += (aXR[alpXR]);
+				//allpass filter X
+				
+				dXR[3] = dXR[2];
+				dXR[2] = dXR[1];
+				dXR[1] = inputSampleR;
+				inputSampleR = (dXR[1] + dXR[2] + dXR[3])/3.0;
+				
+				allpasstemp = alpYR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;}
+				inputSampleR -= aYR[allpasstemp]*constallpass;
+				aYR[alpYR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpYR--; if (alpYR < 0 || alpYR > delayY) {alpYR = delayY;}
+				inputSampleR += (aYR[alpYR]);
+				//allpass filter Y
+				
+				dYR[3] = dYR[2];
+				dYR[2] = dYR[1];
+				dYR[1] = inputSampleR;
+				inputSampleR = (dYR[1] + dYR[2] + dYR[3])/3.0;
+				
+				allpasstemp = alpZR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;}
+				inputSampleR -= aZR[allpasstemp]*constallpass;
+				aZR[alpZR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpZR--; if (alpZR < 0 || alpZR > delayZ) {alpZR = delayZ;}
+				inputSampleR += (aZR[alpZR]);
+				//allpass filter Z
+				
+				dZR[3] = dZR[2];
+				dZR[2] = dZR[1];
+				dZR[1] = inputSampleR;
+				inputSampleR = (dZR[1] + dZR[2] + dZR[3])/3.0;
+				
+				// now the second stage using the 'out' bank of allpasses		
+				
+				allpasstemp = outAR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;}
+				inputSampleR -= oAR[allpasstemp]*constallpass;
+				oAR[outAR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outAR--; if (outAR < 0 || outAR > delayA) {outAR = delayA;}
+				inputSampleR += (oAR[outAR]);
+				//allpass filter A		
+				
+				dAR[6] = dAR[5];
+				dAR[5] = dAR[4];
+				dAR[4] = inputSampleR;
+				inputSampleR = (dAR[4] + dAR[5] + dAR[6])/3.0;
+				
+				allpasstemp = outBR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;}
+				inputSampleR -= oBR[allpasstemp]*constallpass;
+				oBR[outBR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outBR--; if (outBR < 0 || outBR > delayB) {outBR = delayB;}
+				inputSampleR += (oBR[outBR]);
+				//allpass filter B
+				
+				dBR[6] = dBR[5];
+				dBR[5] = dBR[4];
+				dBR[4] = inputSampleR;
+				inputSampleR = (dBR[4] + dBR[5] + dBR[6])/3.0;
+				
+				allpasstemp = outCR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;}
+				inputSampleR -= oCR[allpasstemp]*constallpass;
+				oCR[outCR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outCR--; if (outCR < 0 || outCR > delayC) {outCR = delayC;}
+				inputSampleR += (oCR[outCR]);
+				//allpass filter C
+				
+				dCR[6] = dCR[5];
+				dCR[5] = dCR[4];
+				dCR[4] = inputSampleR;
+				inputSampleR = (dAR[1] + dCR[5] + dCR[6])/3.0;
+				
+				allpasstemp = outDR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;}
+				inputSampleR -= oDR[allpasstemp]*constallpass;
+				oDR[outDR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outDR--; if (outDR < 0 || outDR > delayD) {outDR = delayD;}
+				inputSampleR += (oDR[outDR]);
+				//allpass filter D
+				
+				dDR[6] = dDR[5];
+				dDR[5] = dDR[4];
+				dDR[4] = inputSampleR;
+				inputSampleR = (dDR[4] + dDR[5] + dDR[6])/3.0;
+				
+				allpasstemp = outER - 1;
+				if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;}
+				inputSampleR -= oER[allpasstemp]*constallpass;
+				oER[outER] = inputSampleR;
+				inputSampleR *= constallpass;
+				outER--; if (outER < 0 || outER > delayE) {outER = delayE;}
+				inputSampleR += (oER[outER]);
+				//allpass filter E
+				
+				dER[6] = dER[5];
+				dER[5] = dER[4];
+				dER[4] = inputSampleR;
+				inputSampleR = (dAR[1] + dER[5] + dER[6])/3.0;
+				
+				allpasstemp = outFR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;}
+				inputSampleR -= oFR[allpasstemp]*constallpass;
+				oFR[outFR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outFR--; if (outFR < 0 || outFR > delayF) {outFR = delayF;}
+				inputSampleR += (oFR[outFR]);
+				//allpass filter F
+				
+				dFR[6] = dFR[5];
+				dFR[5] = dFR[4];
+				dFR[4] = inputSampleR;
+				inputSampleR = (dFR[4] + dFR[5] + dFR[6])/3.0;
+				
+				allpasstemp = outGR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;}
+				inputSampleR -= oGR[allpasstemp]*constallpass;
+				oGR[outGR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outGR--; if (outGR < 0 || outGR > delayG) {outGR = delayG;}
+				inputSampleR += (oGR[outGR]);
+				//allpass filter G
+				
+				dGR[6] = dGR[5];
+				dGR[5] = dGR[4];
+				dGR[4] = inputSampleR;
+				inputSampleR = (dGR[4] + dGR[5] + dGR[6])/3.0;
+				
+				allpasstemp = outHR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;}
+				inputSampleR -= oHR[allpasstemp]*constallpass;
+				oHR[outHR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outHR--; if (outHR < 0 || outHR > delayH) {outHR = delayH;}
+				inputSampleR += (oHR[outHR]);
+				//allpass filter H
+				
+				dHR[6] = dHR[5];
+				dHR[5] = dHR[4];
+				dHR[4] = inputSampleR;
+				inputSampleR = (dHR[4] + dHR[5] + dHR[6])/3.0;
+				
+				allpasstemp = outIR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;}
+				inputSampleR -= oIR[allpasstemp]*constallpass;
+				oIR[outIR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outIR--; if (outIR < 0 || outIR > delayI) {outIR = delayI;}
+				inputSampleR += (oIR[outIR]);
+				//allpass filter I
+				
+				dIR[6] = dIR[5];
+				dIR[5] = dIR[4];
+				dIR[4] = inputSampleR;
+				inputSampleR = (dIR[4] + dIR[5] + dIR[6])/3.0;
+				
+				allpasstemp = outJR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;}
+				inputSampleR -= oJR[allpasstemp]*constallpass;
+				oJR[outJR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outJR--; if (outJR < 0 || outJR > delayJ) {outJR = delayJ;}
+				inputSampleR += (oJR[outJR]);
+				//allpass filter J
+				
+				dJR[6] = dJR[5];
+				dJR[5] = dJR[4];
+				dJR[4] = inputSampleR;
+				inputSampleR = (dJR[4] + dJR[5] + dJR[6])/3.0;
+				
+				allpasstemp = outKR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;}
+				inputSampleR -= oKR[allpasstemp]*constallpass;
+				oKR[outKR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outKR--; if (outKR < 0 || outKR > delayK) {outKR = delayK;}
+				inputSampleR += (oKR[outKR]);
+				//allpass filter K
+				
+				dKR[6] = dKR[5];
+				dKR[5] = dKR[4];
+				dKR[4] = inputSampleR;
+				inputSampleR = (dAR[1] + dKR[5] + dKR[6])/3.0;
+				
+				allpasstemp = outLR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;}
+				inputSampleR -= oLR[allpasstemp]*constallpass;
+				oLR[outLR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outLR--; if (outLR < 0 || outLR > delayL) {outLR = delayL;}
+				inputSampleR += (oLR[outLR]);
+				//allpass filter L
+				
+				dLR[6] = dLR[5];
+				dLR[5] = dLR[4];
+				dLR[4] = inputSampleR;
+				inputSampleR = (dLR[4] + dLR[5] + dLR[6])/3.0;
+				
+				allpasstemp = outMR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;}
+				inputSampleR -= oMR[allpasstemp]*constallpass;
+				oMR[outMR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outMR--; if (outMR < 0 || outMR > delayM) {outMR = delayM;}
+				inputSampleR += (oMR[outMR]);
+				//allpass filter M
+				
+				dMR[6] = dMR[5];
+				dMR[5] = dMR[4];
+				dMR[4] = inputSampleR;
+				inputSampleR = (dMR[4] + dMR[5] + dMR[6])/3.0;
+				
+				allpasstemp = outNR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;}
+				inputSampleR -= oNR[allpasstemp]*constallpass;
+				oNR[outNR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outNR--; if (outNR < 0 || outNR > delayN) {outNR = delayN;}
+				inputSampleR += (oNR[outNR]);
+				//allpass filter N
+				
+				dNR[6] = dNR[5];
+				dNR[5] = dNR[4];
+				dNR[4] = inputSampleR;
+				inputSampleR = (dNR[4] + dNR[5] + dNR[6])/3.0;
+				
+				allpasstemp = outOR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;}
+				inputSampleR -= oOR[allpasstemp]*constallpass;
+				oOR[outOR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outOR--; if (outOR < 0 || outOR > delayO) {outOR = delayO;}
+				inputSampleR += (oOR[outOR]);
+				//allpass filter O
+				
+				dOR[6] = dOR[5];
+				dOR[5] = dOR[4];
+				dOR[4] = inputSampleR;
+				inputSampleR = (dAR[1] + dOR[5] + dOR[6])/3.0;
+				
+				allpasstemp = outPR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;}
+				inputSampleR -= oPR[allpasstemp]*constallpass;
+				oPR[outPR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outPR--; if (outPR < 0 || outPR > delayP) {outPR = delayP;}
+				inputSampleR += (oPR[outPR]);
+				//allpass filter P
+				
+				dPR[6] = dPR[5];
+				dPR[5] = dPR[4];
+				dPR[4] = inputSampleR;
+				inputSampleR = (dPR[4] + dPR[5] + dPR[6])/3.0;
+				
+				allpasstemp = outQR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;}
+				inputSampleR -= oQR[allpasstemp]*constallpass;
+				oQR[outQR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outQR--; if (outQR < 0 || outQR > delayQ) {outQR = delayQ;}
+				inputSampleR += (oQR[outQR]);
+				//allpass filter Q
+				
+				dQR[6] = dQR[5];
+				dQR[5] = dQR[4];
+				dQR[4] = inputSampleR;
+				inputSampleR = (dAR[1] + dQR[5] + dQR[6])/3.0;
+				
+				allpasstemp = outRR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;}
+				inputSampleR -= oRR[allpasstemp]*constallpass;
+				oRR[outRR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outRR--; if (outRR < 0 || outRR > delayR) {outRR = delayR;}
+				inputSampleR += (oRR[outRR]);
+				//allpass filter R
+				
+				dRR[6] = dRR[5];
+				dRR[5] = dRR[4];
+				dRR[4] = inputSampleR;
+				inputSampleR = (dRR[4] + dRR[5] + dRR[6])/3.0;
+				
+				allpasstemp = outSR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;}
+				inputSampleR -= oSR[allpasstemp]*constallpass;
+				oSR[outSR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outSR--; if (outSR < 0 || outSR > delayS) {outSR = delayS;}
+				inputSampleR += (oSR[outSR]);
+				//allpass filter S
+				
+				dSR[6] = dSR[5];
+				dSR[5] = dSR[4];
+				dSR[4] = inputSampleR;
+				inputSampleR = (dSR[4] + dSR[5] + dSR[6])/3.0;
+				
+				allpasstemp = outTR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;}
+				inputSampleR -= oTR[allpasstemp]*constallpass;
+				oTR[outTR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outTR--; if (outTR < 0 || outTR > delayT) {outTR = delayT;}
+				inputSampleR += (oTR[outTR]);
+				//allpass filter T
+				
+				dTR[6] = dTR[5];
+				dTR[5] = dTR[4];
+				dTR[4] = inputSampleR;
+				inputSampleR = (dTR[4] + dTR[5] + dTR[6])/3.0;
+				
+				allpasstemp = outUR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;}
+				inputSampleR -= oUR[allpasstemp]*constallpass;
+				oUR[outUR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outUR--; if (outUR < 0 || outUR > delayU) {outUR = delayU;}
+				inputSampleR += (oUR[outUR]);
+				//allpass filter U
+				
+				dUR[6] = dUR[5];
+				dUR[5] = dUR[4];
+				dUR[4] = inputSampleR;
+				inputSampleR = (dAR[1] + dUR[5] + dUR[6])/3.0;
+				
+				allpasstemp = outVR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;}
+				inputSampleR -= oVR[allpasstemp]*constallpass;
+				oVR[outVR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outVR--; if (outVR < 0 || outVR > delayV) {outVR = delayV;}
+				inputSampleR += (oVR[outVR]);
+				//allpass filter V
+				
+				dVR[6] = dVR[5];
+				dVR[5] = dVR[4];
+				dVR[4] = inputSampleR;
+				inputSampleR = (dVR[4] + dVR[5] + dVR[6])/3.0;
+				
+				allpasstemp = outWR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;}
+				inputSampleR -= oWR[allpasstemp]*constallpass;
+				oWR[outWR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outWR--; if (outWR < 0 || outWR > delayW) {outWR = delayW;}
+				inputSampleR += (oWR[outWR]);
+				//allpass filter W
+				
+				dWR[6] = dWR[5];
+				dWR[5] = dWR[4];
+				dWR[4] = inputSampleR;
+				inputSampleR = (dWR[4] + dWR[5] + dWR[6])/3.0;
+				
+				allpasstemp = outXR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;}
+				inputSampleR -= oXR[allpasstemp]*constallpass;
+				oXR[outXR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outXR--; if (outXR < 0 || outXR > delayX) {outXR = delayX;}
+				inputSampleR += (oXR[outXR]);
+				//allpass filter X
+				
+				dXR[6] = dXR[5];
+				dXR[5] = dXR[4];
+				dXR[4] = inputSampleR;
+				inputSampleR = (dXR[4] + dXR[5] + dXR[6])/3.0;
+				
+				allpasstemp = outYR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;}
+				inputSampleR -= oYR[allpasstemp]*constallpass;
+				oYR[outYR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outYR--; if (outYR < 0 || outYR > delayY) {outYR = delayY;}
+				inputSampleR += (oYR[outYR]);
+				//allpass filter Y
+				
+				dYR[6] = dYR[5];
+				dYR[5] = dYR[4];
+				dYR[4] = inputSampleR;
+				inputSampleR = (dYR[4] + dYR[5] + dYR[6])/3.0;
+				
+				allpasstemp = outZR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;}
+				inputSampleR -= oZR[allpasstemp]*constallpass;
+				oZR[outZR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outZR--; if (outZR < 0 || outZR > delayZ) {outZR = delayZ;}
+				inputSampleR += (oZR[outZR]);
+				//allpass filter Z
+				
+				dZR[6] = dZR[5];
+				dZR[5] = dZR[4];
+				dZR[4] = inputSampleR;
+				inputSampleR = (dZR[4] + dZR[5] + dZR[6]);		
+				//output Chamber
+				break;
+				
+				
+				
+				
+				
+			case 2:	//Spring
+				
+				allpasstemp = alpAR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;}
+				inputSampleR -= aAR[allpasstemp]*constallpass;
+				aAR[alpAR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpAR--; if (alpAR < 0 || alpAR > delayA) {alpAR = delayA;}
+				inputSampleR += (aAR[alpAR]);
+				//allpass filter A		
+				
+				dAR[3] = dAR[2];
+				dAR[2] = dAR[1];
+				dAR[1] = inputSampleR;
+				inputSampleR = (dAR[1] + dAR[2] + dAR[3])/3.0;
+				
+				allpasstemp = alpBR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;}
+				inputSampleR -= aBR[allpasstemp]*constallpass;
+				aBR[alpBR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpBR--; if (alpBR < 0 || alpBR > delayB) {alpBR = delayB;}
+				inputSampleR += (aBR[alpBR]);
+				//allpass filter B
+				
+				dBR[3] = dBR[2];
+				dBR[2] = dBR[1];
+				dBR[1] = inputSampleR;
+				inputSampleR = (dBR[1] + dBR[2] + dBR[3])/3.0;
+				
+				allpasstemp = alpCR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;}
+				inputSampleR -= aCR[allpasstemp]*constallpass;
+				aCR[alpCR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpCR--; if (alpCR < 0 || alpCR > delayC) {alpCR = delayC;}
+				inputSampleR += (aCR[alpCR]);
+				//allpass filter C
+				
+				dCR[3] = dCR[2];
+				dCR[2] = dCR[1];
+				dCR[1] = inputSampleR;
+				inputSampleR = (dCR[1] + dCR[2] + dCR[3])/3.0;
+				
+				allpasstemp = alpDR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;}
+				inputSampleR -= aDR[allpasstemp]*constallpass;
+				aDR[alpDR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpDR--; if (alpDR < 0 || alpDR > delayD) {alpDR = delayD;}
+				inputSampleR += (aDR[alpDR]);
+				//allpass filter D
+				
+				dDR[3] = dDR[2];
+				dDR[2] = dDR[1];
+				dDR[1] = inputSampleR;
+				inputSampleR = (dDR[1] + dDR[2] + dDR[3])/3.0;
+				
+				allpasstemp = alpER - 1;
+				if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;}
+				inputSampleR -= aER[allpasstemp]*constallpass;
+				aER[alpER] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpER--; if (alpER < 0 || alpER > delayE) {alpER = delayE;}
+				inputSampleR += (aER[alpER]);
+				//allpass filter E
+				
+				dER[3] = dER[2];
+				dER[2] = dER[1];
+				dER[1] = inputSampleR;
+				inputSampleR = (dER[1] + dER[2] + dER[3])/3.0;
+				
+				allpasstemp = alpFR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;}
+				inputSampleR -= aFR[allpasstemp]*constallpass;
+				aFR[alpFR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpFR--; if (alpFR < 0 || alpFR > delayF) {alpFR = delayF;}
+				inputSampleR += (aFR[alpFR]);
+				//allpass filter F
+				
+				dFR[3] = dFR[2];
+				dFR[2] = dFR[1];
+				dFR[1] = inputSampleR;
+				inputSampleR = (dFR[1] + dFR[2] + dFR[3])/3.0;
+				
+				allpasstemp = alpGR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;}
+				inputSampleR -= aGR[allpasstemp]*constallpass;
+				aGR[alpGR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpGR--; if (alpGR < 0 || alpGR > delayG) {alpGR = delayG;}
+				inputSampleR += (aGR[alpGR]);
+				//allpass filter G
+				
+				dGR[3] = dGR[2];
+				dGR[2] = dGR[1];
+				dGR[1] = inputSampleR;
+				inputSampleR = (dGR[1] + dGR[2] + dGR[3])/3.0;
+				
+				allpasstemp = alpHR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;}
+				inputSampleR -= aHR[allpasstemp]*constallpass;
+				aHR[alpHR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpHR--; if (alpHR < 0 || alpHR > delayH) {alpHR = delayH;}
+				inputSampleR += (aHR[alpHR]);
+				//allpass filter H
+				
+				dHR[3] = dHR[2];
+				dHR[2] = dHR[1];
+				dHR[1] = inputSampleR;
+				inputSampleR = (dHR[1] + dHR[2] + dHR[3])/3.0;
+				
+				allpasstemp = alpIR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;}
+				inputSampleR -= aIR[allpasstemp]*constallpass;
+				aIR[alpIR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpIR--; if (alpIR < 0 || alpIR > delayI) {alpIR = delayI;}
+				inputSampleR += (aIR[alpIR]);
+				//allpass filter I
+				
+				dIR[3] = dIR[2];
+				dIR[2] = dIR[1];
+				dIR[1] = inputSampleR;
+				inputSampleR = (dIR[1] + dIR[2] + dIR[3])/3.0;
+				
+				allpasstemp = alpJR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;}
+				inputSampleR -= aJR[allpasstemp]*constallpass;
+				aJR[alpJR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpJR--; if (alpJR < 0 || alpJR > delayJ) {alpJR = delayJ;}
+				inputSampleR += (aJR[alpJR]);
+				//allpass filter J
+				
+				dJR[3] = dJR[2];
+				dJR[2] = dJR[1];
+				dJR[1] = inputSampleR;
+				inputSampleR = (dJR[1] + dJR[2] + dJR[3])/3.0;
+				
+				allpasstemp = alpKR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;}
+				inputSampleR -= aKR[allpasstemp]*constallpass;
+				aKR[alpKR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpKR--; if (alpKR < 0 || alpKR > delayK) {alpKR = delayK;}
+				inputSampleR += (aKR[alpKR]);
+				//allpass filter K
+				
+				dKR[3] = dKR[2];
+				dKR[2] = dKR[1];
+				dKR[1] = inputSampleR;
+				inputSampleR = (dKR[1] + dKR[2] + dKR[3])/3.0;
+				
+				allpasstemp = alpLR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;}
+				inputSampleR -= aLR[allpasstemp]*constallpass;
+				aLR[alpLR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpLR--; if (alpLR < 0 || alpLR > delayL) {alpLR = delayL;}
+				inputSampleR += (aLR[alpLR]);
+				//allpass filter L
+				
+				dLR[3] = dLR[2];
+				dLR[2] = dLR[1];
+				dLR[1] = inputSampleR;
+				inputSampleR = (dLR[1] + dLR[2] + dLR[3])/3.0;
+				
+				allpasstemp = alpMR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;}
+				inputSampleR -= aMR[allpasstemp]*constallpass;
+				aMR[alpMR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpMR--; if (alpMR < 0 || alpMR > delayM) {alpMR = delayM;}
+				inputSampleR += (aMR[alpMR]);
+				//allpass filter M
+				
+				dMR[3] = dMR[2];
+				dMR[2] = dMR[1];
+				dMR[1] = inputSampleR;
+				inputSampleR = (dMR[1] + dMR[2] + dMR[3])/3.0;
+				
+				allpasstemp = alpNR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;}
+				inputSampleR -= aNR[allpasstemp]*constallpass;
+				aNR[alpNR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpNR--; if (alpNR < 0 || alpNR > delayN) {alpNR = delayN;}
+				inputSampleR += (aNR[alpNR]);
+				//allpass filter N
+				
+				dNR[3] = dNR[2];
+				dNR[2] = dNR[1];
+				dNR[1] = inputSampleR;
+				inputSampleR = (dNR[1] + dNR[2] + dNR[3])/3.0;
+				
+				allpasstemp = alpOR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;}
+				inputSampleR -= aOR[allpasstemp]*constallpass;
+				aOR[alpOR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpOR--; if (alpOR < 0 || alpOR > delayO) {alpOR = delayO;}
+				inputSampleR += (aOR[alpOR]);
+				//allpass filter O
+				
+				dOR[3] = dOR[2];
+				dOR[2] = dOR[1];
+				dOR[1] = inputSampleR;
+				inputSampleR = (dOR[1] + dOR[2] + dOR[3])/3.0;
+				
+				allpasstemp = alpPR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;}
+				inputSampleR -= aPR[allpasstemp]*constallpass;
+				aPR[alpPR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpPR--; if (alpPR < 0 || alpPR > delayP) {alpPR = delayP;}
+				inputSampleR += (aPR[alpPR]);
+				//allpass filter P
+				
+				dPR[3] = dPR[2];
+				dPR[2] = dPR[1];
+				dPR[1] = inputSampleR;
+				inputSampleR = (dPR[1] + dPR[2] + dPR[3])/3.0;
+				
+				allpasstemp = alpQR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;}
+				inputSampleR -= aQR[allpasstemp]*constallpass;
+				aQR[alpQR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpQR--; if (alpQR < 0 || alpQR > delayQ) {alpQR = delayQ;}
+				inputSampleR += (aQR[alpQR]);
+				//allpass filter Q
+				
+				dQR[3] = dQR[2];
+				dQR[2] = dQR[1];
+				dQR[1] = inputSampleR;
+				inputSampleR = (dQR[1] + dQR[2] + dQR[3])/3.0;
+				
+				allpasstemp = alpRR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;}
+				inputSampleR -= aRR[allpasstemp]*constallpass;
+				aRR[alpRR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpRR--; if (alpRR < 0 || alpRR > delayR) {alpRR = delayR;}
+				inputSampleR += (aRR[alpRR]);
+				//allpass filter R
+				
+				dRR[3] = dRR[2];
+				dRR[2] = dRR[1];
+				dRR[1] = inputSampleR;
+				inputSampleR = (dRR[1] + dRR[2] + dRR[3])/3.0;
+				
+				allpasstemp = alpSR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;}
+				inputSampleR -= aSR[allpasstemp]*constallpass;
+				aSR[alpSR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpSR--; if (alpSR < 0 || alpSR > delayS) {alpSR = delayS;}
+				inputSampleR += (aSR[alpSR]);
+				//allpass filter S
+				
+				dSR[3] = dSR[2];
+				dSR[2] = dSR[1];
+				dSR[1] = inputSampleR;
+				inputSampleR = (dSR[1] + dSR[2] + dSR[3])/3.0;
+				
+				allpasstemp = alpTR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;}
+				inputSampleR -= aTR[allpasstemp]*constallpass;
+				aTR[alpTR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpTR--; if (alpTR < 0 || alpTR > delayT) {alpTR = delayT;}
+				inputSampleR += (aTR[alpTR]);
+				//allpass filter T
+				
+				dTR[3] = dTR[2];
+				dTR[2] = dTR[1];
+				dTR[1] = inputSampleR;
+				inputSampleR = (dTR[1] + dTR[2] + dTR[3])/3.0;
+				
+				allpasstemp = alpUR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;}
+				inputSampleR -= aUR[allpasstemp]*constallpass;
+				aUR[alpUR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpUR--; if (alpUR < 0 || alpUR > delayU) {alpUR = delayU;}
+				inputSampleR += (aUR[alpUR]);
+				//allpass filter U
+				
+				dUR[3] = dUR[2];
+				dUR[2] = dUR[1];
+				dUR[1] = inputSampleR;
+				inputSampleR = (dUR[1] + dUR[2] + dUR[3])/3.0;
+				
+				allpasstemp = alpVR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;}
+				inputSampleR -= aVR[allpasstemp]*constallpass;
+				aVR[alpVR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpVR--; if (alpVR < 0 || alpVR > delayV) {alpVR = delayV;}
+				inputSampleR += (aVR[alpVR]);
+				//allpass filter V
+				
+				dVR[3] = dVR[2];
+				dVR[2] = dVR[1];
+				dVR[1] = inputSampleR;
+				inputSampleR = (dVR[1] + dVR[2] + dVR[3])/3.0;
+				
+				allpasstemp = alpWR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;}
+				inputSampleR -= aWR[allpasstemp]*constallpass;
+				aWR[alpWR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpWR--; if (alpWR < 0 || alpWR > delayW) {alpWR = delayW;}
+				inputSampleR += (aWR[alpWR]);
+				//allpass filter W
+				
+				dWR[3] = dWR[2];
+				dWR[2] = dWR[1];
+				dWR[1] = inputSampleR;
+				inputSampleR = (dWR[1] + dWR[2] + dWR[3])/3.0;
+				
+				allpasstemp = alpXR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;}
+				inputSampleR -= aXR[allpasstemp]*constallpass;
+				aXR[alpXR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpXR--; if (alpXR < 0 || alpXR > delayX) {alpXR = delayX;}
+				inputSampleR += (aXR[alpXR]);
+				//allpass filter X
+				
+				dXR[3] = dXR[2];
+				dXR[2] = dXR[1];
+				dXR[1] = inputSampleR;
+				inputSampleR = (dXR[1] + dXR[2] + dXR[3])/3.0;
+				
+				allpasstemp = alpYR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;}
+				inputSampleR -= aYR[allpasstemp]*constallpass;
+				aYR[alpYR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpYR--; if (alpYR < 0 || alpYR > delayY) {alpYR = delayY;}
+				inputSampleR += (aYR[alpYR]);
+				//allpass filter Y
+				
+				dYR[3] = dYR[2];
+				dYR[2] = dYR[1];
+				dYR[1] = inputSampleR;
+				inputSampleR = (dYR[1] + dYR[2] + dYR[3])/3.0;
+				
+				allpasstemp = alpZR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;}
+				inputSampleR -= aZR[allpasstemp]*constallpass;
+				aZR[alpZR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpZR--; if (alpZR < 0 || alpZR > delayZ) {alpZR = delayZ;}
+				inputSampleR += (aZR[alpZR]);
+				//allpass filter Z
+				
+				dZR[3] = dZR[2];
+				dZR[2] = dZR[1];
+				dZR[1] = inputSampleR;
+				inputSampleR = (dZR[1] + dZR[2] + dZR[3])/3.0;
+				
+				// now the second stage using the 'out' bank of allpasses		
+				
+				allpasstemp = outAR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;}
+				inputSampleR -= oAR[allpasstemp]*constallpass;
+				oAR[outAR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outAR--; if (outAR < 0 || outAR > delayA) {outAR = delayA;}
+				inputSampleR += (oAR[outAR]);
+				//allpass filter A		
+				
+				dAR[6] = dAR[5];
+				dAR[5] = dAR[4];
+				dAR[4] = inputSampleR;
+				inputSampleR = (dYR[1] + dAR[5] + dAR[6])/3.0;
+				
+				allpasstemp = outBR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;}
+				inputSampleR -= oBR[allpasstemp]*constallpass;
+				oBR[outBR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outBR--; if (outBR < 0 || outBR > delayB) {outBR = delayB;}
+				inputSampleR += (oBR[outBR]);
+				//allpass filter B
+				
+				dBR[6] = dBR[5];
+				dBR[5] = dBR[4];
+				dBR[4] = inputSampleR;
+				inputSampleR = (dXR[1] + dBR[5] + dBR[6])/3.0;
+				
+				allpasstemp = outCR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;}
+				inputSampleR -= oCR[allpasstemp]*constallpass;
+				oCR[outCR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outCR--; if (outCR < 0 || outCR > delayC) {outCR = delayC;}
+				inputSampleR += (oCR[outCR]);
+				//allpass filter C
+				
+				dCR[6] = dCR[5];
+				dCR[5] = dCR[4];
+				dCR[4] = inputSampleR;
+				inputSampleR = (dWR[1] + dCR[5] + dCR[6])/3.0;
+				
+				allpasstemp = outDR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;}
+				inputSampleR -= oDR[allpasstemp]*constallpass;
+				oDR[outDR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outDR--; if (outDR < 0 || outDR > delayD) {outDR = delayD;}
+				inputSampleR += (oDR[outDR]);
+				//allpass filter D
+				
+				dDR[6] = dDR[5];
+				dDR[5] = dDR[4];
+				dDR[4] = inputSampleR;
+				inputSampleR = (dVR[1] + dDR[5] + dDR[6])/3.0;
+				
+				allpasstemp = outER - 1;
+				if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;}
+				inputSampleR -= oER[allpasstemp]*constallpass;
+				oER[outER] = inputSampleR;
+				inputSampleR *= constallpass;
+				outER--; if (outER < 0 || outER > delayE) {outER = delayE;}
+				inputSampleR += (oER[outER]);
+				//allpass filter E
+				
+				dER[6] = dER[5];
+				dER[5] = dER[4];
+				dER[4] = inputSampleR;
+				inputSampleR = (dUR[1] + dER[5] + dER[6])/3.0;
+				
+				allpasstemp = outFR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;}
+				inputSampleR -= oFR[allpasstemp]*constallpass;
+				oFR[outFR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outFR--; if (outFR < 0 || outFR > delayF) {outFR = delayF;}
+				inputSampleR += (oFR[outFR]);
+				//allpass filter F
+				
+				dFR[6] = dFR[5];
+				dFR[5] = dFR[4];
+				dFR[4] = inputSampleR;
+				inputSampleR = (dTR[1] + dFR[5] + dFR[6])/3.0;
+				
+				allpasstemp = outGR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;}
+				inputSampleR -= oGR[allpasstemp]*constallpass;
+				oGR[outGR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outGR--; if (outGR < 0 || outGR > delayG) {outGR = delayG;}
+				inputSampleR += (oGR[outGR]);
+				//allpass filter G
+				
+				dGR[6] = dGR[5];
+				dGR[5] = dGR[4];
+				dGR[4] = inputSampleR;
+				inputSampleR = (dSR[1] + dGR[5] + dGR[6])/3.0;
+				
+				allpasstemp = outHR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;}
+				inputSampleR -= oHR[allpasstemp]*constallpass;
+				oHR[outHR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outHR--; if (outHR < 0 || outHR > delayH) {outHR = delayH;}
+				inputSampleR += (oHR[outHR]);
+				//allpass filter H
+				
+				dHR[6] = dHR[5];
+				dHR[5] = dHR[4];
+				dHR[4] = inputSampleR;
+				inputSampleR = (dRR[1] + dHR[5] + dHR[6])/3.0;
+				
+				allpasstemp = outIR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;}
+				inputSampleR -= oIR[allpasstemp]*constallpass;
+				oIR[outIR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outIR--; if (outIR < 0 || outIR > delayI) {outIR = delayI;}
+				inputSampleR += (oIR[outIR]);
+				//allpass filter I
+				
+				dIR[6] = dIR[5];
+				dIR[5] = dIR[4];
+				dIR[4] = inputSampleR;
+				inputSampleR = (dQR[1] + dIR[5] + dIR[6])/3.0;
+				
+				allpasstemp = outJR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;}
+				inputSampleR -= oJR[allpasstemp]*constallpass;
+				oJR[outJR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outJR--; if (outJR < 0 || outJR > delayJ) {outJR = delayJ;}
+				inputSampleR += (oJR[outJR]);
+				//allpass filter J
+				
+				dJR[6] = dJR[5];
+				dJR[5] = dJR[4];
+				dJR[4] = inputSampleR;
+				inputSampleR = (dPR[1] + dJR[5] + dJR[6])/3.0;
+				
+				allpasstemp = outKR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;}
+				inputSampleR -= oKR[allpasstemp]*constallpass;
+				oKR[outKR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outKR--; if (outKR < 0 || outKR > delayK) {outKR = delayK;}
+				inputSampleR += (oKR[outKR]);
+				//allpass filter K
+				
+				dKR[6] = dKR[5];
+				dKR[5] = dKR[4];
+				dKR[4] = inputSampleR;
+				inputSampleR = (dOR[1] + dKR[5] + dKR[6])/3.0;
+				
+				allpasstemp = outLR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;}
+				inputSampleR -= oLR[allpasstemp]*constallpass;
+				oLR[outLR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outLR--; if (outLR < 0 || outLR > delayL) {outLR = delayL;}
+				inputSampleR += (oLR[outLR]);
+				//allpass filter L
+				
+				dLR[6] = dLR[5];
+				dLR[5] = dLR[4];
+				dLR[4] = inputSampleR;
+				inputSampleR = (dNR[1] + dLR[5] + dLR[6])/3.0;
+				
+				allpasstemp = outMR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;}
+				inputSampleR -= oMR[allpasstemp]*constallpass;
+				oMR[outMR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outMR--; if (outMR < 0 || outMR > delayM) {outMR = delayM;}
+				inputSampleR += (oMR[outMR]);
+				//allpass filter M
+				
+				dMR[6] = dMR[5];
+				dMR[5] = dMR[4];
+				dMR[4] = inputSampleR;
+				inputSampleR = (dMR[1] + dMR[5] + dMR[6])/3.0;
+				
+				allpasstemp = outNR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;}
+				inputSampleR -= oNR[allpasstemp]*constallpass;
+				oNR[outNR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outNR--; if (outNR < 0 || outNR > delayN) {outNR = delayN;}
+				inputSampleR += (oNR[outNR]);
+				//allpass filter N
+				
+				dNR[6] = dNR[5];
+				dNR[5] = dNR[4];
+				dNR[4] = inputSampleR;
+				inputSampleR = (dLR[1] + dNR[5] + dNR[6])/3.0;
+				
+				allpasstemp = outOR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;}
+				inputSampleR -= oOR[allpasstemp]*constallpass;
+				oOR[outOR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outOR--; if (outOR < 0 || outOR > delayO) {outOR = delayO;}
+				inputSampleR += (oOR[outOR]);
+				//allpass filter O
+				
+				dOR[6] = dOR[5];
+				dOR[5] = dOR[4];
+				dOR[4] = inputSampleR;
+				inputSampleR = (dKR[1] + dOR[5] + dOR[6])/3.0;
+				
+				allpasstemp = outPR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;}
+				inputSampleR -= oPR[allpasstemp]*constallpass;
+				oPR[outPR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outPR--; if (outPR < 0 || outPR > delayP) {outPR = delayP;}
+				inputSampleR += (oPR[outPR]);
+				//allpass filter P
+				
+				dPR[6] = dPR[5];
+				dPR[5] = dPR[4];
+				dPR[4] = inputSampleR;
+				inputSampleR = (dJR[1] + dPR[5] + dPR[6])/3.0;
+				
+				allpasstemp = outQR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;}
+				inputSampleR -= oQR[allpasstemp]*constallpass;
+				oQR[outQR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outQR--; if (outQR < 0 || outQR > delayQ) {outQR = delayQ;}
+				inputSampleR += (oQR[outQR]);
+				//allpass filter Q
+				
+				dQR[6] = dQR[5];
+				dQR[5] = dQR[4];
+				dQR[4] = inputSampleR;
+				inputSampleR = (dIR[1] + dQR[5] + dQR[6])/3.0;
+				
+				allpasstemp = outRR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;}
+				inputSampleR -= oRR[allpasstemp]*constallpass;
+				oRR[outRR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outRR--; if (outRR < 0 || outRR > delayR) {outRR = delayR;}
+				inputSampleR += (oRR[outRR]);
+				//allpass filter R
+				
+				dRR[6] = dRR[5];
+				dRR[5] = dRR[4];
+				dRR[4] = inputSampleR;
+				inputSampleR = (dHR[1] + dRR[5] + dRR[6])/3.0;
+				
+				allpasstemp = outSR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;}
+				inputSampleR -= oSR[allpasstemp]*constallpass;
+				oSR[outSR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outSR--; if (outSR < 0 || outSR > delayS) {outSR = delayS;}
+				inputSampleR += (oSR[outSR]);
+				//allpass filter S
+				
+				dSR[6] = dSR[5];
+				dSR[5] = dSR[4];
+				dSR[4] = inputSampleR;
+				inputSampleR = (dGR[1] + dSR[5] + dSR[6])/3.0;
+				
+				allpasstemp = outTR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;}
+				inputSampleR -= oTR[allpasstemp]*constallpass;
+				oTR[outTR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outTR--; if (outTR < 0 || outTR > delayT) {outTR = delayT;}
+				inputSampleR += (oTR[outTR]);
+				//allpass filter T
+				
+				dTR[6] = dTR[5];
+				dTR[5] = dTR[4];
+				dTR[4] = inputSampleR;
+				inputSampleR = (dFR[1] + dTR[5] + dTR[6])/3.0;
+				
+				allpasstemp = outUR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;}
+				inputSampleR -= oUR[allpasstemp]*constallpass;
+				oUR[outUR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outUR--; if (outUR < 0 || outUR > delayU) {outUR = delayU;}
+				inputSampleR += (oUR[outUR]);
+				//allpass filter U
+				
+				dUR[6] = dUR[5];
+				dUR[5] = dUR[4];
+				dUR[4] = inputSampleR;
+				inputSampleR = (dER[1] + dUR[5] + dUR[6])/3.0;
+				
+				allpasstemp = outVR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;}
+				inputSampleR -= oVR[allpasstemp]*constallpass;
+				oVR[outVR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outVR--; if (outVR < 0 || outVR > delayV) {outVR = delayV;}
+				inputSampleR += (oVR[outVR]);
+				//allpass filter V
+				
+				dVR[6] = dVR[5];
+				dVR[5] = dVR[4];
+				dVR[4] = inputSampleR;
+				inputSampleR = (dDR[1] + dVR[5] + dVR[6])/3.0;
+				
+				allpasstemp = outWR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;}
+				inputSampleR -= oWR[allpasstemp]*constallpass;
+				oWR[outWR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outWR--; if (outWR < 0 || outWR > delayW) {outWR = delayW;}
+				inputSampleR += (oWR[outWR]);
+				//allpass filter W
+				
+				dWR[6] = dWR[5];
+				dWR[5] = dWR[4];
+				dWR[4] = inputSampleR;
+				inputSampleR = (dCR[1] + dWR[5] + dWR[6])/3.0;
+				
+				allpasstemp = outXR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;}
+				inputSampleR -= oXR[allpasstemp]*constallpass;
+				oXR[outXR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outXR--; if (outXR < 0 || outXR > delayX) {outXR = delayX;}
+				inputSampleR += (oXR[outXR]);
+				//allpass filter X
+				
+				dXR[6] = dXR[5];
+				dXR[5] = dXR[4];
+				dXR[4] = inputSampleR;
+				inputSampleR = (dAR[1] + dXR[5] + dXR[6])/3.0;
+				
+				allpasstemp = outYR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;}
+				inputSampleR -= oYR[allpasstemp]*constallpass;
+				oYR[outYR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outYR--; if (outYR < 0 || outYR > delayY) {outYR = delayY;}
+				inputSampleR += (oYR[outYR]);
+				//allpass filter Y
+				
+				dYR[6] = dYR[5];
+				dYR[5] = dYR[4];
+				dYR[4] = inputSampleR;
+				inputSampleR = (dBR[1] + dYR[5] + dYR[6])/3.0;
+				
+				allpasstemp = outZR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;}
+				inputSampleR -= oZR[allpasstemp]*constallpass;
+				oZR[outZR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outZR--; if (outZR < 0 || outZR > delayZ) {outZR = delayZ;}
+				inputSampleR += (oZR[outZR]);
+				//allpass filter Z
+				
+				dZR[6] = dZR[5];
+				dZR[5] = dZR[4];
+				dZR[4] = inputSampleR;
+				inputSampleR = (dZR[5] + dZR[6]);
+				//output Spring
+				break;
+				
+				
+			case 3:	//Tiled
+				allpasstemp = alpAR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;}
+				inputSampleR -= aAR[allpasstemp]*constallpass;
+				aAR[alpAR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpAR--; if (alpAR < 0 || alpAR > delayA) {alpAR = delayA;}
+				inputSampleR += (aAR[alpAR]);
+				//allpass filter A		
+				
+				dAR[2] = dAR[1];
+				dAR[1] = inputSampleR;
+				inputSampleR = (dAR[1] + dAR[2])/2.0;
+				
+				allpasstemp = alpBR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;}
+				inputSampleR -= aBR[allpasstemp]*constallpass;
+				aBR[alpBR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpBR--; if (alpBR < 0 || alpBR > delayB) {alpBR = delayB;}
+				inputSampleR += (aBR[alpBR]);
+				//allpass filter B
+				
+				dBR[2] = dBR[1];
+				dBR[1] = inputSampleR;
+				inputSampleR = (dBR[1] + dBR[2])/2.0;
+				
+				allpasstemp = alpCR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;}
+				inputSampleR -= aCR[allpasstemp]*constallpass;
+				aCR[alpCR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpCR--; if (alpCR < 0 || alpCR > delayC) {alpCR = delayC;}
+				inputSampleR += (aCR[alpCR]);
+				//allpass filter C
+				
+				dCR[2] = dCR[1];
+				dCR[1] = inputSampleR;
+				inputSampleR = (dAR[1] + dCR[2])/2.0;
+				
+				allpasstemp = alpDR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;}
+				inputSampleR -= aDR[allpasstemp]*constallpass;
+				aDR[alpDR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpDR--; if (alpDR < 0 || alpDR > delayD) {alpDR = delayD;}
+				inputSampleR += (aDR[alpDR]);
+				//allpass filter D
+				
+				dDR[2] = dDR[1];
+				dDR[1] = inputSampleR;
+				inputSampleR = (dDR[1] + dDR[2])/2.0;
+				
+				allpasstemp = alpER - 1;
+				if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;}
+				inputSampleR -= aER[allpasstemp]*constallpass;
+				aER[alpER] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpER--; if (alpER < 0 || alpER > delayE) {alpER = delayE;}
+				inputSampleR += (aER[alpER]);
+				//allpass filter E
+				
+				dER[2] = dER[1];
+				dER[1] = inputSampleR;
+				inputSampleR = (dAR[1] + dER[2])/2.0;
+				
+				allpasstemp = alpFR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;}
+				inputSampleR -= aFR[allpasstemp]*constallpass;
+				aFR[alpFR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpFR--; if (alpFR < 0 || alpFR > delayF) {alpFR = delayF;}
+				inputSampleR += (aFR[alpFR]);
+				//allpass filter F
+				
+				dFR[2] = dFR[1];
+				dFR[1] = inputSampleR;
+				inputSampleR = (dFR[1] + dFR[2])/2.0;
+				
+				allpasstemp = alpGR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;}
+				inputSampleR -= aGR[allpasstemp]*constallpass;
+				aGR[alpGR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpGR--; if (alpGR < 0 || alpGR > delayG) {alpGR = delayG;}
+				inputSampleR += (aGR[alpGR]);
+				//allpass filter G
+				
+				dGR[2] = dGR[1];
+				dGR[1] = inputSampleR;
+				inputSampleR = (dAR[1] + dGR[2])/2.0;
+				
+				allpasstemp = alpHR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;}
+				inputSampleR -= aHR[allpasstemp]*constallpass;
+				aHR[alpHR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpHR--; if (alpHR < 0 || alpHR > delayH) {alpHR = delayH;}
+				inputSampleR += (aHR[alpHR]);
+				//allpass filter H
+				
+				dHR[2] = dHR[1];
+				dHR[1] = inputSampleR;
+				inputSampleR = (dHR[1] + dHR[2])/2.0;
+				
+				allpasstemp = alpIR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;}
+				inputSampleR -= aIR[allpasstemp]*constallpass;
+				aIR[alpIR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpIR--; if (alpIR < 0 || alpIR > delayI) {alpIR = delayI;}
+				inputSampleR += (aIR[alpIR]);
+				//allpass filter I
+				
+				dIR[2] = dIR[1];
+				dIR[1] = inputSampleR;
+				inputSampleR = (dIR[1] + dIR[2])/2.0;
+				
+				allpasstemp = alpJR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;}
+				inputSampleR -= aJR[allpasstemp]*constallpass;
+				aJR[alpJR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpJR--; if (alpJR < 0 || alpJR > delayJ) {alpJR = delayJ;}
+				inputSampleR += (aJR[alpJR]);
+				//allpass filter J
+				
+				dJR[2] = dJR[1];
+				dJR[1] = inputSampleR;
+				inputSampleR = (dJR[1] + dJR[2])/2.0;
+				
+				allpasstemp = alpKR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;}
+				inputSampleR -= aKR[allpasstemp]*constallpass;
+				aKR[alpKR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpKR--; if (alpKR < 0 || alpKR > delayK) {alpKR = delayK;}
+				inputSampleR += (aKR[alpKR]);
+				//allpass filter K
+				
+				dKR[2] = dKR[1];
+				dKR[1] = inputSampleR;
+				inputSampleR = (dAR[1] + dKR[2])/2.0;
+				
+				allpasstemp = alpLR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;}
+				inputSampleR -= aLR[allpasstemp]*constallpass;
+				aLR[alpLR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpLR--; if (alpLR < 0 || alpLR > delayL) {alpLR = delayL;}
+				inputSampleR += (aLR[alpLR]);
+				//allpass filter L
+				
+				dLR[2] = dLR[1];
+				dLR[1] = inputSampleR;
+				inputSampleR = (dLR[1] + dLR[2])/2.0;
+				
+				allpasstemp = alpMR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;}
+				inputSampleR -= aMR[allpasstemp]*constallpass;
+				aMR[alpMR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpMR--; if (alpMR < 0 || alpMR > delayM) {alpMR = delayM;}
+				inputSampleR += (aMR[alpMR]);
+				//allpass filter M
+				
+				dMR[2] = dMR[1];
+				dMR[1] = inputSampleR;
+				inputSampleR = (dAR[1] + dMR[2])/2.0;
+				
+				allpasstemp = alpNR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;}
+				inputSampleR -= aNR[allpasstemp]*constallpass;
+				aNR[alpNR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpNR--; if (alpNR < 0 || alpNR > delayN) {alpNR = delayN;}
+				inputSampleR += (aNR[alpNR]);
+				//allpass filter N
+				
+				dNR[2] = dNR[1];
+				dNR[1] = inputSampleR;
+				inputSampleR = (dNR[1] + dNR[2])/2.0;
+				
+				allpasstemp = alpOR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;}
+				inputSampleR -= aOR[allpasstemp]*constallpass;
+				aOR[alpOR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpOR--; if (alpOR < 0 || alpOR > delayO) {alpOR = delayO;}
+				inputSampleR += (aOR[alpOR]);
+				//allpass filter O
+				
+				dOR[2] = dOR[1];
+				dOR[1] = inputSampleR;
+				inputSampleR = (dOR[1] + dOR[2])/2.0;
+				
+				allpasstemp = alpPR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;}
+				inputSampleR -= aPR[allpasstemp]*constallpass;
+				aPR[alpPR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpPR--; if (alpPR < 0 || alpPR > delayP) {alpPR = delayP;}
+				inputSampleR += (aPR[alpPR]);
+				//allpass filter P
+				
+				dPR[2] = dPR[1];
+				dPR[1] = inputSampleR;
+				inputSampleR = (dPR[1] + dPR[2])/2.0;
+				
+				allpasstemp = alpQR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;}
+				inputSampleR -= aQR[allpasstemp]*constallpass;
+				aQR[alpQR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpQR--; if (alpQR < 0 || alpQR > delayQ) {alpQR = delayQ;}
+				inputSampleR += (aQR[alpQR]);
+				//allpass filter Q
+				
+				dQR[2] = dQR[1];
+				dQR[1] = inputSampleR;
+				inputSampleR = (dAR[1] + dQR[2])/2.0;
+				
+				allpasstemp = alpRR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;}
+				inputSampleR -= aRR[allpasstemp]*constallpass;
+				aRR[alpRR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpRR--; if (alpRR < 0 || alpRR > delayR) {alpRR = delayR;}
+				inputSampleR += (aRR[alpRR]);
+				//allpass filter R
+				
+				dRR[2] = dRR[1];
+				dRR[1] = inputSampleR;
+				inputSampleR = (dRR[1] + dRR[2])/2.0;
+				
+				allpasstemp = alpSR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;}
+				inputSampleR -= aSR[allpasstemp]*constallpass;
+				aSR[alpSR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpSR--; if (alpSR < 0 || alpSR > delayS) {alpSR = delayS;}
+				inputSampleR += (aSR[alpSR]);
+				//allpass filter S
+				
+				dSR[2] = dSR[1];
+				dSR[1] = inputSampleR;
+				inputSampleR = (dAR[1] + dSR[2])/2.0;
+				
+				allpasstemp = alpTR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;}
+				inputSampleR -= aTR[allpasstemp]*constallpass;
+				aTR[alpTR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpTR--; if (alpTR < 0 || alpTR > delayT) {alpTR = delayT;}
+				inputSampleR += (aTR[alpTR]);
+				//allpass filter T
+				
+				dTR[2] = dTR[1];
+				dTR[1] = inputSampleR;
+				inputSampleR = (dTR[1] + dTR[2])/2.0;
+				
+				allpasstemp = alpUR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;}
+				inputSampleR -= aUR[allpasstemp]*constallpass;
+				aUR[alpUR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpUR--; if (alpUR < 0 || alpUR > delayU) {alpUR = delayU;}
+				inputSampleR += (aUR[alpUR]);
+				//allpass filter U
+				
+				dUR[2] = dUR[1];
+				dUR[1] = inputSampleR;
+				inputSampleR = (dUR[1] + dUR[2])/2.0;
+				
+				allpasstemp = alpVR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;}
+				inputSampleR -= aVR[allpasstemp]*constallpass;
+				aVR[alpVR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpVR--; if (alpVR < 0 || alpVR > delayV) {alpVR = delayV;}
+				inputSampleR += (aVR[alpVR]);
+				//allpass filter V
+				
+				dVR[2] = dVR[1];
+				dVR[1] = inputSampleR;
+				inputSampleR = (dVR[1] + dVR[2])/2.0;
+				
+				allpasstemp = alpWR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;}
+				inputSampleR -= aWR[allpasstemp]*constallpass;
+				aWR[alpWR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpWR--; if (alpWR < 0 || alpWR > delayW) {alpWR = delayW;}
+				inputSampleR += (aWR[alpWR]);
+				//allpass filter W
+				
+				dWR[2] = dWR[1];
+				dWR[1] = inputSampleR;
+				inputSampleR = (dAR[1] + dWR[2])/2.0;
+				
+				allpasstemp = alpXR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;}
+				inputSampleR -= aXR[allpasstemp]*constallpass;
+				aXR[alpXR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpXR--; if (alpXR < 0 || alpXR > delayX) {alpXR = delayX;}
+				inputSampleR += (aXR[alpXR]);
+				//allpass filter X
+				
+				dXR[2] = dXR[1];
+				dXR[1] = inputSampleR;
+				inputSampleR = (dXR[1] + dXR[2])/2.0;
+				
+				allpasstemp = alpYR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;}
+				inputSampleR -= aYR[allpasstemp]*constallpass;
+				aYR[alpYR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpYR--; if (alpYR < 0 || alpYR > delayY) {alpYR = delayY;}
+				inputSampleR += (aYR[alpYR]);
+				//allpass filter Y
+				
+				dYR[2] = dYR[1];
+				dYR[1] = inputSampleR;
+				inputSampleR = (dYR[1] + dYR[2])/2.0;
+				
+				allpasstemp = alpZR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;}
+				inputSampleR -= aZR[allpasstemp]*constallpass;
+				aZR[alpZR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpZR--; if (alpZR < 0 || alpZR > delayZ) {alpZR = delayZ;}
+				inputSampleR += (aZR[alpZR]);
+				//allpass filter Z
+				
+				dZR[2] = dZR[1];
+				dZR[1] = inputSampleR;
+				inputSampleR = (dZR[1] + dZR[2])/2.0;
+				
+				// now the second stage using the 'out' bank of allpasses		
+				
+				allpasstemp = outAR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;}
+				inputSampleR -= oAR[allpasstemp]*constallpass;
+				oAR[outAR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outAR--; if (outAR < 0 || outAR > delayA) {outAR = delayA;}
+				inputSampleR += (oAR[outAR]);
+				//allpass filter A		
+				
+				dAR[5] = dAR[4];
+				dAR[4] = inputSampleR;
+				inputSampleR = (dAR[4] + dAR[5])/2.0;
+				
+				allpasstemp = outBR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;}
+				inputSampleR -= oBR[allpasstemp]*constallpass;
+				oBR[outBR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outBR--; if (outBR < 0 || outBR > delayB) {outBR = delayB;}
+				inputSampleR += (oBR[outBR]);
+				//allpass filter B
+				
+				dBR[5] = dBR[4];
+				dBR[4] = inputSampleR;
+				inputSampleR = (dBR[4] + dBR[5])/2.0;
+				
+				allpasstemp = outCR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;}
+				inputSampleR -= oCR[allpasstemp]*constallpass;
+				oCR[outCR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outCR--; if (outCR < 0 || outCR > delayC) {outCR = delayC;}
+				inputSampleR += (oCR[outCR]);
+				//allpass filter C
+				
+				dCR[5] = dCR[4];
+				dCR[4] = inputSampleR;
+				inputSampleR = (dAR[1] + dCR[5])/2.0;
+				
+				allpasstemp = outDR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;}
+				inputSampleR -= oDR[allpasstemp]*constallpass;
+				oDR[outDR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outDR--; if (outDR < 0 || outDR > delayD) {outDR = delayD;}
+				inputSampleR += (oDR[outDR]);
+				//allpass filter D
+				
+				dDR[5] = dDR[4];
+				dDR[4] = inputSampleR;
+				inputSampleR = (dDR[4] + dDR[5])/2.0;
+				
+				allpasstemp = outER - 1;
+				if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;}
+				inputSampleR -= oER[allpasstemp]*constallpass;
+				oER[outER] = inputSampleR;
+				inputSampleR *= constallpass;
+				outER--; if (outER < 0 || outER > delayE) {outER = delayE;}
+				inputSampleR += (oER[outER]);
+				//allpass filter E
+				
+				dER[5] = dER[4];
+				dER[4] = inputSampleR;
+				inputSampleR = (dAR[1] + dER[5])/2.0;
+				
+				allpasstemp = outFR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;}
+				inputSampleR -= oFR[allpasstemp]*constallpass;
+				oFR[outFR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outFR--; if (outFR < 0 || outFR > delayF) {outFR = delayF;}
+				inputSampleR += (oFR[outFR]);
+				//allpass filter F
+				
+				dFR[5] = dFR[4];
+				dFR[4] = inputSampleR;
+				inputSampleR = (dFR[4] + dFR[5])/2.0;
+				
+				allpasstemp = outGR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;}
+				inputSampleR -= oGR[allpasstemp]*constallpass;
+				oGR[outGR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outGR--; if (outGR < 0 || outGR > delayG) {outGR = delayG;}
+				inputSampleR += (oGR[outGR]);
+				//allpass filter G
+				
+				dGR[5] = dGR[4];
+				dGR[4] = inputSampleR;
+				inputSampleR = (dGR[4] + dGR[5])/2.0;
+				
+				allpasstemp = outHR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;}
+				inputSampleR -= oHR[allpasstemp]*constallpass;
+				oHR[outHR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outHR--; if (outHR < 0 || outHR > delayH) {outHR = delayH;}
+				inputSampleR += (oHR[outHR]);
+				//allpass filter H
+				
+				dHR[5] = dHR[4];
+				dHR[4] = inputSampleR;
+				inputSampleR = (dHR[4] + dHR[5])/2.0;
+				
+				allpasstemp = outIR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;}
+				inputSampleR -= oIR[allpasstemp]*constallpass;
+				oIR[outIR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outIR--; if (outIR < 0 || outIR > delayI) {outIR = delayI;}
+				inputSampleR += (oIR[outIR]);
+				//allpass filter I
+				
+				dIR[5] = dIR[4];
+				dIR[4] = inputSampleR;
+				inputSampleR = (dIR[4] + dIR[5])/2.0;
+				
+				allpasstemp = outJR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;}
+				inputSampleR -= oJR[allpasstemp]*constallpass;
+				oJR[outJR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outJR--; if (outJR < 0 || outJR > delayJ) {outJR = delayJ;}
+				inputSampleR += (oJR[outJR]);
+				//allpass filter J
+				
+				dJR[5] = dJR[4];
+				dJR[4] = inputSampleR;
+				inputSampleR = (dJR[4] + dJR[5])/2.0;
+				
+				allpasstemp = outKR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;}
+				inputSampleR -= oKR[allpasstemp]*constallpass;
+				oKR[outKR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outKR--; if (outKR < 0 || outKR > delayK) {outKR = delayK;}
+				inputSampleR += (oKR[outKR]);
+				//allpass filter K
+				
+				dKR[5] = dKR[4];
+				dKR[4] = inputSampleR;
+				inputSampleR = (dAR[1] + dKR[5])/2.0;
+				
+				allpasstemp = outLR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;}
+				inputSampleR -= oLR[allpasstemp]*constallpass;
+				oLR[outLR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outLR--; if (outLR < 0 || outLR > delayL) {outLR = delayL;}
+				inputSampleR += (oLR[outLR]);
+				//allpass filter L
+				
+				dLR[5] = dLR[4];
+				dLR[4] = inputSampleR;
+				inputSampleR = (dLR[4] + dLR[5])/2.0;
+				
+				allpasstemp = outMR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;}
+				inputSampleR -= oMR[allpasstemp]*constallpass;
+				oMR[outMR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outMR--; if (outMR < 0 || outMR > delayM) {outMR = delayM;}
+				inputSampleR += (oMR[outMR]);
+				//allpass filter M
+				
+				dMR[5] = dMR[4];
+				dMR[4] = inputSampleR;
+				inputSampleR = (dMR[4] + dMR[5])/2.0;
+				
+				allpasstemp = outNR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;}
+				inputSampleR -= oNR[allpasstemp]*constallpass;
+				oNR[outNR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outNR--; if (outNR < 0 || outNR > delayN) {outNR = delayN;}
+				inputSampleR += (oNR[outNR]);
+				//allpass filter N
+				
+				dNR[5] = dNR[4];
+				dNR[4] = inputSampleR;
+				inputSampleR = (dNR[4] + dNR[5])/2.0;
+				
+				allpasstemp = outOR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;}
+				inputSampleR -= oOR[allpasstemp]*constallpass;
+				oOR[outOR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outOR--; if (outOR < 0 || outOR > delayO) {outOR = delayO;}
+				inputSampleR += (oOR[outOR]);
+				//allpass filter O
+				
+				dOR[5] = dOR[4];
+				dOR[4] = inputSampleR;
+				inputSampleR = (dAR[1] + dOR[5])/2.0;
+				
+				allpasstemp = outPR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;}
+				inputSampleR -= oPR[allpasstemp]*constallpass;
+				oPR[outPR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outPR--; if (outPR < 0 || outPR > delayP) {outPR = delayP;}
+				inputSampleR += (oPR[outPR]);
+				//allpass filter P
+				
+				dPR[5] = dPR[4];
+				dPR[4] = inputSampleR;
+				inputSampleR = (dPR[4] + dPR[5])/2.0;
+				
+				allpasstemp = outQR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;}
+				inputSampleR -= oQR[allpasstemp]*constallpass;
+				oQR[outQR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outQR--; if (outQR < 0 || outQR > delayQ) {outQR = delayQ;}
+				inputSampleR += (oQR[outQR]);
+				//allpass filter Q
+				
+				dQR[5] = dQR[4];
+				dQR[4] = inputSampleR;
+				inputSampleR = (dAR[1] + dQR[5])/2.0;
+				
+				allpasstemp = outRR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;}
+				inputSampleR -= oRR[allpasstemp]*constallpass;
+				oRR[outRR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outRR--; if (outRR < 0 || outRR > delayR) {outRR = delayR;}
+				inputSampleR += (oRR[outRR]);
+				//allpass filter R
+				
+				dRR[5] = dRR[4];
+				dRR[4] = inputSampleR;
+				inputSampleR = (dRR[4] + dRR[5])/2.0;
+				
+				allpasstemp = outSR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;}
+				inputSampleR -= oSR[allpasstemp]*constallpass;
+				oSR[outSR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outSR--; if (outSR < 0 || outSR > delayS) {outSR = delayS;}
+				inputSampleR += (oSR[outSR]);
+				//allpass filter S
+				
+				dSR[5] = dSR[4];
+				dSR[4] = inputSampleR;
+				inputSampleR = (dSR[4] + dSR[5])/2.0;
+				
+				allpasstemp = outTR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;}
+				inputSampleR -= oTR[allpasstemp]*constallpass;
+				oTR[outTR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outTR--; if (outTR < 0 || outTR > delayT) {outTR = delayT;}
+				inputSampleR += (oTR[outTR]);
+				//allpass filter T
+				
+				dTR[5] = dTR[4];
+				dTR[4] = inputSampleR;
+				inputSampleR = (dTR[4] + dTR[5])/2.0;
+				
+				allpasstemp = outUR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;}
+				inputSampleR -= oUR[allpasstemp]*constallpass;
+				oUR[outUR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outUR--; if (outUR < 0 || outUR > delayU) {outUR = delayU;}
+				inputSampleR += (oUR[outUR]);
+				//allpass filter U
+				
+				dUR[5] = dUR[4];
+				dUR[4] = inputSampleR;
+				inputSampleR = (dAR[1] + dUR[5])/2.0;
+				
+				allpasstemp = outVR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;}
+				inputSampleR -= oVR[allpasstemp]*constallpass;
+				oVR[outVR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outVR--; if (outVR < 0 || outVR > delayV) {outVR = delayV;}
+				inputSampleR += (oVR[outVR]);
+				//allpass filter V
+				
+				dVR[5] = dVR[4];
+				dVR[4] = inputSampleR;
+				inputSampleR = (dVR[4] + dVR[5])/2.0;
+				
+				allpasstemp = outWR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;}
+				inputSampleR -= oWR[allpasstemp]*constallpass;
+				oWR[outWR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outWR--; if (outWR < 0 || outWR > delayW) {outWR = delayW;}
+				inputSampleR += (oWR[outWR]);
+				//allpass filter W
+				
+				dWR[5] = dWR[4];
+				dWR[4] = inputSampleR;
+				inputSampleR = (dWR[4] + dWR[5])/2.0;
+				
+				allpasstemp = outXR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;}
+				inputSampleR -= oXR[allpasstemp]*constallpass;
+				oXR[outXR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outXR--; if (outXR < 0 || outXR > delayX) {outXR = delayX;}
+				inputSampleR += (oXR[outXR]);
+				//allpass filter X
+				
+				dXR[5] = dXR[4];
+				dXR[4] = inputSampleR;
+				inputSampleR = (dXR[4] + dXR[5])/2.0;
+				
+				allpasstemp = outYR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;}
+				inputSampleR -= oYR[allpasstemp]*constallpass;
+				oYR[outYR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outYR--; if (outYR < 0 || outYR > delayY) {outYR = delayY;}
+				inputSampleR += (oYR[outYR]);
+				//allpass filter Y
+				
+				dYR[5] = dYR[4];
+				dYR[4] = inputSampleR;
+				inputSampleR = (dYR[4] + dYR[5])/2.0;
+				
+				allpasstemp = outZR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;}
+				inputSampleR -= oZR[allpasstemp]*constallpass;
+				oZR[outZR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outZR--; if (outZR < 0 || outZR > delayZ) {outZR = delayZ;}
+				inputSampleR += (oZR[outZR]);
+				//allpass filter Z
+				
+				dZR[5] = dZR[4];
+				dZR[4] = inputSampleR;
+				inputSampleR = (dZR[4] + dZR[5]);		
+				//output Tiled
+				break;
+				
+				
+			case 4://Room
+				allpasstemp = alpAR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;}
+				inputSampleR -= aAR[allpasstemp]*constallpass;
+				aAR[alpAR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpAR--; if (alpAR < 0 || alpAR > delayA) {alpAR = delayA;}
+				inputSampleR += (aAR[alpAR]);
+				//allpass filter A		
+				
+				dAR[2] = dAR[1];
+				dAR[1] = inputSampleR;
+				inputSampleR = drySampleR;
+				
+				allpasstemp = alpBR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;}
+				inputSampleR -= aBR[allpasstemp]*constallpass;
+				aBR[alpBR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpBR--; if (alpBR < 0 || alpBR > delayB) {alpBR = delayB;}
+				inputSampleR += (aBR[alpBR]);
+				//allpass filter B
+				
+				dBR[2] = dBR[1];
+				dBR[1] = inputSampleR;
+				inputSampleR = drySampleR;
+				
+				allpasstemp = alpCR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;}
+				inputSampleR -= aCR[allpasstemp]*constallpass;
+				aCR[alpCR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpCR--; if (alpCR < 0 || alpCR > delayC) {alpCR = delayC;}
+				inputSampleR += (aCR[alpCR]);
+				//allpass filter C
+				
+				dCR[2] = dCR[1];
+				dCR[1] = inputSampleR;
+				inputSampleR = drySampleR;
+				
+				allpasstemp = alpDR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;}
+				inputSampleR -= aDR[allpasstemp]*constallpass;
+				aDR[alpDR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpDR--; if (alpDR < 0 || alpDR > delayD) {alpDR = delayD;}
+				inputSampleR += (aDR[alpDR]);
+				//allpass filter D
+				
+				dDR[2] = dDR[1];
+				dDR[1] = inputSampleR;
+				inputSampleR = drySampleR;
+				
+				allpasstemp = alpER - 1;
+				if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;}
+				inputSampleR -= aER[allpasstemp]*constallpass;
+				aER[alpER] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpER--; if (alpER < 0 || alpER > delayE) {alpER = delayE;}
+				inputSampleR += (aER[alpER]);
+				//allpass filter E
+				
+				dER[2] = dER[1];
+				dER[1] = inputSampleR;
+				inputSampleR = drySampleR;
+				
+				allpasstemp = alpFR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;}
+				inputSampleR -= aFR[allpasstemp]*constallpass;
+				aFR[alpFR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpFR--; if (alpFR < 0 || alpFR > delayF) {alpFR = delayF;}
+				inputSampleR += (aFR[alpFR]);
+				//allpass filter F
+				
+				dFR[2] = dFR[1];
+				dFR[1] = inputSampleR;
+				inputSampleR = drySampleR;
+				
+				allpasstemp = alpGR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;}
+				inputSampleR -= aGR[allpasstemp]*constallpass;
+				aGR[alpGR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpGR--; if (alpGR < 0 || alpGR > delayG) {alpGR = delayG;}
+				inputSampleR += (aGR[alpGR]);
+				//allpass filter G
+				
+				dGR[2] = dGR[1];
+				dGR[1] = inputSampleR;
+				inputSampleR = drySampleR;
+				
+				allpasstemp = alpHR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;}
+				inputSampleR -= aHR[allpasstemp]*constallpass;
+				aHR[alpHR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpHR--; if (alpHR < 0 || alpHR > delayH) {alpHR = delayH;}
+				inputSampleR += (aHR[alpHR]);
+				//allpass filter H
+				
+				dHR[2] = dHR[1];
+				dHR[1] = inputSampleR;
+				inputSampleR = drySampleR;
+				
+				allpasstemp = alpIR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;}
+				inputSampleR -= aIR[allpasstemp]*constallpass;
+				aIR[alpIR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpIR--; if (alpIR < 0 || alpIR > delayI) {alpIR = delayI;}
+				inputSampleR += (aIR[alpIR]);
+				//allpass filter I
+				
+				dIR[2] = dIR[1];
+				dIR[1] = inputSampleR;
+				inputSampleR = drySampleR;
+				
+				allpasstemp = alpJR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;}
+				inputSampleR -= aJR[allpasstemp]*constallpass;
+				aJR[alpJR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpJR--; if (alpJR < 0 || alpJR > delayJ) {alpJR = delayJ;}
+				inputSampleR += (aJR[alpJR]);
+				//allpass filter J
+				
+				dJR[2] = dJR[1];
+				dJR[1] = inputSampleR;
+				inputSampleR = drySampleR;
+				
+				allpasstemp = alpKR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;}
+				inputSampleR -= aKR[allpasstemp]*constallpass;
+				aKR[alpKR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpKR--; if (alpKR < 0 || alpKR > delayK) {alpKR = delayK;}
+				inputSampleR += (aKR[alpKR]);
+				//allpass filter K
+				
+				dKR[2] = dKR[1];
+				dKR[1] = inputSampleR;
+				inputSampleR = drySampleR;
+				
+				allpasstemp = alpLR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;}
+				inputSampleR -= aLR[allpasstemp]*constallpass;
+				aLR[alpLR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpLR--; if (alpLR < 0 || alpLR > delayL) {alpLR = delayL;}
+				inputSampleR += (aLR[alpLR]);
+				//allpass filter L
+				
+				dLR[2] = dLR[1];
+				dLR[1] = inputSampleR;
+				inputSampleR = drySampleR;
+				
+				allpasstemp = alpMR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;}
+				inputSampleR -= aMR[allpasstemp]*constallpass;
+				aMR[alpMR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpMR--; if (alpMR < 0 || alpMR > delayM) {alpMR = delayM;}
+				inputSampleR += (aMR[alpMR]);
+				//allpass filter M
+				
+				dMR[2] = dMR[1];
+				dMR[1] = inputSampleR;
+				inputSampleR = drySampleR;
+				
+				allpasstemp = alpNR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;}
+				inputSampleR -= aNR[allpasstemp]*constallpass;
+				aNR[alpNR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpNR--; if (alpNR < 0 || alpNR > delayN) {alpNR = delayN;}
+				inputSampleR += (aNR[alpNR]);
+				//allpass filter N
+				
+				dNR[2] = dNR[1];
+				dNR[1] = inputSampleR;
+				inputSampleR = drySampleR;
+				
+				allpasstemp = alpOR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;}
+				inputSampleR -= aOR[allpasstemp]*constallpass;
+				aOR[alpOR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpOR--; if (alpOR < 0 || alpOR > delayO) {alpOR = delayO;}
+				inputSampleR += (aOR[alpOR]);
+				//allpass filter O
+				
+				dOR[2] = dOR[1];
+				dOR[1] = inputSampleR;
+				inputSampleR = drySampleR;
+				
+				allpasstemp = alpPR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;}
+				inputSampleR -= aPR[allpasstemp]*constallpass;
+				aPR[alpPR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpPR--; if (alpPR < 0 || alpPR > delayP) {alpPR = delayP;}
+				inputSampleR += (aPR[alpPR]);
+				//allpass filter P
+				
+				dPR[2] = dPR[1];
+				dPR[1] = inputSampleR;
+				inputSampleR = drySampleR;
+				
+				allpasstemp = alpQR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;}
+				inputSampleR -= aQR[allpasstemp]*constallpass;
+				aQR[alpQR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpQR--; if (alpQR < 0 || alpQR > delayQ) {alpQR = delayQ;}
+				inputSampleR += (aQR[alpQR]);
+				//allpass filter Q
+				
+				dQR[2] = dQR[1];
+				dQR[1] = inputSampleR;
+				inputSampleR = drySampleR;
+				
+				allpasstemp = alpRR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;}
+				inputSampleR -= aRR[allpasstemp]*constallpass;
+				aRR[alpRR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpRR--; if (alpRR < 0 || alpRR > delayR) {alpRR = delayR;}
+				inputSampleR += (aRR[alpRR]);
+				//allpass filter R
+				
+				dRR[2] = dRR[1];
+				dRR[1] = inputSampleR;
+				inputSampleR = drySampleR;
+				
+				allpasstemp = alpSR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;}
+				inputSampleR -= aSR[allpasstemp]*constallpass;
+				aSR[alpSR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpSR--; if (alpSR < 0 || alpSR > delayS) {alpSR = delayS;}
+				inputSampleR += (aSR[alpSR]);
+				//allpass filter S
+				
+				dSR[2] = dSR[1];
+				dSR[1] = inputSampleR;
+				inputSampleR = drySampleR;
+				
+				allpasstemp = alpTR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;}
+				inputSampleR -= aTR[allpasstemp]*constallpass;
+				aTR[alpTR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpTR--; if (alpTR < 0 || alpTR > delayT) {alpTR = delayT;}
+				inputSampleR += (aTR[alpTR]);
+				//allpass filter T
+				
+				dTR[2] = dTR[1];
+				dTR[1] = inputSampleR;
+				inputSampleR = drySampleR;
+				
+				allpasstemp = alpUR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;}
+				inputSampleR -= aUR[allpasstemp]*constallpass;
+				aUR[alpUR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpUR--; if (alpUR < 0 || alpUR > delayU) {alpUR = delayU;}
+				inputSampleR += (aUR[alpUR]);
+				//allpass filter U
+				
+				dUR[2] = dUR[1];
+				dUR[1] = inputSampleR;
+				inputSampleR = drySampleR;
+				
+				allpasstemp = alpVR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;}
+				inputSampleR -= aVR[allpasstemp]*constallpass;
+				aVR[alpVR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpVR--; if (alpVR < 0 || alpVR > delayV) {alpVR = delayV;}
+				inputSampleR += (aVR[alpVR]);
+				//allpass filter V
+				
+				dVR[2] = dVR[1];
+				dVR[1] = inputSampleR;
+				inputSampleR = drySampleR;
+				
+				allpasstemp = alpWR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;}
+				inputSampleR -= aWR[allpasstemp]*constallpass;
+				aWR[alpWR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpWR--; if (alpWR < 0 || alpWR > delayW) {alpWR = delayW;}
+				inputSampleR += (aWR[alpWR]);
+				//allpass filter W
+				
+				dWR[2] = dWR[1];
+				dWR[1] = inputSampleR;
+				inputSampleR = drySampleR;
+				
+				allpasstemp = alpXR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;}
+				inputSampleR -= aXR[allpasstemp]*constallpass;
+				aXR[alpXR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpXR--; if (alpXR < 0 || alpXR > delayX) {alpXR = delayX;}
+				inputSampleR += (aXR[alpXR]);
+				//allpass filter X
+				
+				dXR[2] = dXR[1];
+				dXR[1] = inputSampleR;
+				inputSampleR = drySampleR;
+				
+				allpasstemp = alpYR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;}
+				inputSampleR -= aYR[allpasstemp]*constallpass;
+				aYR[alpYR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpYR--; if (alpYR < 0 || alpYR > delayY) {alpYR = delayY;}
+				inputSampleR += (aYR[alpYR]);
+				//allpass filter Y
+				
+				dYR[2] = dYR[1];
+				dYR[1] = inputSampleR;
+				inputSampleR = drySampleR;
+				
+				allpasstemp = alpZR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;}
+				inputSampleR -= aZR[allpasstemp]*constallpass;
+				aZR[alpZR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpZR--; if (alpZR < 0 || alpZR > delayZ) {alpZR = delayZ;}
+				inputSampleR += (aZR[alpZR]);
+				//allpass filter Z
+				
+				dZR[2] = dZR[1];
+				dZR[1] = inputSampleR;
+				inputSampleR = drySampleR;
+				
+				// now the second stage using the 'out' bank of allpasses		
+				
+				allpasstemp = outAR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;}
+				inputSampleR -= oAR[allpasstemp]*constallpass;
+				oAR[outAR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outAR--; if (outAR < 0 || outAR > delayA) {outAR = delayA;}
+				inputSampleR += (oAR[outAR]);
+				//allpass filter A		
+				
+				dAR[5] = dAR[4];
+				dAR[4] = inputSampleR;
+				inputSampleR = (dAR[1]+dAR[2])/2.0;
+				
+				allpasstemp = outBR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;}
+				inputSampleR -= oBR[allpasstemp]*constallpass;
+				oBR[outBR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outBR--; if (outBR < 0 || outBR > delayB) {outBR = delayB;}
+				inputSampleR += (oBR[outBR]);
+				//allpass filter B
+				
+				dBR[5] = dBR[4];
+				dBR[4] = inputSampleR;
+				inputSampleR = (dBR[1]+dBR[2])/2.0;
+				
+				allpasstemp = outCR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;}
+				inputSampleR -= oCR[allpasstemp]*constallpass;
+				oCR[outCR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outCR--; if (outCR < 0 || outCR > delayC) {outCR = delayC;}
+				inputSampleR += (oCR[outCR]);
+				//allpass filter C
+				
+				dCR[5] = dCR[4];
+				dCR[4] = inputSampleR;
+				inputSampleR = (dCR[1]+dCR[2])/2.0;
+				
+				allpasstemp = outDR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;}
+				inputSampleR -= oDR[allpasstemp]*constallpass;
+				oDR[outDR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outDR--; if (outDR < 0 || outDR > delayD) {outDR = delayD;}
+				inputSampleR += (oDR[outDR]);
+				//allpass filter D
+				
+				dDR[5] = dDR[4];
+				dDR[4] = inputSampleR;
+				inputSampleR = (dDR[1]+dDR[2])/2.0;
+				
+				allpasstemp = outER - 1;
+				if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;}
+				inputSampleR -= oER[allpasstemp]*constallpass;
+				oER[outER] = inputSampleR;
+				inputSampleR *= constallpass;
+				outER--; if (outER < 0 || outER > delayE) {outER = delayE;}
+				inputSampleR += (oER[outER]);
+				//allpass filter E
+				
+				dER[5] = dER[4];
+				dER[4] = inputSampleR;
+				inputSampleR = (dER[1]+dER[2])/2.0;
+				
+				allpasstemp = outFR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;}
+				inputSampleR -= oFR[allpasstemp]*constallpass;
+				oFR[outFR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outFR--; if (outFR < 0 || outFR > delayF) {outFR = delayF;}
+				inputSampleR += (oFR[outFR]);
+				//allpass filter F
+				
+				dFR[5] = dFR[4];
+				dFR[4] = inputSampleR;
+				inputSampleR = (dFR[1]+dFR[2])/2.0;
+				
+				allpasstemp = outGR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;}
+				inputSampleR -= oGR[allpasstemp]*constallpass;
+				oGR[outGR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outGR--; if (outGR < 0 || outGR > delayG) {outGR = delayG;}
+				inputSampleR += (oGR[outGR]);
+				//allpass filter G
+				
+				dGR[5] = dGR[4];
+				dGR[4] = inputSampleR;
+				inputSampleR = (dGR[1]+dGR[2])/2.0;
+				
+				allpasstemp = outHR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;}
+				inputSampleR -= oHR[allpasstemp]*constallpass;
+				oHR[outHR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outHR--; if (outHR < 0 || outHR > delayH) {outHR = delayH;}
+				inputSampleR += (oHR[outHR]);
+				//allpass filter H
+				
+				dHR[5] = dHR[4];
+				dHR[4] = inputSampleR;
+				inputSampleR = (dHR[1]+dHR[2])/2.0;
+				
+				allpasstemp = outIR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;}
+				inputSampleR -= oIR[allpasstemp]*constallpass;
+				oIR[outIR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outIR--; if (outIR < 0 || outIR > delayI) {outIR = delayI;}
+				inputSampleR += (oIR[outIR]);
+				//allpass filter I
+				
+				dIR[5] = dIR[4];
+				dIR[4] = inputSampleR;
+				inputSampleR = (dIR[1]+dIR[2])/2.0;
+				
+				allpasstemp = outJR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;}
+				inputSampleR -= oJR[allpasstemp]*constallpass;
+				oJR[outJR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outJR--; if (outJR < 0 || outJR > delayJ) {outJR = delayJ;}
+				inputSampleR += (oJR[outJR]);
+				//allpass filter J
+				
+				dJR[5] = dJR[4];
+				dJR[4] = inputSampleR;
+				inputSampleR = (dJR[1]+dJR[2])/2.0;
+				
+				allpasstemp = outKR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;}
+				inputSampleR -= oKR[allpasstemp]*constallpass;
+				oKR[outKR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outKR--; if (outKR < 0 || outKR > delayK) {outKR = delayK;}
+				inputSampleR += (oKR[outKR]);
+				//allpass filter K
+				
+				dKR[5] = dKR[4];
+				dKR[4] = inputSampleR;
+				inputSampleR = (dKR[1]+dKR[2])/2.0;
+				
+				allpasstemp = outLR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;}
+				inputSampleR -= oLR[allpasstemp]*constallpass;
+				oLR[outLR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outLR--; if (outLR < 0 || outLR > delayL) {outLR = delayL;}
+				inputSampleR += (oLR[outLR]);
+				//allpass filter L
+				
+				dLR[5] = dLR[4];
+				dLR[4] = inputSampleR;
+				inputSampleR = (dLR[1]+dLR[2])/2.0;
+				
+				allpasstemp = outMR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;}
+				inputSampleR -= oMR[allpasstemp]*constallpass;
+				oMR[outMR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outMR--; if (outMR < 0 || outMR > delayM) {outMR = delayM;}
+				inputSampleR += (oMR[outMR]);
+				//allpass filter M
+				
+				dMR[5] = dMR[4];
+				dMR[4] = inputSampleR;
+				inputSampleR = (dMR[1]+dMR[2])/2.0;
+				
+				allpasstemp = outNR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;}
+				inputSampleR -= oNR[allpasstemp]*constallpass;
+				oNR[outNR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outNR--; if (outNR < 0 || outNR > delayN) {outNR = delayN;}
+				inputSampleR += (oNR[outNR]);
+				//allpass filter N
+				
+				dNR[5] = dNR[4];
+				dNR[4] = inputSampleR;
+				inputSampleR = (dNR[1]+dNR[2])/2.0;
+				
+				allpasstemp = outOR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;}
+				inputSampleR -= oOR[allpasstemp]*constallpass;
+				oOR[outOR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outOR--; if (outOR < 0 || outOR > delayO) {outOR = delayO;}
+				inputSampleR += (oOR[outOR]);
+				//allpass filter O
+				
+				dOR[5] = dOR[4];
+				dOR[4] = inputSampleR;
+				inputSampleR = (dOR[1]+dOR[2])/2.0;
+				
+				allpasstemp = outPR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;}
+				inputSampleR -= oPR[allpasstemp]*constallpass;
+				oPR[outPR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outPR--; if (outPR < 0 || outPR > delayP) {outPR = delayP;}
+				inputSampleR += (oPR[outPR]);
+				//allpass filter P
+				
+				dPR[5] = dPR[4];
+				dPR[4] = inputSampleR;
+				inputSampleR = (dPR[1]+dPR[2])/2.0;
+				
+				allpasstemp = outQR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;}
+				inputSampleR -= oQR[allpasstemp]*constallpass;
+				oQR[outQR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outQR--; if (outQR < 0 || outQR > delayQ) {outQR = delayQ;}
+				inputSampleR += (oQR[outQR]);
+				//allpass filter Q
+				
+				dQR[5] = dQR[4];
+				dQR[4] = inputSampleR;
+				inputSampleR = (dQR[1]+dQR[2])/2.0;
+				
+				allpasstemp = outRR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;}
+				inputSampleR -= oRR[allpasstemp]*constallpass;
+				oRR[outRR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outRR--; if (outRR < 0 || outRR > delayR) {outRR = delayR;}
+				inputSampleR += (oRR[outRR]);
+				//allpass filter R
+				
+				dRR[5] = dRR[4];
+				dRR[4] = inputSampleR;
+				inputSampleR = (dRR[1]+dRR[2])/2.0;
+				
+				allpasstemp = outSR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;}
+				inputSampleR -= oSR[allpasstemp]*constallpass;
+				oSR[outSR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outSR--; if (outSR < 0 || outSR > delayS) {outSR = delayS;}
+				inputSampleR += (oSR[outSR]);
+				//allpass filter S
+				
+				dSR[5] = dSR[4];
+				dSR[4] = inputSampleR;
+				inputSampleR = (dSR[1]+dSR[2])/2.0;
+				
+				allpasstemp = outTR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;}
+				inputSampleR -= oTR[allpasstemp]*constallpass;
+				oTR[outTR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outTR--; if (outTR < 0 || outTR > delayT) {outTR = delayT;}
+				inputSampleR += (oTR[outTR]);
+				//allpass filter T
+				
+				dTR[5] = dTR[4];
+				dTR[4] = inputSampleR;
+				inputSampleR = (dTR[1]+dTR[2])/2.0;
+				
+				allpasstemp = outUR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;}
+				inputSampleR -= oUR[allpasstemp]*constallpass;
+				oUR[outUR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outUR--; if (outUR < 0 || outUR > delayU) {outUR = delayU;}
+				inputSampleR += (oUR[outUR]);
+				//allpass filter U
+				
+				dUR[5] = dUR[4];
+				dUR[4] = inputSampleR;
+				inputSampleR = (dUR[1]+dUR[2])/2.0;
+				
+				allpasstemp = outVR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;}
+				inputSampleR -= oVR[allpasstemp]*constallpass;
+				oVR[outVR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outVR--; if (outVR < 0 || outVR > delayV) {outVR = delayV;}
+				inputSampleR += (oVR[outVR]);
+				//allpass filter V
+				
+				dVR[5] = dVR[4];
+				dVR[4] = inputSampleR;
+				inputSampleR = (dVR[1]+dVR[2])/2.0;
+				
+				allpasstemp = outWR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;}
+				inputSampleR -= oWR[allpasstemp]*constallpass;
+				oWR[outWR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outWR--; if (outWR < 0 || outWR > delayW) {outWR = delayW;}
+				inputSampleR += (oWR[outWR]);
+				//allpass filter W
+				
+				dWR[5] = dWR[4];
+				dWR[4] = inputSampleR;
+				inputSampleR = (dWR[1]+dWR[2])/2.0;
+				
+				allpasstemp = outXR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;}
+				inputSampleR -= oXR[allpasstemp]*constallpass;
+				oXR[outXR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outXR--; if (outXR < 0 || outXR > delayX) {outXR = delayX;}
+				inputSampleR += (oXR[outXR]);
+				//allpass filter X
+				
+				dXR[5] = dXR[4];
+				dXR[4] = inputSampleR;
+				inputSampleR = (dXR[1]+dXR[2])/2.0;
+				
+				allpasstemp = outYR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;}
+				inputSampleR -= oYR[allpasstemp]*constallpass;
+				oYR[outYR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outYR--; if (outYR < 0 || outYR > delayY) {outYR = delayY;}
+				inputSampleR += (oYR[outYR]);
+				//allpass filter Y
+				
+				dYR[5] = dYR[4];
+				dYR[4] = inputSampleR;
+				inputSampleR = (dYR[1]+dYR[2])/2.0;
+				
+				allpasstemp = outZR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;}
+				inputSampleR -= oZR[allpasstemp]*constallpass;
+				oZR[outZR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outZR--; if (outZR < 0 || outZR > delayZ) {outZR = delayZ;}
+				inputSampleR += (oZR[outZR]);
+				//allpass filter Z
+				
+				dZR[5] = dZR[4];
+				dZR[4] = inputSampleR;
+				inputSampleR = (dBR[4] * dryness);		
+				inputSampleR += (dCR[4] * dryness);		
+				inputSampleR += dDR[4];		
+				inputSampleR += dER[4];		
+				inputSampleR += dFR[4];		
+				inputSampleR += dGR[4];		
+				inputSampleR += dHR[4];		
+				inputSampleR += dIR[4];		
+				inputSampleR += dJR[4];		
+				inputSampleR += dKR[4];		
+				inputSampleR += dLR[4];		
+				inputSampleR += dMR[4];		
+				inputSampleR += dNR[4];		
+				inputSampleR += dOR[4];		
+				inputSampleR += dPR[4];		
+				inputSampleR += dQR[4];		
+				inputSampleR += dRR[4];		
+				inputSampleR += dSR[4];		
+				inputSampleR += dTR[4];		
+				inputSampleR += dUR[4];		
+				inputSampleR += dVR[4];		
+				inputSampleR += dWR[4];		
+				inputSampleR += dXR[4];		
+				inputSampleR += dYR[4];		
+				inputSampleR += (dZR[4] * wetness);
+				
+				inputSampleR += (dBR[5] * dryness);		
+				inputSampleR += (dCR[5] * dryness);		
+				inputSampleR += dDR[5];		
+				inputSampleR += dER[5];		
+				inputSampleR += dFR[5];		
+				inputSampleR += dGR[5];		
+				inputSampleR += dHR[5];		
+				inputSampleR += dIR[5];		
+				inputSampleR += dJR[5];		
+				inputSampleR += dKR[5];		
+				inputSampleR += dLR[5];		
+				inputSampleR += dMR[5];		
+				inputSampleR += dNR[5];		
+				inputSampleR += dOR[5];		
+				inputSampleR += dPR[5];		
+				inputSampleR += dQR[5];		
+				inputSampleR += dRR[5];		
+				inputSampleR += dSR[5];		
+				inputSampleR += dTR[5];		
+				inputSampleR += dUR[5];		
+				inputSampleR += dVR[5];		
+				inputSampleR += dWR[5];		
+				inputSampleR += dXR[5];		
+				inputSampleR += dYR[5];		
+				inputSampleR += (dZR[5] * wetness);
+				
+				inputSampleR /= (26.0 + (wetness * 4.0));
+				//output Room effect
+				break;
+				
+				
+				
+				
+				
+				
+			case 5:	//Stretch	
+				allpasstemp = alpAR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;}
+				inputSampleR -= aAR[allpasstemp]*constallpass;
+				aAR[alpAR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpAR--; if (alpAR < 0 || alpAR > delayA) {alpAR = delayA;}
+				inputSampleR += (aAR[alpAR]);
+				//allpass filter A		
+				
+				dAR[2] = dAR[1];
+				dAR[1] = inputSampleR;
+				inputSampleR = (dAR[1] + dAR[2])/2.0;
+				
+				allpasstemp = alpBR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;}
+				inputSampleR -= aBR[allpasstemp]*constallpass;
+				aBR[alpBR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpBR--; if (alpBR < 0 || alpBR > delayB) {alpBR = delayB;}
+				inputSampleR += (aBR[alpBR]);
+				//allpass filter B
+				
+				dBR[2] = dBR[1];
+				dBR[1] = inputSampleR;
+				inputSampleR = (dBR[1] + dBR[2])/2.0;
+				
+				allpasstemp = alpCR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;}
+				inputSampleR -= aCR[allpasstemp]*constallpass;
+				aCR[alpCR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpCR--; if (alpCR < 0 || alpCR > delayC) {alpCR = delayC;}
+				inputSampleR += (aCR[alpCR]);
+				//allpass filter C
+				
+				dCR[2] = dCR[1];
+				dCR[1] = inputSampleR;
+				inputSampleR = (dCR[1] + dCR[2])/2.0;
+				
+				allpasstemp = alpDR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;}
+				inputSampleR -= aDR[allpasstemp]*constallpass;
+				aDR[alpDR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpDR--; if (alpDR < 0 || alpDR > delayD) {alpDR = delayD;}
+				inputSampleR += (aDR[alpDR]);
+				//allpass filter D
+				
+				dDR[2] = dDR[1];
+				dDR[1] = inputSampleR;
+				inputSampleR = (dDR[1] + dDR[2])/2.0;
+				
+				allpasstemp = alpER - 1;
+				if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;}
+				inputSampleR -= aER[allpasstemp]*constallpass;
+				aER[alpER] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpER--; if (alpER < 0 || alpER > delayE) {alpER = delayE;}
+				inputSampleR += (aER[alpER]);
+				//allpass filter E
+				
+				dER[2] = dER[1];
+				dER[1] = inputSampleR;
+				inputSampleR = (dER[1] + dER[2])/2.0;
+				
+				allpasstemp = alpFR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;}
+				inputSampleR -= aFR[allpasstemp]*constallpass;
+				aFR[alpFR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpFR--; if (alpFR < 0 || alpFR > delayF) {alpFR = delayF;}
+				inputSampleR += (aFR[alpFR]);
+				//allpass filter F
+				
+				dFR[2] = dFR[1];
+				dFR[1] = inputSampleR;
+				inputSampleR = (dFR[1] + dFR[2])/2.0;
+				
+				allpasstemp = alpGR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;}
+				inputSampleR -= aGR[allpasstemp]*constallpass;
+				aGR[alpGR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpGR--; if (alpGR < 0 || alpGR > delayG) {alpGR = delayG;}
+				inputSampleR += (aGR[alpGR]);
+				//allpass filter G
+				
+				dGR[2] = dGR[1];
+				dGR[1] = inputSampleR;
+				inputSampleR = (dGR[1] + dGR[2])/2.0;
+				
+				allpasstemp = alpHR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;}
+				inputSampleR -= aHR[allpasstemp]*constallpass;
+				aHR[alpHR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpHR--; if (alpHR < 0 || alpHR > delayH) {alpHR = delayH;}
+				inputSampleR += (aHR[alpHR]);
+				//allpass filter H
+				
+				dHR[2] = dHR[1];
+				dHR[1] = inputSampleR;
+				inputSampleR = (dHR[1] + dHR[2])/2.0;
+				
+				allpasstemp = alpIR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;}
+				inputSampleR -= aIR[allpasstemp]*constallpass;
+				aIR[alpIR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpIR--; if (alpIR < 0 || alpIR > delayI) {alpIR = delayI;}
+				inputSampleR += (aIR[alpIR]);
+				//allpass filter I
+				
+				dIR[2] = dIR[1];
+				dIR[1] = inputSampleR;
+				inputSampleR = (dIR[1] + dIR[2])/2.0;
+				
+				allpasstemp = alpJR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;}
+				inputSampleR -= aJR[allpasstemp]*constallpass;
+				aJR[alpJR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpJR--; if (alpJR < 0 || alpJR > delayJ) {alpJR = delayJ;}
+				inputSampleR += (aJR[alpJR]);
+				//allpass filter J
+				
+				dJR[2] = dJR[1];
+				dJR[1] = inputSampleR;
+				inputSampleR = (dJR[1] + dJR[2])/2.0;
+				
+				allpasstemp = alpKR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;}
+				inputSampleR -= aKR[allpasstemp]*constallpass;
+				aKR[alpKR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpKR--; if (alpKR < 0 || alpKR > delayK) {alpKR = delayK;}
+				inputSampleR += (aKR[alpKR]);
+				//allpass filter K
+				
+				dKR[2] = dKR[1];
+				dKR[1] = inputSampleR;
+				inputSampleR = (dKR[1] + dKR[2])/2.0;
+				
+				allpasstemp = alpLR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;}
+				inputSampleR -= aLR[allpasstemp]*constallpass;
+				aLR[alpLR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpLR--; if (alpLR < 0 || alpLR > delayL) {alpLR = delayL;}
+				inputSampleR += (aLR[alpLR]);
+				//allpass filter L
+				
+				dLR[2] = dLR[1];
+				dLR[1] = inputSampleR;
+				inputSampleR = (dLR[1] + dLR[2])/2.0;
+				
+				allpasstemp = alpMR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;}
+				inputSampleR -= aMR[allpasstemp]*constallpass;
+				aMR[alpMR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpMR--; if (alpMR < 0 || alpMR > delayM) {alpMR = delayM;}
+				inputSampleR += (aMR[alpMR]);
+				//allpass filter M
+				
+				dMR[2] = dMR[1];
+				dMR[1] = inputSampleR;
+				inputSampleR = (dMR[1] + dMR[2])/2.0;
+				
+				allpasstemp = alpNR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;}
+				inputSampleR -= aNR[allpasstemp]*constallpass;
+				aNR[alpNR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpNR--; if (alpNR < 0 || alpNR > delayN) {alpNR = delayN;}
+				inputSampleR += (aNR[alpNR]);
+				//allpass filter N
+				
+				dNR[2] = dNR[1];
+				dNR[1] = inputSampleR;
+				inputSampleR = (dNR[1] + dNR[2])/2.0;
+				
+				allpasstemp = alpOR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;}
+				inputSampleR -= aOR[allpasstemp]*constallpass;
+				aOR[alpOR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpOR--; if (alpOR < 0 || alpOR > delayO) {alpOR = delayO;}
+				inputSampleR += (aOR[alpOR]);
+				//allpass filter O
+				
+				dOR[2] = dOR[1];
+				dOR[1] = inputSampleR;
+				inputSampleR = (dOR[1] + dOR[2])/2.0;
+				
+				allpasstemp = alpPR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;}
+				inputSampleR -= aPR[allpasstemp]*constallpass;
+				aPR[alpPR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpPR--; if (alpPR < 0 || alpPR > delayP) {alpPR = delayP;}
+				inputSampleR += (aPR[alpPR]);
+				//allpass filter P
+				
+				dPR[2] = dPR[1];
+				dPR[1] = inputSampleR;
+				inputSampleR = (dPR[1] + dPR[2])/2.0;
+				
+				allpasstemp = alpQR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;}
+				inputSampleR -= aQR[allpasstemp]*constallpass;
+				aQR[alpQR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpQR--; if (alpQR < 0 || alpQR > delayQ) {alpQR = delayQ;}
+				inputSampleR += (aQR[alpQR]);
+				//allpass filter Q
+				
+				dQR[2] = dQR[1];
+				dQR[1] = inputSampleR;
+				inputSampleR = (dQR[1] + dQR[2])/2.0;
+				
+				allpasstemp = alpRR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;}
+				inputSampleR -= aRR[allpasstemp]*constallpass;
+				aRR[alpRR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpRR--; if (alpRR < 0 || alpRR > delayR) {alpRR = delayR;}
+				inputSampleR += (aRR[alpRR]);
+				//allpass filter R
+				
+				dRR[2] = dRR[1];
+				dRR[1] = inputSampleR;
+				inputSampleR = (dRR[1] + dRR[2])/2.0;
+				
+				allpasstemp = alpSR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;}
+				inputSampleR -= aSR[allpasstemp]*constallpass;
+				aSR[alpSR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpSR--; if (alpSR < 0 || alpSR > delayS) {alpSR = delayS;}
+				inputSampleR += (aSR[alpSR]);
+				//allpass filter S
+				
+				dSR[2] = dSR[1];
+				dSR[1] = inputSampleR;
+				inputSampleR = (dSR[1] + dSR[2])/2.0;
+				
+				allpasstemp = alpTR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;}
+				inputSampleR -= aTR[allpasstemp]*constallpass;
+				aTR[alpTR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpTR--; if (alpTR < 0 || alpTR > delayT) {alpTR = delayT;}
+				inputSampleR += (aTR[alpTR]);
+				//allpass filter T
+				
+				dTR[2] = dTR[1];
+				dTR[1] = inputSampleR;
+				inputSampleR = (dTR[1] + dTR[2])/2.0;
+				
+				allpasstemp = alpUR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;}
+				inputSampleR -= aUR[allpasstemp]*constallpass;
+				aUR[alpUR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpUR--; if (alpUR < 0 || alpUR > delayU) {alpUR = delayU;}
+				inputSampleR += (aUR[alpUR]);
+				//allpass filter U
+				
+				dUR[2] = dUR[1];
+				dUR[1] = inputSampleR;
+				inputSampleR = (dUR[1] + dUR[2])/2.0;
+				
+				allpasstemp = alpVR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;}
+				inputSampleR -= aVR[allpasstemp]*constallpass;
+				aVR[alpVR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpVR--; if (alpVR < 0 || alpVR > delayV) {alpVR = delayV;}
+				inputSampleR += (aVR[alpVR]);
+				//allpass filter V
+				
+				dVR[2] = dVR[1];
+				dVR[1] = inputSampleR;
+				inputSampleR = (dVR[1] + dVR[2])/2.0;
+				
+				allpasstemp = alpWR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;}
+				inputSampleR -= aWR[allpasstemp]*constallpass;
+				aWR[alpWR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpWR--; if (alpWR < 0 || alpWR > delayW) {alpWR = delayW;}
+				inputSampleR += (aWR[alpWR]);
+				//allpass filter W
+				
+				dWR[2] = dWR[1];
+				dWR[1] = inputSampleR;
+				inputSampleR = (dWR[1] + dWR[2])/2.0;
+				
+				allpasstemp = alpXR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;}
+				inputSampleR -= aXR[allpasstemp]*constallpass;
+				aXR[alpXR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpXR--; if (alpXR < 0 || alpXR > delayX) {alpXR = delayX;}
+				inputSampleR += (aXR[alpXR]);
+				//allpass filter X
+				
+				dXR[2] = dXR[1];
+				dXR[1] = inputSampleR;
+				inputSampleR = (dXR[1] + dXR[2])/2.0;
+				
+				allpasstemp = alpYR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;}
+				inputSampleR -= aYR[allpasstemp]*constallpass;
+				aYR[alpYR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpYR--; if (alpYR < 0 || alpYR > delayY) {alpYR = delayY;}
+				inputSampleR += (aYR[alpYR]);
+				//allpass filter Y
+				
+				dYR[2] = dYR[1];
+				dYR[1] = inputSampleR;
+				inputSampleR = (dYR[1] + dYR[2])/2.0;
+				
+				allpasstemp = alpZR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;}
+				inputSampleR -= aZR[allpasstemp]*constallpass;
+				aZR[alpZR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpZR--; if (alpZR < 0 || alpZR > delayZ) {alpZR = delayZ;}
+				inputSampleR += (aZR[alpZR]);
+				//allpass filter Z
+				
+				dZR[2] = dZR[1];
+				dZR[1] = inputSampleR;
+				inputSampleR = (dZR[1] + dZR[2])/2.0;
+				
+				// now the second stage using the 'out' bank of allpasses		
+				
+				allpasstemp = outAR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;}
+				inputSampleR -= oAR[allpasstemp]*constallpass;
+				oAR[outAR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outAR--; if (outAR < 0 || outAR > delayA) {outAR = delayA;}
+				inputSampleR += (oAR[outAR]);
+				//allpass filter A		
+				
+				dAR[5] = dAR[4];
+				dAR[4] = inputSampleR;
+				inputSampleR = (dAR[4] + dAR[5])/2.0;
+				
+				allpasstemp = outBR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;}
+				inputSampleR -= oBR[allpasstemp]*constallpass;
+				oBR[outBR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outBR--; if (outBR < 0 || outBR > delayB) {outBR = delayB;}
+				inputSampleR += (oBR[outBR]);
+				//allpass filter B
+				
+				dBR[5] = dBR[4];
+				dBR[4] = inputSampleR;
+				inputSampleR = (dBR[4] + dBR[5])/2.0;
+				
+				allpasstemp = outCR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;}
+				inputSampleR -= oCR[allpasstemp]*constallpass;
+				oCR[outCR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outCR--; if (outCR < 0 || outCR > delayC) {outCR = delayC;}
+				inputSampleR += (oCR[outCR]);
+				//allpass filter C
+				
+				dCR[5] = dCR[4];
+				dCR[4] = inputSampleR;
+				inputSampleR = (dCR[4] + dCR[5])/2.0;
+				
+				allpasstemp = outDR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;}
+				inputSampleR -= oDR[allpasstemp]*constallpass;
+				oDR[outDR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outDR--; if (outDR < 0 || outDR > delayD) {outDR = delayD;}
+				inputSampleR += (oDR[outDR]);
+				//allpass filter D
+				
+				dDR[5] = dDR[4];
+				dDR[4] = inputSampleR;
+				inputSampleR = (dDR[4] + dDR[5])/2.0;
+				
+				allpasstemp = outER - 1;
+				if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;}
+				inputSampleR -= oER[allpasstemp]*constallpass;
+				oER[outER] = inputSampleR;
+				inputSampleR *= constallpass;
+				outER--; if (outER < 0 || outER > delayE) {outER = delayE;}
+				inputSampleR += (oER[outER]);
+				//allpass filter E
+				
+				dER[5] = dER[4];
+				dER[4] = inputSampleR;
+				inputSampleR = (dER[4] + dER[5])/2.0;
+				
+				allpasstemp = outFR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;}
+				inputSampleR -= oFR[allpasstemp]*constallpass;
+				oFR[outFR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outFR--; if (outFR < 0 || outFR > delayF) {outFR = delayF;}
+				inputSampleR += (oFR[outFR]);
+				//allpass filter F
+				
+				dFR[5] = dFR[4];
+				dFR[4] = inputSampleR;
+				inputSampleR = (dFR[4] + dFR[5])/2.0;
+				
+				allpasstemp = outGR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;}
+				inputSampleR -= oGR[allpasstemp]*constallpass;
+				oGR[outGR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outGR--; if (outGR < 0 || outGR > delayG) {outGR = delayG;}
+				inputSampleR += (oGR[outGR]);
+				//allpass filter G
+				
+				dGR[5] = dGR[4];
+				dGR[4] = inputSampleR;
+				inputSampleR = (dGR[4] + dGR[5])/2.0;
+				
+				allpasstemp = outHR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;}
+				inputSampleR -= oHR[allpasstemp]*constallpass;
+				oHR[outHR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outHR--; if (outHR < 0 || outHR > delayH) {outHR = delayH;}
+				inputSampleR += (oHR[outHR]);
+				//allpass filter H
+				
+				dHR[5] = dHR[4];
+				dHR[4] = inputSampleR;
+				inputSampleR = (dHR[4] + dHR[5])/2.0;
+				
+				allpasstemp = outIR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;}
+				inputSampleR -= oIR[allpasstemp]*constallpass;
+				oIR[outIR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outIR--; if (outIR < 0 || outIR > delayI) {outIR = delayI;}
+				inputSampleR += (oIR[outIR]);
+				//allpass filter I
+				
+				dIR[5] = dIR[4];
+				dIR[4] = inputSampleR;
+				inputSampleR = (dIR[4] + dIR[5])/2.0;
+				
+				allpasstemp = outJR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;}
+				inputSampleR -= oJR[allpasstemp]*constallpass;
+				oJR[outJR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outJR--; if (outJR < 0 || outJR > delayJ) {outJR = delayJ;}
+				inputSampleR += (oJR[outJR]);
+				//allpass filter J
+				
+				dJR[5] = dJR[4];
+				dJR[4] = inputSampleR;
+				inputSampleR = (dJR[4] + dJR[5])/2.0;
+				
+				allpasstemp = outKR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;}
+				inputSampleR -= oKR[allpasstemp]*constallpass;
+				oKR[outKR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outKR--; if (outKR < 0 || outKR > delayK) {outKR = delayK;}
+				inputSampleR += (oKR[outKR]);
+				//allpass filter K
+				
+				dKR[5] = dKR[4];
+				dKR[4] = inputSampleR;
+				inputSampleR = (dKR[4] + dKR[5])/2.0;
+				
+				allpasstemp = outLR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;}
+				inputSampleR -= oLR[allpasstemp]*constallpass;
+				oLR[outLR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outLR--; if (outLR < 0 || outLR > delayL) {outLR = delayL;}
+				inputSampleR += (oLR[outLR]);
+				//allpass filter L
+				
+				dLR[5] = dLR[4];
+				dLR[4] = inputSampleR;
+				inputSampleR = (dLR[4] + dLR[5])/2.0;
+				
+				allpasstemp = outMR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;}
+				inputSampleR -= oMR[allpasstemp]*constallpass;
+				oMR[outMR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outMR--; if (outMR < 0 || outMR > delayM) {outMR = delayM;}
+				inputSampleR += (oMR[outMR]);
+				//allpass filter M
+				
+				dMR[5] = dMR[4];
+				dMR[4] = inputSampleR;
+				inputSampleR = (dMR[4] + dMR[5])/2.0;
+				
+				allpasstemp = outNR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;}
+				inputSampleR -= oNR[allpasstemp]*constallpass;
+				oNR[outNR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outNR--; if (outNR < 0 || outNR > delayN) {outNR = delayN;}
+				inputSampleR += (oNR[outNR]);
+				//allpass filter N
+				
+				dNR[5] = dNR[4];
+				dNR[4] = inputSampleR;
+				inputSampleR = (dNR[4] + dNR[5])/2.0;
+				
+				allpasstemp = outOR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;}
+				inputSampleR -= oOR[allpasstemp]*constallpass;
+				oOR[outOR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outOR--; if (outOR < 0 || outOR > delayO) {outOR = delayO;}
+				inputSampleR += (oOR[outOR]);
+				//allpass filter O
+				
+				dOR[5] = dOR[4];
+				dOR[4] = inputSampleR;
+				inputSampleR = (dOR[4] + dOR[5])/2.0;
+				
+				allpasstemp = outPR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;}
+				inputSampleR -= oPR[allpasstemp]*constallpass;
+				oPR[outPR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outPR--; if (outPR < 0 || outPR > delayP) {outPR = delayP;}
+				inputSampleR += (oPR[outPR]);
+				//allpass filter P
+				
+				dPR[5] = dPR[4];
+				dPR[4] = inputSampleR;
+				inputSampleR = (dPR[4] + dPR[5])/2.0;
+				
+				allpasstemp = outQR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;}
+				inputSampleR -= oQR[allpasstemp]*constallpass;
+				oQR[outQR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outQR--; if (outQR < 0 || outQR > delayQ) {outQR = delayQ;}
+				inputSampleR += (oQR[outQR]);
+				//allpass filter Q
+				
+				dQR[5] = dQR[4];
+				dQR[4] = inputSampleR;
+				inputSampleR = (dQR[4] + dQR[5])/2.0;
+				
+				allpasstemp = outRR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;}
+				inputSampleR -= oRR[allpasstemp]*constallpass;
+				oRR[outRR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outRR--; if (outRR < 0 || outRR > delayR) {outRR = delayR;}
+				inputSampleR += (oRR[outRR]);
+				//allpass filter R
+				
+				dRR[5] = dRR[4];
+				dRR[4] = inputSampleR;
+				inputSampleR = (dRR[4] + dRR[5])/2.0;
+				
+				allpasstemp = outSR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;}
+				inputSampleR -= oSR[allpasstemp]*constallpass;
+				oSR[outSR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outSR--; if (outSR < 0 || outSR > delayS) {outSR = delayS;}
+				inputSampleR += (oSR[outSR]);
+				//allpass filter S
+				
+				dSR[5] = dSR[4];
+				dSR[4] = inputSampleR;
+				inputSampleR = (dSR[4] + dSR[5])/2.0;
+				
+				allpasstemp = outTR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;}
+				inputSampleR -= oTR[allpasstemp]*constallpass;
+				oTR[outTR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outTR--; if (outTR < 0 || outTR > delayT) {outTR = delayT;}
+				inputSampleR += (oTR[outTR]);
+				//allpass filter T
+				
+				dTR[5] = dTR[4];
+				dTR[4] = inputSampleR;
+				inputSampleR = (dTR[4] + dTR[5])/2.0;
+				
+				allpasstemp = outUR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;}
+				inputSampleR -= oUR[allpasstemp]*constallpass;
+				oUR[outUR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outUR--; if (outUR < 0 || outUR > delayU) {outUR = delayU;}
+				inputSampleR += (oUR[outUR]);
+				//allpass filter U
+				
+				dUR[5] = dUR[4];
+				dUR[4] = inputSampleR;
+				inputSampleR = (dUR[4] + dUR[5])/2.0;
+				
+				allpasstemp = outVR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;}
+				inputSampleR -= oVR[allpasstemp]*constallpass;
+				oVR[outVR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outVR--; if (outVR < 0 || outVR > delayV) {outVR = delayV;}
+				inputSampleR += (oVR[outVR]);
+				//allpass filter V
+				
+				dVR[5] = dVR[4];
+				dVR[4] = inputSampleR;
+				inputSampleR = (dVR[4] + dVR[5])/2.0;
+				
+				allpasstemp = outWR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;}
+				inputSampleR -= oWR[allpasstemp]*constallpass;
+				oWR[outWR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outWR--; if (outWR < 0 || outWR > delayW) {outWR = delayW;}
+				inputSampleR += (oWR[outWR]);
+				//allpass filter W
+				
+				dWR[5] = dWR[4];
+				dWR[4] = inputSampleR;
+				inputSampleR = (dWR[4] + dWR[5])/2.0;
+				
+				allpasstemp = outXR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;}
+				inputSampleR -= oXR[allpasstemp]*constallpass;
+				oXR[outXR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outXR--; if (outXR < 0 || outXR > delayX) {outXR = delayX;}
+				inputSampleR += (oXR[outXR]);
+				//allpass filter X
+				
+				dXR[5] = dXR[4];
+				dXR[4] = inputSampleR;
+				inputSampleR = (dXR[4] + dXR[5])/2.0;
+				
+				allpasstemp = outYR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;}
+				inputSampleR -= oYR[allpasstemp]*constallpass;
+				oYR[outYR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outYR--; if (outYR < 0 || outYR > delayY) {outYR = delayY;}
+				inputSampleR += (oYR[outYR]);
+				//allpass filter Y
+				
+				dYR[5] = dYR[4];
+				dYR[4] = inputSampleR;
+				inputSampleR = (dYR[4] + dYR[5])/2.0;
+				
+				allpasstemp = outZR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;}
+				inputSampleR -= oZR[allpasstemp]*constallpass;
+				oZR[outZR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outZR--; if (outZR < 0 || outZR > delayZ) {outZR = delayZ;}
+				inputSampleR += (oZR[outZR]);
+				//allpass filter Z
+				
+				dZR[5] = dZR[4];
+				dZR[4] = inputSampleR;
+				inputSampleR = (dZR[4] + dZR[5])/2.0;		
+				//output Stretch unrealistic but smooth fake Paulstretch
+				break;				
+				
+				
+			case 6:	//Zarathustra	
+				allpasstemp = alpAR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;}
+				inputSampleR -= aAR[allpasstemp]*constallpass;
+				aAR[alpAR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpAR--; if (alpAR < 0 || alpAR > delayA) {alpAR = delayA;}
+				inputSampleR += (aAR[alpAR]);
+				//allpass filter A		
+				
+				dAR[3] = dAR[2];
+				dAR[2] = dAR[1];
+				dAR[1] = inputSampleR;
+				inputSampleR = (dAR[1] + dAR[2] + dZR[3])/3.0; //add feedback
+				
+				allpasstemp = alpBR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;}
+				inputSampleR -= aBR[allpasstemp]*constallpass;
+				aBR[alpBR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpBR--; if (alpBR < 0 || alpBR > delayB) {alpBR = delayB;}
+				inputSampleR += (aBR[alpBR]);
+				//allpass filter B
+				
+				dBR[3] = dBR[2];
+				dBR[2] = dBR[1];
+				dBR[1] = inputSampleR;
+				inputSampleR = (dBR[1] + dBR[2] + dBR[3])/3.0;
+				
+				allpasstemp = alpCR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;}
+				inputSampleR -= aCR[allpasstemp]*constallpass;
+				aCR[alpCR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpCR--; if (alpCR < 0 || alpCR > delayC) {alpCR = delayC;}
+				inputSampleR += (aCR[alpCR]);
+				//allpass filter C
+				
+				dCR[3] = dCR[2];
+				dCR[2] = dCR[1];
+				dCR[1] = inputSampleR;
+				inputSampleR = (dCR[1] + dCR[2] + dCR[3])/3.0;
+				
+				allpasstemp = alpDR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;}
+				inputSampleR -= aDR[allpasstemp]*constallpass;
+				aDR[alpDR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpDR--; if (alpDR < 0 || alpDR > delayD) {alpDR = delayD;}
+				inputSampleR += (aDR[alpDR]);
+				//allpass filter D
+				
+				dDR[3] = dDR[2];
+				dDR[2] = dDR[1];
+				dDR[1] = inputSampleR;
+				inputSampleR = (dDR[1] + dDR[2] + dDR[3])/3.0;
+				
+				allpasstemp = alpER - 1;
+				if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;}
+				inputSampleR -= aER[allpasstemp]*constallpass;
+				aER[alpER] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpER--; if (alpER < 0 || alpER > delayE) {alpER = delayE;}
+				inputSampleR += (aER[alpER]);
+				//allpass filter E
+				
+				dER[3] = dER[2];
+				dER[2] = dER[1];
+				dER[1] = inputSampleR;
+				inputSampleR = (dER[1] + dER[2] + dER[3])/3.0;
+				
+				allpasstemp = alpFR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;}
+				inputSampleR -= aFR[allpasstemp]*constallpass;
+				aFR[alpFR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpFR--; if (alpFR < 0 || alpFR > delayF) {alpFR = delayF;}
+				inputSampleR += (aFR[alpFR]);
+				//allpass filter F
+				
+				dFR[3] = dFR[2];
+				dFR[2] = dFR[1];
+				dFR[1] = inputSampleR;
+				inputSampleR = (dFR[1] + dFR[2] + dFR[3])/3.0;
+				
+				allpasstemp = alpGR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;}
+				inputSampleR -= aGR[allpasstemp]*constallpass;
+				aGR[alpGR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpGR--; if (alpGR < 0 || alpGR > delayG) {alpGR = delayG;}
+				inputSampleR += (aGR[alpGR]);
+				//allpass filter G
+				
+				dGR[3] = dGR[2];
+				dGR[2] = dGR[1];
+				dGR[1] = inputSampleR;
+				inputSampleR = (dGR[1] + dGR[2] + dGR[3])/3.0;
+				
+				allpasstemp = alpHR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;}
+				inputSampleR -= aHR[allpasstemp]*constallpass;
+				aHR[alpHR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpHR--; if (alpHR < 0 || alpHR > delayH) {alpHR = delayH;}
+				inputSampleR += (aHR[alpHR]);
+				//allpass filter H
+				
+				dHR[3] = dHR[2];
+				dHR[2] = dHR[1];
+				dHR[1] = inputSampleR;
+				inputSampleR = (dHR[1] + dHR[2] + dHR[3])/3.0;
+				
+				allpasstemp = alpIR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;}
+				inputSampleR -= aIR[allpasstemp]*constallpass;
+				aIR[alpIR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpIR--; if (alpIR < 0 || alpIR > delayI) {alpIR = delayI;}
+				inputSampleR += (aIR[alpIR]);
+				//allpass filter I
+				
+				dIR[3] = dIR[2];
+				dIR[2] = dIR[1];
+				dIR[1] = inputSampleR;
+				inputSampleR = (dIR[1] + dIR[2] + dIR[3])/3.0;
+				
+				allpasstemp = alpJR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;}
+				inputSampleR -= aJR[allpasstemp]*constallpass;
+				aJR[alpJR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpJR--; if (alpJR < 0 || alpJR > delayJ) {alpJR = delayJ;}
+				inputSampleR += (aJR[alpJR]);
+				//allpass filter J
+				
+				dJR[3] = dJR[2];
+				dJR[2] = dJR[1];
+				dJR[1] = inputSampleR;
+				inputSampleR = (dJR[1] + dJR[2] + dJR[3])/3.0;
+				
+				allpasstemp = alpKR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;}
+				inputSampleR -= aKR[allpasstemp]*constallpass;
+				aKR[alpKR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpKR--; if (alpKR < 0 || alpKR > delayK) {alpKR = delayK;}
+				inputSampleR += (aKR[alpKR]);
+				//allpass filter K
+				
+				dKR[3] = dKR[2];
+				dKR[2] = dKR[1];
+				dKR[1] = inputSampleR;
+				inputSampleR = (dKR[1] + dKR[2] + dKR[3])/3.0;
+				
+				allpasstemp = alpLR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;}
+				inputSampleR -= aLR[allpasstemp]*constallpass;
+				aLR[alpLR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpLR--; if (alpLR < 0 || alpLR > delayL) {alpLR = delayL;}
+				inputSampleR += (aLR[alpLR]);
+				//allpass filter L
+				
+				dLR[3] = dLR[2];
+				dLR[2] = dLR[1];
+				dLR[1] = inputSampleR;
+				inputSampleR = (dLR[1] + dLR[2] + dLR[3])/3.0;
+				
+				allpasstemp = alpMR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;}
+				inputSampleR -= aMR[allpasstemp]*constallpass;
+				aMR[alpMR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpMR--; if (alpMR < 0 || alpMR > delayM) {alpMR = delayM;}
+				inputSampleR += (aMR[alpMR]);
+				//allpass filter M
+				
+				dMR[3] = dMR[2];
+				dMR[2] = dMR[1];
+				dMR[1] = inputSampleR;
+				inputSampleR = (dMR[1] + dMR[2] + dMR[3])/3.0;
+				
+				allpasstemp = alpNR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;}
+				inputSampleR -= aNR[allpasstemp]*constallpass;
+				aNR[alpNR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpNR--; if (alpNR < 0 || alpNR > delayN) {alpNR = delayN;}
+				inputSampleR += (aNR[alpNR]);
+				//allpass filter N
+				
+				dNR[3] = dNR[2];
+				dNR[2] = dNR[1];
+				dNR[1] = inputSampleR;
+				inputSampleR = (dNR[1] + dNR[2] + dNR[3])/3.0;
+				
+				allpasstemp = alpOR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;}
+				inputSampleR -= aOR[allpasstemp]*constallpass;
+				aOR[alpOR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpOR--; if (alpOR < 0 || alpOR > delayO) {alpOR = delayO;}
+				inputSampleR += (aOR[alpOR]);
+				//allpass filter O
+				
+				dOR[3] = dOR[2];
+				dOR[2] = dOR[1];
+				dOR[1] = inputSampleR;
+				inputSampleR = (dOR[1] + dOR[2] + dOR[3])/3.0;
+				
+				allpasstemp = alpPR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;}
+				inputSampleR -= aPR[allpasstemp]*constallpass;
+				aPR[alpPR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpPR--; if (alpPR < 0 || alpPR > delayP) {alpPR = delayP;}
+				inputSampleR += (aPR[alpPR]);
+				//allpass filter P
+				
+				dPR[3] = dPR[2];
+				dPR[2] = dPR[1];
+				dPR[1] = inputSampleR;
+				inputSampleR = (dPR[1] + dPR[2] + dPR[3])/3.0;
+				
+				allpasstemp = alpQR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;}
+				inputSampleR -= aQR[allpasstemp]*constallpass;
+				aQR[alpQR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpQR--; if (alpQR < 0 || alpQR > delayQ) {alpQR = delayQ;}
+				inputSampleR += (aQR[alpQR]);
+				//allpass filter Q
+				
+				dQR[3] = dQR[2];
+				dQR[2] = dQR[1];
+				dQR[1] = inputSampleR;
+				inputSampleR = (dQR[1] + dQR[2] + dQR[3])/3.0;
+				
+				allpasstemp = alpRR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;}
+				inputSampleR -= aRR[allpasstemp]*constallpass;
+				aRR[alpRR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpRR--; if (alpRR < 0 || alpRR > delayR) {alpRR = delayR;}
+				inputSampleR += (aRR[alpRR]);
+				//allpass filter R
+				
+				dRR[3] = dRR[2];
+				dRR[2] = dRR[1];
+				dRR[1] = inputSampleR;
+				inputSampleR = (dRR[1] + dRR[2] + dRR[3])/3.0;
+				
+				allpasstemp = alpSR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;}
+				inputSampleR -= aSR[allpasstemp]*constallpass;
+				aSR[alpSR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpSR--; if (alpSR < 0 || alpSR > delayS) {alpSR = delayS;}
+				inputSampleR += (aSR[alpSR]);
+				//allpass filter S
+				
+				dSR[3] = dSR[2];
+				dSR[2] = dSR[1];
+				dSR[1] = inputSampleR;
+				inputSampleR = (dSR[1] + dSR[2] + dSR[3])/3.0;
+				
+				allpasstemp = alpTR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;}
+				inputSampleR -= aTR[allpasstemp]*constallpass;
+				aTR[alpTR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpTR--; if (alpTR < 0 || alpTR > delayT) {alpTR = delayT;}
+				inputSampleR += (aTR[alpTR]);
+				//allpass filter T
+				
+				dTR[3] = dTR[2];
+				dTR[2] = dTR[1];
+				dTR[1] = inputSampleR;
+				inputSampleR = (dTR[1] + dTR[2] + dTR[3])/3.0;
+				
+				allpasstemp = alpUR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;}
+				inputSampleR -= aUR[allpasstemp]*constallpass;
+				aUR[alpUR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpUR--; if (alpUR < 0 || alpUR > delayU) {alpUR = delayU;}
+				inputSampleR += (aUR[alpUR]);
+				//allpass filter U
+				
+				dUR[3] = dUR[2];
+				dUR[2] = dUR[1];
+				dUR[1] = inputSampleR;
+				inputSampleR = (dUR[1] + dUR[2] + dUR[3])/3.0;
+				
+				allpasstemp = alpVR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;}
+				inputSampleR -= aVR[allpasstemp]*constallpass;
+				aVR[alpVR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpVR--; if (alpVR < 0 || alpVR > delayV) {alpVR = delayV;}
+				inputSampleR += (aVR[alpVR]);
+				//allpass filter V
+				
+				dVR[3] = dVR[2];
+				dVR[2] = dVR[1];
+				dVR[1] = inputSampleR;
+				inputSampleR = (dVR[1] + dVR[2] + dVR[3])/3.0;
+				
+				allpasstemp = alpWR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;}
+				inputSampleR -= aWR[allpasstemp]*constallpass;
+				aWR[alpWR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpWR--; if (alpWR < 0 || alpWR > delayW) {alpWR = delayW;}
+				inputSampleR += (aWR[alpWR]);
+				//allpass filter W
+				
+				dWR[3] = dWR[2];
+				dWR[2] = dWR[1];
+				dWR[1] = inputSampleR;
+				inputSampleR = (dWR[1] + dWR[2] + dWR[3])/3.0;
+				
+				allpasstemp = alpXR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;}
+				inputSampleR -= aXR[allpasstemp]*constallpass;
+				aXR[alpXR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpXR--; if (alpXR < 0 || alpXR > delayX) {alpXR = delayX;}
+				inputSampleR += (aXR[alpXR]);
+				//allpass filter X
+				
+				dXR[3] = dXR[2];
+				dXR[2] = dXR[1];
+				dXR[1] = inputSampleR;
+				inputSampleR = (dXR[1] + dXR[2] + dXR[3])/3.0;
+				
+				allpasstemp = alpYR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;}
+				inputSampleR -= aYR[allpasstemp]*constallpass;
+				aYR[alpYR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpYR--; if (alpYR < 0 || alpYR > delayY) {alpYR = delayY;}
+				inputSampleR += (aYR[alpYR]);
+				//allpass filter Y
+				
+				dYR[3] = dYR[2];
+				dYR[2] = dYR[1];
+				dYR[1] = inputSampleR;
+				inputSampleR = (dYR[1] + dYR[2] + dYR[3])/3.0;
+				
+				allpasstemp = alpZR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;}
+				inputSampleR -= aZR[allpasstemp]*constallpass;
+				aZR[alpZR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpZR--; if (alpZR < 0 || alpZR > delayZ) {alpZR = delayZ;}
+				inputSampleR += (aZR[alpZR]);
+				//allpass filter Z
+				
+				dZR[3] = dZR[2];
+				dZR[2] = dZR[1];
+				dZR[1] = inputSampleR;
+				inputSampleR = (dZR[1] + dZR[2] + dZR[3])/3.0;
+				
+				// now the second stage using the 'out' bank of allpasses		
+				
+				allpasstemp = outAR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;}
+				inputSampleR -= oAR[allpasstemp]*constallpass;
+				oAR[outAR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outAR--; if (outAR < 0 || outAR > delayA) {outAR = delayA;}
+				inputSampleR += (oAR[outAR]);
+				//allpass filter A		
+				
+				dAR[6] = dAR[5];
+				dAR[5] = dAR[4];
+				dAR[4] = inputSampleR;
+				inputSampleR = (dCR[1] + dAR[5] + dAR[6])/3.0;  //note, feeding in dry again for a little more clarity!
+				
+				allpasstemp = outBR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;}
+				inputSampleR -= oBR[allpasstemp]*constallpass;
+				oBR[outBR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outBR--; if (outBR < 0 || outBR > delayB) {outBR = delayB;}
+				inputSampleR += (oBR[outBR]);
+				//allpass filter B
+				
+				dBR[6] = dBR[5];
+				dBR[5] = dBR[4];
+				dBR[4] = inputSampleR;
+				inputSampleR = (dBR[4] + dBR[5] + dBR[6])/3.0;
+				
+				allpasstemp = outCR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;}
+				inputSampleR -= oCR[allpasstemp]*constallpass;
+				oCR[outCR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outCR--; if (outCR < 0 || outCR > delayC) {outCR = delayC;}
+				inputSampleR += (oCR[outCR]);
+				//allpass filter C
+				
+				dCR[6] = dCR[5];
+				dCR[5] = dCR[4];
+				dCR[4] = inputSampleR;
+				inputSampleR = (dCR[4] + dCR[5] + dCR[6])/3.0;
+				
+				allpasstemp = outDR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;}
+				inputSampleR -= oDR[allpasstemp]*constallpass;
+				oDR[outDR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outDR--; if (outDR < 0 || outDR > delayD) {outDR = delayD;}
+				inputSampleR += (oDR[outDR]);
+				//allpass filter D
+				
+				dDR[6] = dDR[5];
+				dDR[5] = dDR[4];
+				dDR[4] = inputSampleR;
+				inputSampleR = (dDR[4] + dDR[5] + dDR[6])/3.0;
+				
+				allpasstemp = outER - 1;
+				if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;}
+				inputSampleR -= oER[allpasstemp]*constallpass;
+				oER[outER] = inputSampleR;
+				inputSampleR *= constallpass;
+				outER--; if (outER < 0 || outER > delayE) {outER = delayE;}
+				inputSampleR += (oER[outER]);
+				//allpass filter E
+				
+				dER[6] = dER[5];
+				dER[5] = dER[4];
+				dER[4] = inputSampleR;
+				inputSampleR = (dER[4] + dER[5] + dER[6])/3.0;
+				
+				allpasstemp = outFR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;}
+				inputSampleR -= oFR[allpasstemp]*constallpass;
+				oFR[outFR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outFR--; if (outFR < 0 || outFR > delayF) {outFR = delayF;}
+				inputSampleR += (oFR[outFR]);
+				//allpass filter F
+				
+				dFR[6] = dFR[5];
+				dFR[5] = dFR[4];
+				dFR[4] = inputSampleR;
+				inputSampleR = (dFR[4] + dFR[5] + dFR[6])/3.0;
+				
+				allpasstemp = outGR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;}
+				inputSampleR -= oGR[allpasstemp]*constallpass;
+				oGR[outGR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outGR--; if (outGR < 0 || outGR > delayG) {outGR = delayG;}
+				inputSampleR += (oGR[outGR]);
+				//allpass filter G
+				
+				dGR[6] = dGR[5];
+				dGR[5] = dGR[4];
+				dGR[4] = inputSampleR;
+				inputSampleR = (dGR[4] + dGR[5] + dGR[6])/3.0;
+				
+				allpasstemp = outHR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;}
+				inputSampleR -= oHR[allpasstemp]*constallpass;
+				oHR[outHR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outHR--; if (outHR < 0 || outHR > delayH) {outHR = delayH;}
+				inputSampleR += (oHR[outHR]);
+				//allpass filter H
+				
+				dHR[6] = dHR[5];
+				dHR[5] = dHR[4];
+				dHR[4] = inputSampleR;
+				inputSampleR = (dHR[4] + dHR[5] + dHR[6])/3.0;
+				
+				allpasstemp = outIR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;}
+				inputSampleR -= oIR[allpasstemp]*constallpass;
+				oIR[outIR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outIR--; if (outIR < 0 || outIR > delayI) {outIR = delayI;}
+				inputSampleR += (oIR[outIR]);
+				//allpass filter I
+				
+				dIR[6] = dIR[5];
+				dIR[5] = dIR[4];
+				dIR[4] = inputSampleR;
+				inputSampleR = (dIR[4] + dIR[5] + dIR[6])/3.0;
+				
+				allpasstemp = outJR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;}
+				inputSampleR -= oJR[allpasstemp]*constallpass;
+				oJR[outJR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outJR--; if (outJR < 0 || outJR > delayJ) {outJR = delayJ;}
+				inputSampleR += (oJR[outJR]);
+				//allpass filter J
+				
+				dJR[6] = dJR[5];
+				dJR[5] = dJR[4];
+				dJR[4] = inputSampleR;
+				inputSampleR = (dJR[4] + dJR[5] + dJR[6])/3.0;
+				
+				allpasstemp = outKR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;}
+				inputSampleR -= oKR[allpasstemp]*constallpass;
+				oKR[outKR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outKR--; if (outKR < 0 || outKR > delayK) {outKR = delayK;}
+				inputSampleR += (oKR[outKR]);
+				//allpass filter K
+				
+				dKR[6] = dKR[5];
+				dKR[5] = dKR[4];
+				dKR[4] = inputSampleR;
+				inputSampleR = (dKR[4] + dKR[5] + dKR[6])/3.0;
+				
+				allpasstemp = outLR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;}
+				inputSampleR -= oLR[allpasstemp]*constallpass;
+				oLR[outLR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outLR--; if (outLR < 0 || outLR > delayL) {outLR = delayL;}
+				inputSampleR += (oLR[outLR]);
+				//allpass filter L
+				
+				dLR[6] = dLR[5];
+				dLR[5] = dLR[4];
+				dLR[4] = inputSampleR;
+				inputSampleR = (dLR[4] + dLR[5] + dLR[6])/3.0;
+				
+				allpasstemp = outMR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;}
+				inputSampleR -= oMR[allpasstemp]*constallpass;
+				oMR[outMR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outMR--; if (outMR < 0 || outMR > delayM) {outMR = delayM;}
+				inputSampleR += (oMR[outMR]);
+				//allpass filter M
+				
+				dMR[6] = dMR[5];
+				dMR[5] = dMR[4];
+				dMR[4] = inputSampleR;
+				inputSampleR = (dMR[4] + dMR[5] + dMR[6])/3.0;
+				
+				allpasstemp = outNR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;}
+				inputSampleR -= oNR[allpasstemp]*constallpass;
+				oNR[outNR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outNR--; if (outNR < 0 || outNR > delayN) {outNR = delayN;}
+				inputSampleR += (oNR[outNR]);
+				//allpass filter N
+				
+				dNR[6] = dNR[5];
+				dNR[5] = dNR[4];
+				dNR[4] = inputSampleR;
+				inputSampleR = (dNR[4] + dNR[5] + dNR[6])/3.0;
+				
+				allpasstemp = outOR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;}
+				inputSampleR -= oOR[allpasstemp]*constallpass;
+				oOR[outOR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outOR--; if (outOR < 0 || outOR > delayO) {outOR = delayO;}
+				inputSampleR += (oOR[outOR]);
+				//allpass filter O
+				
+				dOR[6] = dOR[5];
+				dOR[5] = dOR[4];
+				dOR[4] = inputSampleR;
+				inputSampleR = (dOR[4] + dOR[5] + dOR[6])/3.0;
+				
+				allpasstemp = outPR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;}
+				inputSampleR -= oPR[allpasstemp]*constallpass;
+				oPR[outPR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outPR--; if (outPR < 0 || outPR > delayP) {outPR = delayP;}
+				inputSampleR += (oPR[outPR]);
+				//allpass filter P
+				
+				dPR[6] = dPR[5];
+				dPR[5] = dPR[4];
+				dPR[4] = inputSampleR;
+				inputSampleR = (dPR[4] + dPR[5] + dPR[6])/3.0;
+				
+				allpasstemp = outQR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;}
+				inputSampleR -= oQR[allpasstemp]*constallpass;
+				oQR[outQR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outQR--; if (outQR < 0 || outQR > delayQ) {outQR = delayQ;}
+				inputSampleR += (oQR[outQR]);
+				//allpass filter Q
+				
+				dQR[6] = dQR[5];
+				dQR[5] = dQR[4];
+				dQR[4] = inputSampleR;
+				inputSampleR = (dQR[4] + dQR[5] + dQR[6])/3.0;
+				
+				allpasstemp = outRR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;}
+				inputSampleR -= oRR[allpasstemp]*constallpass;
+				oRR[outRR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outRR--; if (outRR < 0 || outRR > delayR) {outRR = delayR;}
+				inputSampleR += (oRR[outRR]);
+				//allpass filter R
+				
+				dRR[6] = dRR[5];
+				dRR[5] = dRR[4];
+				dRR[4] = inputSampleR;
+				inputSampleR = (dRR[4] + dRR[5] + dRR[6])/3.0;
+				
+				allpasstemp = outSR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;}
+				inputSampleR -= oSR[allpasstemp]*constallpass;
+				oSR[outSR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outSR--; if (outSR < 0 || outSR > delayS) {outSR = delayS;}
+				inputSampleR += (oSR[outSR]);
+				//allpass filter S
+				
+				dSR[6] = dSR[5];
+				dSR[5] = dSR[4];
+				dSR[4] = inputSampleR;
+				inputSampleR = (dSR[4] + dSR[5] + dSR[6])/3.0;
+				
+				allpasstemp = outTR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;}
+				inputSampleR -= oTR[allpasstemp]*constallpass;
+				oTR[outTR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outTR--; if (outTR < 0 || outTR > delayT) {outTR = delayT;}
+				inputSampleR += (oTR[outTR]);
+				//allpass filter T
+				
+				dTR[6] = dTR[5];
+				dTR[5] = dTR[4];
+				dTR[4] = inputSampleR;
+				inputSampleR = (dTR[4] + dTR[5] + dTR[6])/3.0;
+				
+				allpasstemp = outUR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;}
+				inputSampleR -= oUR[allpasstemp]*constallpass;
+				oUR[outUR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outUR--; if (outUR < 0 || outUR > delayU) {outUR = delayU;}
+				inputSampleR += (oUR[outUR]);
+				//allpass filter U
+				
+				dUR[6] = dUR[5];
+				dUR[5] = dUR[4];
+				dUR[4] = inputSampleR;
+				inputSampleR = (dUR[4] + dUR[5] + dUR[6])/3.0;
+				
+				allpasstemp = outVR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;}
+				inputSampleR -= oVR[allpasstemp]*constallpass;
+				oVR[outVR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outVR--; if (outVR < 0 || outVR > delayV) {outVR = delayV;}
+				inputSampleR += (oVR[outVR]);
+				//allpass filter V
+				
+				dVR[6] = dVR[5];
+				dVR[5] = dVR[4];
+				dVR[4] = inputSampleR;
+				inputSampleR = (dVR[4] + dVR[5] + dVR[6])/3.0;
+				
+				allpasstemp = outWR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;}
+				inputSampleR -= oWR[allpasstemp]*constallpass;
+				oWR[outWR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outWR--; if (outWR < 0 || outWR > delayW) {outWR = delayW;}
+				inputSampleR += (oWR[outWR]);
+				//allpass filter W
+				
+				dWR[6] = dWR[5];
+				dWR[5] = dWR[4];
+				dWR[4] = inputSampleR;
+				inputSampleR = (dWR[4] + dWR[5] + dWR[6])/3.0;
+				
+				allpasstemp = outXR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;}
+				inputSampleR -= oXR[allpasstemp]*constallpass;
+				oXR[outXR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outXR--; if (outXR < 0 || outXR > delayX) {outXR = delayX;}
+				inputSampleR += (oXR[outXR]);
+				//allpass filter X
+				
+				dXR[6] = dXR[5];
+				dXR[5] = dXR[4];
+				dXR[4] = inputSampleR;
+				inputSampleR = (dXR[4] + dXR[5] + dXR[6])/3.0;
+				
+				allpasstemp = outYR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;}
+				inputSampleR -= oYR[allpasstemp]*constallpass;
+				oYR[outYR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outYR--; if (outYR < 0 || outYR > delayY) {outYR = delayY;}
+				inputSampleR += (oYR[outYR]);
+				//allpass filter Y
+				
+				dYR[6] = dYR[5];
+				dYR[5] = dYR[4];
+				dYR[4] = inputSampleR;
+				inputSampleR = (dYR[4] + dYR[5] + dYR[6])/3.0;
+				
+				allpasstemp = outZR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;}
+				inputSampleR -= oZR[allpasstemp]*constallpass;
+				oZR[outZR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outZR--; if (outZR < 0 || outZR > delayZ) {outZR = delayZ;}
+				inputSampleR += (oZR[outZR]);
+				//allpass filter Z
+				
+				dZR[6] = dZR[5];
+				dZR[5] = dZR[4];
+				dZR[4] = inputSampleR;
+				inputSampleR = (dZR[4] + dZR[5] + dZR[6]);		
+				//output Zarathustra infinite space verb
+				break;
+				
+		}
+		//end big switch for verb type		
+		
+		
+		bridgerectifier = fabs(inputSampleL);
+		bridgerectifier = 1.0-cos(bridgerectifier);
+		if (inputSampleL > 0) inputSampleL -= bridgerectifier;
+		else inputSampleL += bridgerectifier;
+		inputSampleL /= gain;		
+		bridgerectifier = fabs(inputSampleR);
+		bridgerectifier = 1.0-cos(bridgerectifier);
+		if (inputSampleR > 0) inputSampleR -= bridgerectifier;
+		else inputSampleR += bridgerectifier;
+		inputSampleR /= gain;		
+		//here we apply the ADT2 'console on steroids' trick
+		
+		wetness = wetnesstarget;
+		//setting up verb wetness to be manipulated by gate and peak
+		
+		wetness *= peakL;
+		//but we only use peak (indirect) to deal with dry/wet, so that it'll manipulate the dry/wet like we want
+		
+		drySampleL *= (1.0-wetness);
+		inputSampleL *= wetness;
+		inputSampleL += drySampleL;
+		//here we combine the tanks with the dry signal
+		
+		wetness = wetnesstarget;
+		//setting up verb wetness to be manipulated by gate and peak
+		
+		wetness *= peakR;
+		//but we only use peak (indirect) to deal with dry/wet, so that it'll manipulate the dry/wet like we want
+		
+		drySampleR *= (1.0-wetness);
+		inputSampleR *= wetness;
+		inputSampleR += drySampleR;
+		//here we combine the tanks with the dry signal
+		
+		//begin 32 bit stereo floating point dither
+		int expon; frexpf((float)inputSampleL, &expon);
+		fpd ^= fpd << 13; fpd ^= fpd >> 17; fpd ^= fpd << 5;
+		inputSampleL += ((double(fpd)-uint32_t(0x7fffffff)) * 5.5e-36l * pow(2,expon+62));
+		frexpf((float)inputSampleR, &expon);
+		fpd ^= fpd << 13; fpd ^= fpd >> 17; fpd ^= fpd << 5;
+		inputSampleR += ((double(fpd)-uint32_t(0x7fffffff)) * 5.5e-36l * pow(2,expon+62));
+		//end 32 bit stereo floating point dither
+		
+		*out1 = inputSampleL;
+		*out2 = inputSampleR;
+		
+		*in1++;
+		*in2++;
+		*out1++;
+		*out2++;
+    }
+}
+
+void PocketVerbs::processDoubleReplacing(double **inputs, double **outputs, VstInt32 sampleFrames) 
+{
+    double* in1  =  inputs[0];
+    double* in2  =  inputs[1];
+    double* out1 = outputs[0];
+    double* out2 = outputs[1];
+	
+	int verbtype = (VstInt32)( A * 5.999 )+1;
+	
+	double roomsize = (pow(B,2)*1.9)+0.1;
+	
+	double release = 0.00008 * pow(C,3);
+	if (release == 0.0) {peakL = 1.0; peakR = 1.0;}
+	double wetnesstarget = D;
+	double dryness = (1.0 - wetnesstarget);
+	//verbs use base wetness value internally
+	double wetness = wetnesstarget;
+	double constallpass = 0.618033988749894848204586; //golden ratio!
+	int allpasstemp;
+	int count;
+	int max = 70; //biggest divisor to test primes against
+	double bridgerectifier;
+	double gain = 0.5+(wetnesstarget*0.5); //dryer for less verb drive
+	//used as an aux, saturates when fed high levels
+	
+	//remap values to primes input number in question is 'i'
+	//max is the largest prime we care about- HF interactions more interesting than the big numbers
+	//pushing values larger and larger until we have a result
+	//for (primetest=2; primetest <= max; primetest++) {if ( i!=primetest && i % primetest == 0 ) {i += 1; primetest=2;}}
+	
+	if (savedRoomsize != roomsize) {savedRoomsize = roomsize; countdown = 26;} //kick off the adjustment which will take 26 zippernoise refreshes to complete
+	
+	if (countdown > 0) {switch (countdown)
+		{
+			case 1:
+				delayA = (int(maxdelayA * roomsize));
+				for (count=2; count <= max; count++) {if ( delayA != count && delayA % count == 0 ) {delayA += 1; count=2;}} //try for primeish As
+				if (delayA > maxdelayA) delayA = maxdelayA; //insanitycheck
+				for(count = alpAL; count < 15149; count++) {aAL[count] = 0.0;}
+				for(count = outAL; count < 15149; count++) {oAL[count] = 0.0;}
+				break;
+				
+			case 2:
+				delayB = (int(maxdelayB * roomsize));
+				for (count=2; count <= max; count++) {if ( delayB != count && delayB % count == 0 ) {delayB += 1; count=2;}} //try for primeish Bs
+				if (delayB > maxdelayB) delayB = maxdelayB; //insanitycheck
+				for(count = alpBL; count < 14617; count++) {aBL[count] = 0.0;}
+				for(count = outBL; count < 14617; count++) {oBL[count] = 0.0;}
+				break;
+				
+			case 3:
+				delayC = (int(maxdelayC * roomsize));
+				for (count=2; count <= max; count++) {if ( delayC != count && delayC % count == 0 ) {delayC += 1; count=2;}} //try for primeish Cs
+				if (delayC > maxdelayC) delayC = maxdelayC; //insanitycheck
+				for(count = alpCL; count < 14357; count++) {aCL[count] = 0.0;}
+				for(count = outCL; count < 14357; count++) {oCL[count] = 0.0;}
+				break;
+				
+			case 4:
+				delayD = (int(maxdelayD * roomsize));
+				for (count=2; count <= max; count++) {if ( delayD != count && delayD % count == 0 ) {delayD += 1; count=2;}} //try for primeish Ds
+				if (delayD > maxdelayD) delayD = maxdelayD; //insanitycheck
+				for(count = alpDL; count < 13817; count++) {aDL[count] = 0.0;}
+				for(count = outDL; count < 13817; count++) {oDL[count] = 0.0;}
+				break;
+				
+			case 5:
+				delayE = (int(maxdelayE * roomsize));
+				for (count=2; count <= max; count++) {if ( delayE != count && delayE % count == 0 ) {delayE += 1; count=2;}} //try for primeish Es
+				if (delayE > maxdelayE) delayE = maxdelayE; //insanitycheck
+				for(count = alpEL; count < 13561; count++) {aEL[count] = 0.0;}
+				for(count = outEL; count < 13561; count++) {oEL[count] = 0.0;}
+				break;
+				
+			case 6:
+				delayF = (int(maxdelayF * roomsize));
+				for (count=2; count <= max; count++) {if ( delayF != count && delayF % count == 0 ) {delayF += 1; count=2;}} //try for primeish Fs
+				if (delayF > maxdelayF) delayF = maxdelayF; //insanitycheck
+				for(count = alpFL; count < 13045; count++) {aFL[count] = 0.0;}
+				for(count = outFL; count < 13045; count++) {oFL[count] = 0.0;}
+				break;
+				
+			case 7:
+				delayG = (int(maxdelayG * roomsize));
+				for (count=2; count <= max; count++) {if ( delayG != count && delayG % count == 0 ) {delayG += 1; count=2;}} //try for primeish Gs
+				if (delayG > maxdelayG) delayG = maxdelayG; //insanitycheck
+				for(count = alpGL; count < 11965; count++) {aGL[count] = 0.0;}
+				for(count = outGL; count < 11965; count++) {oGL[count] = 0.0;}
+				break;
+				
+			case 8:
+				delayH = (int(maxdelayH * roomsize));
+				for (count=2; count <= max; count++) {if ( delayH != count && delayH % count == 0 ) {delayH += 1; count=2;}} //try for primeish Hs
+				if (delayH > maxdelayH) delayH = maxdelayH; //insanitycheck
+				for(count = alpHL; count < 11129; count++) {aHL[count] = 0.0;}
+				for(count = outHL; count < 11129; count++) {oHL[count] = 0.0;}
+				break;
+				
+			case 9:
+				delayI = (int(maxdelayI * roomsize));
+				for (count=2; count <= max; count++) {if ( delayI != count && delayI % count == 0 ) {delayI += 1; count=2;}} //try for primeish Is
+				if (delayI > maxdelayI) delayI = maxdelayI; //insanitycheck
+				for(count = alpIL; count < 10597; count++) {aIL[count] = 0.0;}
+				for(count = outIL; count < 10597; count++) {oIL[count] = 0.0;}
+				break;
+				
+			case 10:
+				delayJ = (int(maxdelayJ * roomsize));
+				for (count=2; count <= max; count++) {if ( delayJ != count && delayJ % count == 0 ) {delayJ += 1; count=2;}} //try for primeish Js
+				if (delayJ > maxdelayJ) delayJ = maxdelayJ; //insanitycheck
+				for(count = alpJL; count < 9809; count++) {aJL[count] = 0.0;}
+				for(count = outJL; count < 9809; count++) {oJL[count] = 0.0;}
+				break;
+				
+			case 11:
+				delayK = (int(maxdelayK * roomsize));
+				for (count=2; count <= max; count++) {if ( delayK != count && delayK % count == 0 ) {delayK += 1; count=2;}} //try for primeish Ks
+				if (delayK > maxdelayK) delayK = maxdelayK; //insanitycheck
+				for(count = alpKL; count < 9521; count++) {aKL[count] = 0.0;}
+				for(count = outKL; count < 9521; count++) {oKL[count] = 0.0;}
+				break;
+				
+			case 12:
+				delayL = (int(maxdelayL * roomsize));
+				for (count=2; count <= max; count++) {if ( delayL != count && delayL % count == 0 ) {delayL += 1; count=2;}} //try for primeish Ls
+				if (delayL > maxdelayL) delayL = maxdelayL; //insanitycheck
+				for(count = alpLL; count < 8981; count++) {aLL[count] = 0.0;}
+				for(count = outLL; count < 8981; count++) {oLL[count] = 0.0;}
+				break;
+				
+			case 13:
+				delayM = (int(maxdelayM * roomsize));
+				for (count=2; count <= max; count++) {if ( delayM != count && delayM % count == 0 ) {delayM += 1; count=2;}} //try for primeish Ms
+				if (delayM > maxdelayM) delayM = maxdelayM; //insanitycheck
+				for(count = alpML; count < 8785; count++) {aML[count] = 0.0;}
+				for(count = outML; count < 8785; count++) {oML[count] = 0.0;}
+				break;
+				
+			case 14:
+				delayN = (int(maxdelayN * roomsize));
+				for (count=2; count <= max; count++) {if ( delayN != count && delayN % count == 0 ) {delayN += 1; count=2;}} //try for primeish Ns
+				if (delayN > maxdelayN) delayN = maxdelayN; //insanitycheck
+				for(count = alpNL; count < 8461; count++) {aNL[count] = 0.0;}
+				for(count = outNL; count < 8461; count++) {oNL[count] = 0.0;}
+				break;
+				
+			case 15:
+				delayO = (int(maxdelayO * roomsize));
+				for (count=2; count <= max; count++) {if ( delayO != count && delayO % count == 0 ) {delayO += 1; count=2;}} //try for primeish Os
+				if (delayO > maxdelayO) delayO = maxdelayO; //insanitycheck
+				for(count = alpOL; count < 8309; count++) {aOL[count] = 0.0;}
+				for(count = outOL; count < 8309; count++) {oOL[count] = 0.0;}
+				break;
+				
+			case 16:
+				delayP = (int(maxdelayP * roomsize));
+				for (count=2; count <= max; count++) {if ( delayP != count && delayP % count == 0 ) {delayP += 1; count=2;}} //try for primeish Ps
+				if (delayP > maxdelayP) delayP = maxdelayP; //insanitycheck
+				for(count = alpPL; count < 7981; count++) {aPL[count] = 0.0;}
+				for(count = outPL; count < 7981; count++) {oPL[count] = 0.0;}
+				break;
+				
+			case 17:
+				delayQ = (int(maxdelayQ * roomsize));
+				for (count=2; count <= max; count++) {if ( delayQ != count && delayQ % count == 0 ) {delayQ += 1; count=2;}} //try for primeish Qs
+				if (delayQ > maxdelayQ) delayQ = maxdelayQ; //insanitycheck
+				for(count = alpQL; count < 7321; count++) {aQL[count] = 0.0;}
+				for(count = outQL; count < 7321; count++) {oQL[count] = 0.0;}
+				break;
+				
+			case 18:
+				delayR = (int(maxdelayR * roomsize));
+				for (count=2; count <= max; count++) {if ( delayR != count && delayR % count == 0 ) {delayR += 1; count=2;}} //try for primeish Rs
+				if (delayR > maxdelayR) delayR = maxdelayR; //insanitycheck
+				for(count = alpRL; count < 6817; count++) {aRL[count] = 0.0;}
+				for(count = outRL; count < 6817; count++) {oRL[count] = 0.0;}
+				break;
+				
+			case 19:
+				delayS = (int(maxdelayS * roomsize));
+				for (count=2; count <= max; count++) {if ( delayS != count && delayS % count == 0 ) {delayS += 1; count=2;}} //try for primeish Ss
+				if (delayS > maxdelayS) delayS = maxdelayS; //insanitycheck
+				for(count = alpSL; count < 6505; count++) {aSL[count] = 0.0;}
+				for(count = outSL; count < 6505; count++) {oSL[count] = 0.0;}
+				break;
+				
+			case 20:
+				delayT = (int(maxdelayT * roomsize));
+				for (count=2; count <= max; count++) {if ( delayT != count && delayT % count == 0 ) {delayT += 1; count=2;}} //try for primeish Ts
+				if (delayT > maxdelayT) delayT = maxdelayT; //insanitycheck
+				for(count = alpTL; count < 6001; count++) {aTL[count] = 0.0;}
+				for(count = outTL; count < 6001; count++) {oTL[count] = 0.0;}
+				break;
+				
+			case 21:
+				delayU = (int(maxdelayU * roomsize));
+				for (count=2; count <= max; count++) {if ( delayU != count && delayU % count == 0 ) {delayU += 1; count=2;}} //try for primeish Us
+				if (delayU > maxdelayU) delayU = maxdelayU; //insanitycheck
+				for(count = alpUL; count < 5837; count++) {aUL[count] = 0.0;}
+				for(count = outUL; count < 5837; count++) {oUL[count] = 0.0;}
+				break;
+				
+			case 22:
+				delayV = (int(maxdelayV * roomsize));
+				for (count=2; count <= max; count++) {if ( delayV != count && delayV % count == 0 ) {delayV += 1; count=2;}} //try for primeish Vs
+				if (delayV > maxdelayV) delayV = maxdelayV; //insanitycheck
+				for(count = alpVL; count < 5501; count++) {aVL[count] = 0.0;}
+				for(count = outVL; count < 5501; count++) {oVL[count] = 0.0;}
+				break;
+				
+			case 23:
+				delayW = (int(maxdelayW * roomsize));
+				for (count=2; count <= max; count++) {if ( delayW != count && delayW % count == 0 ) {delayW += 1; count=2;}} //try for primeish Ws
+				if (delayW > maxdelayW) delayW = maxdelayW; //insanitycheck
+				for(count = alpWL; count < 5009; count++) {aWL[count] = 0.0;}
+				for(count = outWL; count < 5009; count++) {oWL[count] = 0.0;}
+				break;
+				
+			case 24:
+				delayX = (int(maxdelayX * roomsize));
+				for (count=2; count <= max; count++) {if ( delayX != count && delayX % count == 0 ) {delayX += 1; count=2;}} //try for primeish Xs
+				if (delayX > maxdelayX) delayX = maxdelayX; //insanitycheck
+				for(count = alpXL; count < 4849; count++) {aXL[count] = 0.0;}
+				for(count = outXL; count < 4849; count++) {oXL[count] = 0.0;}
+				break;
+				
+			case 25:
+				delayY = (int(maxdelayY * roomsize));
+				for (count=2; count <= max; count++) {if ( delayY != count && delayY % count == 0 ) {delayY += 1; count=2;}} //try for primeish Ys
+				if (delayY > maxdelayY) delayY = maxdelayY; //insanitycheck
+				for(count = alpYL; count < 4295; count++) {aYL[count] = 0.0;}
+				for(count = outYL; count < 4295; count++) {oYL[count] = 0.0;}
+				break;
+				
+			case 26:
+				delayZ = (int(maxdelayZ * roomsize));
+				for (count=2; count <= max; count++) {if ( delayZ != count && delayZ % count == 0 ) {delayZ += 1; count=2;}} //try for primeish Zs
+				if (delayZ > maxdelayZ) delayZ = maxdelayZ; //insanitycheck
+				for(count = alpZL; count < 4179; count++) {aZL[count] = 0.0;}	
+				for(count = outZL; count < 4179; count++) {oZL[count] = 0.0;}
+				break;
+		} //end of switch statement
+		//countdown--; we are doing this after the second one
+	}
+	
+	if (countdown > 0) {switch (countdown)
+		{
+			case 1:
+				delayA = (int(maxdelayA * roomsize));
+				for (count=2; count <= max; count++) {if ( delayA != count && delayA % count == 0 ) {delayA += 1; count=2;}} //try for primeish As
+				if (delayA > maxdelayA) delayA = maxdelayA; //insanitycheck
+				for(count = alpAR; count < 15149; count++) {aAR[count] = 0.0;}
+				for(count = outAR; count < 15149; count++) {oAR[count] = 0.0;}
+				break;
+				
+			case 2:
+				delayB = (int(maxdelayB * roomsize));
+				for (count=2; count <= max; count++) {if ( delayB != count && delayB % count == 0 ) {delayB += 1; count=2;}} //try for primeish Bs
+				if (delayB > maxdelayB) delayB = maxdelayB; //insanitycheck
+				for(count = alpBR; count < 14617; count++) {aBR[count] = 0.0;}
+				for(count = outBR; count < 14617; count++) {oBR[count] = 0.0;}
+				break;
+				
+			case 3:
+				delayC = (int(maxdelayC * roomsize));
+				for (count=2; count <= max; count++) {if ( delayC != count && delayC % count == 0 ) {delayC += 1; count=2;}} //try for primeish Cs
+				if (delayC > maxdelayC) delayC = maxdelayC; //insanitycheck
+				for(count = alpCR; count < 14357; count++) {aCR[count] = 0.0;}
+				for(count = outCR; count < 14357; count++) {oCR[count] = 0.0;}
+				break;
+				
+			case 4:
+				delayD = (int(maxdelayD * roomsize));
+				for (count=2; count <= max; count++) {if ( delayD != count && delayD % count == 0 ) {delayD += 1; count=2;}} //try for primeish Ds
+				if (delayD > maxdelayD) delayD = maxdelayD; //insanitycheck
+				for(count = alpDR; count < 13817; count++) {aDR[count] = 0.0;}
+				for(count = outDR; count < 13817; count++) {oDR[count] = 0.0;}
+				break;
+				
+			case 5:
+				delayE = (int(maxdelayE * roomsize));
+				for (count=2; count <= max; count++) {if ( delayE != count && delayE % count == 0 ) {delayE += 1; count=2;}} //try for primeish Es
+				if (delayE > maxdelayE) delayE = maxdelayE; //insanitycheck
+				for(count = alpER; count < 13561; count++) {aER[count] = 0.0;}
+				for(count = outER; count < 13561; count++) {oER[count] = 0.0;}
+				break;
+				
+			case 6:
+				delayF = (int(maxdelayF * roomsize));
+				for (count=2; count <= max; count++) {if ( delayF != count && delayF % count == 0 ) {delayF += 1; count=2;}} //try for primeish Fs
+				if (delayF > maxdelayF) delayF = maxdelayF; //insanitycheck
+				for(count = alpFR; count < 13045; count++) {aFR[count] = 0.0;}
+				for(count = outFR; count < 13045; count++) {oFR[count] = 0.0;}
+				break;
+				
+			case 7:
+				delayG = (int(maxdelayG * roomsize));
+				for (count=2; count <= max; count++) {if ( delayG != count && delayG % count == 0 ) {delayG += 1; count=2;}} //try for primeish Gs
+				if (delayG > maxdelayG) delayG = maxdelayG; //insanitycheck
+				for(count = alpGR; count < 11965; count++) {aGR[count] = 0.0;}
+				for(count = outGR; count < 11965; count++) {oGR[count] = 0.0;}
+				break;
+				
+			case 8:
+				delayH = (int(maxdelayH * roomsize));
+				for (count=2; count <= max; count++) {if ( delayH != count && delayH % count == 0 ) {delayH += 1; count=2;}} //try for primeish Hs
+				if (delayH > maxdelayH) delayH = maxdelayH; //insanitycheck
+				for(count = alpHR; count < 11129; count++) {aHR[count] = 0.0;}
+				for(count = outHR; count < 11129; count++) {oHR[count] = 0.0;}
+				break;
+				
+			case 9:
+				delayI = (int(maxdelayI * roomsize));
+				for (count=2; count <= max; count++) {if ( delayI != count && delayI % count == 0 ) {delayI += 1; count=2;}} //try for primeish Is
+				if (delayI > maxdelayI) delayI = maxdelayI; //insanitycheck
+				for(count = alpIR; count < 10597; count++) {aIR[count] = 0.0;}
+				for(count = outIR; count < 10597; count++) {oIR[count] = 0.0;}
+				break;
+				
+			case 10:
+				delayJ = (int(maxdelayJ * roomsize));
+				for (count=2; count <= max; count++) {if ( delayJ != count && delayJ % count == 0 ) {delayJ += 1; count=2;}} //try for primeish Js
+				if (delayJ > maxdelayJ) delayJ = maxdelayJ; //insanitycheck
+				for(count = alpJR; count < 9809; count++) {aJR[count] = 0.0;}
+				for(count = outJR; count < 9809; count++) {oJR[count] = 0.0;}
+				break;
+				
+			case 11:
+				delayK = (int(maxdelayK * roomsize));
+				for (count=2; count <= max; count++) {if ( delayK != count && delayK % count == 0 ) {delayK += 1; count=2;}} //try for primeish Ks
+				if (delayK > maxdelayK) delayK = maxdelayK; //insanitycheck
+				for(count = alpKR; count < 9521; count++) {aKR[count] = 0.0;}
+				for(count = outKR; count < 9521; count++) {oKR[count] = 0.0;}
+				break;
+				
+			case 12:
+				delayL = (int(maxdelayL * roomsize));
+				for (count=2; count <= max; count++) {if ( delayL != count && delayL % count == 0 ) {delayL += 1; count=2;}} //try for primeish Ls
+				if (delayL > maxdelayL) delayL = maxdelayL; //insanitycheck
+				for(count = alpLR; count < 8981; count++) {aLR[count] = 0.0;}
+				for(count = outLR; count < 8981; count++) {oLR[count] = 0.0;}
+				break;
+				
+			case 13:
+				delayM = (int(maxdelayM * roomsize));
+				for (count=2; count <= max; count++) {if ( delayM != count && delayM % count == 0 ) {delayM += 1; count=2;}} //try for primeish Ms
+				if (delayM > maxdelayM) delayM = maxdelayM; //insanitycheck
+				for(count = alpMR; count < 8785; count++) {aMR[count] = 0.0;}
+				for(count = outMR; count < 8785; count++) {oMR[count] = 0.0;}
+				break;
+				
+			case 14:
+				delayN = (int(maxdelayN * roomsize));
+				for (count=2; count <= max; count++) {if ( delayN != count && delayN % count == 0 ) {delayN += 1; count=2;}} //try for primeish Ns
+				if (delayN > maxdelayN) delayN = maxdelayN; //insanitycheck
+				for(count = alpNR; count < 8461; count++) {aNR[count] = 0.0;}
+				for(count = outNR; count < 8461; count++) {oNR[count] = 0.0;}
+				break;
+				
+			case 15:
+				delayO = (int(maxdelayO * roomsize));
+				for (count=2; count <= max; count++) {if ( delayO != count && delayO % count == 0 ) {delayO += 1; count=2;}} //try for primeish Os
+				if (delayO > maxdelayO) delayO = maxdelayO; //insanitycheck
+				for(count = alpOR; count < 8309; count++) {aOR[count] = 0.0;}
+				for(count = outOR; count < 8309; count++) {oOR[count] = 0.0;}
+				break;
+				
+			case 16:
+				delayP = (int(maxdelayP * roomsize));
+				for (count=2; count <= max; count++) {if ( delayP != count && delayP % count == 0 ) {delayP += 1; count=2;}} //try for primeish Ps
+				if (delayP > maxdelayP) delayP = maxdelayP; //insanitycheck
+				for(count = alpPR; count < 7981; count++) {aPR[count] = 0.0;}
+				for(count = outPR; count < 7981; count++) {oPR[count] = 0.0;}
+				break;
+				
+			case 17:
+				delayQ = (int(maxdelayQ * roomsize));
+				for (count=2; count <= max; count++) {if ( delayQ != count && delayQ % count == 0 ) {delayQ += 1; count=2;}} //try for primeish Qs
+				if (delayQ > maxdelayQ) delayQ = maxdelayQ; //insanitycheck
+				for(count = alpQR; count < 7321; count++) {aQR[count] = 0.0;}
+				for(count = outQR; count < 7321; count++) {oQR[count] = 0.0;}
+				break;
+				
+			case 18:
+				delayR = (int(maxdelayR * roomsize));
+				for (count=2; count <= max; count++) {if ( delayR != count && delayR % count == 0 ) {delayR += 1; count=2;}} //try for primeish Rs
+				if (delayR > maxdelayR) delayR = maxdelayR; //insanitycheck
+				for(count = alpRR; count < 6817; count++) {aRR[count] = 0.0;}
+				for(count = outRR; count < 6817; count++) {oRR[count] = 0.0;}
+				break;
+				
+			case 19:
+				delayS = (int(maxdelayS * roomsize));
+				for (count=2; count <= max; count++) {if ( delayS != count && delayS % count == 0 ) {delayS += 1; count=2;}} //try for primeish Ss
+				if (delayS > maxdelayS) delayS = maxdelayS; //insanitycheck
+				for(count = alpSR; count < 6505; count++) {aSR[count] = 0.0;}
+				for(count = outSR; count < 6505; count++) {oSR[count] = 0.0;}
+				break;
+				
+			case 20:
+				delayT = (int(maxdelayT * roomsize));
+				for (count=2; count <= max; count++) {if ( delayT != count && delayT % count == 0 ) {delayT += 1; count=2;}} //try for primeish Ts
+				if (delayT > maxdelayT) delayT = maxdelayT; //insanitycheck
+				for(count = alpTR; count < 6001; count++) {aTR[count] = 0.0;}
+				for(count = outTR; count < 6001; count++) {oTR[count] = 0.0;}
+				break;
+				
+			case 21:
+				delayU = (int(maxdelayU * roomsize));
+				for (count=2; count <= max; count++) {if ( delayU != count && delayU % count == 0 ) {delayU += 1; count=2;}} //try for primeish Us
+				if (delayU > maxdelayU) delayU = maxdelayU; //insanitycheck
+				for(count = alpUR; count < 5837; count++) {aUR[count] = 0.0;}
+				for(count = outUR; count < 5837; count++) {oUR[count] = 0.0;}
+				break;
+				
+			case 22:
+				delayV = (int(maxdelayV * roomsize));
+				for (count=2; count <= max; count++) {if ( delayV != count && delayV % count == 0 ) {delayV += 1; count=2;}} //try for primeish Vs
+				if (delayV > maxdelayV) delayV = maxdelayV; //insanitycheck
+				for(count = alpVR; count < 5501; count++) {aVR[count] = 0.0;}
+				for(count = outVR; count < 5501; count++) {oVR[count] = 0.0;}
+				break;
+				
+			case 23:
+				delayW = (int(maxdelayW * roomsize));
+				for (count=2; count <= max; count++) {if ( delayW != count && delayW % count == 0 ) {delayW += 1; count=2;}} //try for primeish Ws
+				if (delayW > maxdelayW) delayW = maxdelayW; //insanitycheck
+				for(count = alpWR; count < 5009; count++) {aWR[count] = 0.0;}
+				for(count = outWR; count < 5009; count++) {oWR[count] = 0.0;}
+				break;
+				
+			case 24:
+				delayX = (int(maxdelayX * roomsize));
+				for (count=2; count <= max; count++) {if ( delayX != count && delayX % count == 0 ) {delayX += 1; count=2;}} //try for primeish Xs
+				if (delayX > maxdelayX) delayX = maxdelayX; //insanitycheck
+				for(count = alpXR; count < 4849; count++) {aXR[count] = 0.0;}
+				for(count = outXR; count < 4849; count++) {oXR[count] = 0.0;}
+				break;
+				
+			case 25:
+				delayY = (int(maxdelayY * roomsize));
+				for (count=2; count <= max; count++) {if ( delayY != count && delayY % count == 0 ) {delayY += 1; count=2;}} //try for primeish Ys
+				if (delayY > maxdelayY) delayY = maxdelayY; //insanitycheck
+				for(count = alpYR; count < 4295; count++) {aYR[count] = 0.0;}
+				for(count = outYR; count < 4295; count++) {oYR[count] = 0.0;}
+				break;
+				
+			case 26:
+				delayZ = (int(maxdelayZ * roomsize));
+				for (count=2; count <= max; count++) {if ( delayZ != count && delayZ % count == 0 ) {delayZ += 1; count=2;}} //try for primeish Zs
+				if (delayZ > maxdelayZ) delayZ = maxdelayZ; //insanitycheck
+				for(count = alpZR; count < 4179; count++) {aZR[count] = 0.0;}	
+				for(count = outZR; count < 4179; count++) {oZR[count] = 0.0;}
+				break;
+		} //end of switch statement
+		countdown--; //every buffer we'll do one of the recalculations for prime buffer sizes
+	}
+	
+    while (--sampleFrames >= 0)
+    {
+		long double inputSampleL = *in1;
+		long double inputSampleR = *in2;
+		
+		if (fabs(inputSampleL)<1.18e-43) inputSampleL = fpd * 1.18e-43;
+		if (fabs(inputSampleR)<1.18e-43) inputSampleR = fpd * 1.18e-43;
+		
+		long double drySampleL = inputSampleL;
+		long double drySampleR = inputSampleR;
+		
+		peakL -= release;
+		if (peakL < fabs(inputSampleL*2.0)) peakL = fabs(inputSampleL*2.0);
+		if (peakL > 1.0) peakL = 1.0;
+		peakR -= release;
+		if (peakR < fabs(inputSampleR*2.0)) peakR = fabs(inputSampleR*2.0);
+		if (peakR > 1.0) peakR = 1.0;
+		//chase the maximum signal to incorporate the wetter/louder behavior
+		//boost for more extreme effect when in use, cap it
+		
+		inputSampleL *= gain;
+		bridgerectifier = fabs(inputSampleL);
+		bridgerectifier = sin(bridgerectifier);
+		if (inputSampleL > 0) inputSampleL = bridgerectifier;
+		else inputSampleL = -bridgerectifier;
+		inputSampleR *= gain;
+		bridgerectifier = fabs(inputSampleR);
+		bridgerectifier = sin(bridgerectifier);
+		if (inputSampleR > 0) inputSampleR = bridgerectifier;
+		else inputSampleR = -bridgerectifier;
+		//here we apply the ADT2 console-on-steroids trick		
+		
+		
+		switch (verbtype)
+		{
+				
+				
+			case 1://Chamber
+				allpasstemp = alpAL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;}
+				inputSampleL -= aAL[allpasstemp]*constallpass;
+				aAL[alpAL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpAL--; if (alpAL < 0 || alpAL > delayA) {alpAL = delayA;}
+				inputSampleL += (aAL[alpAL]);
+				//allpass filter A		
+				
+				dAL[3] = dAL[2];
+				dAL[2] = dAL[1];
+				dAL[1] = inputSampleL;
+				inputSampleL = (dAL[1] + dAL[2] + dAL[3])/3.0;
+				
+				allpasstemp = alpBL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;}
+				inputSampleL -= aBL[allpasstemp]*constallpass;
+				aBL[alpBL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpBL--; if (alpBL < 0 || alpBL > delayB) {alpBL = delayB;}
+				inputSampleL += (aBL[alpBL]);
+				//allpass filter B
+				
+				dBL[3] = dBL[2];
+				dBL[2] = dBL[1];
+				dBL[1] = inputSampleL;
+				inputSampleL = (dBL[1] + dBL[2] + dBL[3])/3.0;
+				
+				allpasstemp = alpCL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;}
+				inputSampleL -= aCL[allpasstemp]*constallpass;
+				aCL[alpCL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpCL--; if (alpCL < 0 || alpCL > delayC) {alpCL = delayC;}
+				inputSampleL += (aCL[alpCL]);
+				//allpass filter C
+				
+				dCL[3] = dCL[2];
+				dCL[2] = dCL[1];
+				dCL[1] = inputSampleL;
+				inputSampleL = (dAL[1] + dCL[2] + dCL[3])/3.0;
+				
+				allpasstemp = alpDL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;}
+				inputSampleL -= aDL[allpasstemp]*constallpass;
+				aDL[alpDL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpDL--; if (alpDL < 0 || alpDL > delayD) {alpDL = delayD;}
+				inputSampleL += (aDL[alpDL]);
+				//allpass filter D
+				
+				dDL[3] = dDL[2];
+				dDL[2] = dDL[1];
+				dDL[1] = inputSampleL;
+				inputSampleL = (dDL[1] + dDL[2] + dDL[3])/3.0;
+				
+				allpasstemp = alpEL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;}
+				inputSampleL -= aEL[allpasstemp]*constallpass;
+				aEL[alpEL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpEL--; if (alpEL < 0 || alpEL > delayE) {alpEL = delayE;}
+				inputSampleL += (aEL[alpEL]);
+				//allpass filter E
+				
+				dEL[3] = dEL[2];
+				dEL[2] = dEL[1];
+				dEL[1] = inputSampleL;
+				inputSampleL = (dAL[1] + dEL[2] + dEL[3])/3.0;
+				
+				allpasstemp = alpFL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;}
+				inputSampleL -= aFL[allpasstemp]*constallpass;
+				aFL[alpFL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpFL--; if (alpFL < 0 || alpFL > delayF) {alpFL = delayF;}
+				inputSampleL += (aFL[alpFL]);
+				//allpass filter F
+				
+				dFL[3] = dFL[2];
+				dFL[2] = dFL[1];
+				dFL[1] = inputSampleL;
+				inputSampleL = (dFL[1] + dFL[2] + dFL[3])/3.0;
+				
+				allpasstemp = alpGL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;}
+				inputSampleL -= aGL[allpasstemp]*constallpass;
+				aGL[alpGL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpGL--; if (alpGL < 0 || alpGL > delayG) {alpGL = delayG;}
+				inputSampleL += (aGL[alpGL]);
+				//allpass filter G
+				
+				dGL[3] = dGL[2];
+				dGL[2] = dGL[1];
+				dGL[1] = inputSampleL;
+				inputSampleL = (dAL[1] + dGL[2] + dGL[3])/3.0;
+				
+				allpasstemp = alpHL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;}
+				inputSampleL -= aHL[allpasstemp]*constallpass;
+				aHL[alpHL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpHL--; if (alpHL < 0 || alpHL > delayH) {alpHL = delayH;}
+				inputSampleL += (aHL[alpHL]);
+				//allpass filter H
+				
+				dHL[3] = dHL[2];
+				dHL[2] = dHL[1];
+				dHL[1] = inputSampleL;
+				inputSampleL = (dHL[1] + dHL[2] + dHL[3])/3.0;
+				
+				allpasstemp = alpIL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;}
+				inputSampleL -= aIL[allpasstemp]*constallpass;
+				aIL[alpIL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpIL--; if (alpIL < 0 || alpIL > delayI) {alpIL = delayI;}
+				inputSampleL += (aIL[alpIL]);
+				//allpass filter I
+				
+				dIL[3] = dIL[2];
+				dIL[2] = dIL[1];
+				dIL[1] = inputSampleL;
+				inputSampleL = (dIL[1] + dIL[2] + dIL[3])/3.0;
+				
+				allpasstemp = alpJL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;}
+				inputSampleL -= aJL[allpasstemp]*constallpass;
+				aJL[alpJL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpJL--; if (alpJL < 0 || alpJL > delayJ) {alpJL = delayJ;}
+				inputSampleL += (aJL[alpJL]);
+				//allpass filter J
+				
+				dJL[3] = dJL[2];
+				dJL[2] = dJL[1];
+				dJL[1] = inputSampleL;
+				inputSampleL = (dJL[1] + dJL[2] + dJL[3])/3.0;
+				
+				allpasstemp = alpKL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;}
+				inputSampleL -= aKL[allpasstemp]*constallpass;
+				aKL[alpKL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpKL--; if (alpKL < 0 || alpKL > delayK) {alpKL = delayK;}
+				inputSampleL += (aKL[alpKL]);
+				//allpass filter K
+				
+				dKL[3] = dKL[2];
+				dKL[2] = dKL[1];
+				dKL[1] = inputSampleL;
+				inputSampleL = (dAL[1] + dKL[2] + dKL[3])/3.0;
+				
+				allpasstemp = alpLL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;}
+				inputSampleL -= aLL[allpasstemp]*constallpass;
+				aLL[alpLL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpLL--; if (alpLL < 0 || alpLL > delayL) {alpLL = delayL;}
+				inputSampleL += (aLL[alpLL]);
+				//allpass filter L
+				
+				dLL[3] = dLL[2];
+				dLL[2] = dLL[1];
+				dLL[1] = inputSampleL;
+				inputSampleL = (dLL[1] + dLL[2] + dLL[3])/3.0;
+				
+				allpasstemp = alpML - 1;
+				if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;}
+				inputSampleL -= aML[allpasstemp]*constallpass;
+				aML[alpML] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpML--; if (alpML < 0 || alpML > delayM) {alpML = delayM;}
+				inputSampleL += (aML[alpML]);
+				//allpass filter M
+				
+				dML[3] = dML[2];
+				dML[2] = dML[1];
+				dML[1] = inputSampleL;
+				inputSampleL = (dAL[1] + dML[2] + dML[3])/3.0;
+				
+				allpasstemp = alpNL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;}
+				inputSampleL -= aNL[allpasstemp]*constallpass;
+				aNL[alpNL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpNL--; if (alpNL < 0 || alpNL > delayN) {alpNL = delayN;}
+				inputSampleL += (aNL[alpNL]);
+				//allpass filter N
+				
+				dNL[3] = dNL[2];
+				dNL[2] = dNL[1];
+				dNL[1] = inputSampleL;
+				inputSampleL = (dNL[1] + dNL[2] + dNL[3])/3.0;
+				
+				allpasstemp = alpOL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;}
+				inputSampleL -= aOL[allpasstemp]*constallpass;
+				aOL[alpOL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpOL--; if (alpOL < 0 || alpOL > delayO) {alpOL = delayO;}
+				inputSampleL += (aOL[alpOL]);
+				//allpass filter O
+				
+				dOL[3] = dOL[2];
+				dOL[2] = dOL[1];
+				dOL[1] = inputSampleL;
+				inputSampleL = (dOL[1] + dOL[2] + dOL[3])/3.0;
+				
+				allpasstemp = alpPL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;}
+				inputSampleL -= aPL[allpasstemp]*constallpass;
+				aPL[alpPL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpPL--; if (alpPL < 0 || alpPL > delayP) {alpPL = delayP;}
+				inputSampleL += (aPL[alpPL]);
+				//allpass filter P
+				
+				dPL[3] = dPL[2];
+				dPL[2] = dPL[1];
+				dPL[1] = inputSampleL;
+				inputSampleL = (dPL[1] + dPL[2] + dPL[3])/3.0;
+				
+				allpasstemp = alpQL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;}
+				inputSampleL -= aQL[allpasstemp]*constallpass;
+				aQL[alpQL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpQL--; if (alpQL < 0 || alpQL > delayQ) {alpQL = delayQ;}
+				inputSampleL += (aQL[alpQL]);
+				//allpass filter Q
+				
+				dQL[3] = dQL[2];
+				dQL[2] = dQL[1];
+				dQL[1] = inputSampleL;
+				inputSampleL = (dAL[1] + dQL[2] + dQL[3])/3.0;
+				
+				allpasstemp = alpRL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;}
+				inputSampleL -= aRL[allpasstemp]*constallpass;
+				aRL[alpRL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpRL--; if (alpRL < 0 || alpRL > delayR) {alpRL = delayR;}
+				inputSampleL += (aRL[alpRL]);
+				//allpass filter R
+				
+				dRL[3] = dRL[2];
+				dRL[2] = dRL[1];
+				dRL[1] = inputSampleL;
+				inputSampleL = (dRL[1] + dRL[2] + dRL[3])/3.0;
+				
+				allpasstemp = alpSL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;}
+				inputSampleL -= aSL[allpasstemp]*constallpass;
+				aSL[alpSL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpSL--; if (alpSL < 0 || alpSL > delayS) {alpSL = delayS;}
+				inputSampleL += (aSL[alpSL]);
+				//allpass filter S
+				
+				dSL[3] = dSL[2];
+				dSL[2] = dSL[1];
+				dSL[1] = inputSampleL;
+				inputSampleL = (dAL[1] + dSL[2] + dSL[3])/3.0;
+				
+				allpasstemp = alpTL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;}
+				inputSampleL -= aTL[allpasstemp]*constallpass;
+				aTL[alpTL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpTL--; if (alpTL < 0 || alpTL > delayT) {alpTL = delayT;}
+				inputSampleL += (aTL[alpTL]);
+				//allpass filter T
+				
+				dTL[3] = dTL[2];
+				dTL[2] = dTL[1];
+				dTL[1] = inputSampleL;
+				inputSampleL = (dTL[1] + dTL[2] + dTL[3])/3.0;
+				
+				allpasstemp = alpUL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;}
+				inputSampleL -= aUL[allpasstemp]*constallpass;
+				aUL[alpUL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpUL--; if (alpUL < 0 || alpUL > delayU) {alpUL = delayU;}
+				inputSampleL += (aUL[alpUL]);
+				//allpass filter U
+				
+				dUL[3] = dUL[2];
+				dUL[2] = dUL[1];
+				dUL[1] = inputSampleL;
+				inputSampleL = (dUL[1] + dUL[2] + dUL[3])/3.0;
+				
+				allpasstemp = alpVL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;}
+				inputSampleL -= aVL[allpasstemp]*constallpass;
+				aVL[alpVL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpVL--; if (alpVL < 0 || alpVL > delayV) {alpVL = delayV;}
+				inputSampleL += (aVL[alpVL]);
+				//allpass filter V
+				
+				dVL[3] = dVL[2];
+				dVL[2] = dVL[1];
+				dVL[1] = inputSampleL;
+				inputSampleL = (dVL[1] + dVL[2] + dVL[3])/3.0;
+				
+				allpasstemp = alpWL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;}
+				inputSampleL -= aWL[allpasstemp]*constallpass;
+				aWL[alpWL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpWL--; if (alpWL < 0 || alpWL > delayW) {alpWL = delayW;}
+				inputSampleL += (aWL[alpWL]);
+				//allpass filter W
+				
+				dWL[3] = dWL[2];
+				dWL[2] = dWL[1];
+				dWL[1] = inputSampleL;
+				inputSampleL = (dAL[1] + dWL[2] + dWL[3])/3.0;
+				
+				allpasstemp = alpXL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;}
+				inputSampleL -= aXL[allpasstemp]*constallpass;
+				aXL[alpXL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpXL--; if (alpXL < 0 || alpXL > delayX) {alpXL = delayX;}
+				inputSampleL += (aXL[alpXL]);
+				//allpass filter X
+				
+				dXL[3] = dXL[2];
+				dXL[2] = dXL[1];
+				dXL[1] = inputSampleL;
+				inputSampleL = (dXL[1] + dXL[2] + dXL[3])/3.0;
+				
+				allpasstemp = alpYL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;}
+				inputSampleL -= aYL[allpasstemp]*constallpass;
+				aYL[alpYL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpYL--; if (alpYL < 0 || alpYL > delayY) {alpYL = delayY;}
+				inputSampleL += (aYL[alpYL]);
+				//allpass filter Y
+				
+				dYL[3] = dYL[2];
+				dYL[2] = dYL[1];
+				dYL[1] = inputSampleL;
+				inputSampleL = (dYL[1] + dYL[2] + dYL[3])/3.0;
+				
+				allpasstemp = alpZL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;}
+				inputSampleL -= aZL[allpasstemp]*constallpass;
+				aZL[alpZL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpZL--; if (alpZL < 0 || alpZL > delayZ) {alpZL = delayZ;}
+				inputSampleL += (aZL[alpZL]);
+				//allpass filter Z
+				
+				dZL[3] = dZL[2];
+				dZL[2] = dZL[1];
+				dZL[1] = inputSampleL;
+				inputSampleL = (dZL[1] + dZL[2] + dZL[3])/3.0;
+				
+				// now the second stage using the 'out' bank of allpasses		
+				
+				allpasstemp = outAL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;}
+				inputSampleL -= oAL[allpasstemp]*constallpass;
+				oAL[outAL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outAL--; if (outAL < 0 || outAL > delayA) {outAL = delayA;}
+				inputSampleL += (oAL[outAL]);
+				//allpass filter A		
+				
+				dAL[6] = dAL[5];
+				dAL[5] = dAL[4];
+				dAL[4] = inputSampleL;
+				inputSampleL = (dAL[4] + dAL[5] + dAL[6])/3.0;
+				
+				allpasstemp = outBL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;}
+				inputSampleL -= oBL[allpasstemp]*constallpass;
+				oBL[outBL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outBL--; if (outBL < 0 || outBL > delayB) {outBL = delayB;}
+				inputSampleL += (oBL[outBL]);
+				//allpass filter B
+				
+				dBL[6] = dBL[5];
+				dBL[5] = dBL[4];
+				dBL[4] = inputSampleL;
+				inputSampleL = (dBL[4] + dBL[5] + dBL[6])/3.0;
+				
+				allpasstemp = outCL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;}
+				inputSampleL -= oCL[allpasstemp]*constallpass;
+				oCL[outCL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outCL--; if (outCL < 0 || outCL > delayC) {outCL = delayC;}
+				inputSampleL += (oCL[outCL]);
+				//allpass filter C
+				
+				dCL[6] = dCL[5];
+				dCL[5] = dCL[4];
+				dCL[4] = inputSampleL;
+				inputSampleL = (dAL[1] + dCL[5] + dCL[6])/3.0;
+				
+				allpasstemp = outDL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;}
+				inputSampleL -= oDL[allpasstemp]*constallpass;
+				oDL[outDL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outDL--; if (outDL < 0 || outDL > delayD) {outDL = delayD;}
+				inputSampleL += (oDL[outDL]);
+				//allpass filter D
+				
+				dDL[6] = dDL[5];
+				dDL[5] = dDL[4];
+				dDL[4] = inputSampleL;
+				inputSampleL = (dDL[4] + dDL[5] + dDL[6])/3.0;
+				
+				allpasstemp = outEL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;}
+				inputSampleL -= oEL[allpasstemp]*constallpass;
+				oEL[outEL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outEL--; if (outEL < 0 || outEL > delayE) {outEL = delayE;}
+				inputSampleL += (oEL[outEL]);
+				//allpass filter E
+				
+				dEL[6] = dEL[5];
+				dEL[5] = dEL[4];
+				dEL[4] = inputSampleL;
+				inputSampleL = (dAL[1] + dEL[5] + dEL[6])/3.0;
+				
+				allpasstemp = outFL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;}
+				inputSampleL -= oFL[allpasstemp]*constallpass;
+				oFL[outFL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outFL--; if (outFL < 0 || outFL > delayF) {outFL = delayF;}
+				inputSampleL += (oFL[outFL]);
+				//allpass filter F
+				
+				dFL[6] = dFL[5];
+				dFL[5] = dFL[4];
+				dFL[4] = inputSampleL;
+				inputSampleL = (dFL[4] + dFL[5] + dFL[6])/3.0;
+				
+				allpasstemp = outGL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;}
+				inputSampleL -= oGL[allpasstemp]*constallpass;
+				oGL[outGL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outGL--; if (outGL < 0 || outGL > delayG) {outGL = delayG;}
+				inputSampleL += (oGL[outGL]);
+				//allpass filter G
+				
+				dGL[6] = dGL[5];
+				dGL[5] = dGL[4];
+				dGL[4] = inputSampleL;
+				inputSampleL = (dGL[4] + dGL[5] + dGL[6])/3.0;
+				
+				allpasstemp = outHL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;}
+				inputSampleL -= oHL[allpasstemp]*constallpass;
+				oHL[outHL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outHL--; if (outHL < 0 || outHL > delayH) {outHL = delayH;}
+				inputSampleL += (oHL[outHL]);
+				//allpass filter H
+				
+				dHL[6] = dHL[5];
+				dHL[5] = dHL[4];
+				dHL[4] = inputSampleL;
+				inputSampleL = (dHL[4] + dHL[5] + dHL[6])/3.0;
+				
+				allpasstemp = outIL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;}
+				inputSampleL -= oIL[allpasstemp]*constallpass;
+				oIL[outIL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outIL--; if (outIL < 0 || outIL > delayI) {outIL = delayI;}
+				inputSampleL += (oIL[outIL]);
+				//allpass filter I
+				
+				dIL[6] = dIL[5];
+				dIL[5] = dIL[4];
+				dIL[4] = inputSampleL;
+				inputSampleL = (dIL[4] + dIL[5] + dIL[6])/3.0;
+				
+				allpasstemp = outJL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;}
+				inputSampleL -= oJL[allpasstemp]*constallpass;
+				oJL[outJL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outJL--; if (outJL < 0 || outJL > delayJ) {outJL = delayJ;}
+				inputSampleL += (oJL[outJL]);
+				//allpass filter J
+				
+				dJL[6] = dJL[5];
+				dJL[5] = dJL[4];
+				dJL[4] = inputSampleL;
+				inputSampleL = (dJL[4] + dJL[5] + dJL[6])/3.0;
+				
+				allpasstemp = outKL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;}
+				inputSampleL -= oKL[allpasstemp]*constallpass;
+				oKL[outKL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outKL--; if (outKL < 0 || outKL > delayK) {outKL = delayK;}
+				inputSampleL += (oKL[outKL]);
+				//allpass filter K
+				
+				dKL[6] = dKL[5];
+				dKL[5] = dKL[4];
+				dKL[4] = inputSampleL;
+				inputSampleL = (dAL[1] + dKL[5] + dKL[6])/3.0;
+				
+				allpasstemp = outLL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;}
+				inputSampleL -= oLL[allpasstemp]*constallpass;
+				oLL[outLL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outLL--; if (outLL < 0 || outLL > delayL) {outLL = delayL;}
+				inputSampleL += (oLL[outLL]);
+				//allpass filter L
+				
+				dLL[6] = dLL[5];
+				dLL[5] = dLL[4];
+				dLL[4] = inputSampleL;
+				inputSampleL = (dLL[4] + dLL[5] + dLL[6])/3.0;
+				
+				allpasstemp = outML - 1;
+				if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;}
+				inputSampleL -= oML[allpasstemp]*constallpass;
+				oML[outML] = inputSampleL;
+				inputSampleL *= constallpass;
+				outML--; if (outML < 0 || outML > delayM) {outML = delayM;}
+				inputSampleL += (oML[outML]);
+				//allpass filter M
+				
+				dML[6] = dML[5];
+				dML[5] = dML[4];
+				dML[4] = inputSampleL;
+				inputSampleL = (dML[4] + dML[5] + dML[6])/3.0;
+				
+				allpasstemp = outNL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;}
+				inputSampleL -= oNL[allpasstemp]*constallpass;
+				oNL[outNL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outNL--; if (outNL < 0 || outNL > delayN) {outNL = delayN;}
+				inputSampleL += (oNL[outNL]);
+				//allpass filter N
+				
+				dNL[6] = dNL[5];
+				dNL[5] = dNL[4];
+				dNL[4] = inputSampleL;
+				inputSampleL = (dNL[4] + dNL[5] + dNL[6])/3.0;
+				
+				allpasstemp = outOL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;}
+				inputSampleL -= oOL[allpasstemp]*constallpass;
+				oOL[outOL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outOL--; if (outOL < 0 || outOL > delayO) {outOL = delayO;}
+				inputSampleL += (oOL[outOL]);
+				//allpass filter O
+				
+				dOL[6] = dOL[5];
+				dOL[5] = dOL[4];
+				dOL[4] = inputSampleL;
+				inputSampleL = (dAL[1] + dOL[5] + dOL[6])/3.0;
+				
+				allpasstemp = outPL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;}
+				inputSampleL -= oPL[allpasstemp]*constallpass;
+				oPL[outPL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outPL--; if (outPL < 0 || outPL > delayP) {outPL = delayP;}
+				inputSampleL += (oPL[outPL]);
+				//allpass filter P
+				
+				dPL[6] = dPL[5];
+				dPL[5] = dPL[4];
+				dPL[4] = inputSampleL;
+				inputSampleL = (dPL[4] + dPL[5] + dPL[6])/3.0;
+				
+				allpasstemp = outQL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;}
+				inputSampleL -= oQL[allpasstemp]*constallpass;
+				oQL[outQL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outQL--; if (outQL < 0 || outQL > delayQ) {outQL = delayQ;}
+				inputSampleL += (oQL[outQL]);
+				//allpass filter Q
+				
+				dQL[6] = dQL[5];
+				dQL[5] = dQL[4];
+				dQL[4] = inputSampleL;
+				inputSampleL = (dAL[1] + dQL[5] + dQL[6])/3.0;
+				
+				allpasstemp = outRL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;}
+				inputSampleL -= oRL[allpasstemp]*constallpass;
+				oRL[outRL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outRL--; if (outRL < 0 || outRL > delayR) {outRL = delayR;}
+				inputSampleL += (oRL[outRL]);
+				//allpass filter R
+				
+				dRL[6] = dRL[5];
+				dRL[5] = dRL[4];
+				dRL[4] = inputSampleL;
+				inputSampleL = (dRL[4] + dRL[5] + dRL[6])/3.0;
+				
+				allpasstemp = outSL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;}
+				inputSampleL -= oSL[allpasstemp]*constallpass;
+				oSL[outSL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outSL--; if (outSL < 0 || outSL > delayS) {outSL = delayS;}
+				inputSampleL += (oSL[outSL]);
+				//allpass filter S
+				
+				dSL[6] = dSL[5];
+				dSL[5] = dSL[4];
+				dSL[4] = inputSampleL;
+				inputSampleL = (dSL[4] + dSL[5] + dSL[6])/3.0;
+				
+				allpasstemp = outTL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;}
+				inputSampleL -= oTL[allpasstemp]*constallpass;
+				oTL[outTL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outTL--; if (outTL < 0 || outTL > delayT) {outTL = delayT;}
+				inputSampleL += (oTL[outTL]);
+				//allpass filter T
+				
+				dTL[6] = dTL[5];
+				dTL[5] = dTL[4];
+				dTL[4] = inputSampleL;
+				inputSampleL = (dTL[4] + dTL[5] + dTL[6])/3.0;
+				
+				allpasstemp = outUL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;}
+				inputSampleL -= oUL[allpasstemp]*constallpass;
+				oUL[outUL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outUL--; if (outUL < 0 || outUL > delayU) {outUL = delayU;}
+				inputSampleL += (oUL[outUL]);
+				//allpass filter U
+				
+				dUL[6] = dUL[5];
+				dUL[5] = dUL[4];
+				dUL[4] = inputSampleL;
+				inputSampleL = (dAL[1] + dUL[5] + dUL[6])/3.0;
+				
+				allpasstemp = outVL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;}
+				inputSampleL -= oVL[allpasstemp]*constallpass;
+				oVL[outVL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outVL--; if (outVL < 0 || outVL > delayV) {outVL = delayV;}
+				inputSampleL += (oVL[outVL]);
+				//allpass filter V
+				
+				dVL[6] = dVL[5];
+				dVL[5] = dVL[4];
+				dVL[4] = inputSampleL;
+				inputSampleL = (dVL[4] + dVL[5] + dVL[6])/3.0;
+				
+				allpasstemp = outWL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;}
+				inputSampleL -= oWL[allpasstemp]*constallpass;
+				oWL[outWL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outWL--; if (outWL < 0 || outWL > delayW) {outWL = delayW;}
+				inputSampleL += (oWL[outWL]);
+				//allpass filter W
+				
+				dWL[6] = dWL[5];
+				dWL[5] = dWL[4];
+				dWL[4] = inputSampleL;
+				inputSampleL = (dWL[4] + dWL[5] + dWL[6])/3.0;
+				
+				allpasstemp = outXL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;}
+				inputSampleL -= oXL[allpasstemp]*constallpass;
+				oXL[outXL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outXL--; if (outXL < 0 || outXL > delayX) {outXL = delayX;}
+				inputSampleL += (oXL[outXL]);
+				//allpass filter X
+				
+				dXL[6] = dXL[5];
+				dXL[5] = dXL[4];
+				dXL[4] = inputSampleL;
+				inputSampleL = (dXL[4] + dXL[5] + dXL[6])/3.0;
+				
+				allpasstemp = outYL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;}
+				inputSampleL -= oYL[allpasstemp]*constallpass;
+				oYL[outYL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outYL--; if (outYL < 0 || outYL > delayY) {outYL = delayY;}
+				inputSampleL += (oYL[outYL]);
+				//allpass filter Y
+				
+				dYL[6] = dYL[5];
+				dYL[5] = dYL[4];
+				dYL[4] = inputSampleL;
+				inputSampleL = (dYL[4] + dYL[5] + dYL[6])/3.0;
+				
+				allpasstemp = outZL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;}
+				inputSampleL -= oZL[allpasstemp]*constallpass;
+				oZL[outZL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outZL--; if (outZL < 0 || outZL > delayZ) {outZL = delayZ;}
+				inputSampleL += (oZL[outZL]);
+				//allpass filter Z
+				
+				dZL[6] = dZL[5];
+				dZL[5] = dZL[4];
+				dZL[4] = inputSampleL;
+				inputSampleL = (dZL[4] + dZL[5] + dZL[6]);		
+				//output Chamber
+				break;
+				
+				
+				
+				
+				
+			case 2:	//Spring
+				
+				allpasstemp = alpAL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;}
+				inputSampleL -= aAL[allpasstemp]*constallpass;
+				aAL[alpAL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpAL--; if (alpAL < 0 || alpAL > delayA) {alpAL = delayA;}
+				inputSampleL += (aAL[alpAL]);
+				//allpass filter A		
+				
+				dAL[3] = dAL[2];
+				dAL[2] = dAL[1];
+				dAL[1] = inputSampleL;
+				inputSampleL = (dAL[1] + dAL[2] + dAL[3])/3.0;
+				
+				allpasstemp = alpBL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;}
+				inputSampleL -= aBL[allpasstemp]*constallpass;
+				aBL[alpBL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpBL--; if (alpBL < 0 || alpBL > delayB) {alpBL = delayB;}
+				inputSampleL += (aBL[alpBL]);
+				//allpass filter B
+				
+				dBL[3] = dBL[2];
+				dBL[2] = dBL[1];
+				dBL[1] = inputSampleL;
+				inputSampleL = (dBL[1] + dBL[2] + dBL[3])/3.0;
+				
+				allpasstemp = alpCL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;}
+				inputSampleL -= aCL[allpasstemp]*constallpass;
+				aCL[alpCL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpCL--; if (alpCL < 0 || alpCL > delayC) {alpCL = delayC;}
+				inputSampleL += (aCL[alpCL]);
+				//allpass filter C
+				
+				dCL[3] = dCL[2];
+				dCL[2] = dCL[1];
+				dCL[1] = inputSampleL;
+				inputSampleL = (dCL[1] + dCL[2] + dCL[3])/3.0;
+				
+				allpasstemp = alpDL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;}
+				inputSampleL -= aDL[allpasstemp]*constallpass;
+				aDL[alpDL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpDL--; if (alpDL < 0 || alpDL > delayD) {alpDL = delayD;}
+				inputSampleL += (aDL[alpDL]);
+				//allpass filter D
+				
+				dDL[3] = dDL[2];
+				dDL[2] = dDL[1];
+				dDL[1] = inputSampleL;
+				inputSampleL = (dDL[1] + dDL[2] + dDL[3])/3.0;
+				
+				allpasstemp = alpEL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;}
+				inputSampleL -= aEL[allpasstemp]*constallpass;
+				aEL[alpEL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpEL--; if (alpEL < 0 || alpEL > delayE) {alpEL = delayE;}
+				inputSampleL += (aEL[alpEL]);
+				//allpass filter E
+				
+				dEL[3] = dEL[2];
+				dEL[2] = dEL[1];
+				dEL[1] = inputSampleL;
+				inputSampleL = (dEL[1] + dEL[2] + dEL[3])/3.0;
+				
+				allpasstemp = alpFL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;}
+				inputSampleL -= aFL[allpasstemp]*constallpass;
+				aFL[alpFL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpFL--; if (alpFL < 0 || alpFL > delayF) {alpFL = delayF;}
+				inputSampleL += (aFL[alpFL]);
+				//allpass filter F
+				
+				dFL[3] = dFL[2];
+				dFL[2] = dFL[1];
+				dFL[1] = inputSampleL;
+				inputSampleL = (dFL[1] + dFL[2] + dFL[3])/3.0;
+				
+				allpasstemp = alpGL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;}
+				inputSampleL -= aGL[allpasstemp]*constallpass;
+				aGL[alpGL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpGL--; if (alpGL < 0 || alpGL > delayG) {alpGL = delayG;}
+				inputSampleL += (aGL[alpGL]);
+				//allpass filter G
+				
+				dGL[3] = dGL[2];
+				dGL[2] = dGL[1];
+				dGL[1] = inputSampleL;
+				inputSampleL = (dGL[1] + dGL[2] + dGL[3])/3.0;
+				
+				allpasstemp = alpHL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;}
+				inputSampleL -= aHL[allpasstemp]*constallpass;
+				aHL[alpHL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpHL--; if (alpHL < 0 || alpHL > delayH) {alpHL = delayH;}
+				inputSampleL += (aHL[alpHL]);
+				//allpass filter H
+				
+				dHL[3] = dHL[2];
+				dHL[2] = dHL[1];
+				dHL[1] = inputSampleL;
+				inputSampleL = (dHL[1] + dHL[2] + dHL[3])/3.0;
+				
+				allpasstemp = alpIL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;}
+				inputSampleL -= aIL[allpasstemp]*constallpass;
+				aIL[alpIL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpIL--; if (alpIL < 0 || alpIL > delayI) {alpIL = delayI;}
+				inputSampleL += (aIL[alpIL]);
+				//allpass filter I
+				
+				dIL[3] = dIL[2];
+				dIL[2] = dIL[1];
+				dIL[1] = inputSampleL;
+				inputSampleL = (dIL[1] + dIL[2] + dIL[3])/3.0;
+				
+				allpasstemp = alpJL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;}
+				inputSampleL -= aJL[allpasstemp]*constallpass;
+				aJL[alpJL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpJL--; if (alpJL < 0 || alpJL > delayJ) {alpJL = delayJ;}
+				inputSampleL += (aJL[alpJL]);
+				//allpass filter J
+				
+				dJL[3] = dJL[2];
+				dJL[2] = dJL[1];
+				dJL[1] = inputSampleL;
+				inputSampleL = (dJL[1] + dJL[2] + dJL[3])/3.0;
+				
+				allpasstemp = alpKL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;}
+				inputSampleL -= aKL[allpasstemp]*constallpass;
+				aKL[alpKL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpKL--; if (alpKL < 0 || alpKL > delayK) {alpKL = delayK;}
+				inputSampleL += (aKL[alpKL]);
+				//allpass filter K
+				
+				dKL[3] = dKL[2];
+				dKL[2] = dKL[1];
+				dKL[1] = inputSampleL;
+				inputSampleL = (dKL[1] + dKL[2] + dKL[3])/3.0;
+				
+				allpasstemp = alpLL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;}
+				inputSampleL -= aLL[allpasstemp]*constallpass;
+				aLL[alpLL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpLL--; if (alpLL < 0 || alpLL > delayL) {alpLL = delayL;}
+				inputSampleL += (aLL[alpLL]);
+				//allpass filter L
+				
+				dLL[3] = dLL[2];
+				dLL[2] = dLL[1];
+				dLL[1] = inputSampleL;
+				inputSampleL = (dLL[1] + dLL[2] + dLL[3])/3.0;
+				
+				allpasstemp = alpML - 1;
+				if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;}
+				inputSampleL -= aML[allpasstemp]*constallpass;
+				aML[alpML] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpML--; if (alpML < 0 || alpML > delayM) {alpML = delayM;}
+				inputSampleL += (aML[alpML]);
+				//allpass filter M
+				
+				dML[3] = dML[2];
+				dML[2] = dML[1];
+				dML[1] = inputSampleL;
+				inputSampleL = (dML[1] + dML[2] + dML[3])/3.0;
+				
+				allpasstemp = alpNL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;}
+				inputSampleL -= aNL[allpasstemp]*constallpass;
+				aNL[alpNL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpNL--; if (alpNL < 0 || alpNL > delayN) {alpNL = delayN;}
+				inputSampleL += (aNL[alpNL]);
+				//allpass filter N
+				
+				dNL[3] = dNL[2];
+				dNL[2] = dNL[1];
+				dNL[1] = inputSampleL;
+				inputSampleL = (dNL[1] + dNL[2] + dNL[3])/3.0;
+				
+				allpasstemp = alpOL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;}
+				inputSampleL -= aOL[allpasstemp]*constallpass;
+				aOL[alpOL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpOL--; if (alpOL < 0 || alpOL > delayO) {alpOL = delayO;}
+				inputSampleL += (aOL[alpOL]);
+				//allpass filter O
+				
+				dOL[3] = dOL[2];
+				dOL[2] = dOL[1];
+				dOL[1] = inputSampleL;
+				inputSampleL = (dOL[1] + dOL[2] + dOL[3])/3.0;
+				
+				allpasstemp = alpPL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;}
+				inputSampleL -= aPL[allpasstemp]*constallpass;
+				aPL[alpPL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpPL--; if (alpPL < 0 || alpPL > delayP) {alpPL = delayP;}
+				inputSampleL += (aPL[alpPL]);
+				//allpass filter P
+				
+				dPL[3] = dPL[2];
+				dPL[2] = dPL[1];
+				dPL[1] = inputSampleL;
+				inputSampleL = (dPL[1] + dPL[2] + dPL[3])/3.0;
+				
+				allpasstemp = alpQL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;}
+				inputSampleL -= aQL[allpasstemp]*constallpass;
+				aQL[alpQL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpQL--; if (alpQL < 0 || alpQL > delayQ) {alpQL = delayQ;}
+				inputSampleL += (aQL[alpQL]);
+				//allpass filter Q
+				
+				dQL[3] = dQL[2];
+				dQL[2] = dQL[1];
+				dQL[1] = inputSampleL;
+				inputSampleL = (dQL[1] + dQL[2] + dQL[3])/3.0;
+				
+				allpasstemp = alpRL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;}
+				inputSampleL -= aRL[allpasstemp]*constallpass;
+				aRL[alpRL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpRL--; if (alpRL < 0 || alpRL > delayR) {alpRL = delayR;}
+				inputSampleL += (aRL[alpRL]);
+				//allpass filter R
+				
+				dRL[3] = dRL[2];
+				dRL[2] = dRL[1];
+				dRL[1] = inputSampleL;
+				inputSampleL = (dRL[1] + dRL[2] + dRL[3])/3.0;
+				
+				allpasstemp = alpSL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;}
+				inputSampleL -= aSL[allpasstemp]*constallpass;
+				aSL[alpSL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpSL--; if (alpSL < 0 || alpSL > delayS) {alpSL = delayS;}
+				inputSampleL += (aSL[alpSL]);
+				//allpass filter S
+				
+				dSL[3] = dSL[2];
+				dSL[2] = dSL[1];
+				dSL[1] = inputSampleL;
+				inputSampleL = (dSL[1] + dSL[2] + dSL[3])/3.0;
+				
+				allpasstemp = alpTL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;}
+				inputSampleL -= aTL[allpasstemp]*constallpass;
+				aTL[alpTL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpTL--; if (alpTL < 0 || alpTL > delayT) {alpTL = delayT;}
+				inputSampleL += (aTL[alpTL]);
+				//allpass filter T
+				
+				dTL[3] = dTL[2];
+				dTL[2] = dTL[1];
+				dTL[1] = inputSampleL;
+				inputSampleL = (dTL[1] + dTL[2] + dTL[3])/3.0;
+				
+				allpasstemp = alpUL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;}
+				inputSampleL -= aUL[allpasstemp]*constallpass;
+				aUL[alpUL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpUL--; if (alpUL < 0 || alpUL > delayU) {alpUL = delayU;}
+				inputSampleL += (aUL[alpUL]);
+				//allpass filter U
+				
+				dUL[3] = dUL[2];
+				dUL[2] = dUL[1];
+				dUL[1] = inputSampleL;
+				inputSampleL = (dUL[1] + dUL[2] + dUL[3])/3.0;
+				
+				allpasstemp = alpVL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;}
+				inputSampleL -= aVL[allpasstemp]*constallpass;
+				aVL[alpVL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpVL--; if (alpVL < 0 || alpVL > delayV) {alpVL = delayV;}
+				inputSampleL += (aVL[alpVL]);
+				//allpass filter V
+				
+				dVL[3] = dVL[2];
+				dVL[2] = dVL[1];
+				dVL[1] = inputSampleL;
+				inputSampleL = (dVL[1] + dVL[2] + dVL[3])/3.0;
+				
+				allpasstemp = alpWL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;}
+				inputSampleL -= aWL[allpasstemp]*constallpass;
+				aWL[alpWL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpWL--; if (alpWL < 0 || alpWL > delayW) {alpWL = delayW;}
+				inputSampleL += (aWL[alpWL]);
+				//allpass filter W
+				
+				dWL[3] = dWL[2];
+				dWL[2] = dWL[1];
+				dWL[1] = inputSampleL;
+				inputSampleL = (dWL[1] + dWL[2] + dWL[3])/3.0;
+				
+				allpasstemp = alpXL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;}
+				inputSampleL -= aXL[allpasstemp]*constallpass;
+				aXL[alpXL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpXL--; if (alpXL < 0 || alpXL > delayX) {alpXL = delayX;}
+				inputSampleL += (aXL[alpXL]);
+				//allpass filter X
+				
+				dXL[3] = dXL[2];
+				dXL[2] = dXL[1];
+				dXL[1] = inputSampleL;
+				inputSampleL = (dXL[1] + dXL[2] + dXL[3])/3.0;
+				
+				allpasstemp = alpYL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;}
+				inputSampleL -= aYL[allpasstemp]*constallpass;
+				aYL[alpYL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpYL--; if (alpYL < 0 || alpYL > delayY) {alpYL = delayY;}
+				inputSampleL += (aYL[alpYL]);
+				//allpass filter Y
+				
+				dYL[3] = dYL[2];
+				dYL[2] = dYL[1];
+				dYL[1] = inputSampleL;
+				inputSampleL = (dYL[1] + dYL[2] + dYL[3])/3.0;
+				
+				allpasstemp = alpZL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;}
+				inputSampleL -= aZL[allpasstemp]*constallpass;
+				aZL[alpZL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpZL--; if (alpZL < 0 || alpZL > delayZ) {alpZL = delayZ;}
+				inputSampleL += (aZL[alpZL]);
+				//allpass filter Z
+				
+				dZL[3] = dZL[2];
+				dZL[2] = dZL[1];
+				dZL[1] = inputSampleL;
+				inputSampleL = (dZL[1] + dZL[2] + dZL[3])/3.0;
+				
+				// now the second stage using the 'out' bank of allpasses		
+				
+				allpasstemp = outAL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;}
+				inputSampleL -= oAL[allpasstemp]*constallpass;
+				oAL[outAL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outAL--; if (outAL < 0 || outAL > delayA) {outAL = delayA;}
+				inputSampleL += (oAL[outAL]);
+				//allpass filter A		
+				
+				dAL[6] = dAL[5];
+				dAL[5] = dAL[4];
+				dAL[4] = inputSampleL;
+				inputSampleL = (dYL[1] + dAL[5] + dAL[6])/3.0;
+				
+				allpasstemp = outBL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;}
+				inputSampleL -= oBL[allpasstemp]*constallpass;
+				oBL[outBL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outBL--; if (outBL < 0 || outBL > delayB) {outBL = delayB;}
+				inputSampleL += (oBL[outBL]);
+				//allpass filter B
+				
+				dBL[6] = dBL[5];
+				dBL[5] = dBL[4];
+				dBL[4] = inputSampleL;
+				inputSampleL = (dXL[1] + dBL[5] + dBL[6])/3.0;
+				
+				allpasstemp = outCL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;}
+				inputSampleL -= oCL[allpasstemp]*constallpass;
+				oCL[outCL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outCL--; if (outCL < 0 || outCL > delayC) {outCL = delayC;}
+				inputSampleL += (oCL[outCL]);
+				//allpass filter C
+				
+				dCL[6] = dCL[5];
+				dCL[5] = dCL[4];
+				dCL[4] = inputSampleL;
+				inputSampleL = (dWL[1] + dCL[5] + dCL[6])/3.0;
+				
+				allpasstemp = outDL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;}
+				inputSampleL -= oDL[allpasstemp]*constallpass;
+				oDL[outDL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outDL--; if (outDL < 0 || outDL > delayD) {outDL = delayD;}
+				inputSampleL += (oDL[outDL]);
+				//allpass filter D
+				
+				dDL[6] = dDL[5];
+				dDL[5] = dDL[4];
+				dDL[4] = inputSampleL;
+				inputSampleL = (dVL[1] + dDL[5] + dDL[6])/3.0;
+				
+				allpasstemp = outEL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;}
+				inputSampleL -= oEL[allpasstemp]*constallpass;
+				oEL[outEL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outEL--; if (outEL < 0 || outEL > delayE) {outEL = delayE;}
+				inputSampleL += (oEL[outEL]);
+				//allpass filter E
+				
+				dEL[6] = dEL[5];
+				dEL[5] = dEL[4];
+				dEL[4] = inputSampleL;
+				inputSampleL = (dUL[1] + dEL[5] + dEL[6])/3.0;
+				
+				allpasstemp = outFL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;}
+				inputSampleL -= oFL[allpasstemp]*constallpass;
+				oFL[outFL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outFL--; if (outFL < 0 || outFL > delayF) {outFL = delayF;}
+				inputSampleL += (oFL[outFL]);
+				//allpass filter F
+				
+				dFL[6] = dFL[5];
+				dFL[5] = dFL[4];
+				dFL[4] = inputSampleL;
+				inputSampleL = (dTL[1] + dFL[5] + dFL[6])/3.0;
+				
+				allpasstemp = outGL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;}
+				inputSampleL -= oGL[allpasstemp]*constallpass;
+				oGL[outGL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outGL--; if (outGL < 0 || outGL > delayG) {outGL = delayG;}
+				inputSampleL += (oGL[outGL]);
+				//allpass filter G
+				
+				dGL[6] = dGL[5];
+				dGL[5] = dGL[4];
+				dGL[4] = inputSampleL;
+				inputSampleL = (dSL[1] + dGL[5] + dGL[6])/3.0;
+				
+				allpasstemp = outHL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;}
+				inputSampleL -= oHL[allpasstemp]*constallpass;
+				oHL[outHL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outHL--; if (outHL < 0 || outHL > delayH) {outHL = delayH;}
+				inputSampleL += (oHL[outHL]);
+				//allpass filter H
+				
+				dHL[6] = dHL[5];
+				dHL[5] = dHL[4];
+				dHL[4] = inputSampleL;
+				inputSampleL = (dRL[1] + dHL[5] + dHL[6])/3.0;
+				
+				allpasstemp = outIL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;}
+				inputSampleL -= oIL[allpasstemp]*constallpass;
+				oIL[outIL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outIL--; if (outIL < 0 || outIL > delayI) {outIL = delayI;}
+				inputSampleL += (oIL[outIL]);
+				//allpass filter I
+				
+				dIL[6] = dIL[5];
+				dIL[5] = dIL[4];
+				dIL[4] = inputSampleL;
+				inputSampleL = (dQL[1] + dIL[5] + dIL[6])/3.0;
+				
+				allpasstemp = outJL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;}
+				inputSampleL -= oJL[allpasstemp]*constallpass;
+				oJL[outJL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outJL--; if (outJL < 0 || outJL > delayJ) {outJL = delayJ;}
+				inputSampleL += (oJL[outJL]);
+				//allpass filter J
+				
+				dJL[6] = dJL[5];
+				dJL[5] = dJL[4];
+				dJL[4] = inputSampleL;
+				inputSampleL = (dPL[1] + dJL[5] + dJL[6])/3.0;
+				
+				allpasstemp = outKL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;}
+				inputSampleL -= oKL[allpasstemp]*constallpass;
+				oKL[outKL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outKL--; if (outKL < 0 || outKL > delayK) {outKL = delayK;}
+				inputSampleL += (oKL[outKL]);
+				//allpass filter K
+				
+				dKL[6] = dKL[5];
+				dKL[5] = dKL[4];
+				dKL[4] = inputSampleL;
+				inputSampleL = (dOL[1] + dKL[5] + dKL[6])/3.0;
+				
+				allpasstemp = outLL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;}
+				inputSampleL -= oLL[allpasstemp]*constallpass;
+				oLL[outLL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outLL--; if (outLL < 0 || outLL > delayL) {outLL = delayL;}
+				inputSampleL += (oLL[outLL]);
+				//allpass filter L
+				
+				dLL[6] = dLL[5];
+				dLL[5] = dLL[4];
+				dLL[4] = inputSampleL;
+				inputSampleL = (dNL[1] + dLL[5] + dLL[6])/3.0;
+				
+				allpasstemp = outML - 1;
+				if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;}
+				inputSampleL -= oML[allpasstemp]*constallpass;
+				oML[outML] = inputSampleL;
+				inputSampleL *= constallpass;
+				outML--; if (outML < 0 || outML > delayM) {outML = delayM;}
+				inputSampleL += (oML[outML]);
+				//allpass filter M
+				
+				dML[6] = dML[5];
+				dML[5] = dML[4];
+				dML[4] = inputSampleL;
+				inputSampleL = (dML[1] + dML[5] + dML[6])/3.0;
+				
+				allpasstemp = outNL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;}
+				inputSampleL -= oNL[allpasstemp]*constallpass;
+				oNL[outNL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outNL--; if (outNL < 0 || outNL > delayN) {outNL = delayN;}
+				inputSampleL += (oNL[outNL]);
+				//allpass filter N
+				
+				dNL[6] = dNL[5];
+				dNL[5] = dNL[4];
+				dNL[4] = inputSampleL;
+				inputSampleL = (dLL[1] + dNL[5] + dNL[6])/3.0;
+				
+				allpasstemp = outOL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;}
+				inputSampleL -= oOL[allpasstemp]*constallpass;
+				oOL[outOL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outOL--; if (outOL < 0 || outOL > delayO) {outOL = delayO;}
+				inputSampleL += (oOL[outOL]);
+				//allpass filter O
+				
+				dOL[6] = dOL[5];
+				dOL[5] = dOL[4];
+				dOL[4] = inputSampleL;
+				inputSampleL = (dKL[1] + dOL[5] + dOL[6])/3.0;
+				
+				allpasstemp = outPL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;}
+				inputSampleL -= oPL[allpasstemp]*constallpass;
+				oPL[outPL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outPL--; if (outPL < 0 || outPL > delayP) {outPL = delayP;}
+				inputSampleL += (oPL[outPL]);
+				//allpass filter P
+				
+				dPL[6] = dPL[5];
+				dPL[5] = dPL[4];
+				dPL[4] = inputSampleL;
+				inputSampleL = (dJL[1] + dPL[5] + dPL[6])/3.0;
+				
+				allpasstemp = outQL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;}
+				inputSampleL -= oQL[allpasstemp]*constallpass;
+				oQL[outQL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outQL--; if (outQL < 0 || outQL > delayQ) {outQL = delayQ;}
+				inputSampleL += (oQL[outQL]);
+				//allpass filter Q
+				
+				dQL[6] = dQL[5];
+				dQL[5] = dQL[4];
+				dQL[4] = inputSampleL;
+				inputSampleL = (dIL[1] + dQL[5] + dQL[6])/3.0;
+				
+				allpasstemp = outRL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;}
+				inputSampleL -= oRL[allpasstemp]*constallpass;
+				oRL[outRL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outRL--; if (outRL < 0 || outRL > delayR) {outRL = delayR;}
+				inputSampleL += (oRL[outRL]);
+				//allpass filter R
+				
+				dRL[6] = dRL[5];
+				dRL[5] = dRL[4];
+				dRL[4] = inputSampleL;
+				inputSampleL = (dHL[1] + dRL[5] + dRL[6])/3.0;
+				
+				allpasstemp = outSL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;}
+				inputSampleL -= oSL[allpasstemp]*constallpass;
+				oSL[outSL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outSL--; if (outSL < 0 || outSL > delayS) {outSL = delayS;}
+				inputSampleL += (oSL[outSL]);
+				//allpass filter S
+				
+				dSL[6] = dSL[5];
+				dSL[5] = dSL[4];
+				dSL[4] = inputSampleL;
+				inputSampleL = (dGL[1] + dSL[5] + dSL[6])/3.0;
+				
+				allpasstemp = outTL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;}
+				inputSampleL -= oTL[allpasstemp]*constallpass;
+				oTL[outTL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outTL--; if (outTL < 0 || outTL > delayT) {outTL = delayT;}
+				inputSampleL += (oTL[outTL]);
+				//allpass filter T
+				
+				dTL[6] = dTL[5];
+				dTL[5] = dTL[4];
+				dTL[4] = inputSampleL;
+				inputSampleL = (dFL[1] + dTL[5] + dTL[6])/3.0;
+				
+				allpasstemp = outUL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;}
+				inputSampleL -= oUL[allpasstemp]*constallpass;
+				oUL[outUL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outUL--; if (outUL < 0 || outUL > delayU) {outUL = delayU;}
+				inputSampleL += (oUL[outUL]);
+				//allpass filter U
+				
+				dUL[6] = dUL[5];
+				dUL[5] = dUL[4];
+				dUL[4] = inputSampleL;
+				inputSampleL = (dEL[1] + dUL[5] + dUL[6])/3.0;
+				
+				allpasstemp = outVL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;}
+				inputSampleL -= oVL[allpasstemp]*constallpass;
+				oVL[outVL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outVL--; if (outVL < 0 || outVL > delayV) {outVL = delayV;}
+				inputSampleL += (oVL[outVL]);
+				//allpass filter V
+				
+				dVL[6] = dVL[5];
+				dVL[5] = dVL[4];
+				dVL[4] = inputSampleL;
+				inputSampleL = (dDL[1] + dVL[5] + dVL[6])/3.0;
+				
+				allpasstemp = outWL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;}
+				inputSampleL -= oWL[allpasstemp]*constallpass;
+				oWL[outWL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outWL--; if (outWL < 0 || outWL > delayW) {outWL = delayW;}
+				inputSampleL += (oWL[outWL]);
+				//allpass filter W
+				
+				dWL[6] = dWL[5];
+				dWL[5] = dWL[4];
+				dWL[4] = inputSampleL;
+				inputSampleL = (dCL[1] + dWL[5] + dWL[6])/3.0;
+				
+				allpasstemp = outXL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;}
+				inputSampleL -= oXL[allpasstemp]*constallpass;
+				oXL[outXL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outXL--; if (outXL < 0 || outXL > delayX) {outXL = delayX;}
+				inputSampleL += (oXL[outXL]);
+				//allpass filter X
+				
+				dXL[6] = dXL[5];
+				dXL[5] = dXL[4];
+				dXL[4] = inputSampleL;
+				inputSampleL = (dAL[1] + dXL[5] + dXL[6])/3.0;
+				
+				allpasstemp = outYL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;}
+				inputSampleL -= oYL[allpasstemp]*constallpass;
+				oYL[outYL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outYL--; if (outYL < 0 || outYL > delayY) {outYL = delayY;}
+				inputSampleL += (oYL[outYL]);
+				//allpass filter Y
+				
+				dYL[6] = dYL[5];
+				dYL[5] = dYL[4];
+				dYL[4] = inputSampleL;
+				inputSampleL = (dBL[1] + dYL[5] + dYL[6])/3.0;
+				
+				allpasstemp = outZL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;}
+				inputSampleL -= oZL[allpasstemp]*constallpass;
+				oZL[outZL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outZL--; if (outZL < 0 || outZL > delayZ) {outZL = delayZ;}
+				inputSampleL += (oZL[outZL]);
+				//allpass filter Z
+				
+				dZL[6] = dZL[5];
+				dZL[5] = dZL[4];
+				dZL[4] = inputSampleL;
+				inputSampleL = (dZL[5] + dZL[6]);
+				//output Spring
+				break;
+				
+				
+			case 3:	//Tiled
+				allpasstemp = alpAL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;}
+				inputSampleL -= aAL[allpasstemp]*constallpass;
+				aAL[alpAL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpAL--; if (alpAL < 0 || alpAL > delayA) {alpAL = delayA;}
+				inputSampleL += (aAL[alpAL]);
+				//allpass filter A		
+				
+				dAL[2] = dAL[1];
+				dAL[1] = inputSampleL;
+				inputSampleL = (dAL[1] + dAL[2])/2.0;
+				
+				allpasstemp = alpBL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;}
+				inputSampleL -= aBL[allpasstemp]*constallpass;
+				aBL[alpBL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpBL--; if (alpBL < 0 || alpBL > delayB) {alpBL = delayB;}
+				inputSampleL += (aBL[alpBL]);
+				//allpass filter B
+				
+				dBL[2] = dBL[1];
+				dBL[1] = inputSampleL;
+				inputSampleL = (dBL[1] + dBL[2])/2.0;
+				
+				allpasstemp = alpCL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;}
+				inputSampleL -= aCL[allpasstemp]*constallpass;
+				aCL[alpCL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpCL--; if (alpCL < 0 || alpCL > delayC) {alpCL = delayC;}
+				inputSampleL += (aCL[alpCL]);
+				//allpass filter C
+				
+				dCL[2] = dCL[1];
+				dCL[1] = inputSampleL;
+				inputSampleL = (dAL[1] + dCL[2])/2.0;
+				
+				allpasstemp = alpDL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;}
+				inputSampleL -= aDL[allpasstemp]*constallpass;
+				aDL[alpDL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpDL--; if (alpDL < 0 || alpDL > delayD) {alpDL = delayD;}
+				inputSampleL += (aDL[alpDL]);
+				//allpass filter D
+				
+				dDL[2] = dDL[1];
+				dDL[1] = inputSampleL;
+				inputSampleL = (dDL[1] + dDL[2])/2.0;
+				
+				allpasstemp = alpEL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;}
+				inputSampleL -= aEL[allpasstemp]*constallpass;
+				aEL[alpEL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpEL--; if (alpEL < 0 || alpEL > delayE) {alpEL = delayE;}
+				inputSampleL += (aEL[alpEL]);
+				//allpass filter E
+				
+				dEL[2] = dEL[1];
+				dEL[1] = inputSampleL;
+				inputSampleL = (dAL[1] + dEL[2])/2.0;
+				
+				allpasstemp = alpFL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;}
+				inputSampleL -= aFL[allpasstemp]*constallpass;
+				aFL[alpFL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpFL--; if (alpFL < 0 || alpFL > delayF) {alpFL = delayF;}
+				inputSampleL += (aFL[alpFL]);
+				//allpass filter F
+				
+				dFL[2] = dFL[1];
+				dFL[1] = inputSampleL;
+				inputSampleL = (dFL[1] + dFL[2])/2.0;
+				
+				allpasstemp = alpGL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;}
+				inputSampleL -= aGL[allpasstemp]*constallpass;
+				aGL[alpGL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpGL--; if (alpGL < 0 || alpGL > delayG) {alpGL = delayG;}
+				inputSampleL += (aGL[alpGL]);
+				//allpass filter G
+				
+				dGL[2] = dGL[1];
+				dGL[1] = inputSampleL;
+				inputSampleL = (dAL[1] + dGL[2])/2.0;
+				
+				allpasstemp = alpHL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;}
+				inputSampleL -= aHL[allpasstemp]*constallpass;
+				aHL[alpHL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpHL--; if (alpHL < 0 || alpHL > delayH) {alpHL = delayH;}
+				inputSampleL += (aHL[alpHL]);
+				//allpass filter H
+				
+				dHL[2] = dHL[1];
+				dHL[1] = inputSampleL;
+				inputSampleL = (dHL[1] + dHL[2])/2.0;
+				
+				allpasstemp = alpIL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;}
+				inputSampleL -= aIL[allpasstemp]*constallpass;
+				aIL[alpIL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpIL--; if (alpIL < 0 || alpIL > delayI) {alpIL = delayI;}
+				inputSampleL += (aIL[alpIL]);
+				//allpass filter I
+				
+				dIL[2] = dIL[1];
+				dIL[1] = inputSampleL;
+				inputSampleL = (dIL[1] + dIL[2])/2.0;
+				
+				allpasstemp = alpJL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;}
+				inputSampleL -= aJL[allpasstemp]*constallpass;
+				aJL[alpJL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpJL--; if (alpJL < 0 || alpJL > delayJ) {alpJL = delayJ;}
+				inputSampleL += (aJL[alpJL]);
+				//allpass filter J
+				
+				dJL[2] = dJL[1];
+				dJL[1] = inputSampleL;
+				inputSampleL = (dJL[1] + dJL[2])/2.0;
+				
+				allpasstemp = alpKL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;}
+				inputSampleL -= aKL[allpasstemp]*constallpass;
+				aKL[alpKL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpKL--; if (alpKL < 0 || alpKL > delayK) {alpKL = delayK;}
+				inputSampleL += (aKL[alpKL]);
+				//allpass filter K
+				
+				dKL[2] = dKL[1];
+				dKL[1] = inputSampleL;
+				inputSampleL = (dAL[1] + dKL[2])/2.0;
+				
+				allpasstemp = alpLL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;}
+				inputSampleL -= aLL[allpasstemp]*constallpass;
+				aLL[alpLL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpLL--; if (alpLL < 0 || alpLL > delayL) {alpLL = delayL;}
+				inputSampleL += (aLL[alpLL]);
+				//allpass filter L
+				
+				dLL[2] = dLL[1];
+				dLL[1] = inputSampleL;
+				inputSampleL = (dLL[1] + dLL[2])/2.0;
+				
+				allpasstemp = alpML - 1;
+				if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;}
+				inputSampleL -= aML[allpasstemp]*constallpass;
+				aML[alpML] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpML--; if (alpML < 0 || alpML > delayM) {alpML = delayM;}
+				inputSampleL += (aML[alpML]);
+				//allpass filter M
+				
+				dML[2] = dML[1];
+				dML[1] = inputSampleL;
+				inputSampleL = (dAL[1] + dML[2])/2.0;
+				
+				allpasstemp = alpNL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;}
+				inputSampleL -= aNL[allpasstemp]*constallpass;
+				aNL[alpNL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpNL--; if (alpNL < 0 || alpNL > delayN) {alpNL = delayN;}
+				inputSampleL += (aNL[alpNL]);
+				//allpass filter N
+				
+				dNL[2] = dNL[1];
+				dNL[1] = inputSampleL;
+				inputSampleL = (dNL[1] + dNL[2])/2.0;
+				
+				allpasstemp = alpOL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;}
+				inputSampleL -= aOL[allpasstemp]*constallpass;
+				aOL[alpOL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpOL--; if (alpOL < 0 || alpOL > delayO) {alpOL = delayO;}
+				inputSampleL += (aOL[alpOL]);
+				//allpass filter O
+				
+				dOL[2] = dOL[1];
+				dOL[1] = inputSampleL;
+				inputSampleL = (dOL[1] + dOL[2])/2.0;
+				
+				allpasstemp = alpPL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;}
+				inputSampleL -= aPL[allpasstemp]*constallpass;
+				aPL[alpPL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpPL--; if (alpPL < 0 || alpPL > delayP) {alpPL = delayP;}
+				inputSampleL += (aPL[alpPL]);
+				//allpass filter P
+				
+				dPL[2] = dPL[1];
+				dPL[1] = inputSampleL;
+				inputSampleL = (dPL[1] + dPL[2])/2.0;
+				
+				allpasstemp = alpQL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;}
+				inputSampleL -= aQL[allpasstemp]*constallpass;
+				aQL[alpQL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpQL--; if (alpQL < 0 || alpQL > delayQ) {alpQL = delayQ;}
+				inputSampleL += (aQL[alpQL]);
+				//allpass filter Q
+				
+				dQL[2] = dQL[1];
+				dQL[1] = inputSampleL;
+				inputSampleL = (dAL[1] + dQL[2])/2.0;
+				
+				allpasstemp = alpRL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;}
+				inputSampleL -= aRL[allpasstemp]*constallpass;
+				aRL[alpRL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpRL--; if (alpRL < 0 || alpRL > delayR) {alpRL = delayR;}
+				inputSampleL += (aRL[alpRL]);
+				//allpass filter R
+				
+				dRL[2] = dRL[1];
+				dRL[1] = inputSampleL;
+				inputSampleL = (dRL[1] + dRL[2])/2.0;
+				
+				allpasstemp = alpSL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;}
+				inputSampleL -= aSL[allpasstemp]*constallpass;
+				aSL[alpSL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpSL--; if (alpSL < 0 || alpSL > delayS) {alpSL = delayS;}
+				inputSampleL += (aSL[alpSL]);
+				//allpass filter S
+				
+				dSL[2] = dSL[1];
+				dSL[1] = inputSampleL;
+				inputSampleL = (dAL[1] + dSL[2])/2.0;
+				
+				allpasstemp = alpTL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;}
+				inputSampleL -= aTL[allpasstemp]*constallpass;
+				aTL[alpTL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpTL--; if (alpTL < 0 || alpTL > delayT) {alpTL = delayT;}
+				inputSampleL += (aTL[alpTL]);
+				//allpass filter T
+				
+				dTL[2] = dTL[1];
+				dTL[1] = inputSampleL;
+				inputSampleL = (dTL[1] + dTL[2])/2.0;
+				
+				allpasstemp = alpUL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;}
+				inputSampleL -= aUL[allpasstemp]*constallpass;
+				aUL[alpUL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpUL--; if (alpUL < 0 || alpUL > delayU) {alpUL = delayU;}
+				inputSampleL += (aUL[alpUL]);
+				//allpass filter U
+				
+				dUL[2] = dUL[1];
+				dUL[1] = inputSampleL;
+				inputSampleL = (dUL[1] + dUL[2])/2.0;
+				
+				allpasstemp = alpVL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;}
+				inputSampleL -= aVL[allpasstemp]*constallpass;
+				aVL[alpVL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpVL--; if (alpVL < 0 || alpVL > delayV) {alpVL = delayV;}
+				inputSampleL += (aVL[alpVL]);
+				//allpass filter V
+				
+				dVL[2] = dVL[1];
+				dVL[1] = inputSampleL;
+				inputSampleL = (dVL[1] + dVL[2])/2.0;
+				
+				allpasstemp = alpWL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;}
+				inputSampleL -= aWL[allpasstemp]*constallpass;
+				aWL[alpWL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpWL--; if (alpWL < 0 || alpWL > delayW) {alpWL = delayW;}
+				inputSampleL += (aWL[alpWL]);
+				//allpass filter W
+				
+				dWL[2] = dWL[1];
+				dWL[1] = inputSampleL;
+				inputSampleL = (dAL[1] + dWL[2])/2.0;
+				
+				allpasstemp = alpXL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;}
+				inputSampleL -= aXL[allpasstemp]*constallpass;
+				aXL[alpXL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpXL--; if (alpXL < 0 || alpXL > delayX) {alpXL = delayX;}
+				inputSampleL += (aXL[alpXL]);
+				//allpass filter X
+				
+				dXL[2] = dXL[1];
+				dXL[1] = inputSampleL;
+				inputSampleL = (dXL[1] + dXL[2])/2.0;
+				
+				allpasstemp = alpYL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;}
+				inputSampleL -= aYL[allpasstemp]*constallpass;
+				aYL[alpYL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpYL--; if (alpYL < 0 || alpYL > delayY) {alpYL = delayY;}
+				inputSampleL += (aYL[alpYL]);
+				//allpass filter Y
+				
+				dYL[2] = dYL[1];
+				dYL[1] = inputSampleL;
+				inputSampleL = (dYL[1] + dYL[2])/2.0;
+				
+				allpasstemp = alpZL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;}
+				inputSampleL -= aZL[allpasstemp]*constallpass;
+				aZL[alpZL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpZL--; if (alpZL < 0 || alpZL > delayZ) {alpZL = delayZ;}
+				inputSampleL += (aZL[alpZL]);
+				//allpass filter Z
+				
+				dZL[2] = dZL[1];
+				dZL[1] = inputSampleL;
+				inputSampleL = (dZL[1] + dZL[2])/2.0;
+				
+				// now the second stage using the 'out' bank of allpasses		
+				
+				allpasstemp = outAL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;}
+				inputSampleL -= oAL[allpasstemp]*constallpass;
+				oAL[outAL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outAL--; if (outAL < 0 || outAL > delayA) {outAL = delayA;}
+				inputSampleL += (oAL[outAL]);
+				//allpass filter A		
+				
+				dAL[5] = dAL[4];
+				dAL[4] = inputSampleL;
+				inputSampleL = (dAL[4] + dAL[5])/2.0;
+				
+				allpasstemp = outBL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;}
+				inputSampleL -= oBL[allpasstemp]*constallpass;
+				oBL[outBL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outBL--; if (outBL < 0 || outBL > delayB) {outBL = delayB;}
+				inputSampleL += (oBL[outBL]);
+				//allpass filter B
+				
+				dBL[5] = dBL[4];
+				dBL[4] = inputSampleL;
+				inputSampleL = (dBL[4] + dBL[5])/2.0;
+				
+				allpasstemp = outCL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;}
+				inputSampleL -= oCL[allpasstemp]*constallpass;
+				oCL[outCL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outCL--; if (outCL < 0 || outCL > delayC) {outCL = delayC;}
+				inputSampleL += (oCL[outCL]);
+				//allpass filter C
+				
+				dCL[5] = dCL[4];
+				dCL[4] = inputSampleL;
+				inputSampleL = (dAL[1] + dCL[5])/2.0;
+				
+				allpasstemp = outDL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;}
+				inputSampleL -= oDL[allpasstemp]*constallpass;
+				oDL[outDL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outDL--; if (outDL < 0 || outDL > delayD) {outDL = delayD;}
+				inputSampleL += (oDL[outDL]);
+				//allpass filter D
+				
+				dDL[5] = dDL[4];
+				dDL[4] = inputSampleL;
+				inputSampleL = (dDL[4] + dDL[5])/2.0;
+				
+				allpasstemp = outEL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;}
+				inputSampleL -= oEL[allpasstemp]*constallpass;
+				oEL[outEL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outEL--; if (outEL < 0 || outEL > delayE) {outEL = delayE;}
+				inputSampleL += (oEL[outEL]);
+				//allpass filter E
+				
+				dEL[5] = dEL[4];
+				dEL[4] = inputSampleL;
+				inputSampleL = (dAL[1] + dEL[5])/2.0;
+				
+				allpasstemp = outFL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;}
+				inputSampleL -= oFL[allpasstemp]*constallpass;
+				oFL[outFL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outFL--; if (outFL < 0 || outFL > delayF) {outFL = delayF;}
+				inputSampleL += (oFL[outFL]);
+				//allpass filter F
+				
+				dFL[5] = dFL[4];
+				dFL[4] = inputSampleL;
+				inputSampleL = (dFL[4] + dFL[5])/2.0;
+				
+				allpasstemp = outGL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;}
+				inputSampleL -= oGL[allpasstemp]*constallpass;
+				oGL[outGL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outGL--; if (outGL < 0 || outGL > delayG) {outGL = delayG;}
+				inputSampleL += (oGL[outGL]);
+				//allpass filter G
+				
+				dGL[5] = dGL[4];
+				dGL[4] = inputSampleL;
+				inputSampleL = (dGL[4] + dGL[5])/2.0;
+				
+				allpasstemp = outHL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;}
+				inputSampleL -= oHL[allpasstemp]*constallpass;
+				oHL[outHL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outHL--; if (outHL < 0 || outHL > delayH) {outHL = delayH;}
+				inputSampleL += (oHL[outHL]);
+				//allpass filter H
+				
+				dHL[5] = dHL[4];
+				dHL[4] = inputSampleL;
+				inputSampleL = (dHL[4] + dHL[5])/2.0;
+				
+				allpasstemp = outIL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;}
+				inputSampleL -= oIL[allpasstemp]*constallpass;
+				oIL[outIL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outIL--; if (outIL < 0 || outIL > delayI) {outIL = delayI;}
+				inputSampleL += (oIL[outIL]);
+				//allpass filter I
+				
+				dIL[5] = dIL[4];
+				dIL[4] = inputSampleL;
+				inputSampleL = (dIL[4] + dIL[5])/2.0;
+				
+				allpasstemp = outJL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;}
+				inputSampleL -= oJL[allpasstemp]*constallpass;
+				oJL[outJL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outJL--; if (outJL < 0 || outJL > delayJ) {outJL = delayJ;}
+				inputSampleL += (oJL[outJL]);
+				//allpass filter J
+				
+				dJL[5] = dJL[4];
+				dJL[4] = inputSampleL;
+				inputSampleL = (dJL[4] + dJL[5])/2.0;
+				
+				allpasstemp = outKL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;}
+				inputSampleL -= oKL[allpasstemp]*constallpass;
+				oKL[outKL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outKL--; if (outKL < 0 || outKL > delayK) {outKL = delayK;}
+				inputSampleL += (oKL[outKL]);
+				//allpass filter K
+				
+				dKL[5] = dKL[4];
+				dKL[4] = inputSampleL;
+				inputSampleL = (dAL[1] + dKL[5])/2.0;
+				
+				allpasstemp = outLL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;}
+				inputSampleL -= oLL[allpasstemp]*constallpass;
+				oLL[outLL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outLL--; if (outLL < 0 || outLL > delayL) {outLL = delayL;}
+				inputSampleL += (oLL[outLL]);
+				//allpass filter L
+				
+				dLL[5] = dLL[4];
+				dLL[4] = inputSampleL;
+				inputSampleL = (dLL[4] + dLL[5])/2.0;
+				
+				allpasstemp = outML - 1;
+				if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;}
+				inputSampleL -= oML[allpasstemp]*constallpass;
+				oML[outML] = inputSampleL;
+				inputSampleL *= constallpass;
+				outML--; if (outML < 0 || outML > delayM) {outML = delayM;}
+				inputSampleL += (oML[outML]);
+				//allpass filter M
+				
+				dML[5] = dML[4];
+				dML[4] = inputSampleL;
+				inputSampleL = (dML[4] + dML[5])/2.0;
+				
+				allpasstemp = outNL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;}
+				inputSampleL -= oNL[allpasstemp]*constallpass;
+				oNL[outNL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outNL--; if (outNL < 0 || outNL > delayN) {outNL = delayN;}
+				inputSampleL += (oNL[outNL]);
+				//allpass filter N
+				
+				dNL[5] = dNL[4];
+				dNL[4] = inputSampleL;
+				inputSampleL = (dNL[4] + dNL[5])/2.0;
+				
+				allpasstemp = outOL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;}
+				inputSampleL -= oOL[allpasstemp]*constallpass;
+				oOL[outOL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outOL--; if (outOL < 0 || outOL > delayO) {outOL = delayO;}
+				inputSampleL += (oOL[outOL]);
+				//allpass filter O
+				
+				dOL[5] = dOL[4];
+				dOL[4] = inputSampleL;
+				inputSampleL = (dAL[1] + dOL[5])/2.0;
+				
+				allpasstemp = outPL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;}
+				inputSampleL -= oPL[allpasstemp]*constallpass;
+				oPL[outPL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outPL--; if (outPL < 0 || outPL > delayP) {outPL = delayP;}
+				inputSampleL += (oPL[outPL]);
+				//allpass filter P
+				
+				dPL[5] = dPL[4];
+				dPL[4] = inputSampleL;
+				inputSampleL = (dPL[4] + dPL[5])/2.0;
+				
+				allpasstemp = outQL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;}
+				inputSampleL -= oQL[allpasstemp]*constallpass;
+				oQL[outQL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outQL--; if (outQL < 0 || outQL > delayQ) {outQL = delayQ;}
+				inputSampleL += (oQL[outQL]);
+				//allpass filter Q
+				
+				dQL[5] = dQL[4];
+				dQL[4] = inputSampleL;
+				inputSampleL = (dAL[1] + dQL[5])/2.0;
+				
+				allpasstemp = outRL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;}
+				inputSampleL -= oRL[allpasstemp]*constallpass;
+				oRL[outRL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outRL--; if (outRL < 0 || outRL > delayR) {outRL = delayR;}
+				inputSampleL += (oRL[outRL]);
+				//allpass filter R
+				
+				dRL[5] = dRL[4];
+				dRL[4] = inputSampleL;
+				inputSampleL = (dRL[4] + dRL[5])/2.0;
+				
+				allpasstemp = outSL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;}
+				inputSampleL -= oSL[allpasstemp]*constallpass;
+				oSL[outSL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outSL--; if (outSL < 0 || outSL > delayS) {outSL = delayS;}
+				inputSampleL += (oSL[outSL]);
+				//allpass filter S
+				
+				dSL[5] = dSL[4];
+				dSL[4] = inputSampleL;
+				inputSampleL = (dSL[4] + dSL[5])/2.0;
+				
+				allpasstemp = outTL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;}
+				inputSampleL -= oTL[allpasstemp]*constallpass;
+				oTL[outTL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outTL--; if (outTL < 0 || outTL > delayT) {outTL = delayT;}
+				inputSampleL += (oTL[outTL]);
+				//allpass filter T
+				
+				dTL[5] = dTL[4];
+				dTL[4] = inputSampleL;
+				inputSampleL = (dTL[4] + dTL[5])/2.0;
+				
+				allpasstemp = outUL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;}
+				inputSampleL -= oUL[allpasstemp]*constallpass;
+				oUL[outUL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outUL--; if (outUL < 0 || outUL > delayU) {outUL = delayU;}
+				inputSampleL += (oUL[outUL]);
+				//allpass filter U
+				
+				dUL[5] = dUL[4];
+				dUL[4] = inputSampleL;
+				inputSampleL = (dAL[1] + dUL[5])/2.0;
+				
+				allpasstemp = outVL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;}
+				inputSampleL -= oVL[allpasstemp]*constallpass;
+				oVL[outVL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outVL--; if (outVL < 0 || outVL > delayV) {outVL = delayV;}
+				inputSampleL += (oVL[outVL]);
+				//allpass filter V
+				
+				dVL[5] = dVL[4];
+				dVL[4] = inputSampleL;
+				inputSampleL = (dVL[4] + dVL[5])/2.0;
+				
+				allpasstemp = outWL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;}
+				inputSampleL -= oWL[allpasstemp]*constallpass;
+				oWL[outWL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outWL--; if (outWL < 0 || outWL > delayW) {outWL = delayW;}
+				inputSampleL += (oWL[outWL]);
+				//allpass filter W
+				
+				dWL[5] = dWL[4];
+				dWL[4] = inputSampleL;
+				inputSampleL = (dWL[4] + dWL[5])/2.0;
+				
+				allpasstemp = outXL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;}
+				inputSampleL -= oXL[allpasstemp]*constallpass;
+				oXL[outXL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outXL--; if (outXL < 0 || outXL > delayX) {outXL = delayX;}
+				inputSampleL += (oXL[outXL]);
+				//allpass filter X
+				
+				dXL[5] = dXL[4];
+				dXL[4] = inputSampleL;
+				inputSampleL = (dXL[4] + dXL[5])/2.0;
+				
+				allpasstemp = outYL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;}
+				inputSampleL -= oYL[allpasstemp]*constallpass;
+				oYL[outYL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outYL--; if (outYL < 0 || outYL > delayY) {outYL = delayY;}
+				inputSampleL += (oYL[outYL]);
+				//allpass filter Y
+				
+				dYL[5] = dYL[4];
+				dYL[4] = inputSampleL;
+				inputSampleL = (dYL[4] + dYL[5])/2.0;
+				
+				allpasstemp = outZL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;}
+				inputSampleL -= oZL[allpasstemp]*constallpass;
+				oZL[outZL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outZL--; if (outZL < 0 || outZL > delayZ) {outZL = delayZ;}
+				inputSampleL += (oZL[outZL]);
+				//allpass filter Z
+				
+				dZL[5] = dZL[4];
+				dZL[4] = inputSampleL;
+				inputSampleL = (dZL[4] + dZL[5]);		
+				//output Tiled
+				break;
+				
+				
+			case 4://Room
+				allpasstemp = alpAL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;}
+				inputSampleL -= aAL[allpasstemp]*constallpass;
+				aAL[alpAL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpAL--; if (alpAL < 0 || alpAL > delayA) {alpAL = delayA;}
+				inputSampleL += (aAL[alpAL]);
+				//allpass filter A		
+				
+				dAL[2] = dAL[1];
+				dAL[1] = inputSampleL;
+				inputSampleL = drySampleL;
+				
+				allpasstemp = alpBL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;}
+				inputSampleL -= aBL[allpasstemp]*constallpass;
+				aBL[alpBL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpBL--; if (alpBL < 0 || alpBL > delayB) {alpBL = delayB;}
+				inputSampleL += (aBL[alpBL]);
+				//allpass filter B
+				
+				dBL[2] = dBL[1];
+				dBL[1] = inputSampleL;
+				inputSampleL = drySampleL;
+				
+				allpasstemp = alpCL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;}
+				inputSampleL -= aCL[allpasstemp]*constallpass;
+				aCL[alpCL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpCL--; if (alpCL < 0 || alpCL > delayC) {alpCL = delayC;}
+				inputSampleL += (aCL[alpCL]);
+				//allpass filter C
+				
+				dCL[2] = dCL[1];
+				dCL[1] = inputSampleL;
+				inputSampleL = drySampleL;
+				
+				allpasstemp = alpDL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;}
+				inputSampleL -= aDL[allpasstemp]*constallpass;
+				aDL[alpDL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpDL--; if (alpDL < 0 || alpDL > delayD) {alpDL = delayD;}
+				inputSampleL += (aDL[alpDL]);
+				//allpass filter D
+				
+				dDL[2] = dDL[1];
+				dDL[1] = inputSampleL;
+				inputSampleL = drySampleL;
+				
+				allpasstemp = alpEL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;}
+				inputSampleL -= aEL[allpasstemp]*constallpass;
+				aEL[alpEL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpEL--; if (alpEL < 0 || alpEL > delayE) {alpEL = delayE;}
+				inputSampleL += (aEL[alpEL]);
+				//allpass filter E
+				
+				dEL[2] = dEL[1];
+				dEL[1] = inputSampleL;
+				inputSampleL = drySampleL;
+				
+				allpasstemp = alpFL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;}
+				inputSampleL -= aFL[allpasstemp]*constallpass;
+				aFL[alpFL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpFL--; if (alpFL < 0 || alpFL > delayF) {alpFL = delayF;}
+				inputSampleL += (aFL[alpFL]);
+				//allpass filter F
+				
+				dFL[2] = dFL[1];
+				dFL[1] = inputSampleL;
+				inputSampleL = drySampleL;
+				
+				allpasstemp = alpGL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;}
+				inputSampleL -= aGL[allpasstemp]*constallpass;
+				aGL[alpGL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpGL--; if (alpGL < 0 || alpGL > delayG) {alpGL = delayG;}
+				inputSampleL += (aGL[alpGL]);
+				//allpass filter G
+				
+				dGL[2] = dGL[1];
+				dGL[1] = inputSampleL;
+				inputSampleL = drySampleL;
+				
+				allpasstemp = alpHL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;}
+				inputSampleL -= aHL[allpasstemp]*constallpass;
+				aHL[alpHL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpHL--; if (alpHL < 0 || alpHL > delayH) {alpHL = delayH;}
+				inputSampleL += (aHL[alpHL]);
+				//allpass filter H
+				
+				dHL[2] = dHL[1];
+				dHL[1] = inputSampleL;
+				inputSampleL = drySampleL;
+				
+				allpasstemp = alpIL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;}
+				inputSampleL -= aIL[allpasstemp]*constallpass;
+				aIL[alpIL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpIL--; if (alpIL < 0 || alpIL > delayI) {alpIL = delayI;}
+				inputSampleL += (aIL[alpIL]);
+				//allpass filter I
+				
+				dIL[2] = dIL[1];
+				dIL[1] = inputSampleL;
+				inputSampleL = drySampleL;
+				
+				allpasstemp = alpJL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;}
+				inputSampleL -= aJL[allpasstemp]*constallpass;
+				aJL[alpJL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpJL--; if (alpJL < 0 || alpJL > delayJ) {alpJL = delayJ;}
+				inputSampleL += (aJL[alpJL]);
+				//allpass filter J
+				
+				dJL[2] = dJL[1];
+				dJL[1] = inputSampleL;
+				inputSampleL = drySampleL;
+				
+				allpasstemp = alpKL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;}
+				inputSampleL -= aKL[allpasstemp]*constallpass;
+				aKL[alpKL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpKL--; if (alpKL < 0 || alpKL > delayK) {alpKL = delayK;}
+				inputSampleL += (aKL[alpKL]);
+				//allpass filter K
+				
+				dKL[2] = dKL[1];
+				dKL[1] = inputSampleL;
+				inputSampleL = drySampleL;
+				
+				allpasstemp = alpLL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;}
+				inputSampleL -= aLL[allpasstemp]*constallpass;
+				aLL[alpLL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpLL--; if (alpLL < 0 || alpLL > delayL) {alpLL = delayL;}
+				inputSampleL += (aLL[alpLL]);
+				//allpass filter L
+				
+				dLL[2] = dLL[1];
+				dLL[1] = inputSampleL;
+				inputSampleL = drySampleL;
+				
+				allpasstemp = alpML - 1;
+				if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;}
+				inputSampleL -= aML[allpasstemp]*constallpass;
+				aML[alpML] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpML--; if (alpML < 0 || alpML > delayM) {alpML = delayM;}
+				inputSampleL += (aML[alpML]);
+				//allpass filter M
+				
+				dML[2] = dML[1];
+				dML[1] = inputSampleL;
+				inputSampleL = drySampleL;
+				
+				allpasstemp = alpNL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;}
+				inputSampleL -= aNL[allpasstemp]*constallpass;
+				aNL[alpNL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpNL--; if (alpNL < 0 || alpNL > delayN) {alpNL = delayN;}
+				inputSampleL += (aNL[alpNL]);
+				//allpass filter N
+				
+				dNL[2] = dNL[1];
+				dNL[1] = inputSampleL;
+				inputSampleL = drySampleL;
+				
+				allpasstemp = alpOL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;}
+				inputSampleL -= aOL[allpasstemp]*constallpass;
+				aOL[alpOL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpOL--; if (alpOL < 0 || alpOL > delayO) {alpOL = delayO;}
+				inputSampleL += (aOL[alpOL]);
+				//allpass filter O
+				
+				dOL[2] = dOL[1];
+				dOL[1] = inputSampleL;
+				inputSampleL = drySampleL;
+				
+				allpasstemp = alpPL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;}
+				inputSampleL -= aPL[allpasstemp]*constallpass;
+				aPL[alpPL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpPL--; if (alpPL < 0 || alpPL > delayP) {alpPL = delayP;}
+				inputSampleL += (aPL[alpPL]);
+				//allpass filter P
+				
+				dPL[2] = dPL[1];
+				dPL[1] = inputSampleL;
+				inputSampleL = drySampleL;
+				
+				allpasstemp = alpQL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;}
+				inputSampleL -= aQL[allpasstemp]*constallpass;
+				aQL[alpQL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpQL--; if (alpQL < 0 || alpQL > delayQ) {alpQL = delayQ;}
+				inputSampleL += (aQL[alpQL]);
+				//allpass filter Q
+				
+				dQL[2] = dQL[1];
+				dQL[1] = inputSampleL;
+				inputSampleL = drySampleL;
+				
+				allpasstemp = alpRL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;}
+				inputSampleL -= aRL[allpasstemp]*constallpass;
+				aRL[alpRL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpRL--; if (alpRL < 0 || alpRL > delayR) {alpRL = delayR;}
+				inputSampleL += (aRL[alpRL]);
+				//allpass filter R
+				
+				dRL[2] = dRL[1];
+				dRL[1] = inputSampleL;
+				inputSampleL = drySampleL;
+				
+				allpasstemp = alpSL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;}
+				inputSampleL -= aSL[allpasstemp]*constallpass;
+				aSL[alpSL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpSL--; if (alpSL < 0 || alpSL > delayS) {alpSL = delayS;}
+				inputSampleL += (aSL[alpSL]);
+				//allpass filter S
+				
+				dSL[2] = dSL[1];
+				dSL[1] = inputSampleL;
+				inputSampleL = drySampleL;
+				
+				allpasstemp = alpTL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;}
+				inputSampleL -= aTL[allpasstemp]*constallpass;
+				aTL[alpTL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpTL--; if (alpTL < 0 || alpTL > delayT) {alpTL = delayT;}
+				inputSampleL += (aTL[alpTL]);
+				//allpass filter T
+				
+				dTL[2] = dTL[1];
+				dTL[1] = inputSampleL;
+				inputSampleL = drySampleL;
+				
+				allpasstemp = alpUL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;}
+				inputSampleL -= aUL[allpasstemp]*constallpass;
+				aUL[alpUL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpUL--; if (alpUL < 0 || alpUL > delayU) {alpUL = delayU;}
+				inputSampleL += (aUL[alpUL]);
+				//allpass filter U
+				
+				dUL[2] = dUL[1];
+				dUL[1] = inputSampleL;
+				inputSampleL = drySampleL;
+				
+				allpasstemp = alpVL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;}
+				inputSampleL -= aVL[allpasstemp]*constallpass;
+				aVL[alpVL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpVL--; if (alpVL < 0 || alpVL > delayV) {alpVL = delayV;}
+				inputSampleL += (aVL[alpVL]);
+				//allpass filter V
+				
+				dVL[2] = dVL[1];
+				dVL[1] = inputSampleL;
+				inputSampleL = drySampleL;
+				
+				allpasstemp = alpWL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;}
+				inputSampleL -= aWL[allpasstemp]*constallpass;
+				aWL[alpWL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpWL--; if (alpWL < 0 || alpWL > delayW) {alpWL = delayW;}
+				inputSampleL += (aWL[alpWL]);
+				//allpass filter W
+				
+				dWL[2] = dWL[1];
+				dWL[1] = inputSampleL;
+				inputSampleL = drySampleL;
+				
+				allpasstemp = alpXL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;}
+				inputSampleL -= aXL[allpasstemp]*constallpass;
+				aXL[alpXL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpXL--; if (alpXL < 0 || alpXL > delayX) {alpXL = delayX;}
+				inputSampleL += (aXL[alpXL]);
+				//allpass filter X
+				
+				dXL[2] = dXL[1];
+				dXL[1] = inputSampleL;
+				inputSampleL = drySampleL;
+				
+				allpasstemp = alpYL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;}
+				inputSampleL -= aYL[allpasstemp]*constallpass;
+				aYL[alpYL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpYL--; if (alpYL < 0 || alpYL > delayY) {alpYL = delayY;}
+				inputSampleL += (aYL[alpYL]);
+				//allpass filter Y
+				
+				dYL[2] = dYL[1];
+				dYL[1] = inputSampleL;
+				inputSampleL = drySampleL;
+				
+				allpasstemp = alpZL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;}
+				inputSampleL -= aZL[allpasstemp]*constallpass;
+				aZL[alpZL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpZL--; if (alpZL < 0 || alpZL > delayZ) {alpZL = delayZ;}
+				inputSampleL += (aZL[alpZL]);
+				//allpass filter Z
+				
+				dZL[2] = dZL[1];
+				dZL[1] = inputSampleL;
+				inputSampleL = drySampleL;
+				
+				// now the second stage using the 'out' bank of allpasses		
+				
+				allpasstemp = outAL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;}
+				inputSampleL -= oAL[allpasstemp]*constallpass;
+				oAL[outAL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outAL--; if (outAL < 0 || outAL > delayA) {outAL = delayA;}
+				inputSampleL += (oAL[outAL]);
+				//allpass filter A		
+				
+				dAL[5] = dAL[4];
+				dAL[4] = inputSampleL;
+				inputSampleL = (dAL[1]+dAL[2])/2.0;
+				
+				allpasstemp = outBL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;}
+				inputSampleL -= oBL[allpasstemp]*constallpass;
+				oBL[outBL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outBL--; if (outBL < 0 || outBL > delayB) {outBL = delayB;}
+				inputSampleL += (oBL[outBL]);
+				//allpass filter B
+				
+				dBL[5] = dBL[4];
+				dBL[4] = inputSampleL;
+				inputSampleL = (dBL[1]+dBL[2])/2.0;
+				
+				allpasstemp = outCL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;}
+				inputSampleL -= oCL[allpasstemp]*constallpass;
+				oCL[outCL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outCL--; if (outCL < 0 || outCL > delayC) {outCL = delayC;}
+				inputSampleL += (oCL[outCL]);
+				//allpass filter C
+				
+				dCL[5] = dCL[4];
+				dCL[4] = inputSampleL;
+				inputSampleL = (dCL[1]+dCL[2])/2.0;
+				
+				allpasstemp = outDL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;}
+				inputSampleL -= oDL[allpasstemp]*constallpass;
+				oDL[outDL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outDL--; if (outDL < 0 || outDL > delayD) {outDL = delayD;}
+				inputSampleL += (oDL[outDL]);
+				//allpass filter D
+				
+				dDL[5] = dDL[4];
+				dDL[4] = inputSampleL;
+				inputSampleL = (dDL[1]+dDL[2])/2.0;
+				
+				allpasstemp = outEL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;}
+				inputSampleL -= oEL[allpasstemp]*constallpass;
+				oEL[outEL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outEL--; if (outEL < 0 || outEL > delayE) {outEL = delayE;}
+				inputSampleL += (oEL[outEL]);
+				//allpass filter E
+				
+				dEL[5] = dEL[4];
+				dEL[4] = inputSampleL;
+				inputSampleL = (dEL[1]+dEL[2])/2.0;
+				
+				allpasstemp = outFL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;}
+				inputSampleL -= oFL[allpasstemp]*constallpass;
+				oFL[outFL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outFL--; if (outFL < 0 || outFL > delayF) {outFL = delayF;}
+				inputSampleL += (oFL[outFL]);
+				//allpass filter F
+				
+				dFL[5] = dFL[4];
+				dFL[4] = inputSampleL;
+				inputSampleL = (dFL[1]+dFL[2])/2.0;
+				
+				allpasstemp = outGL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;}
+				inputSampleL -= oGL[allpasstemp]*constallpass;
+				oGL[outGL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outGL--; if (outGL < 0 || outGL > delayG) {outGL = delayG;}
+				inputSampleL += (oGL[outGL]);
+				//allpass filter G
+				
+				dGL[5] = dGL[4];
+				dGL[4] = inputSampleL;
+				inputSampleL = (dGL[1]+dGL[2])/2.0;
+				
+				allpasstemp = outHL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;}
+				inputSampleL -= oHL[allpasstemp]*constallpass;
+				oHL[outHL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outHL--; if (outHL < 0 || outHL > delayH) {outHL = delayH;}
+				inputSampleL += (oHL[outHL]);
+				//allpass filter H
+				
+				dHL[5] = dHL[4];
+				dHL[4] = inputSampleL;
+				inputSampleL = (dHL[1]+dHL[2])/2.0;
+				
+				allpasstemp = outIL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;}
+				inputSampleL -= oIL[allpasstemp]*constallpass;
+				oIL[outIL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outIL--; if (outIL < 0 || outIL > delayI) {outIL = delayI;}
+				inputSampleL += (oIL[outIL]);
+				//allpass filter I
+				
+				dIL[5] = dIL[4];
+				dIL[4] = inputSampleL;
+				inputSampleL = (dIL[1]+dIL[2])/2.0;
+				
+				allpasstemp = outJL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;}
+				inputSampleL -= oJL[allpasstemp]*constallpass;
+				oJL[outJL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outJL--; if (outJL < 0 || outJL > delayJ) {outJL = delayJ;}
+				inputSampleL += (oJL[outJL]);
+				//allpass filter J
+				
+				dJL[5] = dJL[4];
+				dJL[4] = inputSampleL;
+				inputSampleL = (dJL[1]+dJL[2])/2.0;
+				
+				allpasstemp = outKL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;}
+				inputSampleL -= oKL[allpasstemp]*constallpass;
+				oKL[outKL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outKL--; if (outKL < 0 || outKL > delayK) {outKL = delayK;}
+				inputSampleL += (oKL[outKL]);
+				//allpass filter K
+				
+				dKL[5] = dKL[4];
+				dKL[4] = inputSampleL;
+				inputSampleL = (dKL[1]+dKL[2])/2.0;
+				
+				allpasstemp = outLL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;}
+				inputSampleL -= oLL[allpasstemp]*constallpass;
+				oLL[outLL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outLL--; if (outLL < 0 || outLL > delayL) {outLL = delayL;}
+				inputSampleL += (oLL[outLL]);
+				//allpass filter L
+				
+				dLL[5] = dLL[4];
+				dLL[4] = inputSampleL;
+				inputSampleL = (dLL[1]+dLL[2])/2.0;
+				
+				allpasstemp = outML - 1;
+				if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;}
+				inputSampleL -= oML[allpasstemp]*constallpass;
+				oML[outML] = inputSampleL;
+				inputSampleL *= constallpass;
+				outML--; if (outML < 0 || outML > delayM) {outML = delayM;}
+				inputSampleL += (oML[outML]);
+				//allpass filter M
+				
+				dML[5] = dML[4];
+				dML[4] = inputSampleL;
+				inputSampleL = (dML[1]+dML[2])/2.0;
+				
+				allpasstemp = outNL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;}
+				inputSampleL -= oNL[allpasstemp]*constallpass;
+				oNL[outNL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outNL--; if (outNL < 0 || outNL > delayN) {outNL = delayN;}
+				inputSampleL += (oNL[outNL]);
+				//allpass filter N
+				
+				dNL[5] = dNL[4];
+				dNL[4] = inputSampleL;
+				inputSampleL = (dNL[1]+dNL[2])/2.0;
+				
+				allpasstemp = outOL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;}
+				inputSampleL -= oOL[allpasstemp]*constallpass;
+				oOL[outOL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outOL--; if (outOL < 0 || outOL > delayO) {outOL = delayO;}
+				inputSampleL += (oOL[outOL]);
+				//allpass filter O
+				
+				dOL[5] = dOL[4];
+				dOL[4] = inputSampleL;
+				inputSampleL = (dOL[1]+dOL[2])/2.0;
+				
+				allpasstemp = outPL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;}
+				inputSampleL -= oPL[allpasstemp]*constallpass;
+				oPL[outPL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outPL--; if (outPL < 0 || outPL > delayP) {outPL = delayP;}
+				inputSampleL += (oPL[outPL]);
+				//allpass filter P
+				
+				dPL[5] = dPL[4];
+				dPL[4] = inputSampleL;
+				inputSampleL = (dPL[1]+dPL[2])/2.0;
+				
+				allpasstemp = outQL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;}
+				inputSampleL -= oQL[allpasstemp]*constallpass;
+				oQL[outQL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outQL--; if (outQL < 0 || outQL > delayQ) {outQL = delayQ;}
+				inputSampleL += (oQL[outQL]);
+				//allpass filter Q
+				
+				dQL[5] = dQL[4];
+				dQL[4] = inputSampleL;
+				inputSampleL = (dQL[1]+dQL[2])/2.0;
+				
+				allpasstemp = outRL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;}
+				inputSampleL -= oRL[allpasstemp]*constallpass;
+				oRL[outRL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outRL--; if (outRL < 0 || outRL > delayR) {outRL = delayR;}
+				inputSampleL += (oRL[outRL]);
+				//allpass filter R
+				
+				dRL[5] = dRL[4];
+				dRL[4] = inputSampleL;
+				inputSampleL = (dRL[1]+dRL[2])/2.0;
+				
+				allpasstemp = outSL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;}
+				inputSampleL -= oSL[allpasstemp]*constallpass;
+				oSL[outSL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outSL--; if (outSL < 0 || outSL > delayS) {outSL = delayS;}
+				inputSampleL += (oSL[outSL]);
+				//allpass filter S
+				
+				dSL[5] = dSL[4];
+				dSL[4] = inputSampleL;
+				inputSampleL = (dSL[1]+dSL[2])/2.0;
+				
+				allpasstemp = outTL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;}
+				inputSampleL -= oTL[allpasstemp]*constallpass;
+				oTL[outTL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outTL--; if (outTL < 0 || outTL > delayT) {outTL = delayT;}
+				inputSampleL += (oTL[outTL]);
+				//allpass filter T
+				
+				dTL[5] = dTL[4];
+				dTL[4] = inputSampleL;
+				inputSampleL = (dTL[1]+dTL[2])/2.0;
+				
+				allpasstemp = outUL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;}
+				inputSampleL -= oUL[allpasstemp]*constallpass;
+				oUL[outUL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outUL--; if (outUL < 0 || outUL > delayU) {outUL = delayU;}
+				inputSampleL += (oUL[outUL]);
+				//allpass filter U
+				
+				dUL[5] = dUL[4];
+				dUL[4] = inputSampleL;
+				inputSampleL = (dUL[1]+dUL[2])/2.0;
+				
+				allpasstemp = outVL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;}
+				inputSampleL -= oVL[allpasstemp]*constallpass;
+				oVL[outVL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outVL--; if (outVL < 0 || outVL > delayV) {outVL = delayV;}
+				inputSampleL += (oVL[outVL]);
+				//allpass filter V
+				
+				dVL[5] = dVL[4];
+				dVL[4] = inputSampleL;
+				inputSampleL = (dVL[1]+dVL[2])/2.0;
+				
+				allpasstemp = outWL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;}
+				inputSampleL -= oWL[allpasstemp]*constallpass;
+				oWL[outWL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outWL--; if (outWL < 0 || outWL > delayW) {outWL = delayW;}
+				inputSampleL += (oWL[outWL]);
+				//allpass filter W
+				
+				dWL[5] = dWL[4];
+				dWL[4] = inputSampleL;
+				inputSampleL = (dWL[1]+dWL[2])/2.0;
+				
+				allpasstemp = outXL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;}
+				inputSampleL -= oXL[allpasstemp]*constallpass;
+				oXL[outXL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outXL--; if (outXL < 0 || outXL > delayX) {outXL = delayX;}
+				inputSampleL += (oXL[outXL]);
+				//allpass filter X
+				
+				dXL[5] = dXL[4];
+				dXL[4] = inputSampleL;
+				inputSampleL = (dXL[1]+dXL[2])/2.0;
+				
+				allpasstemp = outYL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;}
+				inputSampleL -= oYL[allpasstemp]*constallpass;
+				oYL[outYL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outYL--; if (outYL < 0 || outYL > delayY) {outYL = delayY;}
+				inputSampleL += (oYL[outYL]);
+				//allpass filter Y
+				
+				dYL[5] = dYL[4];
+				dYL[4] = inputSampleL;
+				inputSampleL = (dYL[1]+dYL[2])/2.0;
+				
+				allpasstemp = outZL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;}
+				inputSampleL -= oZL[allpasstemp]*constallpass;
+				oZL[outZL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outZL--; if (outZL < 0 || outZL > delayZ) {outZL = delayZ;}
+				inputSampleL += (oZL[outZL]);
+				//allpass filter Z
+				
+				dZL[5] = dZL[4];
+				dZL[4] = inputSampleL;
+				inputSampleL = (dBL[4] * dryness);		
+				inputSampleL += (dCL[4] * dryness);		
+				inputSampleL += dDL[4];		
+				inputSampleL += dEL[4];		
+				inputSampleL += dFL[4];		
+				inputSampleL += dGL[4];		
+				inputSampleL += dHL[4];		
+				inputSampleL += dIL[4];		
+				inputSampleL += dJL[4];		
+				inputSampleL += dKL[4];		
+				inputSampleL += dLL[4];		
+				inputSampleL += dML[4];		
+				inputSampleL += dNL[4];		
+				inputSampleL += dOL[4];		
+				inputSampleL += dPL[4];		
+				inputSampleL += dQL[4];		
+				inputSampleL += dRL[4];		
+				inputSampleL += dSL[4];		
+				inputSampleL += dTL[4];		
+				inputSampleL += dUL[4];		
+				inputSampleL += dVL[4];		
+				inputSampleL += dWL[4];		
+				inputSampleL += dXL[4];		
+				inputSampleL += dYL[4];		
+				inputSampleL += (dZL[4] * wetness);
+				
+				inputSampleL += (dBL[5] * dryness);		
+				inputSampleL += (dCL[5] * dryness);		
+				inputSampleL += dDL[5];		
+				inputSampleL += dEL[5];		
+				inputSampleL += dFL[5];		
+				inputSampleL += dGL[5];		
+				inputSampleL += dHL[5];		
+				inputSampleL += dIL[5];		
+				inputSampleL += dJL[5];		
+				inputSampleL += dKL[5];		
+				inputSampleL += dLL[5];		
+				inputSampleL += dML[5];		
+				inputSampleL += dNL[5];		
+				inputSampleL += dOL[5];		
+				inputSampleL += dPL[5];		
+				inputSampleL += dQL[5];		
+				inputSampleL += dRL[5];		
+				inputSampleL += dSL[5];		
+				inputSampleL += dTL[5];		
+				inputSampleL += dUL[5];		
+				inputSampleL += dVL[5];		
+				inputSampleL += dWL[5];		
+				inputSampleL += dXL[5];		
+				inputSampleL += dYL[5];		
+				inputSampleL += (dZL[5] * wetness);
+				
+				inputSampleL /= (26.0 + (wetness * 4.0));
+				//output Room effect
+				break;
+				
+				
+				
+				
+				
+				
+			case 5:	//Stretch	
+				allpasstemp = alpAL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;}
+				inputSampleL -= aAL[allpasstemp]*constallpass;
+				aAL[alpAL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpAL--; if (alpAL < 0 || alpAL > delayA) {alpAL = delayA;}
+				inputSampleL += (aAL[alpAL]);
+				//allpass filter A		
+				
+				dAL[2] = dAL[1];
+				dAL[1] = inputSampleL;
+				inputSampleL = (dAL[1] + dAL[2])/2.0;
+				
+				allpasstemp = alpBL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;}
+				inputSampleL -= aBL[allpasstemp]*constallpass;
+				aBL[alpBL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpBL--; if (alpBL < 0 || alpBL > delayB) {alpBL = delayB;}
+				inputSampleL += (aBL[alpBL]);
+				//allpass filter B
+				
+				dBL[2] = dBL[1];
+				dBL[1] = inputSampleL;
+				inputSampleL = (dBL[1] + dBL[2])/2.0;
+				
+				allpasstemp = alpCL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;}
+				inputSampleL -= aCL[allpasstemp]*constallpass;
+				aCL[alpCL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpCL--; if (alpCL < 0 || alpCL > delayC) {alpCL = delayC;}
+				inputSampleL += (aCL[alpCL]);
+				//allpass filter C
+				
+				dCL[2] = dCL[1];
+				dCL[1] = inputSampleL;
+				inputSampleL = (dCL[1] + dCL[2])/2.0;
+				
+				allpasstemp = alpDL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;}
+				inputSampleL -= aDL[allpasstemp]*constallpass;
+				aDL[alpDL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpDL--; if (alpDL < 0 || alpDL > delayD) {alpDL = delayD;}
+				inputSampleL += (aDL[alpDL]);
+				//allpass filter D
+				
+				dDL[2] = dDL[1];
+				dDL[1] = inputSampleL;
+				inputSampleL = (dDL[1] + dDL[2])/2.0;
+				
+				allpasstemp = alpEL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;}
+				inputSampleL -= aEL[allpasstemp]*constallpass;
+				aEL[alpEL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpEL--; if (alpEL < 0 || alpEL > delayE) {alpEL = delayE;}
+				inputSampleL += (aEL[alpEL]);
+				//allpass filter E
+				
+				dEL[2] = dEL[1];
+				dEL[1] = inputSampleL;
+				inputSampleL = (dEL[1] + dEL[2])/2.0;
+				
+				allpasstemp = alpFL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;}
+				inputSampleL -= aFL[allpasstemp]*constallpass;
+				aFL[alpFL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpFL--; if (alpFL < 0 || alpFL > delayF) {alpFL = delayF;}
+				inputSampleL += (aFL[alpFL]);
+				//allpass filter F
+				
+				dFL[2] = dFL[1];
+				dFL[1] = inputSampleL;
+				inputSampleL = (dFL[1] + dFL[2])/2.0;
+				
+				allpasstemp = alpGL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;}
+				inputSampleL -= aGL[allpasstemp]*constallpass;
+				aGL[alpGL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpGL--; if (alpGL < 0 || alpGL > delayG) {alpGL = delayG;}
+				inputSampleL += (aGL[alpGL]);
+				//allpass filter G
+				
+				dGL[2] = dGL[1];
+				dGL[1] = inputSampleL;
+				inputSampleL = (dGL[1] + dGL[2])/2.0;
+				
+				allpasstemp = alpHL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;}
+				inputSampleL -= aHL[allpasstemp]*constallpass;
+				aHL[alpHL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpHL--; if (alpHL < 0 || alpHL > delayH) {alpHL = delayH;}
+				inputSampleL += (aHL[alpHL]);
+				//allpass filter H
+				
+				dHL[2] = dHL[1];
+				dHL[1] = inputSampleL;
+				inputSampleL = (dHL[1] + dHL[2])/2.0;
+				
+				allpasstemp = alpIL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;}
+				inputSampleL -= aIL[allpasstemp]*constallpass;
+				aIL[alpIL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpIL--; if (alpIL < 0 || alpIL > delayI) {alpIL = delayI;}
+				inputSampleL += (aIL[alpIL]);
+				//allpass filter I
+				
+				dIL[2] = dIL[1];
+				dIL[1] = inputSampleL;
+				inputSampleL = (dIL[1] + dIL[2])/2.0;
+				
+				allpasstemp = alpJL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;}
+				inputSampleL -= aJL[allpasstemp]*constallpass;
+				aJL[alpJL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpJL--; if (alpJL < 0 || alpJL > delayJ) {alpJL = delayJ;}
+				inputSampleL += (aJL[alpJL]);
+				//allpass filter J
+				
+				dJL[2] = dJL[1];
+				dJL[1] = inputSampleL;
+				inputSampleL = (dJL[1] + dJL[2])/2.0;
+				
+				allpasstemp = alpKL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;}
+				inputSampleL -= aKL[allpasstemp]*constallpass;
+				aKL[alpKL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpKL--; if (alpKL < 0 || alpKL > delayK) {alpKL = delayK;}
+				inputSampleL += (aKL[alpKL]);
+				//allpass filter K
+				
+				dKL[2] = dKL[1];
+				dKL[1] = inputSampleL;
+				inputSampleL = (dKL[1] + dKL[2])/2.0;
+				
+				allpasstemp = alpLL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;}
+				inputSampleL -= aLL[allpasstemp]*constallpass;
+				aLL[alpLL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpLL--; if (alpLL < 0 || alpLL > delayL) {alpLL = delayL;}
+				inputSampleL += (aLL[alpLL]);
+				//allpass filter L
+				
+				dLL[2] = dLL[1];
+				dLL[1] = inputSampleL;
+				inputSampleL = (dLL[1] + dLL[2])/2.0;
+				
+				allpasstemp = alpML - 1;
+				if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;}
+				inputSampleL -= aML[allpasstemp]*constallpass;
+				aML[alpML] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpML--; if (alpML < 0 || alpML > delayM) {alpML = delayM;}
+				inputSampleL += (aML[alpML]);
+				//allpass filter M
+				
+				dML[2] = dML[1];
+				dML[1] = inputSampleL;
+				inputSampleL = (dML[1] + dML[2])/2.0;
+				
+				allpasstemp = alpNL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;}
+				inputSampleL -= aNL[allpasstemp]*constallpass;
+				aNL[alpNL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpNL--; if (alpNL < 0 || alpNL > delayN) {alpNL = delayN;}
+				inputSampleL += (aNL[alpNL]);
+				//allpass filter N
+				
+				dNL[2] = dNL[1];
+				dNL[1] = inputSampleL;
+				inputSampleL = (dNL[1] + dNL[2])/2.0;
+				
+				allpasstemp = alpOL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;}
+				inputSampleL -= aOL[allpasstemp]*constallpass;
+				aOL[alpOL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpOL--; if (alpOL < 0 || alpOL > delayO) {alpOL = delayO;}
+				inputSampleL += (aOL[alpOL]);
+				//allpass filter O
+				
+				dOL[2] = dOL[1];
+				dOL[1] = inputSampleL;
+				inputSampleL = (dOL[1] + dOL[2])/2.0;
+				
+				allpasstemp = alpPL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;}
+				inputSampleL -= aPL[allpasstemp]*constallpass;
+				aPL[alpPL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpPL--; if (alpPL < 0 || alpPL > delayP) {alpPL = delayP;}
+				inputSampleL += (aPL[alpPL]);
+				//allpass filter P
+				
+				dPL[2] = dPL[1];
+				dPL[1] = inputSampleL;
+				inputSampleL = (dPL[1] + dPL[2])/2.0;
+				
+				allpasstemp = alpQL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;}
+				inputSampleL -= aQL[allpasstemp]*constallpass;
+				aQL[alpQL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpQL--; if (alpQL < 0 || alpQL > delayQ) {alpQL = delayQ;}
+				inputSampleL += (aQL[alpQL]);
+				//allpass filter Q
+				
+				dQL[2] = dQL[1];
+				dQL[1] = inputSampleL;
+				inputSampleL = (dQL[1] + dQL[2])/2.0;
+				
+				allpasstemp = alpRL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;}
+				inputSampleL -= aRL[allpasstemp]*constallpass;
+				aRL[alpRL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpRL--; if (alpRL < 0 || alpRL > delayR) {alpRL = delayR;}
+				inputSampleL += (aRL[alpRL]);
+				//allpass filter R
+				
+				dRL[2] = dRL[1];
+				dRL[1] = inputSampleL;
+				inputSampleL = (dRL[1] + dRL[2])/2.0;
+				
+				allpasstemp = alpSL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;}
+				inputSampleL -= aSL[allpasstemp]*constallpass;
+				aSL[alpSL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpSL--; if (alpSL < 0 || alpSL > delayS) {alpSL = delayS;}
+				inputSampleL += (aSL[alpSL]);
+				//allpass filter S
+				
+				dSL[2] = dSL[1];
+				dSL[1] = inputSampleL;
+				inputSampleL = (dSL[1] + dSL[2])/2.0;
+				
+				allpasstemp = alpTL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;}
+				inputSampleL -= aTL[allpasstemp]*constallpass;
+				aTL[alpTL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpTL--; if (alpTL < 0 || alpTL > delayT) {alpTL = delayT;}
+				inputSampleL += (aTL[alpTL]);
+				//allpass filter T
+				
+				dTL[2] = dTL[1];
+				dTL[1] = inputSampleL;
+				inputSampleL = (dTL[1] + dTL[2])/2.0;
+				
+				allpasstemp = alpUL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;}
+				inputSampleL -= aUL[allpasstemp]*constallpass;
+				aUL[alpUL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpUL--; if (alpUL < 0 || alpUL > delayU) {alpUL = delayU;}
+				inputSampleL += (aUL[alpUL]);
+				//allpass filter U
+				
+				dUL[2] = dUL[1];
+				dUL[1] = inputSampleL;
+				inputSampleL = (dUL[1] + dUL[2])/2.0;
+				
+				allpasstemp = alpVL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;}
+				inputSampleL -= aVL[allpasstemp]*constallpass;
+				aVL[alpVL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpVL--; if (alpVL < 0 || alpVL > delayV) {alpVL = delayV;}
+				inputSampleL += (aVL[alpVL]);
+				//allpass filter V
+				
+				dVL[2] = dVL[1];
+				dVL[1] = inputSampleL;
+				inputSampleL = (dVL[1] + dVL[2])/2.0;
+				
+				allpasstemp = alpWL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;}
+				inputSampleL -= aWL[allpasstemp]*constallpass;
+				aWL[alpWL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpWL--; if (alpWL < 0 || alpWL > delayW) {alpWL = delayW;}
+				inputSampleL += (aWL[alpWL]);
+				//allpass filter W
+				
+				dWL[2] = dWL[1];
+				dWL[1] = inputSampleL;
+				inputSampleL = (dWL[1] + dWL[2])/2.0;
+				
+				allpasstemp = alpXL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;}
+				inputSampleL -= aXL[allpasstemp]*constallpass;
+				aXL[alpXL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpXL--; if (alpXL < 0 || alpXL > delayX) {alpXL = delayX;}
+				inputSampleL += (aXL[alpXL]);
+				//allpass filter X
+				
+				dXL[2] = dXL[1];
+				dXL[1] = inputSampleL;
+				inputSampleL = (dXL[1] + dXL[2])/2.0;
+				
+				allpasstemp = alpYL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;}
+				inputSampleL -= aYL[allpasstemp]*constallpass;
+				aYL[alpYL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpYL--; if (alpYL < 0 || alpYL > delayY) {alpYL = delayY;}
+				inputSampleL += (aYL[alpYL]);
+				//allpass filter Y
+				
+				dYL[2] = dYL[1];
+				dYL[1] = inputSampleL;
+				inputSampleL = (dYL[1] + dYL[2])/2.0;
+				
+				allpasstemp = alpZL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;}
+				inputSampleL -= aZL[allpasstemp]*constallpass;
+				aZL[alpZL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpZL--; if (alpZL < 0 || alpZL > delayZ) {alpZL = delayZ;}
+				inputSampleL += (aZL[alpZL]);
+				//allpass filter Z
+				
+				dZL[2] = dZL[1];
+				dZL[1] = inputSampleL;
+				inputSampleL = (dZL[1] + dZL[2])/2.0;
+				
+				// now the second stage using the 'out' bank of allpasses		
+				
+				allpasstemp = outAL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;}
+				inputSampleL -= oAL[allpasstemp]*constallpass;
+				oAL[outAL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outAL--; if (outAL < 0 || outAL > delayA) {outAL = delayA;}
+				inputSampleL += (oAL[outAL]);
+				//allpass filter A		
+				
+				dAL[5] = dAL[4];
+				dAL[4] = inputSampleL;
+				inputSampleL = (dAL[4] + dAL[5])/2.0;
+				
+				allpasstemp = outBL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;}
+				inputSampleL -= oBL[allpasstemp]*constallpass;
+				oBL[outBL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outBL--; if (outBL < 0 || outBL > delayB) {outBL = delayB;}
+				inputSampleL += (oBL[outBL]);
+				//allpass filter B
+				
+				dBL[5] = dBL[4];
+				dBL[4] = inputSampleL;
+				inputSampleL = (dBL[4] + dBL[5])/2.0;
+				
+				allpasstemp = outCL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;}
+				inputSampleL -= oCL[allpasstemp]*constallpass;
+				oCL[outCL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outCL--; if (outCL < 0 || outCL > delayC) {outCL = delayC;}
+				inputSampleL += (oCL[outCL]);
+				//allpass filter C
+				
+				dCL[5] = dCL[4];
+				dCL[4] = inputSampleL;
+				inputSampleL = (dCL[4] + dCL[5])/2.0;
+				
+				allpasstemp = outDL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;}
+				inputSampleL -= oDL[allpasstemp]*constallpass;
+				oDL[outDL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outDL--; if (outDL < 0 || outDL > delayD) {outDL = delayD;}
+				inputSampleL += (oDL[outDL]);
+				//allpass filter D
+				
+				dDL[5] = dDL[4];
+				dDL[4] = inputSampleL;
+				inputSampleL = (dDL[4] + dDL[5])/2.0;
+				
+				allpasstemp = outEL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;}
+				inputSampleL -= oEL[allpasstemp]*constallpass;
+				oEL[outEL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outEL--; if (outEL < 0 || outEL > delayE) {outEL = delayE;}
+				inputSampleL += (oEL[outEL]);
+				//allpass filter E
+				
+				dEL[5] = dEL[4];
+				dEL[4] = inputSampleL;
+				inputSampleL = (dEL[4] + dEL[5])/2.0;
+				
+				allpasstemp = outFL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;}
+				inputSampleL -= oFL[allpasstemp]*constallpass;
+				oFL[outFL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outFL--; if (outFL < 0 || outFL > delayF) {outFL = delayF;}
+				inputSampleL += (oFL[outFL]);
+				//allpass filter F
+				
+				dFL[5] = dFL[4];
+				dFL[4] = inputSampleL;
+				inputSampleL = (dFL[4] + dFL[5])/2.0;
+				
+				allpasstemp = outGL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;}
+				inputSampleL -= oGL[allpasstemp]*constallpass;
+				oGL[outGL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outGL--; if (outGL < 0 || outGL > delayG) {outGL = delayG;}
+				inputSampleL += (oGL[outGL]);
+				//allpass filter G
+				
+				dGL[5] = dGL[4];
+				dGL[4] = inputSampleL;
+				inputSampleL = (dGL[4] + dGL[5])/2.0;
+				
+				allpasstemp = outHL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;}
+				inputSampleL -= oHL[allpasstemp]*constallpass;
+				oHL[outHL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outHL--; if (outHL < 0 || outHL > delayH) {outHL = delayH;}
+				inputSampleL += (oHL[outHL]);
+				//allpass filter H
+				
+				dHL[5] = dHL[4];
+				dHL[4] = inputSampleL;
+				inputSampleL = (dHL[4] + dHL[5])/2.0;
+				
+				allpasstemp = outIL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;}
+				inputSampleL -= oIL[allpasstemp]*constallpass;
+				oIL[outIL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outIL--; if (outIL < 0 || outIL > delayI) {outIL = delayI;}
+				inputSampleL += (oIL[outIL]);
+				//allpass filter I
+				
+				dIL[5] = dIL[4];
+				dIL[4] = inputSampleL;
+				inputSampleL = (dIL[4] + dIL[5])/2.0;
+				
+				allpasstemp = outJL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;}
+				inputSampleL -= oJL[allpasstemp]*constallpass;
+				oJL[outJL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outJL--; if (outJL < 0 || outJL > delayJ) {outJL = delayJ;}
+				inputSampleL += (oJL[outJL]);
+				//allpass filter J
+				
+				dJL[5] = dJL[4];
+				dJL[4] = inputSampleL;
+				inputSampleL = (dJL[4] + dJL[5])/2.0;
+				
+				allpasstemp = outKL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;}
+				inputSampleL -= oKL[allpasstemp]*constallpass;
+				oKL[outKL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outKL--; if (outKL < 0 || outKL > delayK) {outKL = delayK;}
+				inputSampleL += (oKL[outKL]);
+				//allpass filter K
+				
+				dKL[5] = dKL[4];
+				dKL[4] = inputSampleL;
+				inputSampleL = (dKL[4] + dKL[5])/2.0;
+				
+				allpasstemp = outLL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;}
+				inputSampleL -= oLL[allpasstemp]*constallpass;
+				oLL[outLL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outLL--; if (outLL < 0 || outLL > delayL) {outLL = delayL;}
+				inputSampleL += (oLL[outLL]);
+				//allpass filter L
+				
+				dLL[5] = dLL[4];
+				dLL[4] = inputSampleL;
+				inputSampleL = (dLL[4] + dLL[5])/2.0;
+				
+				allpasstemp = outML - 1;
+				if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;}
+				inputSampleL -= oML[allpasstemp]*constallpass;
+				oML[outML] = inputSampleL;
+				inputSampleL *= constallpass;
+				outML--; if (outML < 0 || outML > delayM) {outML = delayM;}
+				inputSampleL += (oML[outML]);
+				//allpass filter M
+				
+				dML[5] = dML[4];
+				dML[4] = inputSampleL;
+				inputSampleL = (dML[4] + dML[5])/2.0;
+				
+				allpasstemp = outNL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;}
+				inputSampleL -= oNL[allpasstemp]*constallpass;
+				oNL[outNL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outNL--; if (outNL < 0 || outNL > delayN) {outNL = delayN;}
+				inputSampleL += (oNL[outNL]);
+				//allpass filter N
+				
+				dNL[5] = dNL[4];
+				dNL[4] = inputSampleL;
+				inputSampleL = (dNL[4] + dNL[5])/2.0;
+				
+				allpasstemp = outOL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;}
+				inputSampleL -= oOL[allpasstemp]*constallpass;
+				oOL[outOL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outOL--; if (outOL < 0 || outOL > delayO) {outOL = delayO;}
+				inputSampleL += (oOL[outOL]);
+				//allpass filter O
+				
+				dOL[5] = dOL[4];
+				dOL[4] = inputSampleL;
+				inputSampleL = (dOL[4] + dOL[5])/2.0;
+				
+				allpasstemp = outPL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;}
+				inputSampleL -= oPL[allpasstemp]*constallpass;
+				oPL[outPL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outPL--; if (outPL < 0 || outPL > delayP) {outPL = delayP;}
+				inputSampleL += (oPL[outPL]);
+				//allpass filter P
+				
+				dPL[5] = dPL[4];
+				dPL[4] = inputSampleL;
+				inputSampleL = (dPL[4] + dPL[5])/2.0;
+				
+				allpasstemp = outQL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;}
+				inputSampleL -= oQL[allpasstemp]*constallpass;
+				oQL[outQL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outQL--; if (outQL < 0 || outQL > delayQ) {outQL = delayQ;}
+				inputSampleL += (oQL[outQL]);
+				//allpass filter Q
+				
+				dQL[5] = dQL[4];
+				dQL[4] = inputSampleL;
+				inputSampleL = (dQL[4] + dQL[5])/2.0;
+				
+				allpasstemp = outRL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;}
+				inputSampleL -= oRL[allpasstemp]*constallpass;
+				oRL[outRL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outRL--; if (outRL < 0 || outRL > delayR) {outRL = delayR;}
+				inputSampleL += (oRL[outRL]);
+				//allpass filter R
+				
+				dRL[5] = dRL[4];
+				dRL[4] = inputSampleL;
+				inputSampleL = (dRL[4] + dRL[5])/2.0;
+				
+				allpasstemp = outSL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;}
+				inputSampleL -= oSL[allpasstemp]*constallpass;
+				oSL[outSL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outSL--; if (outSL < 0 || outSL > delayS) {outSL = delayS;}
+				inputSampleL += (oSL[outSL]);
+				//allpass filter S
+				
+				dSL[5] = dSL[4];
+				dSL[4] = inputSampleL;
+				inputSampleL = (dSL[4] + dSL[5])/2.0;
+				
+				allpasstemp = outTL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;}
+				inputSampleL -= oTL[allpasstemp]*constallpass;
+				oTL[outTL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outTL--; if (outTL < 0 || outTL > delayT) {outTL = delayT;}
+				inputSampleL += (oTL[outTL]);
+				//allpass filter T
+				
+				dTL[5] = dTL[4];
+				dTL[4] = inputSampleL;
+				inputSampleL = (dTL[4] + dTL[5])/2.0;
+				
+				allpasstemp = outUL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;}
+				inputSampleL -= oUL[allpasstemp]*constallpass;
+				oUL[outUL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outUL--; if (outUL < 0 || outUL > delayU) {outUL = delayU;}
+				inputSampleL += (oUL[outUL]);
+				//allpass filter U
+				
+				dUL[5] = dUL[4];
+				dUL[4] = inputSampleL;
+				inputSampleL = (dUL[4] + dUL[5])/2.0;
+				
+				allpasstemp = outVL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;}
+				inputSampleL -= oVL[allpasstemp]*constallpass;
+				oVL[outVL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outVL--; if (outVL < 0 || outVL > delayV) {outVL = delayV;}
+				inputSampleL += (oVL[outVL]);
+				//allpass filter V
+				
+				dVL[5] = dVL[4];
+				dVL[4] = inputSampleL;
+				inputSampleL = (dVL[4] + dVL[5])/2.0;
+				
+				allpasstemp = outWL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;}
+				inputSampleL -= oWL[allpasstemp]*constallpass;
+				oWL[outWL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outWL--; if (outWL < 0 || outWL > delayW) {outWL = delayW;}
+				inputSampleL += (oWL[outWL]);
+				//allpass filter W
+				
+				dWL[5] = dWL[4];
+				dWL[4] = inputSampleL;
+				inputSampleL = (dWL[4] + dWL[5])/2.0;
+				
+				allpasstemp = outXL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;}
+				inputSampleL -= oXL[allpasstemp]*constallpass;
+				oXL[outXL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outXL--; if (outXL < 0 || outXL > delayX) {outXL = delayX;}
+				inputSampleL += (oXL[outXL]);
+				//allpass filter X
+				
+				dXL[5] = dXL[4];
+				dXL[4] = inputSampleL;
+				inputSampleL = (dXL[4] + dXL[5])/2.0;
+				
+				allpasstemp = outYL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;}
+				inputSampleL -= oYL[allpasstemp]*constallpass;
+				oYL[outYL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outYL--; if (outYL < 0 || outYL > delayY) {outYL = delayY;}
+				inputSampleL += (oYL[outYL]);
+				//allpass filter Y
+				
+				dYL[5] = dYL[4];
+				dYL[4] = inputSampleL;
+				inputSampleL = (dYL[4] + dYL[5])/2.0;
+				
+				allpasstemp = outZL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;}
+				inputSampleL -= oZL[allpasstemp]*constallpass;
+				oZL[outZL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outZL--; if (outZL < 0 || outZL > delayZ) {outZL = delayZ;}
+				inputSampleL += (oZL[outZL]);
+				//allpass filter Z
+				
+				dZL[5] = dZL[4];
+				dZL[4] = inputSampleL;
+				inputSampleL = (dZL[4] + dZL[5])/2.0;		
+				//output Stretch unrealistic but smooth fake Paulstretch
+				break;				
+				
+				
+			case 6:	//Zarathustra	
+				allpasstemp = alpAL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;}
+				inputSampleL -= aAL[allpasstemp]*constallpass;
+				aAL[alpAL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpAL--; if (alpAL < 0 || alpAL > delayA) {alpAL = delayA;}
+				inputSampleL += (aAL[alpAL]);
+				//allpass filter A		
+				
+				dAL[3] = dAL[2];
+				dAL[2] = dAL[1];
+				dAL[1] = inputSampleL;
+				inputSampleL = (dAL[1] + dAL[2] + dZL[3])/3.0; //add feedback
+				
+				allpasstemp = alpBL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;}
+				inputSampleL -= aBL[allpasstemp]*constallpass;
+				aBL[alpBL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpBL--; if (alpBL < 0 || alpBL > delayB) {alpBL = delayB;}
+				inputSampleL += (aBL[alpBL]);
+				//allpass filter B
+				
+				dBL[3] = dBL[2];
+				dBL[2] = dBL[1];
+				dBL[1] = inputSampleL;
+				inputSampleL = (dBL[1] + dBL[2] + dBL[3])/3.0;
+				
+				allpasstemp = alpCL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;}
+				inputSampleL -= aCL[allpasstemp]*constallpass;
+				aCL[alpCL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpCL--; if (alpCL < 0 || alpCL > delayC) {alpCL = delayC;}
+				inputSampleL += (aCL[alpCL]);
+				//allpass filter C
+				
+				dCL[3] = dCL[2];
+				dCL[2] = dCL[1];
+				dCL[1] = inputSampleL;
+				inputSampleL = (dCL[1] + dCL[2] + dCL[3])/3.0;
+				
+				allpasstemp = alpDL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;}
+				inputSampleL -= aDL[allpasstemp]*constallpass;
+				aDL[alpDL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpDL--; if (alpDL < 0 || alpDL > delayD) {alpDL = delayD;}
+				inputSampleL += (aDL[alpDL]);
+				//allpass filter D
+				
+				dDL[3] = dDL[2];
+				dDL[2] = dDL[1];
+				dDL[1] = inputSampleL;
+				inputSampleL = (dDL[1] + dDL[2] + dDL[3])/3.0;
+				
+				allpasstemp = alpEL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;}
+				inputSampleL -= aEL[allpasstemp]*constallpass;
+				aEL[alpEL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpEL--; if (alpEL < 0 || alpEL > delayE) {alpEL = delayE;}
+				inputSampleL += (aEL[alpEL]);
+				//allpass filter E
+				
+				dEL[3] = dEL[2];
+				dEL[2] = dEL[1];
+				dEL[1] = inputSampleL;
+				inputSampleL = (dEL[1] + dEL[2] + dEL[3])/3.0;
+				
+				allpasstemp = alpFL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;}
+				inputSampleL -= aFL[allpasstemp]*constallpass;
+				aFL[alpFL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpFL--; if (alpFL < 0 || alpFL > delayF) {alpFL = delayF;}
+				inputSampleL += (aFL[alpFL]);
+				//allpass filter F
+				
+				dFL[3] = dFL[2];
+				dFL[2] = dFL[1];
+				dFL[1] = inputSampleL;
+				inputSampleL = (dFL[1] + dFL[2] + dFL[3])/3.0;
+				
+				allpasstemp = alpGL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;}
+				inputSampleL -= aGL[allpasstemp]*constallpass;
+				aGL[alpGL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpGL--; if (alpGL < 0 || alpGL > delayG) {alpGL = delayG;}
+				inputSampleL += (aGL[alpGL]);
+				//allpass filter G
+				
+				dGL[3] = dGL[2];
+				dGL[2] = dGL[1];
+				dGL[1] = inputSampleL;
+				inputSampleL = (dGL[1] + dGL[2] + dGL[3])/3.0;
+				
+				allpasstemp = alpHL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;}
+				inputSampleL -= aHL[allpasstemp]*constallpass;
+				aHL[alpHL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpHL--; if (alpHL < 0 || alpHL > delayH) {alpHL = delayH;}
+				inputSampleL += (aHL[alpHL]);
+				//allpass filter H
+				
+				dHL[3] = dHL[2];
+				dHL[2] = dHL[1];
+				dHL[1] = inputSampleL;
+				inputSampleL = (dHL[1] + dHL[2] + dHL[3])/3.0;
+				
+				allpasstemp = alpIL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;}
+				inputSampleL -= aIL[allpasstemp]*constallpass;
+				aIL[alpIL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpIL--; if (alpIL < 0 || alpIL > delayI) {alpIL = delayI;}
+				inputSampleL += (aIL[alpIL]);
+				//allpass filter I
+				
+				dIL[3] = dIL[2];
+				dIL[2] = dIL[1];
+				dIL[1] = inputSampleL;
+				inputSampleL = (dIL[1] + dIL[2] + dIL[3])/3.0;
+				
+				allpasstemp = alpJL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;}
+				inputSampleL -= aJL[allpasstemp]*constallpass;
+				aJL[alpJL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpJL--; if (alpJL < 0 || alpJL > delayJ) {alpJL = delayJ;}
+				inputSampleL += (aJL[alpJL]);
+				//allpass filter J
+				
+				dJL[3] = dJL[2];
+				dJL[2] = dJL[1];
+				dJL[1] = inputSampleL;
+				inputSampleL = (dJL[1] + dJL[2] + dJL[3])/3.0;
+				
+				allpasstemp = alpKL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;}
+				inputSampleL -= aKL[allpasstemp]*constallpass;
+				aKL[alpKL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpKL--; if (alpKL < 0 || alpKL > delayK) {alpKL = delayK;}
+				inputSampleL += (aKL[alpKL]);
+				//allpass filter K
+				
+				dKL[3] = dKL[2];
+				dKL[2] = dKL[1];
+				dKL[1] = inputSampleL;
+				inputSampleL = (dKL[1] + dKL[2] + dKL[3])/3.0;
+				
+				allpasstemp = alpLL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;}
+				inputSampleL -= aLL[allpasstemp]*constallpass;
+				aLL[alpLL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpLL--; if (alpLL < 0 || alpLL > delayL) {alpLL = delayL;}
+				inputSampleL += (aLL[alpLL]);
+				//allpass filter L
+				
+				dLL[3] = dLL[2];
+				dLL[2] = dLL[1];
+				dLL[1] = inputSampleL;
+				inputSampleL = (dLL[1] + dLL[2] + dLL[3])/3.0;
+				
+				allpasstemp = alpML - 1;
+				if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;}
+				inputSampleL -= aML[allpasstemp]*constallpass;
+				aML[alpML] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpML--; if (alpML < 0 || alpML > delayM) {alpML = delayM;}
+				inputSampleL += (aML[alpML]);
+				//allpass filter M
+				
+				dML[3] = dML[2];
+				dML[2] = dML[1];
+				dML[1] = inputSampleL;
+				inputSampleL = (dML[1] + dML[2] + dML[3])/3.0;
+				
+				allpasstemp = alpNL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;}
+				inputSampleL -= aNL[allpasstemp]*constallpass;
+				aNL[alpNL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpNL--; if (alpNL < 0 || alpNL > delayN) {alpNL = delayN;}
+				inputSampleL += (aNL[alpNL]);
+				//allpass filter N
+				
+				dNL[3] = dNL[2];
+				dNL[2] = dNL[1];
+				dNL[1] = inputSampleL;
+				inputSampleL = (dNL[1] + dNL[2] + dNL[3])/3.0;
+				
+				allpasstemp = alpOL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;}
+				inputSampleL -= aOL[allpasstemp]*constallpass;
+				aOL[alpOL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpOL--; if (alpOL < 0 || alpOL > delayO) {alpOL = delayO;}
+				inputSampleL += (aOL[alpOL]);
+				//allpass filter O
+				
+				dOL[3] = dOL[2];
+				dOL[2] = dOL[1];
+				dOL[1] = inputSampleL;
+				inputSampleL = (dOL[1] + dOL[2] + dOL[3])/3.0;
+				
+				allpasstemp = alpPL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;}
+				inputSampleL -= aPL[allpasstemp]*constallpass;
+				aPL[alpPL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpPL--; if (alpPL < 0 || alpPL > delayP) {alpPL = delayP;}
+				inputSampleL += (aPL[alpPL]);
+				//allpass filter P
+				
+				dPL[3] = dPL[2];
+				dPL[2] = dPL[1];
+				dPL[1] = inputSampleL;
+				inputSampleL = (dPL[1] + dPL[2] + dPL[3])/3.0;
+				
+				allpasstemp = alpQL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;}
+				inputSampleL -= aQL[allpasstemp]*constallpass;
+				aQL[alpQL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpQL--; if (alpQL < 0 || alpQL > delayQ) {alpQL = delayQ;}
+				inputSampleL += (aQL[alpQL]);
+				//allpass filter Q
+				
+				dQL[3] = dQL[2];
+				dQL[2] = dQL[1];
+				dQL[1] = inputSampleL;
+				inputSampleL = (dQL[1] + dQL[2] + dQL[3])/3.0;
+				
+				allpasstemp = alpRL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;}
+				inputSampleL -= aRL[allpasstemp]*constallpass;
+				aRL[alpRL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpRL--; if (alpRL < 0 || alpRL > delayR) {alpRL = delayR;}
+				inputSampleL += (aRL[alpRL]);
+				//allpass filter R
+				
+				dRL[3] = dRL[2];
+				dRL[2] = dRL[1];
+				dRL[1] = inputSampleL;
+				inputSampleL = (dRL[1] + dRL[2] + dRL[3])/3.0;
+				
+				allpasstemp = alpSL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;}
+				inputSampleL -= aSL[allpasstemp]*constallpass;
+				aSL[alpSL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpSL--; if (alpSL < 0 || alpSL > delayS) {alpSL = delayS;}
+				inputSampleL += (aSL[alpSL]);
+				//allpass filter S
+				
+				dSL[3] = dSL[2];
+				dSL[2] = dSL[1];
+				dSL[1] = inputSampleL;
+				inputSampleL = (dSL[1] + dSL[2] + dSL[3])/3.0;
+				
+				allpasstemp = alpTL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;}
+				inputSampleL -= aTL[allpasstemp]*constallpass;
+				aTL[alpTL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpTL--; if (alpTL < 0 || alpTL > delayT) {alpTL = delayT;}
+				inputSampleL += (aTL[alpTL]);
+				//allpass filter T
+				
+				dTL[3] = dTL[2];
+				dTL[2] = dTL[1];
+				dTL[1] = inputSampleL;
+				inputSampleL = (dTL[1] + dTL[2] + dTL[3])/3.0;
+				
+				allpasstemp = alpUL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;}
+				inputSampleL -= aUL[allpasstemp]*constallpass;
+				aUL[alpUL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpUL--; if (alpUL < 0 || alpUL > delayU) {alpUL = delayU;}
+				inputSampleL += (aUL[alpUL]);
+				//allpass filter U
+				
+				dUL[3] = dUL[2];
+				dUL[2] = dUL[1];
+				dUL[1] = inputSampleL;
+				inputSampleL = (dUL[1] + dUL[2] + dUL[3])/3.0;
+				
+				allpasstemp = alpVL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;}
+				inputSampleL -= aVL[allpasstemp]*constallpass;
+				aVL[alpVL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpVL--; if (alpVL < 0 || alpVL > delayV) {alpVL = delayV;}
+				inputSampleL += (aVL[alpVL]);
+				//allpass filter V
+				
+				dVL[3] = dVL[2];
+				dVL[2] = dVL[1];
+				dVL[1] = inputSampleL;
+				inputSampleL = (dVL[1] + dVL[2] + dVL[3])/3.0;
+				
+				allpasstemp = alpWL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;}
+				inputSampleL -= aWL[allpasstemp]*constallpass;
+				aWL[alpWL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpWL--; if (alpWL < 0 || alpWL > delayW) {alpWL = delayW;}
+				inputSampleL += (aWL[alpWL]);
+				//allpass filter W
+				
+				dWL[3] = dWL[2];
+				dWL[2] = dWL[1];
+				dWL[1] = inputSampleL;
+				inputSampleL = (dWL[1] + dWL[2] + dWL[3])/3.0;
+				
+				allpasstemp = alpXL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;}
+				inputSampleL -= aXL[allpasstemp]*constallpass;
+				aXL[alpXL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpXL--; if (alpXL < 0 || alpXL > delayX) {alpXL = delayX;}
+				inputSampleL += (aXL[alpXL]);
+				//allpass filter X
+				
+				dXL[3] = dXL[2];
+				dXL[2] = dXL[1];
+				dXL[1] = inputSampleL;
+				inputSampleL = (dXL[1] + dXL[2] + dXL[3])/3.0;
+				
+				allpasstemp = alpYL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;}
+				inputSampleL -= aYL[allpasstemp]*constallpass;
+				aYL[alpYL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpYL--; if (alpYL < 0 || alpYL > delayY) {alpYL = delayY;}
+				inputSampleL += (aYL[alpYL]);
+				//allpass filter Y
+				
+				dYL[3] = dYL[2];
+				dYL[2] = dYL[1];
+				dYL[1] = inputSampleL;
+				inputSampleL = (dYL[1] + dYL[2] + dYL[3])/3.0;
+				
+				allpasstemp = alpZL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;}
+				inputSampleL -= aZL[allpasstemp]*constallpass;
+				aZL[alpZL] = inputSampleL;
+				inputSampleL *= constallpass;
+				alpZL--; if (alpZL < 0 || alpZL > delayZ) {alpZL = delayZ;}
+				inputSampleL += (aZL[alpZL]);
+				//allpass filter Z
+				
+				dZL[3] = dZL[2];
+				dZL[2] = dZL[1];
+				dZL[1] = inputSampleL;
+				inputSampleL = (dZL[1] + dZL[2] + dZL[3])/3.0;
+				
+				// now the second stage using the 'out' bank of allpasses		
+				
+				allpasstemp = outAL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;}
+				inputSampleL -= oAL[allpasstemp]*constallpass;
+				oAL[outAL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outAL--; if (outAL < 0 || outAL > delayA) {outAL = delayA;}
+				inputSampleL += (oAL[outAL]);
+				//allpass filter A		
+				
+				dAL[6] = dAL[5];
+				dAL[5] = dAL[4];
+				dAL[4] = inputSampleL;
+				inputSampleL = (dCL[1] + dAL[5] + dAL[6])/3.0;  //note, feeding in dry again for a little more clarity!
+				
+				allpasstemp = outBL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;}
+				inputSampleL -= oBL[allpasstemp]*constallpass;
+				oBL[outBL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outBL--; if (outBL < 0 || outBL > delayB) {outBL = delayB;}
+				inputSampleL += (oBL[outBL]);
+				//allpass filter B
+				
+				dBL[6] = dBL[5];
+				dBL[5] = dBL[4];
+				dBL[4] = inputSampleL;
+				inputSampleL = (dBL[4] + dBL[5] + dBL[6])/3.0;
+				
+				allpasstemp = outCL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;}
+				inputSampleL -= oCL[allpasstemp]*constallpass;
+				oCL[outCL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outCL--; if (outCL < 0 || outCL > delayC) {outCL = delayC;}
+				inputSampleL += (oCL[outCL]);
+				//allpass filter C
+				
+				dCL[6] = dCL[5];
+				dCL[5] = dCL[4];
+				dCL[4] = inputSampleL;
+				inputSampleL = (dCL[4] + dCL[5] + dCL[6])/3.0;
+				
+				allpasstemp = outDL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;}
+				inputSampleL -= oDL[allpasstemp]*constallpass;
+				oDL[outDL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outDL--; if (outDL < 0 || outDL > delayD) {outDL = delayD;}
+				inputSampleL += (oDL[outDL]);
+				//allpass filter D
+				
+				dDL[6] = dDL[5];
+				dDL[5] = dDL[4];
+				dDL[4] = inputSampleL;
+				inputSampleL = (dDL[4] + dDL[5] + dDL[6])/3.0;
+				
+				allpasstemp = outEL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;}
+				inputSampleL -= oEL[allpasstemp]*constallpass;
+				oEL[outEL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outEL--; if (outEL < 0 || outEL > delayE) {outEL = delayE;}
+				inputSampleL += (oEL[outEL]);
+				//allpass filter E
+				
+				dEL[6] = dEL[5];
+				dEL[5] = dEL[4];
+				dEL[4] = inputSampleL;
+				inputSampleL = (dEL[4] + dEL[5] + dEL[6])/3.0;
+				
+				allpasstemp = outFL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;}
+				inputSampleL -= oFL[allpasstemp]*constallpass;
+				oFL[outFL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outFL--; if (outFL < 0 || outFL > delayF) {outFL = delayF;}
+				inputSampleL += (oFL[outFL]);
+				//allpass filter F
+				
+				dFL[6] = dFL[5];
+				dFL[5] = dFL[4];
+				dFL[4] = inputSampleL;
+				inputSampleL = (dFL[4] + dFL[5] + dFL[6])/3.0;
+				
+				allpasstemp = outGL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;}
+				inputSampleL -= oGL[allpasstemp]*constallpass;
+				oGL[outGL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outGL--; if (outGL < 0 || outGL > delayG) {outGL = delayG;}
+				inputSampleL += (oGL[outGL]);
+				//allpass filter G
+				
+				dGL[6] = dGL[5];
+				dGL[5] = dGL[4];
+				dGL[4] = inputSampleL;
+				inputSampleL = (dGL[4] + dGL[5] + dGL[6])/3.0;
+				
+				allpasstemp = outHL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;}
+				inputSampleL -= oHL[allpasstemp]*constallpass;
+				oHL[outHL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outHL--; if (outHL < 0 || outHL > delayH) {outHL = delayH;}
+				inputSampleL += (oHL[outHL]);
+				//allpass filter H
+				
+				dHL[6] = dHL[5];
+				dHL[5] = dHL[4];
+				dHL[4] = inputSampleL;
+				inputSampleL = (dHL[4] + dHL[5] + dHL[6])/3.0;
+				
+				allpasstemp = outIL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;}
+				inputSampleL -= oIL[allpasstemp]*constallpass;
+				oIL[outIL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outIL--; if (outIL < 0 || outIL > delayI) {outIL = delayI;}
+				inputSampleL += (oIL[outIL]);
+				//allpass filter I
+				
+				dIL[6] = dIL[5];
+				dIL[5] = dIL[4];
+				dIL[4] = inputSampleL;
+				inputSampleL = (dIL[4] + dIL[5] + dIL[6])/3.0;
+				
+				allpasstemp = outJL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;}
+				inputSampleL -= oJL[allpasstemp]*constallpass;
+				oJL[outJL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outJL--; if (outJL < 0 || outJL > delayJ) {outJL = delayJ;}
+				inputSampleL += (oJL[outJL]);
+				//allpass filter J
+				
+				dJL[6] = dJL[5];
+				dJL[5] = dJL[4];
+				dJL[4] = inputSampleL;
+				inputSampleL = (dJL[4] + dJL[5] + dJL[6])/3.0;
+				
+				allpasstemp = outKL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;}
+				inputSampleL -= oKL[allpasstemp]*constallpass;
+				oKL[outKL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outKL--; if (outKL < 0 || outKL > delayK) {outKL = delayK;}
+				inputSampleL += (oKL[outKL]);
+				//allpass filter K
+				
+				dKL[6] = dKL[5];
+				dKL[5] = dKL[4];
+				dKL[4] = inputSampleL;
+				inputSampleL = (dKL[4] + dKL[5] + dKL[6])/3.0;
+				
+				allpasstemp = outLL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;}
+				inputSampleL -= oLL[allpasstemp]*constallpass;
+				oLL[outLL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outLL--; if (outLL < 0 || outLL > delayL) {outLL = delayL;}
+				inputSampleL += (oLL[outLL]);
+				//allpass filter L
+				
+				dLL[6] = dLL[5];
+				dLL[5] = dLL[4];
+				dLL[4] = inputSampleL;
+				inputSampleL = (dLL[4] + dLL[5] + dLL[6])/3.0;
+				
+				allpasstemp = outML - 1;
+				if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;}
+				inputSampleL -= oML[allpasstemp]*constallpass;
+				oML[outML] = inputSampleL;
+				inputSampleL *= constallpass;
+				outML--; if (outML < 0 || outML > delayM) {outML = delayM;}
+				inputSampleL += (oML[outML]);
+				//allpass filter M
+				
+				dML[6] = dML[5];
+				dML[5] = dML[4];
+				dML[4] = inputSampleL;
+				inputSampleL = (dML[4] + dML[5] + dML[6])/3.0;
+				
+				allpasstemp = outNL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;}
+				inputSampleL -= oNL[allpasstemp]*constallpass;
+				oNL[outNL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outNL--; if (outNL < 0 || outNL > delayN) {outNL = delayN;}
+				inputSampleL += (oNL[outNL]);
+				//allpass filter N
+				
+				dNL[6] = dNL[5];
+				dNL[5] = dNL[4];
+				dNL[4] = inputSampleL;
+				inputSampleL = (dNL[4] + dNL[5] + dNL[6])/3.0;
+				
+				allpasstemp = outOL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;}
+				inputSampleL -= oOL[allpasstemp]*constallpass;
+				oOL[outOL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outOL--; if (outOL < 0 || outOL > delayO) {outOL = delayO;}
+				inputSampleL += (oOL[outOL]);
+				//allpass filter O
+				
+				dOL[6] = dOL[5];
+				dOL[5] = dOL[4];
+				dOL[4] = inputSampleL;
+				inputSampleL = (dOL[4] + dOL[5] + dOL[6])/3.0;
+				
+				allpasstemp = outPL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;}
+				inputSampleL -= oPL[allpasstemp]*constallpass;
+				oPL[outPL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outPL--; if (outPL < 0 || outPL > delayP) {outPL = delayP;}
+				inputSampleL += (oPL[outPL]);
+				//allpass filter P
+				
+				dPL[6] = dPL[5];
+				dPL[5] = dPL[4];
+				dPL[4] = inputSampleL;
+				inputSampleL = (dPL[4] + dPL[5] + dPL[6])/3.0;
+				
+				allpasstemp = outQL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;}
+				inputSampleL -= oQL[allpasstemp]*constallpass;
+				oQL[outQL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outQL--; if (outQL < 0 || outQL > delayQ) {outQL = delayQ;}
+				inputSampleL += (oQL[outQL]);
+				//allpass filter Q
+				
+				dQL[6] = dQL[5];
+				dQL[5] = dQL[4];
+				dQL[4] = inputSampleL;
+				inputSampleL = (dQL[4] + dQL[5] + dQL[6])/3.0;
+				
+				allpasstemp = outRL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;}
+				inputSampleL -= oRL[allpasstemp]*constallpass;
+				oRL[outRL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outRL--; if (outRL < 0 || outRL > delayR) {outRL = delayR;}
+				inputSampleL += (oRL[outRL]);
+				//allpass filter R
+				
+				dRL[6] = dRL[5];
+				dRL[5] = dRL[4];
+				dRL[4] = inputSampleL;
+				inputSampleL = (dRL[4] + dRL[5] + dRL[6])/3.0;
+				
+				allpasstemp = outSL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;}
+				inputSampleL -= oSL[allpasstemp]*constallpass;
+				oSL[outSL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outSL--; if (outSL < 0 || outSL > delayS) {outSL = delayS;}
+				inputSampleL += (oSL[outSL]);
+				//allpass filter S
+				
+				dSL[6] = dSL[5];
+				dSL[5] = dSL[4];
+				dSL[4] = inputSampleL;
+				inputSampleL = (dSL[4] + dSL[5] + dSL[6])/3.0;
+				
+				allpasstemp = outTL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;}
+				inputSampleL -= oTL[allpasstemp]*constallpass;
+				oTL[outTL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outTL--; if (outTL < 0 || outTL > delayT) {outTL = delayT;}
+				inputSampleL += (oTL[outTL]);
+				//allpass filter T
+				
+				dTL[6] = dTL[5];
+				dTL[5] = dTL[4];
+				dTL[4] = inputSampleL;
+				inputSampleL = (dTL[4] + dTL[5] + dTL[6])/3.0;
+				
+				allpasstemp = outUL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;}
+				inputSampleL -= oUL[allpasstemp]*constallpass;
+				oUL[outUL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outUL--; if (outUL < 0 || outUL > delayU) {outUL = delayU;}
+				inputSampleL += (oUL[outUL]);
+				//allpass filter U
+				
+				dUL[6] = dUL[5];
+				dUL[5] = dUL[4];
+				dUL[4] = inputSampleL;
+				inputSampleL = (dUL[4] + dUL[5] + dUL[6])/3.0;
+				
+				allpasstemp = outVL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;}
+				inputSampleL -= oVL[allpasstemp]*constallpass;
+				oVL[outVL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outVL--; if (outVL < 0 || outVL > delayV) {outVL = delayV;}
+				inputSampleL += (oVL[outVL]);
+				//allpass filter V
+				
+				dVL[6] = dVL[5];
+				dVL[5] = dVL[4];
+				dVL[4] = inputSampleL;
+				inputSampleL = (dVL[4] + dVL[5] + dVL[6])/3.0;
+				
+				allpasstemp = outWL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;}
+				inputSampleL -= oWL[allpasstemp]*constallpass;
+				oWL[outWL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outWL--; if (outWL < 0 || outWL > delayW) {outWL = delayW;}
+				inputSampleL += (oWL[outWL]);
+				//allpass filter W
+				
+				dWL[6] = dWL[5];
+				dWL[5] = dWL[4];
+				dWL[4] = inputSampleL;
+				inputSampleL = (dWL[4] + dWL[5] + dWL[6])/3.0;
+				
+				allpasstemp = outXL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;}
+				inputSampleL -= oXL[allpasstemp]*constallpass;
+				oXL[outXL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outXL--; if (outXL < 0 || outXL > delayX) {outXL = delayX;}
+				inputSampleL += (oXL[outXL]);
+				//allpass filter X
+				
+				dXL[6] = dXL[5];
+				dXL[5] = dXL[4];
+				dXL[4] = inputSampleL;
+				inputSampleL = (dXL[4] + dXL[5] + dXL[6])/3.0;
+				
+				allpasstemp = outYL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;}
+				inputSampleL -= oYL[allpasstemp]*constallpass;
+				oYL[outYL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outYL--; if (outYL < 0 || outYL > delayY) {outYL = delayY;}
+				inputSampleL += (oYL[outYL]);
+				//allpass filter Y
+				
+				dYL[6] = dYL[5];
+				dYL[5] = dYL[4];
+				dYL[4] = inputSampleL;
+				inputSampleL = (dYL[4] + dYL[5] + dYL[6])/3.0;
+				
+				allpasstemp = outZL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;}
+				inputSampleL -= oZL[allpasstemp]*constallpass;
+				oZL[outZL] = inputSampleL;
+				inputSampleL *= constallpass;
+				outZL--; if (outZL < 0 || outZL > delayZ) {outZL = delayZ;}
+				inputSampleL += (oZL[outZL]);
+				//allpass filter Z
+				
+				dZL[6] = dZL[5];
+				dZL[5] = dZL[4];
+				dZL[4] = inputSampleL;
+				inputSampleL = (dZL[4] + dZL[5] + dZL[6]);		
+				//output Zarathustra infinite space verb
+				break;
+				
+		}
+		//end big switch for verb type
+		
+		switch (verbtype)
+		{
+				
+				
+			case 1://Chamber
+				allpasstemp = alpAR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;}
+				inputSampleR -= aAR[allpasstemp]*constallpass;
+				aAR[alpAR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpAR--; if (alpAR < 0 || alpAR > delayA) {alpAR = delayA;}
+				inputSampleR += (aAR[alpAR]);
+				//allpass filter A		
+				
+				dAR[3] = dAR[2];
+				dAR[2] = dAR[1];
+				dAR[1] = inputSampleR;
+				inputSampleR = (dAR[1] + dAR[2] + dAR[3])/3.0;
+				
+				allpasstemp = alpBR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;}
+				inputSampleR -= aBR[allpasstemp]*constallpass;
+				aBR[alpBR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpBR--; if (alpBR < 0 || alpBR > delayB) {alpBR = delayB;}
+				inputSampleR += (aBR[alpBR]);
+				//allpass filter B
+				
+				dBR[3] = dBR[2];
+				dBR[2] = dBR[1];
+				dBR[1] = inputSampleR;
+				inputSampleR = (dBR[1] + dBR[2] + dBR[3])/3.0;
+				
+				allpasstemp = alpCR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;}
+				inputSampleR -= aCR[allpasstemp]*constallpass;
+				aCR[alpCR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpCR--; if (alpCR < 0 || alpCR > delayC) {alpCR = delayC;}
+				inputSampleR += (aCR[alpCR]);
+				//allpass filter C
+				
+				dCR[3] = dCR[2];
+				dCR[2] = dCR[1];
+				dCR[1] = inputSampleR;
+				inputSampleR = (dAR[1] + dCR[2] + dCR[3])/3.0;
+				
+				allpasstemp = alpDR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;}
+				inputSampleR -= aDR[allpasstemp]*constallpass;
+				aDR[alpDR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpDR--; if (alpDR < 0 || alpDR > delayD) {alpDR = delayD;}
+				inputSampleR += (aDR[alpDR]);
+				//allpass filter D
+				
+				dDR[3] = dDR[2];
+				dDR[2] = dDR[1];
+				dDR[1] = inputSampleR;
+				inputSampleR = (dDR[1] + dDR[2] + dDR[3])/3.0;
+				
+				allpasstemp = alpER - 1;
+				if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;}
+				inputSampleR -= aER[allpasstemp]*constallpass;
+				aER[alpER] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpER--; if (alpER < 0 || alpER > delayE) {alpER = delayE;}
+				inputSampleR += (aER[alpER]);
+				//allpass filter E
+				
+				dER[3] = dER[2];
+				dER[2] = dER[1];
+				dER[1] = inputSampleR;
+				inputSampleR = (dAR[1] + dER[2] + dER[3])/3.0;
+				
+				allpasstemp = alpFR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;}
+				inputSampleR -= aFR[allpasstemp]*constallpass;
+				aFR[alpFR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpFR--; if (alpFR < 0 || alpFR > delayF) {alpFR = delayF;}
+				inputSampleR += (aFR[alpFR]);
+				//allpass filter F
+				
+				dFR[3] = dFR[2];
+				dFR[2] = dFR[1];
+				dFR[1] = inputSampleR;
+				inputSampleR = (dFR[1] + dFR[2] + dFR[3])/3.0;
+				
+				allpasstemp = alpGR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;}
+				inputSampleR -= aGR[allpasstemp]*constallpass;
+				aGR[alpGR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpGR--; if (alpGR < 0 || alpGR > delayG) {alpGR = delayG;}
+				inputSampleR += (aGR[alpGR]);
+				//allpass filter G
+				
+				dGR[3] = dGR[2];
+				dGR[2] = dGR[1];
+				dGR[1] = inputSampleR;
+				inputSampleR = (dAR[1] + dGR[2] + dGR[3])/3.0;
+				
+				allpasstemp = alpHR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;}
+				inputSampleR -= aHR[allpasstemp]*constallpass;
+				aHR[alpHR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpHR--; if (alpHR < 0 || alpHR > delayH) {alpHR = delayH;}
+				inputSampleR += (aHR[alpHR]);
+				//allpass filter H
+				
+				dHR[3] = dHR[2];
+				dHR[2] = dHR[1];
+				dHR[1] = inputSampleR;
+				inputSampleR = (dHR[1] + dHR[2] + dHR[3])/3.0;
+				
+				allpasstemp = alpIR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;}
+				inputSampleR -= aIR[allpasstemp]*constallpass;
+				aIR[alpIR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpIR--; if (alpIR < 0 || alpIR > delayI) {alpIR = delayI;}
+				inputSampleR += (aIR[alpIR]);
+				//allpass filter I
+				
+				dIR[3] = dIR[2];
+				dIR[2] = dIR[1];
+				dIR[1] = inputSampleR;
+				inputSampleR = (dIR[1] + dIR[2] + dIR[3])/3.0;
+				
+				allpasstemp = alpJR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;}
+				inputSampleR -= aJR[allpasstemp]*constallpass;
+				aJR[alpJR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpJR--; if (alpJR < 0 || alpJR > delayJ) {alpJR = delayJ;}
+				inputSampleR += (aJR[alpJR]);
+				//allpass filter J
+				
+				dJR[3] = dJR[2];
+				dJR[2] = dJR[1];
+				dJR[1] = inputSampleR;
+				inputSampleR = (dJR[1] + dJR[2] + dJR[3])/3.0;
+				
+				allpasstemp = alpKR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;}
+				inputSampleR -= aKR[allpasstemp]*constallpass;
+				aKR[alpKR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpKR--; if (alpKR < 0 || alpKR > delayK) {alpKR = delayK;}
+				inputSampleR += (aKR[alpKR]);
+				//allpass filter K
+				
+				dKR[3] = dKR[2];
+				dKR[2] = dKR[1];
+				dKR[1] = inputSampleR;
+				inputSampleR = (dAR[1] + dKR[2] + dKR[3])/3.0;
+				
+				allpasstemp = alpLR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;}
+				inputSampleR -= aLR[allpasstemp]*constallpass;
+				aLR[alpLR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpLR--; if (alpLR < 0 || alpLR > delayL) {alpLR = delayL;}
+				inputSampleR += (aLR[alpLR]);
+				//allpass filter L
+				
+				dLR[3] = dLR[2];
+				dLR[2] = dLR[1];
+				dLR[1] = inputSampleR;
+				inputSampleR = (dLR[1] + dLR[2] + dLR[3])/3.0;
+				
+				allpasstemp = alpMR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;}
+				inputSampleR -= aMR[allpasstemp]*constallpass;
+				aMR[alpMR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpMR--; if (alpMR < 0 || alpMR > delayM) {alpMR = delayM;}
+				inputSampleR += (aMR[alpMR]);
+				//allpass filter M
+				
+				dMR[3] = dMR[2];
+				dMR[2] = dMR[1];
+				dMR[1] = inputSampleR;
+				inputSampleR = (dAR[1] + dMR[2] + dMR[3])/3.0;
+				
+				allpasstemp = alpNR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;}
+				inputSampleR -= aNR[allpasstemp]*constallpass;
+				aNR[alpNR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpNR--; if (alpNR < 0 || alpNR > delayN) {alpNR = delayN;}
+				inputSampleR += (aNR[alpNR]);
+				//allpass filter N
+				
+				dNR[3] = dNR[2];
+				dNR[2] = dNR[1];
+				dNR[1] = inputSampleR;
+				inputSampleR = (dNR[1] + dNR[2] + dNR[3])/3.0;
+				
+				allpasstemp = alpOR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;}
+				inputSampleR -= aOR[allpasstemp]*constallpass;
+				aOR[alpOR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpOR--; if (alpOR < 0 || alpOR > delayO) {alpOR = delayO;}
+				inputSampleR += (aOR[alpOR]);
+				//allpass filter O
+				
+				dOR[3] = dOR[2];
+				dOR[2] = dOR[1];
+				dOR[1] = inputSampleR;
+				inputSampleR = (dOR[1] + dOR[2] + dOR[3])/3.0;
+				
+				allpasstemp = alpPR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;}
+				inputSampleR -= aPR[allpasstemp]*constallpass;
+				aPR[alpPR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpPR--; if (alpPR < 0 || alpPR > delayP) {alpPR = delayP;}
+				inputSampleR += (aPR[alpPR]);
+				//allpass filter P
+				
+				dPR[3] = dPR[2];
+				dPR[2] = dPR[1];
+				dPR[1] = inputSampleR;
+				inputSampleR = (dPR[1] + dPR[2] + dPR[3])/3.0;
+				
+				allpasstemp = alpQR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;}
+				inputSampleR -= aQR[allpasstemp]*constallpass;
+				aQR[alpQR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpQR--; if (alpQR < 0 || alpQR > delayQ) {alpQR = delayQ;}
+				inputSampleR += (aQR[alpQR]);
+				//allpass filter Q
+				
+				dQR[3] = dQR[2];
+				dQR[2] = dQR[1];
+				dQR[1] = inputSampleR;
+				inputSampleR = (dAR[1] + dQR[2] + dQR[3])/3.0;
+				
+				allpasstemp = alpRR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;}
+				inputSampleR -= aRR[allpasstemp]*constallpass;
+				aRR[alpRR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpRR--; if (alpRR < 0 || alpRR > delayR) {alpRR = delayR;}
+				inputSampleR += (aRR[alpRR]);
+				//allpass filter R
+				
+				dRR[3] = dRR[2];
+				dRR[2] = dRR[1];
+				dRR[1] = inputSampleR;
+				inputSampleR = (dRR[1] + dRR[2] + dRR[3])/3.0;
+				
+				allpasstemp = alpSR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;}
+				inputSampleR -= aSR[allpasstemp]*constallpass;
+				aSR[alpSR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpSR--; if (alpSR < 0 || alpSR > delayS) {alpSR = delayS;}
+				inputSampleR += (aSR[alpSR]);
+				//allpass filter S
+				
+				dSR[3] = dSR[2];
+				dSR[2] = dSR[1];
+				dSR[1] = inputSampleR;
+				inputSampleR = (dAR[1] + dSR[2] + dSR[3])/3.0;
+				
+				allpasstemp = alpTR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;}
+				inputSampleR -= aTR[allpasstemp]*constallpass;
+				aTR[alpTR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpTR--; if (alpTR < 0 || alpTR > delayT) {alpTR = delayT;}
+				inputSampleR += (aTR[alpTR]);
+				//allpass filter T
+				
+				dTR[3] = dTR[2];
+				dTR[2] = dTR[1];
+				dTR[1] = inputSampleR;
+				inputSampleR = (dTR[1] + dTR[2] + dTR[3])/3.0;
+				
+				allpasstemp = alpUR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;}
+				inputSampleR -= aUR[allpasstemp]*constallpass;
+				aUR[alpUR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpUR--; if (alpUR < 0 || alpUR > delayU) {alpUR = delayU;}
+				inputSampleR += (aUR[alpUR]);
+				//allpass filter U
+				
+				dUR[3] = dUR[2];
+				dUR[2] = dUR[1];
+				dUR[1] = inputSampleR;
+				inputSampleR = (dUR[1] + dUR[2] + dUR[3])/3.0;
+				
+				allpasstemp = alpVR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;}
+				inputSampleR -= aVR[allpasstemp]*constallpass;
+				aVR[alpVR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpVR--; if (alpVR < 0 || alpVR > delayV) {alpVR = delayV;}
+				inputSampleR += (aVR[alpVR]);
+				//allpass filter V
+				
+				dVR[3] = dVR[2];
+				dVR[2] = dVR[1];
+				dVR[1] = inputSampleR;
+				inputSampleR = (dVR[1] + dVR[2] + dVR[3])/3.0;
+				
+				allpasstemp = alpWR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;}
+				inputSampleR -= aWR[allpasstemp]*constallpass;
+				aWR[alpWR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpWR--; if (alpWR < 0 || alpWR > delayW) {alpWR = delayW;}
+				inputSampleR += (aWR[alpWR]);
+				//allpass filter W
+				
+				dWR[3] = dWR[2];
+				dWR[2] = dWR[1];
+				dWR[1] = inputSampleR;
+				inputSampleR = (dAR[1] + dWR[2] + dWR[3])/3.0;
+				
+				allpasstemp = alpXR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;}
+				inputSampleR -= aXR[allpasstemp]*constallpass;
+				aXR[alpXR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpXR--; if (alpXR < 0 || alpXR > delayX) {alpXR = delayX;}
+				inputSampleR += (aXR[alpXR]);
+				//allpass filter X
+				
+				dXR[3] = dXR[2];
+				dXR[2] = dXR[1];
+				dXR[1] = inputSampleR;
+				inputSampleR = (dXR[1] + dXR[2] + dXR[3])/3.0;
+				
+				allpasstemp = alpYR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;}
+				inputSampleR -= aYR[allpasstemp]*constallpass;
+				aYR[alpYR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpYR--; if (alpYR < 0 || alpYR > delayY) {alpYR = delayY;}
+				inputSampleR += (aYR[alpYR]);
+				//allpass filter Y
+				
+				dYR[3] = dYR[2];
+				dYR[2] = dYR[1];
+				dYR[1] = inputSampleR;
+				inputSampleR = (dYR[1] + dYR[2] + dYR[3])/3.0;
+				
+				allpasstemp = alpZR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;}
+				inputSampleR -= aZR[allpasstemp]*constallpass;
+				aZR[alpZR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpZR--; if (alpZR < 0 || alpZR > delayZ) {alpZR = delayZ;}
+				inputSampleR += (aZR[alpZR]);
+				//allpass filter Z
+				
+				dZR[3] = dZR[2];
+				dZR[2] = dZR[1];
+				dZR[1] = inputSampleR;
+				inputSampleR = (dZR[1] + dZR[2] + dZR[3])/3.0;
+				
+				// now the second stage using the 'out' bank of allpasses		
+				
+				allpasstemp = outAR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;}
+				inputSampleR -= oAR[allpasstemp]*constallpass;
+				oAR[outAR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outAR--; if (outAR < 0 || outAR > delayA) {outAR = delayA;}
+				inputSampleR += (oAR[outAR]);
+				//allpass filter A		
+				
+				dAR[6] = dAR[5];
+				dAR[5] = dAR[4];
+				dAR[4] = inputSampleR;
+				inputSampleR = (dAR[4] + dAR[5] + dAR[6])/3.0;
+				
+				allpasstemp = outBR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;}
+				inputSampleR -= oBR[allpasstemp]*constallpass;
+				oBR[outBR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outBR--; if (outBR < 0 || outBR > delayB) {outBR = delayB;}
+				inputSampleR += (oBR[outBR]);
+				//allpass filter B
+				
+				dBR[6] = dBR[5];
+				dBR[5] = dBR[4];
+				dBR[4] = inputSampleR;
+				inputSampleR = (dBR[4] + dBR[5] + dBR[6])/3.0;
+				
+				allpasstemp = outCR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;}
+				inputSampleR -= oCR[allpasstemp]*constallpass;
+				oCR[outCR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outCR--; if (outCR < 0 || outCR > delayC) {outCR = delayC;}
+				inputSampleR += (oCR[outCR]);
+				//allpass filter C
+				
+				dCR[6] = dCR[5];
+				dCR[5] = dCR[4];
+				dCR[4] = inputSampleR;
+				inputSampleR = (dAR[1] + dCR[5] + dCR[6])/3.0;
+				
+				allpasstemp = outDR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;}
+				inputSampleR -= oDR[allpasstemp]*constallpass;
+				oDR[outDR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outDR--; if (outDR < 0 || outDR > delayD) {outDR = delayD;}
+				inputSampleR += (oDR[outDR]);
+				//allpass filter D
+				
+				dDR[6] = dDR[5];
+				dDR[5] = dDR[4];
+				dDR[4] = inputSampleR;
+				inputSampleR = (dDR[4] + dDR[5] + dDR[6])/3.0;
+				
+				allpasstemp = outER - 1;
+				if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;}
+				inputSampleR -= oER[allpasstemp]*constallpass;
+				oER[outER] = inputSampleR;
+				inputSampleR *= constallpass;
+				outER--; if (outER < 0 || outER > delayE) {outER = delayE;}
+				inputSampleR += (oER[outER]);
+				//allpass filter E
+				
+				dER[6] = dER[5];
+				dER[5] = dER[4];
+				dER[4] = inputSampleR;
+				inputSampleR = (dAR[1] + dER[5] + dER[6])/3.0;
+				
+				allpasstemp = outFR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;}
+				inputSampleR -= oFR[allpasstemp]*constallpass;
+				oFR[outFR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outFR--; if (outFR < 0 || outFR > delayF) {outFR = delayF;}
+				inputSampleR += (oFR[outFR]);
+				//allpass filter F
+				
+				dFR[6] = dFR[5];
+				dFR[5] = dFR[4];
+				dFR[4] = inputSampleR;
+				inputSampleR = (dFR[4] + dFR[5] + dFR[6])/3.0;
+				
+				allpasstemp = outGR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;}
+				inputSampleR -= oGR[allpasstemp]*constallpass;
+				oGR[outGR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outGR--; if (outGR < 0 || outGR > delayG) {outGR = delayG;}
+				inputSampleR += (oGR[outGR]);
+				//allpass filter G
+				
+				dGR[6] = dGR[5];
+				dGR[5] = dGR[4];
+				dGR[4] = inputSampleR;
+				inputSampleR = (dGR[4] + dGR[5] + dGR[6])/3.0;
+				
+				allpasstemp = outHR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;}
+				inputSampleR -= oHR[allpasstemp]*constallpass;
+				oHR[outHR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outHR--; if (outHR < 0 || outHR > delayH) {outHR = delayH;}
+				inputSampleR += (oHR[outHR]);
+				//allpass filter H
+				
+				dHR[6] = dHR[5];
+				dHR[5] = dHR[4];
+				dHR[4] = inputSampleR;
+				inputSampleR = (dHR[4] + dHR[5] + dHR[6])/3.0;
+				
+				allpasstemp = outIR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;}
+				inputSampleR -= oIR[allpasstemp]*constallpass;
+				oIR[outIR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outIR--; if (outIR < 0 || outIR > delayI) {outIR = delayI;}
+				inputSampleR += (oIR[outIR]);
+				//allpass filter I
+				
+				dIR[6] = dIR[5];
+				dIR[5] = dIR[4];
+				dIR[4] = inputSampleR;
+				inputSampleR = (dIR[4] + dIR[5] + dIR[6])/3.0;
+				
+				allpasstemp = outJR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;}
+				inputSampleR -= oJR[allpasstemp]*constallpass;
+				oJR[outJR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outJR--; if (outJR < 0 || outJR > delayJ) {outJR = delayJ;}
+				inputSampleR += (oJR[outJR]);
+				//allpass filter J
+				
+				dJR[6] = dJR[5];
+				dJR[5] = dJR[4];
+				dJR[4] = inputSampleR;
+				inputSampleR = (dJR[4] + dJR[5] + dJR[6])/3.0;
+				
+				allpasstemp = outKR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;}
+				inputSampleR -= oKR[allpasstemp]*constallpass;
+				oKR[outKR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outKR--; if (outKR < 0 || outKR > delayK) {outKR = delayK;}
+				inputSampleR += (oKR[outKR]);
+				//allpass filter K
+				
+				dKR[6] = dKR[5];
+				dKR[5] = dKR[4];
+				dKR[4] = inputSampleR;
+				inputSampleR = (dAR[1] + dKR[5] + dKR[6])/3.0;
+				
+				allpasstemp = outLR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;}
+				inputSampleR -= oLR[allpasstemp]*constallpass;
+				oLR[outLR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outLR--; if (outLR < 0 || outLR > delayL) {outLR = delayL;}
+				inputSampleR += (oLR[outLR]);
+				//allpass filter L
+				
+				dLR[6] = dLR[5];
+				dLR[5] = dLR[4];
+				dLR[4] = inputSampleR;
+				inputSampleR = (dLR[4] + dLR[5] + dLR[6])/3.0;
+				
+				allpasstemp = outMR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;}
+				inputSampleR -= oMR[allpasstemp]*constallpass;
+				oMR[outMR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outMR--; if (outMR < 0 || outMR > delayM) {outMR = delayM;}
+				inputSampleR += (oMR[outMR]);
+				//allpass filter M
+				
+				dMR[6] = dMR[5];
+				dMR[5] = dMR[4];
+				dMR[4] = inputSampleR;
+				inputSampleR = (dMR[4] + dMR[5] + dMR[6])/3.0;
+				
+				allpasstemp = outNR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;}
+				inputSampleR -= oNR[allpasstemp]*constallpass;
+				oNR[outNR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outNR--; if (outNR < 0 || outNR > delayN) {outNR = delayN;}
+				inputSampleR += (oNR[outNR]);
+				//allpass filter N
+				
+				dNR[6] = dNR[5];
+				dNR[5] = dNR[4];
+				dNR[4] = inputSampleR;
+				inputSampleR = (dNR[4] + dNR[5] + dNR[6])/3.0;
+				
+				allpasstemp = outOR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;}
+				inputSampleR -= oOR[allpasstemp]*constallpass;
+				oOR[outOR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outOR--; if (outOR < 0 || outOR > delayO) {outOR = delayO;}
+				inputSampleR += (oOR[outOR]);
+				//allpass filter O
+				
+				dOR[6] = dOR[5];
+				dOR[5] = dOR[4];
+				dOR[4] = inputSampleR;
+				inputSampleR = (dAR[1] + dOR[5] + dOR[6])/3.0;
+				
+				allpasstemp = outPR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;}
+				inputSampleR -= oPR[allpasstemp]*constallpass;
+				oPR[outPR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outPR--; if (outPR < 0 || outPR > delayP) {outPR = delayP;}
+				inputSampleR += (oPR[outPR]);
+				//allpass filter P
+				
+				dPR[6] = dPR[5];
+				dPR[5] = dPR[4];
+				dPR[4] = inputSampleR;
+				inputSampleR = (dPR[4] + dPR[5] + dPR[6])/3.0;
+				
+				allpasstemp = outQR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;}
+				inputSampleR -= oQR[allpasstemp]*constallpass;
+				oQR[outQR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outQR--; if (outQR < 0 || outQR > delayQ) {outQR = delayQ;}
+				inputSampleR += (oQR[outQR]);
+				//allpass filter Q
+				
+				dQR[6] = dQR[5];
+				dQR[5] = dQR[4];
+				dQR[4] = inputSampleR;
+				inputSampleR = (dAR[1] + dQR[5] + dQR[6])/3.0;
+				
+				allpasstemp = outRR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;}
+				inputSampleR -= oRR[allpasstemp]*constallpass;
+				oRR[outRR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outRR--; if (outRR < 0 || outRR > delayR) {outRR = delayR;}
+				inputSampleR += (oRR[outRR]);
+				//allpass filter R
+				
+				dRR[6] = dRR[5];
+				dRR[5] = dRR[4];
+				dRR[4] = inputSampleR;
+				inputSampleR = (dRR[4] + dRR[5] + dRR[6])/3.0;
+				
+				allpasstemp = outSR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;}
+				inputSampleR -= oSR[allpasstemp]*constallpass;
+				oSR[outSR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outSR--; if (outSR < 0 || outSR > delayS) {outSR = delayS;}
+				inputSampleR += (oSR[outSR]);
+				//allpass filter S
+				
+				dSR[6] = dSR[5];
+				dSR[5] = dSR[4];
+				dSR[4] = inputSampleR;
+				inputSampleR = (dSR[4] + dSR[5] + dSR[6])/3.0;
+				
+				allpasstemp = outTR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;}
+				inputSampleR -= oTR[allpasstemp]*constallpass;
+				oTR[outTR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outTR--; if (outTR < 0 || outTR > delayT) {outTR = delayT;}
+				inputSampleR += (oTR[outTR]);
+				//allpass filter T
+				
+				dTR[6] = dTR[5];
+				dTR[5] = dTR[4];
+				dTR[4] = inputSampleR;
+				inputSampleR = (dTR[4] + dTR[5] + dTR[6])/3.0;
+				
+				allpasstemp = outUR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;}
+				inputSampleR -= oUR[allpasstemp]*constallpass;
+				oUR[outUR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outUR--; if (outUR < 0 || outUR > delayU) {outUR = delayU;}
+				inputSampleR += (oUR[outUR]);
+				//allpass filter U
+				
+				dUR[6] = dUR[5];
+				dUR[5] = dUR[4];
+				dUR[4] = inputSampleR;
+				inputSampleR = (dAR[1] + dUR[5] + dUR[6])/3.0;
+				
+				allpasstemp = outVR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;}
+				inputSampleR -= oVR[allpasstemp]*constallpass;
+				oVR[outVR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outVR--; if (outVR < 0 || outVR > delayV) {outVR = delayV;}
+				inputSampleR += (oVR[outVR]);
+				//allpass filter V
+				
+				dVR[6] = dVR[5];
+				dVR[5] = dVR[4];
+				dVR[4] = inputSampleR;
+				inputSampleR = (dVR[4] + dVR[5] + dVR[6])/3.0;
+				
+				allpasstemp = outWR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;}
+				inputSampleR -= oWR[allpasstemp]*constallpass;
+				oWR[outWR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outWR--; if (outWR < 0 || outWR > delayW) {outWR = delayW;}
+				inputSampleR += (oWR[outWR]);
+				//allpass filter W
+				
+				dWR[6] = dWR[5];
+				dWR[5] = dWR[4];
+				dWR[4] = inputSampleR;
+				inputSampleR = (dWR[4] + dWR[5] + dWR[6])/3.0;
+				
+				allpasstemp = outXR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;}
+				inputSampleR -= oXR[allpasstemp]*constallpass;
+				oXR[outXR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outXR--; if (outXR < 0 || outXR > delayX) {outXR = delayX;}
+				inputSampleR += (oXR[outXR]);
+				//allpass filter X
+				
+				dXR[6] = dXR[5];
+				dXR[5] = dXR[4];
+				dXR[4] = inputSampleR;
+				inputSampleR = (dXR[4] + dXR[5] + dXR[6])/3.0;
+				
+				allpasstemp = outYR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;}
+				inputSampleR -= oYR[allpasstemp]*constallpass;
+				oYR[outYR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outYR--; if (outYR < 0 || outYR > delayY) {outYR = delayY;}
+				inputSampleR += (oYR[outYR]);
+				//allpass filter Y
+				
+				dYR[6] = dYR[5];
+				dYR[5] = dYR[4];
+				dYR[4] = inputSampleR;
+				inputSampleR = (dYR[4] + dYR[5] + dYR[6])/3.0;
+				
+				allpasstemp = outZR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;}
+				inputSampleR -= oZR[allpasstemp]*constallpass;
+				oZR[outZR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outZR--; if (outZR < 0 || outZR > delayZ) {outZR = delayZ;}
+				inputSampleR += (oZR[outZR]);
+				//allpass filter Z
+				
+				dZR[6] = dZR[5];
+				dZR[5] = dZR[4];
+				dZR[4] = inputSampleR;
+				inputSampleR = (dZR[4] + dZR[5] + dZR[6]);		
+				//output Chamber
+				break;
+				
+				
+				
+				
+				
+			case 2:	//Spring
+				
+				allpasstemp = alpAR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;}
+				inputSampleR -= aAR[allpasstemp]*constallpass;
+				aAR[alpAR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpAR--; if (alpAR < 0 || alpAR > delayA) {alpAR = delayA;}
+				inputSampleR += (aAR[alpAR]);
+				//allpass filter A		
+				
+				dAR[3] = dAR[2];
+				dAR[2] = dAR[1];
+				dAR[1] = inputSampleR;
+				inputSampleR = (dAR[1] + dAR[2] + dAR[3])/3.0;
+				
+				allpasstemp = alpBR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;}
+				inputSampleR -= aBR[allpasstemp]*constallpass;
+				aBR[alpBR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpBR--; if (alpBR < 0 || alpBR > delayB) {alpBR = delayB;}
+				inputSampleR += (aBR[alpBR]);
+				//allpass filter B
+				
+				dBR[3] = dBR[2];
+				dBR[2] = dBR[1];
+				dBR[1] = inputSampleR;
+				inputSampleR = (dBR[1] + dBR[2] + dBR[3])/3.0;
+				
+				allpasstemp = alpCR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;}
+				inputSampleR -= aCR[allpasstemp]*constallpass;
+				aCR[alpCR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpCR--; if (alpCR < 0 || alpCR > delayC) {alpCR = delayC;}
+				inputSampleR += (aCR[alpCR]);
+				//allpass filter C
+				
+				dCR[3] = dCR[2];
+				dCR[2] = dCR[1];
+				dCR[1] = inputSampleR;
+				inputSampleR = (dCR[1] + dCR[2] + dCR[3])/3.0;
+				
+				allpasstemp = alpDR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;}
+				inputSampleR -= aDR[allpasstemp]*constallpass;
+				aDR[alpDR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpDR--; if (alpDR < 0 || alpDR > delayD) {alpDR = delayD;}
+				inputSampleR += (aDR[alpDR]);
+				//allpass filter D
+				
+				dDR[3] = dDR[2];
+				dDR[2] = dDR[1];
+				dDR[1] = inputSampleR;
+				inputSampleR = (dDR[1] + dDR[2] + dDR[3])/3.0;
+				
+				allpasstemp = alpER - 1;
+				if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;}
+				inputSampleR -= aER[allpasstemp]*constallpass;
+				aER[alpER] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpER--; if (alpER < 0 || alpER > delayE) {alpER = delayE;}
+				inputSampleR += (aER[alpER]);
+				//allpass filter E
+				
+				dER[3] = dER[2];
+				dER[2] = dER[1];
+				dER[1] = inputSampleR;
+				inputSampleR = (dER[1] + dER[2] + dER[3])/3.0;
+				
+				allpasstemp = alpFR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;}
+				inputSampleR -= aFR[allpasstemp]*constallpass;
+				aFR[alpFR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpFR--; if (alpFR < 0 || alpFR > delayF) {alpFR = delayF;}
+				inputSampleR += (aFR[alpFR]);
+				//allpass filter F
+				
+				dFR[3] = dFR[2];
+				dFR[2] = dFR[1];
+				dFR[1] = inputSampleR;
+				inputSampleR = (dFR[1] + dFR[2] + dFR[3])/3.0;
+				
+				allpasstemp = alpGR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;}
+				inputSampleR -= aGR[allpasstemp]*constallpass;
+				aGR[alpGR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpGR--; if (alpGR < 0 || alpGR > delayG) {alpGR = delayG;}
+				inputSampleR += (aGR[alpGR]);
+				//allpass filter G
+				
+				dGR[3] = dGR[2];
+				dGR[2] = dGR[1];
+				dGR[1] = inputSampleR;
+				inputSampleR = (dGR[1] + dGR[2] + dGR[3])/3.0;
+				
+				allpasstemp = alpHR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;}
+				inputSampleR -= aHR[allpasstemp]*constallpass;
+				aHR[alpHR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpHR--; if (alpHR < 0 || alpHR > delayH) {alpHR = delayH;}
+				inputSampleR += (aHR[alpHR]);
+				//allpass filter H
+				
+				dHR[3] = dHR[2];
+				dHR[2] = dHR[1];
+				dHR[1] = inputSampleR;
+				inputSampleR = (dHR[1] + dHR[2] + dHR[3])/3.0;
+				
+				allpasstemp = alpIR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;}
+				inputSampleR -= aIR[allpasstemp]*constallpass;
+				aIR[alpIR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpIR--; if (alpIR < 0 || alpIR > delayI) {alpIR = delayI;}
+				inputSampleR += (aIR[alpIR]);
+				//allpass filter I
+				
+				dIR[3] = dIR[2];
+				dIR[2] = dIR[1];
+				dIR[1] = inputSampleR;
+				inputSampleR = (dIR[1] + dIR[2] + dIR[3])/3.0;
+				
+				allpasstemp = alpJR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;}
+				inputSampleR -= aJR[allpasstemp]*constallpass;
+				aJR[alpJR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpJR--; if (alpJR < 0 || alpJR > delayJ) {alpJR = delayJ;}
+				inputSampleR += (aJR[alpJR]);
+				//allpass filter J
+				
+				dJR[3] = dJR[2];
+				dJR[2] = dJR[1];
+				dJR[1] = inputSampleR;
+				inputSampleR = (dJR[1] + dJR[2] + dJR[3])/3.0;
+				
+				allpasstemp = alpKR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;}
+				inputSampleR -= aKR[allpasstemp]*constallpass;
+				aKR[alpKR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpKR--; if (alpKR < 0 || alpKR > delayK) {alpKR = delayK;}
+				inputSampleR += (aKR[alpKR]);
+				//allpass filter K
+				
+				dKR[3] = dKR[2];
+				dKR[2] = dKR[1];
+				dKR[1] = inputSampleR;
+				inputSampleR = (dKR[1] + dKR[2] + dKR[3])/3.0;
+				
+				allpasstemp = alpLR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;}
+				inputSampleR -= aLR[allpasstemp]*constallpass;
+				aLR[alpLR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpLR--; if (alpLR < 0 || alpLR > delayL) {alpLR = delayL;}
+				inputSampleR += (aLR[alpLR]);
+				//allpass filter L
+				
+				dLR[3] = dLR[2];
+				dLR[2] = dLR[1];
+				dLR[1] = inputSampleR;
+				inputSampleR = (dLR[1] + dLR[2] + dLR[3])/3.0;
+				
+				allpasstemp = alpMR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;}
+				inputSampleR -= aMR[allpasstemp]*constallpass;
+				aMR[alpMR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpMR--; if (alpMR < 0 || alpMR > delayM) {alpMR = delayM;}
+				inputSampleR += (aMR[alpMR]);
+				//allpass filter M
+				
+				dMR[3] = dMR[2];
+				dMR[2] = dMR[1];
+				dMR[1] = inputSampleR;
+				inputSampleR = (dMR[1] + dMR[2] + dMR[3])/3.0;
+				
+				allpasstemp = alpNR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;}
+				inputSampleR -= aNR[allpasstemp]*constallpass;
+				aNR[alpNR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpNR--; if (alpNR < 0 || alpNR > delayN) {alpNR = delayN;}
+				inputSampleR += (aNR[alpNR]);
+				//allpass filter N
+				
+				dNR[3] = dNR[2];
+				dNR[2] = dNR[1];
+				dNR[1] = inputSampleR;
+				inputSampleR = (dNR[1] + dNR[2] + dNR[3])/3.0;
+				
+				allpasstemp = alpOR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;}
+				inputSampleR -= aOR[allpasstemp]*constallpass;
+				aOR[alpOR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpOR--; if (alpOR < 0 || alpOR > delayO) {alpOR = delayO;}
+				inputSampleR += (aOR[alpOR]);
+				//allpass filter O
+				
+				dOR[3] = dOR[2];
+				dOR[2] = dOR[1];
+				dOR[1] = inputSampleR;
+				inputSampleR = (dOR[1] + dOR[2] + dOR[3])/3.0;
+				
+				allpasstemp = alpPR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;}
+				inputSampleR -= aPR[allpasstemp]*constallpass;
+				aPR[alpPR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpPR--; if (alpPR < 0 || alpPR > delayP) {alpPR = delayP;}
+				inputSampleR += (aPR[alpPR]);
+				//allpass filter P
+				
+				dPR[3] = dPR[2];
+				dPR[2] = dPR[1];
+				dPR[1] = inputSampleR;
+				inputSampleR = (dPR[1] + dPR[2] + dPR[3])/3.0;
+				
+				allpasstemp = alpQR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;}
+				inputSampleR -= aQR[allpasstemp]*constallpass;
+				aQR[alpQR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpQR--; if (alpQR < 0 || alpQR > delayQ) {alpQR = delayQ;}
+				inputSampleR += (aQR[alpQR]);
+				//allpass filter Q
+				
+				dQR[3] = dQR[2];
+				dQR[2] = dQR[1];
+				dQR[1] = inputSampleR;
+				inputSampleR = (dQR[1] + dQR[2] + dQR[3])/3.0;
+				
+				allpasstemp = alpRR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;}
+				inputSampleR -= aRR[allpasstemp]*constallpass;
+				aRR[alpRR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpRR--; if (alpRR < 0 || alpRR > delayR) {alpRR = delayR;}
+				inputSampleR += (aRR[alpRR]);
+				//allpass filter R
+				
+				dRR[3] = dRR[2];
+				dRR[2] = dRR[1];
+				dRR[1] = inputSampleR;
+				inputSampleR = (dRR[1] + dRR[2] + dRR[3])/3.0;
+				
+				allpasstemp = alpSR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;}
+				inputSampleR -= aSR[allpasstemp]*constallpass;
+				aSR[alpSR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpSR--; if (alpSR < 0 || alpSR > delayS) {alpSR = delayS;}
+				inputSampleR += (aSR[alpSR]);
+				//allpass filter S
+				
+				dSR[3] = dSR[2];
+				dSR[2] = dSR[1];
+				dSR[1] = inputSampleR;
+				inputSampleR = (dSR[1] + dSR[2] + dSR[3])/3.0;
+				
+				allpasstemp = alpTR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;}
+				inputSampleR -= aTR[allpasstemp]*constallpass;
+				aTR[alpTR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpTR--; if (alpTR < 0 || alpTR > delayT) {alpTR = delayT;}
+				inputSampleR += (aTR[alpTR]);
+				//allpass filter T
+				
+				dTR[3] = dTR[2];
+				dTR[2] = dTR[1];
+				dTR[1] = inputSampleR;
+				inputSampleR = (dTR[1] + dTR[2] + dTR[3])/3.0;
+				
+				allpasstemp = alpUR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;}
+				inputSampleR -= aUR[allpasstemp]*constallpass;
+				aUR[alpUR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpUR--; if (alpUR < 0 || alpUR > delayU) {alpUR = delayU;}
+				inputSampleR += (aUR[alpUR]);
+				//allpass filter U
+				
+				dUR[3] = dUR[2];
+				dUR[2] = dUR[1];
+				dUR[1] = inputSampleR;
+				inputSampleR = (dUR[1] + dUR[2] + dUR[3])/3.0;
+				
+				allpasstemp = alpVR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;}
+				inputSampleR -= aVR[allpasstemp]*constallpass;
+				aVR[alpVR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpVR--; if (alpVR < 0 || alpVR > delayV) {alpVR = delayV;}
+				inputSampleR += (aVR[alpVR]);
+				//allpass filter V
+				
+				dVR[3] = dVR[2];
+				dVR[2] = dVR[1];
+				dVR[1] = inputSampleR;
+				inputSampleR = (dVR[1] + dVR[2] + dVR[3])/3.0;
+				
+				allpasstemp = alpWR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;}
+				inputSampleR -= aWR[allpasstemp]*constallpass;
+				aWR[alpWR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpWR--; if (alpWR < 0 || alpWR > delayW) {alpWR = delayW;}
+				inputSampleR += (aWR[alpWR]);
+				//allpass filter W
+				
+				dWR[3] = dWR[2];
+				dWR[2] = dWR[1];
+				dWR[1] = inputSampleR;
+				inputSampleR = (dWR[1] + dWR[2] + dWR[3])/3.0;
+				
+				allpasstemp = alpXR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;}
+				inputSampleR -= aXR[allpasstemp]*constallpass;
+				aXR[alpXR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpXR--; if (alpXR < 0 || alpXR > delayX) {alpXR = delayX;}
+				inputSampleR += (aXR[alpXR]);
+				//allpass filter X
+				
+				dXR[3] = dXR[2];
+				dXR[2] = dXR[1];
+				dXR[1] = inputSampleR;
+				inputSampleR = (dXR[1] + dXR[2] + dXR[3])/3.0;
+				
+				allpasstemp = alpYR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;}
+				inputSampleR -= aYR[allpasstemp]*constallpass;
+				aYR[alpYR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpYR--; if (alpYR < 0 || alpYR > delayY) {alpYR = delayY;}
+				inputSampleR += (aYR[alpYR]);
+				//allpass filter Y
+				
+				dYR[3] = dYR[2];
+				dYR[2] = dYR[1];
+				dYR[1] = inputSampleR;
+				inputSampleR = (dYR[1] + dYR[2] + dYR[3])/3.0;
+				
+				allpasstemp = alpZR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;}
+				inputSampleR -= aZR[allpasstemp]*constallpass;
+				aZR[alpZR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpZR--; if (alpZR < 0 || alpZR > delayZ) {alpZR = delayZ;}
+				inputSampleR += (aZR[alpZR]);
+				//allpass filter Z
+				
+				dZR[3] = dZR[2];
+				dZR[2] = dZR[1];
+				dZR[1] = inputSampleR;
+				inputSampleR = (dZR[1] + dZR[2] + dZR[3])/3.0;
+				
+				// now the second stage using the 'out' bank of allpasses		
+				
+				allpasstemp = outAR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;}
+				inputSampleR -= oAR[allpasstemp]*constallpass;
+				oAR[outAR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outAR--; if (outAR < 0 || outAR > delayA) {outAR = delayA;}
+				inputSampleR += (oAR[outAR]);
+				//allpass filter A		
+				
+				dAR[6] = dAR[5];
+				dAR[5] = dAR[4];
+				dAR[4] = inputSampleR;
+				inputSampleR = (dYR[1] + dAR[5] + dAR[6])/3.0;
+				
+				allpasstemp = outBR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;}
+				inputSampleR -= oBR[allpasstemp]*constallpass;
+				oBR[outBR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outBR--; if (outBR < 0 || outBR > delayB) {outBR = delayB;}
+				inputSampleR += (oBR[outBR]);
+				//allpass filter B
+				
+				dBR[6] = dBR[5];
+				dBR[5] = dBR[4];
+				dBR[4] = inputSampleR;
+				inputSampleR = (dXR[1] + dBR[5] + dBR[6])/3.0;
+				
+				allpasstemp = outCR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;}
+				inputSampleR -= oCR[allpasstemp]*constallpass;
+				oCR[outCR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outCR--; if (outCR < 0 || outCR > delayC) {outCR = delayC;}
+				inputSampleR += (oCR[outCR]);
+				//allpass filter C
+				
+				dCR[6] = dCR[5];
+				dCR[5] = dCR[4];
+				dCR[4] = inputSampleR;
+				inputSampleR = (dWR[1] + dCR[5] + dCR[6])/3.0;
+				
+				allpasstemp = outDR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;}
+				inputSampleR -= oDR[allpasstemp]*constallpass;
+				oDR[outDR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outDR--; if (outDR < 0 || outDR > delayD) {outDR = delayD;}
+				inputSampleR += (oDR[outDR]);
+				//allpass filter D
+				
+				dDR[6] = dDR[5];
+				dDR[5] = dDR[4];
+				dDR[4] = inputSampleR;
+				inputSampleR = (dVR[1] + dDR[5] + dDR[6])/3.0;
+				
+				allpasstemp = outER - 1;
+				if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;}
+				inputSampleR -= oER[allpasstemp]*constallpass;
+				oER[outER] = inputSampleR;
+				inputSampleR *= constallpass;
+				outER--; if (outER < 0 || outER > delayE) {outER = delayE;}
+				inputSampleR += (oER[outER]);
+				//allpass filter E
+				
+				dER[6] = dER[5];
+				dER[5] = dER[4];
+				dER[4] = inputSampleR;
+				inputSampleR = (dUR[1] + dER[5] + dER[6])/3.0;
+				
+				allpasstemp = outFR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;}
+				inputSampleR -= oFR[allpasstemp]*constallpass;
+				oFR[outFR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outFR--; if (outFR < 0 || outFR > delayF) {outFR = delayF;}
+				inputSampleR += (oFR[outFR]);
+				//allpass filter F
+				
+				dFR[6] = dFR[5];
+				dFR[5] = dFR[4];
+				dFR[4] = inputSampleR;
+				inputSampleR = (dTR[1] + dFR[5] + dFR[6])/3.0;
+				
+				allpasstemp = outGR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;}
+				inputSampleR -= oGR[allpasstemp]*constallpass;
+				oGR[outGR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outGR--; if (outGR < 0 || outGR > delayG) {outGR = delayG;}
+				inputSampleR += (oGR[outGR]);
+				//allpass filter G
+				
+				dGR[6] = dGR[5];
+				dGR[5] = dGR[4];
+				dGR[4] = inputSampleR;
+				inputSampleR = (dSR[1] + dGR[5] + dGR[6])/3.0;
+				
+				allpasstemp = outHR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;}
+				inputSampleR -= oHR[allpasstemp]*constallpass;
+				oHR[outHR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outHR--; if (outHR < 0 || outHR > delayH) {outHR = delayH;}
+				inputSampleR += (oHR[outHR]);
+				//allpass filter H
+				
+				dHR[6] = dHR[5];
+				dHR[5] = dHR[4];
+				dHR[4] = inputSampleR;
+				inputSampleR = (dRR[1] + dHR[5] + dHR[6])/3.0;
+				
+				allpasstemp = outIR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;}
+				inputSampleR -= oIR[allpasstemp]*constallpass;
+				oIR[outIR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outIR--; if (outIR < 0 || outIR > delayI) {outIR = delayI;}
+				inputSampleR += (oIR[outIR]);
+				//allpass filter I
+				
+				dIR[6] = dIR[5];
+				dIR[5] = dIR[4];
+				dIR[4] = inputSampleR;
+				inputSampleR = (dQR[1] + dIR[5] + dIR[6])/3.0;
+				
+				allpasstemp = outJR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;}
+				inputSampleR -= oJR[allpasstemp]*constallpass;
+				oJR[outJR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outJR--; if (outJR < 0 || outJR > delayJ) {outJR = delayJ;}
+				inputSampleR += (oJR[outJR]);
+				//allpass filter J
+				
+				dJR[6] = dJR[5];
+				dJR[5] = dJR[4];
+				dJR[4] = inputSampleR;
+				inputSampleR = (dPR[1] + dJR[5] + dJR[6])/3.0;
+				
+				allpasstemp = outKR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;}
+				inputSampleR -= oKR[allpasstemp]*constallpass;
+				oKR[outKR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outKR--; if (outKR < 0 || outKR > delayK) {outKR = delayK;}
+				inputSampleR += (oKR[outKR]);
+				//allpass filter K
+				
+				dKR[6] = dKR[5];
+				dKR[5] = dKR[4];
+				dKR[4] = inputSampleR;
+				inputSampleR = (dOR[1] + dKR[5] + dKR[6])/3.0;
+				
+				allpasstemp = outLR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;}
+				inputSampleR -= oLR[allpasstemp]*constallpass;
+				oLR[outLR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outLR--; if (outLR < 0 || outLR > delayL) {outLR = delayL;}
+				inputSampleR += (oLR[outLR]);
+				//allpass filter L
+				
+				dLR[6] = dLR[5];
+				dLR[5] = dLR[4];
+				dLR[4] = inputSampleR;
+				inputSampleR = (dNR[1] + dLR[5] + dLR[6])/3.0;
+				
+				allpasstemp = outMR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;}
+				inputSampleR -= oMR[allpasstemp]*constallpass;
+				oMR[outMR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outMR--; if (outMR < 0 || outMR > delayM) {outMR = delayM;}
+				inputSampleR += (oMR[outMR]);
+				//allpass filter M
+				
+				dMR[6] = dMR[5];
+				dMR[5] = dMR[4];
+				dMR[4] = inputSampleR;
+				inputSampleR = (dMR[1] + dMR[5] + dMR[6])/3.0;
+				
+				allpasstemp = outNR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;}
+				inputSampleR -= oNR[allpasstemp]*constallpass;
+				oNR[outNR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outNR--; if (outNR < 0 || outNR > delayN) {outNR = delayN;}
+				inputSampleR += (oNR[outNR]);
+				//allpass filter N
+				
+				dNR[6] = dNR[5];
+				dNR[5] = dNR[4];
+				dNR[4] = inputSampleR;
+				inputSampleR = (dLR[1] + dNR[5] + dNR[6])/3.0;
+				
+				allpasstemp = outOR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;}
+				inputSampleR -= oOR[allpasstemp]*constallpass;
+				oOR[outOR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outOR--; if (outOR < 0 || outOR > delayO) {outOR = delayO;}
+				inputSampleR += (oOR[outOR]);
+				//allpass filter O
+				
+				dOR[6] = dOR[5];
+				dOR[5] = dOR[4];
+				dOR[4] = inputSampleR;
+				inputSampleR = (dKR[1] + dOR[5] + dOR[6])/3.0;
+				
+				allpasstemp = outPR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;}
+				inputSampleR -= oPR[allpasstemp]*constallpass;
+				oPR[outPR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outPR--; if (outPR < 0 || outPR > delayP) {outPR = delayP;}
+				inputSampleR += (oPR[outPR]);
+				//allpass filter P
+				
+				dPR[6] = dPR[5];
+				dPR[5] = dPR[4];
+				dPR[4] = inputSampleR;
+				inputSampleR = (dJR[1] + dPR[5] + dPR[6])/3.0;
+				
+				allpasstemp = outQR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;}
+				inputSampleR -= oQR[allpasstemp]*constallpass;
+				oQR[outQR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outQR--; if (outQR < 0 || outQR > delayQ) {outQR = delayQ;}
+				inputSampleR += (oQR[outQR]);
+				//allpass filter Q
+				
+				dQR[6] = dQR[5];
+				dQR[5] = dQR[4];
+				dQR[4] = inputSampleR;
+				inputSampleR = (dIR[1] + dQR[5] + dQR[6])/3.0;
+				
+				allpasstemp = outRR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;}
+				inputSampleR -= oRR[allpasstemp]*constallpass;
+				oRR[outRR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outRR--; if (outRR < 0 || outRR > delayR) {outRR = delayR;}
+				inputSampleR += (oRR[outRR]);
+				//allpass filter R
+				
+				dRR[6] = dRR[5];
+				dRR[5] = dRR[4];
+				dRR[4] = inputSampleR;
+				inputSampleR = (dHR[1] + dRR[5] + dRR[6])/3.0;
+				
+				allpasstemp = outSR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;}
+				inputSampleR -= oSR[allpasstemp]*constallpass;
+				oSR[outSR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outSR--; if (outSR < 0 || outSR > delayS) {outSR = delayS;}
+				inputSampleR += (oSR[outSR]);
+				//allpass filter S
+				
+				dSR[6] = dSR[5];
+				dSR[5] = dSR[4];
+				dSR[4] = inputSampleR;
+				inputSampleR = (dGR[1] + dSR[5] + dSR[6])/3.0;
+				
+				allpasstemp = outTR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;}
+				inputSampleR -= oTR[allpasstemp]*constallpass;
+				oTR[outTR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outTR--; if (outTR < 0 || outTR > delayT) {outTR = delayT;}
+				inputSampleR += (oTR[outTR]);
+				//allpass filter T
+				
+				dTR[6] = dTR[5];
+				dTR[5] = dTR[4];
+				dTR[4] = inputSampleR;
+				inputSampleR = (dFR[1] + dTR[5] + dTR[6])/3.0;
+				
+				allpasstemp = outUR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;}
+				inputSampleR -= oUR[allpasstemp]*constallpass;
+				oUR[outUR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outUR--; if (outUR < 0 || outUR > delayU) {outUR = delayU;}
+				inputSampleR += (oUR[outUR]);
+				//allpass filter U
+				
+				dUR[6] = dUR[5];
+				dUR[5] = dUR[4];
+				dUR[4] = inputSampleR;
+				inputSampleR = (dER[1] + dUR[5] + dUR[6])/3.0;
+				
+				allpasstemp = outVR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;}
+				inputSampleR -= oVR[allpasstemp]*constallpass;
+				oVR[outVR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outVR--; if (outVR < 0 || outVR > delayV) {outVR = delayV;}
+				inputSampleR += (oVR[outVR]);
+				//allpass filter V
+				
+				dVR[6] = dVR[5];
+				dVR[5] = dVR[4];
+				dVR[4] = inputSampleR;
+				inputSampleR = (dDR[1] + dVR[5] + dVR[6])/3.0;
+				
+				allpasstemp = outWR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;}
+				inputSampleR -= oWR[allpasstemp]*constallpass;
+				oWR[outWR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outWR--; if (outWR < 0 || outWR > delayW) {outWR = delayW;}
+				inputSampleR += (oWR[outWR]);
+				//allpass filter W
+				
+				dWR[6] = dWR[5];
+				dWR[5] = dWR[4];
+				dWR[4] = inputSampleR;
+				inputSampleR = (dCR[1] + dWR[5] + dWR[6])/3.0;
+				
+				allpasstemp = outXR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;}
+				inputSampleR -= oXR[allpasstemp]*constallpass;
+				oXR[outXR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outXR--; if (outXR < 0 || outXR > delayX) {outXR = delayX;}
+				inputSampleR += (oXR[outXR]);
+				//allpass filter X
+				
+				dXR[6] = dXR[5];
+				dXR[5] = dXR[4];
+				dXR[4] = inputSampleR;
+				inputSampleR = (dAR[1] + dXR[5] + dXR[6])/3.0;
+				
+				allpasstemp = outYR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;}
+				inputSampleR -= oYR[allpasstemp]*constallpass;
+				oYR[outYR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outYR--; if (outYR < 0 || outYR > delayY) {outYR = delayY;}
+				inputSampleR += (oYR[outYR]);
+				//allpass filter Y
+				
+				dYR[6] = dYR[5];
+				dYR[5] = dYR[4];
+				dYR[4] = inputSampleR;
+				inputSampleR = (dBR[1] + dYR[5] + dYR[6])/3.0;
+				
+				allpasstemp = outZR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;}
+				inputSampleR -= oZR[allpasstemp]*constallpass;
+				oZR[outZR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outZR--; if (outZR < 0 || outZR > delayZ) {outZR = delayZ;}
+				inputSampleR += (oZR[outZR]);
+				//allpass filter Z
+				
+				dZR[6] = dZR[5];
+				dZR[5] = dZR[4];
+				dZR[4] = inputSampleR;
+				inputSampleR = (dZR[5] + dZR[6]);
+				//output Spring
+				break;
+				
+				
+			case 3:	//Tiled
+				allpasstemp = alpAR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;}
+				inputSampleR -= aAR[allpasstemp]*constallpass;
+				aAR[alpAR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpAR--; if (alpAR < 0 || alpAR > delayA) {alpAR = delayA;}
+				inputSampleR += (aAR[alpAR]);
+				//allpass filter A		
+				
+				dAR[2] = dAR[1];
+				dAR[1] = inputSampleR;
+				inputSampleR = (dAR[1] + dAR[2])/2.0;
+				
+				allpasstemp = alpBR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;}
+				inputSampleR -= aBR[allpasstemp]*constallpass;
+				aBR[alpBR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpBR--; if (alpBR < 0 || alpBR > delayB) {alpBR = delayB;}
+				inputSampleR += (aBR[alpBR]);
+				//allpass filter B
+				
+				dBR[2] = dBR[1];
+				dBR[1] = inputSampleR;
+				inputSampleR = (dBR[1] + dBR[2])/2.0;
+				
+				allpasstemp = alpCR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;}
+				inputSampleR -= aCR[allpasstemp]*constallpass;
+				aCR[alpCR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpCR--; if (alpCR < 0 || alpCR > delayC) {alpCR = delayC;}
+				inputSampleR += (aCR[alpCR]);
+				//allpass filter C
+				
+				dCR[2] = dCR[1];
+				dCR[1] = inputSampleR;
+				inputSampleR = (dAR[1] + dCR[2])/2.0;
+				
+				allpasstemp = alpDR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;}
+				inputSampleR -= aDR[allpasstemp]*constallpass;
+				aDR[alpDR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpDR--; if (alpDR < 0 || alpDR > delayD) {alpDR = delayD;}
+				inputSampleR += (aDR[alpDR]);
+				//allpass filter D
+				
+				dDR[2] = dDR[1];
+				dDR[1] = inputSampleR;
+				inputSampleR = (dDR[1] + dDR[2])/2.0;
+				
+				allpasstemp = alpER - 1;
+				if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;}
+				inputSampleR -= aER[allpasstemp]*constallpass;
+				aER[alpER] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpER--; if (alpER < 0 || alpER > delayE) {alpER = delayE;}
+				inputSampleR += (aER[alpER]);
+				//allpass filter E
+				
+				dER[2] = dER[1];
+				dER[1] = inputSampleR;
+				inputSampleR = (dAR[1] + dER[2])/2.0;
+				
+				allpasstemp = alpFR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;}
+				inputSampleR -= aFR[allpasstemp]*constallpass;
+				aFR[alpFR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpFR--; if (alpFR < 0 || alpFR > delayF) {alpFR = delayF;}
+				inputSampleR += (aFR[alpFR]);
+				//allpass filter F
+				
+				dFR[2] = dFR[1];
+				dFR[1] = inputSampleR;
+				inputSampleR = (dFR[1] + dFR[2])/2.0;
+				
+				allpasstemp = alpGR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;}
+				inputSampleR -= aGR[allpasstemp]*constallpass;
+				aGR[alpGR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpGR--; if (alpGR < 0 || alpGR > delayG) {alpGR = delayG;}
+				inputSampleR += (aGR[alpGR]);
+				//allpass filter G
+				
+				dGR[2] = dGR[1];
+				dGR[1] = inputSampleR;
+				inputSampleR = (dAR[1] + dGR[2])/2.0;
+				
+				allpasstemp = alpHR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;}
+				inputSampleR -= aHR[allpasstemp]*constallpass;
+				aHR[alpHR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpHR--; if (alpHR < 0 || alpHR > delayH) {alpHR = delayH;}
+				inputSampleR += (aHR[alpHR]);
+				//allpass filter H
+				
+				dHR[2] = dHR[1];
+				dHR[1] = inputSampleR;
+				inputSampleR = (dHR[1] + dHR[2])/2.0;
+				
+				allpasstemp = alpIR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;}
+				inputSampleR -= aIR[allpasstemp]*constallpass;
+				aIR[alpIR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpIR--; if (alpIR < 0 || alpIR > delayI) {alpIR = delayI;}
+				inputSampleR += (aIR[alpIR]);
+				//allpass filter I
+				
+				dIR[2] = dIR[1];
+				dIR[1] = inputSampleR;
+				inputSampleR = (dIR[1] + dIR[2])/2.0;
+				
+				allpasstemp = alpJR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;}
+				inputSampleR -= aJR[allpasstemp]*constallpass;
+				aJR[alpJR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpJR--; if (alpJR < 0 || alpJR > delayJ) {alpJR = delayJ;}
+				inputSampleR += (aJR[alpJR]);
+				//allpass filter J
+				
+				dJR[2] = dJR[1];
+				dJR[1] = inputSampleR;
+				inputSampleR = (dJR[1] + dJR[2])/2.0;
+				
+				allpasstemp = alpKR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;}
+				inputSampleR -= aKR[allpasstemp]*constallpass;
+				aKR[alpKR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpKR--; if (alpKR < 0 || alpKR > delayK) {alpKR = delayK;}
+				inputSampleR += (aKR[alpKR]);
+				//allpass filter K
+				
+				dKR[2] = dKR[1];
+				dKR[1] = inputSampleR;
+				inputSampleR = (dAR[1] + dKR[2])/2.0;
+				
+				allpasstemp = alpLR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;}
+				inputSampleR -= aLR[allpasstemp]*constallpass;
+				aLR[alpLR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpLR--; if (alpLR < 0 || alpLR > delayL) {alpLR = delayL;}
+				inputSampleR += (aLR[alpLR]);
+				//allpass filter L
+				
+				dLR[2] = dLR[1];
+				dLR[1] = inputSampleR;
+				inputSampleR = (dLR[1] + dLR[2])/2.0;
+				
+				allpasstemp = alpMR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;}
+				inputSampleR -= aMR[allpasstemp]*constallpass;
+				aMR[alpMR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpMR--; if (alpMR < 0 || alpMR > delayM) {alpMR = delayM;}
+				inputSampleR += (aMR[alpMR]);
+				//allpass filter M
+				
+				dMR[2] = dMR[1];
+				dMR[1] = inputSampleR;
+				inputSampleR = (dAR[1] + dMR[2])/2.0;
+				
+				allpasstemp = alpNR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;}
+				inputSampleR -= aNR[allpasstemp]*constallpass;
+				aNR[alpNR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpNR--; if (alpNR < 0 || alpNR > delayN) {alpNR = delayN;}
+				inputSampleR += (aNR[alpNR]);
+				//allpass filter N
+				
+				dNR[2] = dNR[1];
+				dNR[1] = inputSampleR;
+				inputSampleR = (dNR[1] + dNR[2])/2.0;
+				
+				allpasstemp = alpOR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;}
+				inputSampleR -= aOR[allpasstemp]*constallpass;
+				aOR[alpOR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpOR--; if (alpOR < 0 || alpOR > delayO) {alpOR = delayO;}
+				inputSampleR += (aOR[alpOR]);
+				//allpass filter O
+				
+				dOR[2] = dOR[1];
+				dOR[1] = inputSampleR;
+				inputSampleR = (dOR[1] + dOR[2])/2.0;
+				
+				allpasstemp = alpPR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;}
+				inputSampleR -= aPR[allpasstemp]*constallpass;
+				aPR[alpPR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpPR--; if (alpPR < 0 || alpPR > delayP) {alpPR = delayP;}
+				inputSampleR += (aPR[alpPR]);
+				//allpass filter P
+				
+				dPR[2] = dPR[1];
+				dPR[1] = inputSampleR;
+				inputSampleR = (dPR[1] + dPR[2])/2.0;
+				
+				allpasstemp = alpQR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;}
+				inputSampleR -= aQR[allpasstemp]*constallpass;
+				aQR[alpQR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpQR--; if (alpQR < 0 || alpQR > delayQ) {alpQR = delayQ;}
+				inputSampleR += (aQR[alpQR]);
+				//allpass filter Q
+				
+				dQR[2] = dQR[1];
+				dQR[1] = inputSampleR;
+				inputSampleR = (dAR[1] + dQR[2])/2.0;
+				
+				allpasstemp = alpRR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;}
+				inputSampleR -= aRR[allpasstemp]*constallpass;
+				aRR[alpRR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpRR--; if (alpRR < 0 || alpRR > delayR) {alpRR = delayR;}
+				inputSampleR += (aRR[alpRR]);
+				//allpass filter R
+				
+				dRR[2] = dRR[1];
+				dRR[1] = inputSampleR;
+				inputSampleR = (dRR[1] + dRR[2])/2.0;
+				
+				allpasstemp = alpSR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;}
+				inputSampleR -= aSR[allpasstemp]*constallpass;
+				aSR[alpSR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpSR--; if (alpSR < 0 || alpSR > delayS) {alpSR = delayS;}
+				inputSampleR += (aSR[alpSR]);
+				//allpass filter S
+				
+				dSR[2] = dSR[1];
+				dSR[1] = inputSampleR;
+				inputSampleR = (dAR[1] + dSR[2])/2.0;
+				
+				allpasstemp = alpTR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;}
+				inputSampleR -= aTR[allpasstemp]*constallpass;
+				aTR[alpTR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpTR--; if (alpTR < 0 || alpTR > delayT) {alpTR = delayT;}
+				inputSampleR += (aTR[alpTR]);
+				//allpass filter T
+				
+				dTR[2] = dTR[1];
+				dTR[1] = inputSampleR;
+				inputSampleR = (dTR[1] + dTR[2])/2.0;
+				
+				allpasstemp = alpUR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;}
+				inputSampleR -= aUR[allpasstemp]*constallpass;
+				aUR[alpUR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpUR--; if (alpUR < 0 || alpUR > delayU) {alpUR = delayU;}
+				inputSampleR += (aUR[alpUR]);
+				//allpass filter U
+				
+				dUR[2] = dUR[1];
+				dUR[1] = inputSampleR;
+				inputSampleR = (dUR[1] + dUR[2])/2.0;
+				
+				allpasstemp = alpVR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;}
+				inputSampleR -= aVR[allpasstemp]*constallpass;
+				aVR[alpVR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpVR--; if (alpVR < 0 || alpVR > delayV) {alpVR = delayV;}
+				inputSampleR += (aVR[alpVR]);
+				//allpass filter V
+				
+				dVR[2] = dVR[1];
+				dVR[1] = inputSampleR;
+				inputSampleR = (dVR[1] + dVR[2])/2.0;
+				
+				allpasstemp = alpWR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;}
+				inputSampleR -= aWR[allpasstemp]*constallpass;
+				aWR[alpWR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpWR--; if (alpWR < 0 || alpWR > delayW) {alpWR = delayW;}
+				inputSampleR += (aWR[alpWR]);
+				//allpass filter W
+				
+				dWR[2] = dWR[1];
+				dWR[1] = inputSampleR;
+				inputSampleR = (dAR[1] + dWR[2])/2.0;
+				
+				allpasstemp = alpXR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;}
+				inputSampleR -= aXR[allpasstemp]*constallpass;
+				aXR[alpXR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpXR--; if (alpXR < 0 || alpXR > delayX) {alpXR = delayX;}
+				inputSampleR += (aXR[alpXR]);
+				//allpass filter X
+				
+				dXR[2] = dXR[1];
+				dXR[1] = inputSampleR;
+				inputSampleR = (dXR[1] + dXR[2])/2.0;
+				
+				allpasstemp = alpYR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;}
+				inputSampleR -= aYR[allpasstemp]*constallpass;
+				aYR[alpYR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpYR--; if (alpYR < 0 || alpYR > delayY) {alpYR = delayY;}
+				inputSampleR += (aYR[alpYR]);
+				//allpass filter Y
+				
+				dYR[2] = dYR[1];
+				dYR[1] = inputSampleR;
+				inputSampleR = (dYR[1] + dYR[2])/2.0;
+				
+				allpasstemp = alpZR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;}
+				inputSampleR -= aZR[allpasstemp]*constallpass;
+				aZR[alpZR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpZR--; if (alpZR < 0 || alpZR > delayZ) {alpZR = delayZ;}
+				inputSampleR += (aZR[alpZR]);
+				//allpass filter Z
+				
+				dZR[2] = dZR[1];
+				dZR[1] = inputSampleR;
+				inputSampleR = (dZR[1] + dZR[2])/2.0;
+				
+				// now the second stage using the 'out' bank of allpasses		
+				
+				allpasstemp = outAR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;}
+				inputSampleR -= oAR[allpasstemp]*constallpass;
+				oAR[outAR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outAR--; if (outAR < 0 || outAR > delayA) {outAR = delayA;}
+				inputSampleR += (oAR[outAR]);
+				//allpass filter A		
+				
+				dAR[5] = dAR[4];
+				dAR[4] = inputSampleR;
+				inputSampleR = (dAR[4] + dAR[5])/2.0;
+				
+				allpasstemp = outBR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;}
+				inputSampleR -= oBR[allpasstemp]*constallpass;
+				oBR[outBR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outBR--; if (outBR < 0 || outBR > delayB) {outBR = delayB;}
+				inputSampleR += (oBR[outBR]);
+				//allpass filter B
+				
+				dBR[5] = dBR[4];
+				dBR[4] = inputSampleR;
+				inputSampleR = (dBR[4] + dBR[5])/2.0;
+				
+				allpasstemp = outCR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;}
+				inputSampleR -= oCR[allpasstemp]*constallpass;
+				oCR[outCR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outCR--; if (outCR < 0 || outCR > delayC) {outCR = delayC;}
+				inputSampleR += (oCR[outCR]);
+				//allpass filter C
+				
+				dCR[5] = dCR[4];
+				dCR[4] = inputSampleR;
+				inputSampleR = (dAR[1] + dCR[5])/2.0;
+				
+				allpasstemp = outDR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;}
+				inputSampleR -= oDR[allpasstemp]*constallpass;
+				oDR[outDR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outDR--; if (outDR < 0 || outDR > delayD) {outDR = delayD;}
+				inputSampleR += (oDR[outDR]);
+				//allpass filter D
+				
+				dDR[5] = dDR[4];
+				dDR[4] = inputSampleR;
+				inputSampleR = (dDR[4] + dDR[5])/2.0;
+				
+				allpasstemp = outER - 1;
+				if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;}
+				inputSampleR -= oER[allpasstemp]*constallpass;
+				oER[outER] = inputSampleR;
+				inputSampleR *= constallpass;
+				outER--; if (outER < 0 || outER > delayE) {outER = delayE;}
+				inputSampleR += (oER[outER]);
+				//allpass filter E
+				
+				dER[5] = dER[4];
+				dER[4] = inputSampleR;
+				inputSampleR = (dAR[1] + dER[5])/2.0;
+				
+				allpasstemp = outFR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;}
+				inputSampleR -= oFR[allpasstemp]*constallpass;
+				oFR[outFR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outFR--; if (outFR < 0 || outFR > delayF) {outFR = delayF;}
+				inputSampleR += (oFR[outFR]);
+				//allpass filter F
+				
+				dFR[5] = dFR[4];
+				dFR[4] = inputSampleR;
+				inputSampleR = (dFR[4] + dFR[5])/2.0;
+				
+				allpasstemp = outGR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;}
+				inputSampleR -= oGR[allpasstemp]*constallpass;
+				oGR[outGR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outGR--; if (outGR < 0 || outGR > delayG) {outGR = delayG;}
+				inputSampleR += (oGR[outGR]);
+				//allpass filter G
+				
+				dGR[5] = dGR[4];
+				dGR[4] = inputSampleR;
+				inputSampleR = (dGR[4] + dGR[5])/2.0;
+				
+				allpasstemp = outHR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;}
+				inputSampleR -= oHR[allpasstemp]*constallpass;
+				oHR[outHR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outHR--; if (outHR < 0 || outHR > delayH) {outHR = delayH;}
+				inputSampleR += (oHR[outHR]);
+				//allpass filter H
+				
+				dHR[5] = dHR[4];
+				dHR[4] = inputSampleR;
+				inputSampleR = (dHR[4] + dHR[5])/2.0;
+				
+				allpasstemp = outIR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;}
+				inputSampleR -= oIR[allpasstemp]*constallpass;
+				oIR[outIR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outIR--; if (outIR < 0 || outIR > delayI) {outIR = delayI;}
+				inputSampleR += (oIR[outIR]);
+				//allpass filter I
+				
+				dIR[5] = dIR[4];
+				dIR[4] = inputSampleR;
+				inputSampleR = (dIR[4] + dIR[5])/2.0;
+				
+				allpasstemp = outJR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;}
+				inputSampleR -= oJR[allpasstemp]*constallpass;
+				oJR[outJR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outJR--; if (outJR < 0 || outJR > delayJ) {outJR = delayJ;}
+				inputSampleR += (oJR[outJR]);
+				//allpass filter J
+				
+				dJR[5] = dJR[4];
+				dJR[4] = inputSampleR;
+				inputSampleR = (dJR[4] + dJR[5])/2.0;
+				
+				allpasstemp = outKR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;}
+				inputSampleR -= oKR[allpasstemp]*constallpass;
+				oKR[outKR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outKR--; if (outKR < 0 || outKR > delayK) {outKR = delayK;}
+				inputSampleR += (oKR[outKR]);
+				//allpass filter K
+				
+				dKR[5] = dKR[4];
+				dKR[4] = inputSampleR;
+				inputSampleR = (dAR[1] + dKR[5])/2.0;
+				
+				allpasstemp = outLR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;}
+				inputSampleR -= oLR[allpasstemp]*constallpass;
+				oLR[outLR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outLR--; if (outLR < 0 || outLR > delayL) {outLR = delayL;}
+				inputSampleR += (oLR[outLR]);
+				//allpass filter L
+				
+				dLR[5] = dLR[4];
+				dLR[4] = inputSampleR;
+				inputSampleR = (dLR[4] + dLR[5])/2.0;
+				
+				allpasstemp = outMR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;}
+				inputSampleR -= oMR[allpasstemp]*constallpass;
+				oMR[outMR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outMR--; if (outMR < 0 || outMR > delayM) {outMR = delayM;}
+				inputSampleR += (oMR[outMR]);
+				//allpass filter M
+				
+				dMR[5] = dMR[4];
+				dMR[4] = inputSampleR;
+				inputSampleR = (dMR[4] + dMR[5])/2.0;
+				
+				allpasstemp = outNR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;}
+				inputSampleR -= oNR[allpasstemp]*constallpass;
+				oNR[outNR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outNR--; if (outNR < 0 || outNR > delayN) {outNR = delayN;}
+				inputSampleR += (oNR[outNR]);
+				//allpass filter N
+				
+				dNR[5] = dNR[4];
+				dNR[4] = inputSampleR;
+				inputSampleR = (dNR[4] + dNR[5])/2.0;
+				
+				allpasstemp = outOR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;}
+				inputSampleR -= oOR[allpasstemp]*constallpass;
+				oOR[outOR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outOR--; if (outOR < 0 || outOR > delayO) {outOR = delayO;}
+				inputSampleR += (oOR[outOR]);
+				//allpass filter O
+				
+				dOR[5] = dOR[4];
+				dOR[4] = inputSampleR;
+				inputSampleR = (dAR[1] + dOR[5])/2.0;
+				
+				allpasstemp = outPR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;}
+				inputSampleR -= oPR[allpasstemp]*constallpass;
+				oPR[outPR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outPR--; if (outPR < 0 || outPR > delayP) {outPR = delayP;}
+				inputSampleR += (oPR[outPR]);
+				//allpass filter P
+				
+				dPR[5] = dPR[4];
+				dPR[4] = inputSampleR;
+				inputSampleR = (dPR[4] + dPR[5])/2.0;
+				
+				allpasstemp = outQR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;}
+				inputSampleR -= oQR[allpasstemp]*constallpass;
+				oQR[outQR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outQR--; if (outQR < 0 || outQR > delayQ) {outQR = delayQ;}
+				inputSampleR += (oQR[outQR]);
+				//allpass filter Q
+				
+				dQR[5] = dQR[4];
+				dQR[4] = inputSampleR;
+				inputSampleR = (dAR[1] + dQR[5])/2.0;
+				
+				allpasstemp = outRR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;}
+				inputSampleR -= oRR[allpasstemp]*constallpass;
+				oRR[outRR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outRR--; if (outRR < 0 || outRR > delayR) {outRR = delayR;}
+				inputSampleR += (oRR[outRR]);
+				//allpass filter R
+				
+				dRR[5] = dRR[4];
+				dRR[4] = inputSampleR;
+				inputSampleR = (dRR[4] + dRR[5])/2.0;
+				
+				allpasstemp = outSR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;}
+				inputSampleR -= oSR[allpasstemp]*constallpass;
+				oSR[outSR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outSR--; if (outSR < 0 || outSR > delayS) {outSR = delayS;}
+				inputSampleR += (oSR[outSR]);
+				//allpass filter S
+				
+				dSR[5] = dSR[4];
+				dSR[4] = inputSampleR;
+				inputSampleR = (dSR[4] + dSR[5])/2.0;
+				
+				allpasstemp = outTR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;}
+				inputSampleR -= oTR[allpasstemp]*constallpass;
+				oTR[outTR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outTR--; if (outTR < 0 || outTR > delayT) {outTR = delayT;}
+				inputSampleR += (oTR[outTR]);
+				//allpass filter T
+				
+				dTR[5] = dTR[4];
+				dTR[4] = inputSampleR;
+				inputSampleR = (dTR[4] + dTR[5])/2.0;
+				
+				allpasstemp = outUR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;}
+				inputSampleR -= oUR[allpasstemp]*constallpass;
+				oUR[outUR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outUR--; if (outUR < 0 || outUR > delayU) {outUR = delayU;}
+				inputSampleR += (oUR[outUR]);
+				//allpass filter U
+				
+				dUR[5] = dUR[4];
+				dUR[4] = inputSampleR;
+				inputSampleR = (dAR[1] + dUR[5])/2.0;
+				
+				allpasstemp = outVR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;}
+				inputSampleR -= oVR[allpasstemp]*constallpass;
+				oVR[outVR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outVR--; if (outVR < 0 || outVR > delayV) {outVR = delayV;}
+				inputSampleR += (oVR[outVR]);
+				//allpass filter V
+				
+				dVR[5] = dVR[4];
+				dVR[4] = inputSampleR;
+				inputSampleR = (dVR[4] + dVR[5])/2.0;
+				
+				allpasstemp = outWR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;}
+				inputSampleR -= oWR[allpasstemp]*constallpass;
+				oWR[outWR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outWR--; if (outWR < 0 || outWR > delayW) {outWR = delayW;}
+				inputSampleR += (oWR[outWR]);
+				//allpass filter W
+				
+				dWR[5] = dWR[4];
+				dWR[4] = inputSampleR;
+				inputSampleR = (dWR[4] + dWR[5])/2.0;
+				
+				allpasstemp = outXR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;}
+				inputSampleR -= oXR[allpasstemp]*constallpass;
+				oXR[outXR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outXR--; if (outXR < 0 || outXR > delayX) {outXR = delayX;}
+				inputSampleR += (oXR[outXR]);
+				//allpass filter X
+				
+				dXR[5] = dXR[4];
+				dXR[4] = inputSampleR;
+				inputSampleR = (dXR[4] + dXR[5])/2.0;
+				
+				allpasstemp = outYR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;}
+				inputSampleR -= oYR[allpasstemp]*constallpass;
+				oYR[outYR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outYR--; if (outYR < 0 || outYR > delayY) {outYR = delayY;}
+				inputSampleR += (oYR[outYR]);
+				//allpass filter Y
+				
+				dYR[5] = dYR[4];
+				dYR[4] = inputSampleR;
+				inputSampleR = (dYR[4] + dYR[5])/2.0;
+				
+				allpasstemp = outZR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;}
+				inputSampleR -= oZR[allpasstemp]*constallpass;
+				oZR[outZR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outZR--; if (outZR < 0 || outZR > delayZ) {outZR = delayZ;}
+				inputSampleR += (oZR[outZR]);
+				//allpass filter Z
+				
+				dZR[5] = dZR[4];
+				dZR[4] = inputSampleR;
+				inputSampleR = (dZR[4] + dZR[5]);		
+				//output Tiled
+				break;
+				
+				
+			case 4://Room
+				allpasstemp = alpAR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;}
+				inputSampleR -= aAR[allpasstemp]*constallpass;
+				aAR[alpAR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpAR--; if (alpAR < 0 || alpAR > delayA) {alpAR = delayA;}
+				inputSampleR += (aAR[alpAR]);
+				//allpass filter A		
+				
+				dAR[2] = dAR[1];
+				dAR[1] = inputSampleR;
+				inputSampleR = drySampleR;
+				
+				allpasstemp = alpBR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;}
+				inputSampleR -= aBR[allpasstemp]*constallpass;
+				aBR[alpBR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpBR--; if (alpBR < 0 || alpBR > delayB) {alpBR = delayB;}
+				inputSampleR += (aBR[alpBR]);
+				//allpass filter B
+				
+				dBR[2] = dBR[1];
+				dBR[1] = inputSampleR;
+				inputSampleR = drySampleR;
+				
+				allpasstemp = alpCR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;}
+				inputSampleR -= aCR[allpasstemp]*constallpass;
+				aCR[alpCR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpCR--; if (alpCR < 0 || alpCR > delayC) {alpCR = delayC;}
+				inputSampleR += (aCR[alpCR]);
+				//allpass filter C
+				
+				dCR[2] = dCR[1];
+				dCR[1] = inputSampleR;
+				inputSampleR = drySampleR;
+				
+				allpasstemp = alpDR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;}
+				inputSampleR -= aDR[allpasstemp]*constallpass;
+				aDR[alpDR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpDR--; if (alpDR < 0 || alpDR > delayD) {alpDR = delayD;}
+				inputSampleR += (aDR[alpDR]);
+				//allpass filter D
+				
+				dDR[2] = dDR[1];
+				dDR[1] = inputSampleR;
+				inputSampleR = drySampleR;
+				
+				allpasstemp = alpER - 1;
+				if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;}
+				inputSampleR -= aER[allpasstemp]*constallpass;
+				aER[alpER] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpER--; if (alpER < 0 || alpER > delayE) {alpER = delayE;}
+				inputSampleR += (aER[alpER]);
+				//allpass filter E
+				
+				dER[2] = dER[1];
+				dER[1] = inputSampleR;
+				inputSampleR = drySampleR;
+				
+				allpasstemp = alpFR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;}
+				inputSampleR -= aFR[allpasstemp]*constallpass;
+				aFR[alpFR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpFR--; if (alpFR < 0 || alpFR > delayF) {alpFR = delayF;}
+				inputSampleR += (aFR[alpFR]);
+				//allpass filter F
+				
+				dFR[2] = dFR[1];
+				dFR[1] = inputSampleR;
+				inputSampleR = drySampleR;
+				
+				allpasstemp = alpGR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;}
+				inputSampleR -= aGR[allpasstemp]*constallpass;
+				aGR[alpGR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpGR--; if (alpGR < 0 || alpGR > delayG) {alpGR = delayG;}
+				inputSampleR += (aGR[alpGR]);
+				//allpass filter G
+				
+				dGR[2] = dGR[1];
+				dGR[1] = inputSampleR;
+				inputSampleR = drySampleR;
+				
+				allpasstemp = alpHR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;}
+				inputSampleR -= aHR[allpasstemp]*constallpass;
+				aHR[alpHR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpHR--; if (alpHR < 0 || alpHR > delayH) {alpHR = delayH;}
+				inputSampleR += (aHR[alpHR]);
+				//allpass filter H
+				
+				dHR[2] = dHR[1];
+				dHR[1] = inputSampleR;
+				inputSampleR = drySampleR;
+				
+				allpasstemp = alpIR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;}
+				inputSampleR -= aIR[allpasstemp]*constallpass;
+				aIR[alpIR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpIR--; if (alpIR < 0 || alpIR > delayI) {alpIR = delayI;}
+				inputSampleR += (aIR[alpIR]);
+				//allpass filter I
+				
+				dIR[2] = dIR[1];
+				dIR[1] = inputSampleR;
+				inputSampleR = drySampleR;
+				
+				allpasstemp = alpJR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;}
+				inputSampleR -= aJR[allpasstemp]*constallpass;
+				aJR[alpJR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpJR--; if (alpJR < 0 || alpJR > delayJ) {alpJR = delayJ;}
+				inputSampleR += (aJR[alpJR]);
+				//allpass filter J
+				
+				dJR[2] = dJR[1];
+				dJR[1] = inputSampleR;
+				inputSampleR = drySampleR;
+				
+				allpasstemp = alpKR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;}
+				inputSampleR -= aKR[allpasstemp]*constallpass;
+				aKR[alpKR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpKR--; if (alpKR < 0 || alpKR > delayK) {alpKR = delayK;}
+				inputSampleR += (aKR[alpKR]);
+				//allpass filter K
+				
+				dKR[2] = dKR[1];
+				dKR[1] = inputSampleR;
+				inputSampleR = drySampleR;
+				
+				allpasstemp = alpLR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;}
+				inputSampleR -= aLR[allpasstemp]*constallpass;
+				aLR[alpLR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpLR--; if (alpLR < 0 || alpLR > delayL) {alpLR = delayL;}
+				inputSampleR += (aLR[alpLR]);
+				//allpass filter L
+				
+				dLR[2] = dLR[1];
+				dLR[1] = inputSampleR;
+				inputSampleR = drySampleR;
+				
+				allpasstemp = alpMR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;}
+				inputSampleR -= aMR[allpasstemp]*constallpass;
+				aMR[alpMR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpMR--; if (alpMR < 0 || alpMR > delayM) {alpMR = delayM;}
+				inputSampleR += (aMR[alpMR]);
+				//allpass filter M
+				
+				dMR[2] = dMR[1];
+				dMR[1] = inputSampleR;
+				inputSampleR = drySampleR;
+				
+				allpasstemp = alpNR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;}
+				inputSampleR -= aNR[allpasstemp]*constallpass;
+				aNR[alpNR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpNR--; if (alpNR < 0 || alpNR > delayN) {alpNR = delayN;}
+				inputSampleR += (aNR[alpNR]);
+				//allpass filter N
+				
+				dNR[2] = dNR[1];
+				dNR[1] = inputSampleR;
+				inputSampleR = drySampleR;
+				
+				allpasstemp = alpOR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;}
+				inputSampleR -= aOR[allpasstemp]*constallpass;
+				aOR[alpOR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpOR--; if (alpOR < 0 || alpOR > delayO) {alpOR = delayO;}
+				inputSampleR += (aOR[alpOR]);
+				//allpass filter O
+				
+				dOR[2] = dOR[1];
+				dOR[1] = inputSampleR;
+				inputSampleR = drySampleR;
+				
+				allpasstemp = alpPR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;}
+				inputSampleR -= aPR[allpasstemp]*constallpass;
+				aPR[alpPR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpPR--; if (alpPR < 0 || alpPR > delayP) {alpPR = delayP;}
+				inputSampleR += (aPR[alpPR]);
+				//allpass filter P
+				
+				dPR[2] = dPR[1];
+				dPR[1] = inputSampleR;
+				inputSampleR = drySampleR;
+				
+				allpasstemp = alpQR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;}
+				inputSampleR -= aQR[allpasstemp]*constallpass;
+				aQR[alpQR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpQR--; if (alpQR < 0 || alpQR > delayQ) {alpQR = delayQ;}
+				inputSampleR += (aQR[alpQR]);
+				//allpass filter Q
+				
+				dQR[2] = dQR[1];
+				dQR[1] = inputSampleR;
+				inputSampleR = drySampleR;
+				
+				allpasstemp = alpRR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;}
+				inputSampleR -= aRR[allpasstemp]*constallpass;
+				aRR[alpRR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpRR--; if (alpRR < 0 || alpRR > delayR) {alpRR = delayR;}
+				inputSampleR += (aRR[alpRR]);
+				//allpass filter R
+				
+				dRR[2] = dRR[1];
+				dRR[1] = inputSampleR;
+				inputSampleR = drySampleR;
+				
+				allpasstemp = alpSR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;}
+				inputSampleR -= aSR[allpasstemp]*constallpass;
+				aSR[alpSR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpSR--; if (alpSR < 0 || alpSR > delayS) {alpSR = delayS;}
+				inputSampleR += (aSR[alpSR]);
+				//allpass filter S
+				
+				dSR[2] = dSR[1];
+				dSR[1] = inputSampleR;
+				inputSampleR = drySampleR;
+				
+				allpasstemp = alpTR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;}
+				inputSampleR -= aTR[allpasstemp]*constallpass;
+				aTR[alpTR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpTR--; if (alpTR < 0 || alpTR > delayT) {alpTR = delayT;}
+				inputSampleR += (aTR[alpTR]);
+				//allpass filter T
+				
+				dTR[2] = dTR[1];
+				dTR[1] = inputSampleR;
+				inputSampleR = drySampleR;
+				
+				allpasstemp = alpUR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;}
+				inputSampleR -= aUR[allpasstemp]*constallpass;
+				aUR[alpUR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpUR--; if (alpUR < 0 || alpUR > delayU) {alpUR = delayU;}
+				inputSampleR += (aUR[alpUR]);
+				//allpass filter U
+				
+				dUR[2] = dUR[1];
+				dUR[1] = inputSampleR;
+				inputSampleR = drySampleR;
+				
+				allpasstemp = alpVR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;}
+				inputSampleR -= aVR[allpasstemp]*constallpass;
+				aVR[alpVR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpVR--; if (alpVR < 0 || alpVR > delayV) {alpVR = delayV;}
+				inputSampleR += (aVR[alpVR]);
+				//allpass filter V
+				
+				dVR[2] = dVR[1];
+				dVR[1] = inputSampleR;
+				inputSampleR = drySampleR;
+				
+				allpasstemp = alpWR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;}
+				inputSampleR -= aWR[allpasstemp]*constallpass;
+				aWR[alpWR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpWR--; if (alpWR < 0 || alpWR > delayW) {alpWR = delayW;}
+				inputSampleR += (aWR[alpWR]);
+				//allpass filter W
+				
+				dWR[2] = dWR[1];
+				dWR[1] = inputSampleR;
+				inputSampleR = drySampleR;
+				
+				allpasstemp = alpXR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;}
+				inputSampleR -= aXR[allpasstemp]*constallpass;
+				aXR[alpXR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpXR--; if (alpXR < 0 || alpXR > delayX) {alpXR = delayX;}
+				inputSampleR += (aXR[alpXR]);
+				//allpass filter X
+				
+				dXR[2] = dXR[1];
+				dXR[1] = inputSampleR;
+				inputSampleR = drySampleR;
+				
+				allpasstemp = alpYR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;}
+				inputSampleR -= aYR[allpasstemp]*constallpass;
+				aYR[alpYR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpYR--; if (alpYR < 0 || alpYR > delayY) {alpYR = delayY;}
+				inputSampleR += (aYR[alpYR]);
+				//allpass filter Y
+				
+				dYR[2] = dYR[1];
+				dYR[1] = inputSampleR;
+				inputSampleR = drySampleR;
+				
+				allpasstemp = alpZR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;}
+				inputSampleR -= aZR[allpasstemp]*constallpass;
+				aZR[alpZR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpZR--; if (alpZR < 0 || alpZR > delayZ) {alpZR = delayZ;}
+				inputSampleR += (aZR[alpZR]);
+				//allpass filter Z
+				
+				dZR[2] = dZR[1];
+				dZR[1] = inputSampleR;
+				inputSampleR = drySampleR;
+				
+				// now the second stage using the 'out' bank of allpasses		
+				
+				allpasstemp = outAR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;}
+				inputSampleR -= oAR[allpasstemp]*constallpass;
+				oAR[outAR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outAR--; if (outAR < 0 || outAR > delayA) {outAR = delayA;}
+				inputSampleR += (oAR[outAR]);
+				//allpass filter A		
+				
+				dAR[5] = dAR[4];
+				dAR[4] = inputSampleR;
+				inputSampleR = (dAR[1]+dAR[2])/2.0;
+				
+				allpasstemp = outBR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;}
+				inputSampleR -= oBR[allpasstemp]*constallpass;
+				oBR[outBR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outBR--; if (outBR < 0 || outBR > delayB) {outBR = delayB;}
+				inputSampleR += (oBR[outBR]);
+				//allpass filter B
+				
+				dBR[5] = dBR[4];
+				dBR[4] = inputSampleR;
+				inputSampleR = (dBR[1]+dBR[2])/2.0;
+				
+				allpasstemp = outCR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;}
+				inputSampleR -= oCR[allpasstemp]*constallpass;
+				oCR[outCR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outCR--; if (outCR < 0 || outCR > delayC) {outCR = delayC;}
+				inputSampleR += (oCR[outCR]);
+				//allpass filter C
+				
+				dCR[5] = dCR[4];
+				dCR[4] = inputSampleR;
+				inputSampleR = (dCR[1]+dCR[2])/2.0;
+				
+				allpasstemp = outDR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;}
+				inputSampleR -= oDR[allpasstemp]*constallpass;
+				oDR[outDR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outDR--; if (outDR < 0 || outDR > delayD) {outDR = delayD;}
+				inputSampleR += (oDR[outDR]);
+				//allpass filter D
+				
+				dDR[5] = dDR[4];
+				dDR[4] = inputSampleR;
+				inputSampleR = (dDR[1]+dDR[2])/2.0;
+				
+				allpasstemp = outER - 1;
+				if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;}
+				inputSampleR -= oER[allpasstemp]*constallpass;
+				oER[outER] = inputSampleR;
+				inputSampleR *= constallpass;
+				outER--; if (outER < 0 || outER > delayE) {outER = delayE;}
+				inputSampleR += (oER[outER]);
+				//allpass filter E
+				
+				dER[5] = dER[4];
+				dER[4] = inputSampleR;
+				inputSampleR = (dER[1]+dER[2])/2.0;
+				
+				allpasstemp = outFR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;}
+				inputSampleR -= oFR[allpasstemp]*constallpass;
+				oFR[outFR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outFR--; if (outFR < 0 || outFR > delayF) {outFR = delayF;}
+				inputSampleR += (oFR[outFR]);
+				//allpass filter F
+				
+				dFR[5] = dFR[4];
+				dFR[4] = inputSampleR;
+				inputSampleR = (dFR[1]+dFR[2])/2.0;
+				
+				allpasstemp = outGR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;}
+				inputSampleR -= oGR[allpasstemp]*constallpass;
+				oGR[outGR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outGR--; if (outGR < 0 || outGR > delayG) {outGR = delayG;}
+				inputSampleR += (oGR[outGR]);
+				//allpass filter G
+				
+				dGR[5] = dGR[4];
+				dGR[4] = inputSampleR;
+				inputSampleR = (dGR[1]+dGR[2])/2.0;
+				
+				allpasstemp = outHR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;}
+				inputSampleR -= oHR[allpasstemp]*constallpass;
+				oHR[outHR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outHR--; if (outHR < 0 || outHR > delayH) {outHR = delayH;}
+				inputSampleR += (oHR[outHR]);
+				//allpass filter H
+				
+				dHR[5] = dHR[4];
+				dHR[4] = inputSampleR;
+				inputSampleR = (dHR[1]+dHR[2])/2.0;
+				
+				allpasstemp = outIR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;}
+				inputSampleR -= oIR[allpasstemp]*constallpass;
+				oIR[outIR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outIR--; if (outIR < 0 || outIR > delayI) {outIR = delayI;}
+				inputSampleR += (oIR[outIR]);
+				//allpass filter I
+				
+				dIR[5] = dIR[4];
+				dIR[4] = inputSampleR;
+				inputSampleR = (dIR[1]+dIR[2])/2.0;
+				
+				allpasstemp = outJR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;}
+				inputSampleR -= oJR[allpasstemp]*constallpass;
+				oJR[outJR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outJR--; if (outJR < 0 || outJR > delayJ) {outJR = delayJ;}
+				inputSampleR += (oJR[outJR]);
+				//allpass filter J
+				
+				dJR[5] = dJR[4];
+				dJR[4] = inputSampleR;
+				inputSampleR = (dJR[1]+dJR[2])/2.0;
+				
+				allpasstemp = outKR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;}
+				inputSampleR -= oKR[allpasstemp]*constallpass;
+				oKR[outKR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outKR--; if (outKR < 0 || outKR > delayK) {outKR = delayK;}
+				inputSampleR += (oKR[outKR]);
+				//allpass filter K
+				
+				dKR[5] = dKR[4];
+				dKR[4] = inputSampleR;
+				inputSampleR = (dKR[1]+dKR[2])/2.0;
+				
+				allpasstemp = outLR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;}
+				inputSampleR -= oLR[allpasstemp]*constallpass;
+				oLR[outLR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outLR--; if (outLR < 0 || outLR > delayL) {outLR = delayL;}
+				inputSampleR += (oLR[outLR]);
+				//allpass filter L
+				
+				dLR[5] = dLR[4];
+				dLR[4] = inputSampleR;
+				inputSampleR = (dLR[1]+dLR[2])/2.0;
+				
+				allpasstemp = outMR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;}
+				inputSampleR -= oMR[allpasstemp]*constallpass;
+				oMR[outMR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outMR--; if (outMR < 0 || outMR > delayM) {outMR = delayM;}
+				inputSampleR += (oMR[outMR]);
+				//allpass filter M
+				
+				dMR[5] = dMR[4];
+				dMR[4] = inputSampleR;
+				inputSampleR = (dMR[1]+dMR[2])/2.0;
+				
+				allpasstemp = outNR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;}
+				inputSampleR -= oNR[allpasstemp]*constallpass;
+				oNR[outNR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outNR--; if (outNR < 0 || outNR > delayN) {outNR = delayN;}
+				inputSampleR += (oNR[outNR]);
+				//allpass filter N
+				
+				dNR[5] = dNR[4];
+				dNR[4] = inputSampleR;
+				inputSampleR = (dNR[1]+dNR[2])/2.0;
+				
+				allpasstemp = outOR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;}
+				inputSampleR -= oOR[allpasstemp]*constallpass;
+				oOR[outOR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outOR--; if (outOR < 0 || outOR > delayO) {outOR = delayO;}
+				inputSampleR += (oOR[outOR]);
+				//allpass filter O
+				
+				dOR[5] = dOR[4];
+				dOR[4] = inputSampleR;
+				inputSampleR = (dOR[1]+dOR[2])/2.0;
+				
+				allpasstemp = outPR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;}
+				inputSampleR -= oPR[allpasstemp]*constallpass;
+				oPR[outPR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outPR--; if (outPR < 0 || outPR > delayP) {outPR = delayP;}
+				inputSampleR += (oPR[outPR]);
+				//allpass filter P
+				
+				dPR[5] = dPR[4];
+				dPR[4] = inputSampleR;
+				inputSampleR = (dPR[1]+dPR[2])/2.0;
+				
+				allpasstemp = outQR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;}
+				inputSampleR -= oQR[allpasstemp]*constallpass;
+				oQR[outQR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outQR--; if (outQR < 0 || outQR > delayQ) {outQR = delayQ;}
+				inputSampleR += (oQR[outQR]);
+				//allpass filter Q
+				
+				dQR[5] = dQR[4];
+				dQR[4] = inputSampleR;
+				inputSampleR = (dQR[1]+dQR[2])/2.0;
+				
+				allpasstemp = outRR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;}
+				inputSampleR -= oRR[allpasstemp]*constallpass;
+				oRR[outRR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outRR--; if (outRR < 0 || outRR > delayR) {outRR = delayR;}
+				inputSampleR += (oRR[outRR]);
+				//allpass filter R
+				
+				dRR[5] = dRR[4];
+				dRR[4] = inputSampleR;
+				inputSampleR = (dRR[1]+dRR[2])/2.0;
+				
+				allpasstemp = outSR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;}
+				inputSampleR -= oSR[allpasstemp]*constallpass;
+				oSR[outSR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outSR--; if (outSR < 0 || outSR > delayS) {outSR = delayS;}
+				inputSampleR += (oSR[outSR]);
+				//allpass filter S
+				
+				dSR[5] = dSR[4];
+				dSR[4] = inputSampleR;
+				inputSampleR = (dSR[1]+dSR[2])/2.0;
+				
+				allpasstemp = outTR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;}
+				inputSampleR -= oTR[allpasstemp]*constallpass;
+				oTR[outTR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outTR--; if (outTR < 0 || outTR > delayT) {outTR = delayT;}
+				inputSampleR += (oTR[outTR]);
+				//allpass filter T
+				
+				dTR[5] = dTR[4];
+				dTR[4] = inputSampleR;
+				inputSampleR = (dTR[1]+dTR[2])/2.0;
+				
+				allpasstemp = outUR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;}
+				inputSampleR -= oUR[allpasstemp]*constallpass;
+				oUR[outUR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outUR--; if (outUR < 0 || outUR > delayU) {outUR = delayU;}
+				inputSampleR += (oUR[outUR]);
+				//allpass filter U
+				
+				dUR[5] = dUR[4];
+				dUR[4] = inputSampleR;
+				inputSampleR = (dUR[1]+dUR[2])/2.0;
+				
+				allpasstemp = outVR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;}
+				inputSampleR -= oVR[allpasstemp]*constallpass;
+				oVR[outVR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outVR--; if (outVR < 0 || outVR > delayV) {outVR = delayV;}
+				inputSampleR += (oVR[outVR]);
+				//allpass filter V
+				
+				dVR[5] = dVR[4];
+				dVR[4] = inputSampleR;
+				inputSampleR = (dVR[1]+dVR[2])/2.0;
+				
+				allpasstemp = outWR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;}
+				inputSampleR -= oWR[allpasstemp]*constallpass;
+				oWR[outWR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outWR--; if (outWR < 0 || outWR > delayW) {outWR = delayW;}
+				inputSampleR += (oWR[outWR]);
+				//allpass filter W
+				
+				dWR[5] = dWR[4];
+				dWR[4] = inputSampleR;
+				inputSampleR = (dWR[1]+dWR[2])/2.0;
+				
+				allpasstemp = outXR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;}
+				inputSampleR -= oXR[allpasstemp]*constallpass;
+				oXR[outXR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outXR--; if (outXR < 0 || outXR > delayX) {outXR = delayX;}
+				inputSampleR += (oXR[outXR]);
+				//allpass filter X
+				
+				dXR[5] = dXR[4];
+				dXR[4] = inputSampleR;
+				inputSampleR = (dXR[1]+dXR[2])/2.0;
+				
+				allpasstemp = outYR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;}
+				inputSampleR -= oYR[allpasstemp]*constallpass;
+				oYR[outYR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outYR--; if (outYR < 0 || outYR > delayY) {outYR = delayY;}
+				inputSampleR += (oYR[outYR]);
+				//allpass filter Y
+				
+				dYR[5] = dYR[4];
+				dYR[4] = inputSampleR;
+				inputSampleR = (dYR[1]+dYR[2])/2.0;
+				
+				allpasstemp = outZR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;}
+				inputSampleR -= oZR[allpasstemp]*constallpass;
+				oZR[outZR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outZR--; if (outZR < 0 || outZR > delayZ) {outZR = delayZ;}
+				inputSampleR += (oZR[outZR]);
+				//allpass filter Z
+				
+				dZR[5] = dZR[4];
+				dZR[4] = inputSampleR;
+				inputSampleR = (dBR[4] * dryness);		
+				inputSampleR += (dCR[4] * dryness);		
+				inputSampleR += dDR[4];		
+				inputSampleR += dER[4];		
+				inputSampleR += dFR[4];		
+				inputSampleR += dGR[4];		
+				inputSampleR += dHR[4];		
+				inputSampleR += dIR[4];		
+				inputSampleR += dJR[4];		
+				inputSampleR += dKR[4];		
+				inputSampleR += dLR[4];		
+				inputSampleR += dMR[4];		
+				inputSampleR += dNR[4];		
+				inputSampleR += dOR[4];		
+				inputSampleR += dPR[4];		
+				inputSampleR += dQR[4];		
+				inputSampleR += dRR[4];		
+				inputSampleR += dSR[4];		
+				inputSampleR += dTR[4];		
+				inputSampleR += dUR[4];		
+				inputSampleR += dVR[4];		
+				inputSampleR += dWR[4];		
+				inputSampleR += dXR[4];		
+				inputSampleR += dYR[4];		
+				inputSampleR += (dZR[4] * wetness);
+				
+				inputSampleR += (dBR[5] * dryness);		
+				inputSampleR += (dCR[5] * dryness);		
+				inputSampleR += dDR[5];		
+				inputSampleR += dER[5];		
+				inputSampleR += dFR[5];		
+				inputSampleR += dGR[5];		
+				inputSampleR += dHR[5];		
+				inputSampleR += dIR[5];		
+				inputSampleR += dJR[5];		
+				inputSampleR += dKR[5];		
+				inputSampleR += dLR[5];		
+				inputSampleR += dMR[5];		
+				inputSampleR += dNR[5];		
+				inputSampleR += dOR[5];		
+				inputSampleR += dPR[5];		
+				inputSampleR += dQR[5];		
+				inputSampleR += dRR[5];		
+				inputSampleR += dSR[5];		
+				inputSampleR += dTR[5];		
+				inputSampleR += dUR[5];		
+				inputSampleR += dVR[5];		
+				inputSampleR += dWR[5];		
+				inputSampleR += dXR[5];		
+				inputSampleR += dYR[5];		
+				inputSampleR += (dZR[5] * wetness);
+				
+				inputSampleR /= (26.0 + (wetness * 4.0));
+				//output Room effect
+				break;
+				
+				
+				
+				
+				
+				
+			case 5:	//Stretch	
+				allpasstemp = alpAR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;}
+				inputSampleR -= aAR[allpasstemp]*constallpass;
+				aAR[alpAR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpAR--; if (alpAR < 0 || alpAR > delayA) {alpAR = delayA;}
+				inputSampleR += (aAR[alpAR]);
+				//allpass filter A		
+				
+				dAR[2] = dAR[1];
+				dAR[1] = inputSampleR;
+				inputSampleR = (dAR[1] + dAR[2])/2.0;
+				
+				allpasstemp = alpBR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;}
+				inputSampleR -= aBR[allpasstemp]*constallpass;
+				aBR[alpBR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpBR--; if (alpBR < 0 || alpBR > delayB) {alpBR = delayB;}
+				inputSampleR += (aBR[alpBR]);
+				//allpass filter B
+				
+				dBR[2] = dBR[1];
+				dBR[1] = inputSampleR;
+				inputSampleR = (dBR[1] + dBR[2])/2.0;
+				
+				allpasstemp = alpCR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;}
+				inputSampleR -= aCR[allpasstemp]*constallpass;
+				aCR[alpCR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpCR--; if (alpCR < 0 || alpCR > delayC) {alpCR = delayC;}
+				inputSampleR += (aCR[alpCR]);
+				//allpass filter C
+				
+				dCR[2] = dCR[1];
+				dCR[1] = inputSampleR;
+				inputSampleR = (dCR[1] + dCR[2])/2.0;
+				
+				allpasstemp = alpDR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;}
+				inputSampleR -= aDR[allpasstemp]*constallpass;
+				aDR[alpDR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpDR--; if (alpDR < 0 || alpDR > delayD) {alpDR = delayD;}
+				inputSampleR += (aDR[alpDR]);
+				//allpass filter D
+				
+				dDR[2] = dDR[1];
+				dDR[1] = inputSampleR;
+				inputSampleR = (dDR[1] + dDR[2])/2.0;
+				
+				allpasstemp = alpER - 1;
+				if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;}
+				inputSampleR -= aER[allpasstemp]*constallpass;
+				aER[alpER] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpER--; if (alpER < 0 || alpER > delayE) {alpER = delayE;}
+				inputSampleR += (aER[alpER]);
+				//allpass filter E
+				
+				dER[2] = dER[1];
+				dER[1] = inputSampleR;
+				inputSampleR = (dER[1] + dER[2])/2.0;
+				
+				allpasstemp = alpFR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;}
+				inputSampleR -= aFR[allpasstemp]*constallpass;
+				aFR[alpFR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpFR--; if (alpFR < 0 || alpFR > delayF) {alpFR = delayF;}
+				inputSampleR += (aFR[alpFR]);
+				//allpass filter F
+				
+				dFR[2] = dFR[1];
+				dFR[1] = inputSampleR;
+				inputSampleR = (dFR[1] + dFR[2])/2.0;
+				
+				allpasstemp = alpGR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;}
+				inputSampleR -= aGR[allpasstemp]*constallpass;
+				aGR[alpGR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpGR--; if (alpGR < 0 || alpGR > delayG) {alpGR = delayG;}
+				inputSampleR += (aGR[alpGR]);
+				//allpass filter G
+				
+				dGR[2] = dGR[1];
+				dGR[1] = inputSampleR;
+				inputSampleR = (dGR[1] + dGR[2])/2.0;
+				
+				allpasstemp = alpHR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;}
+				inputSampleR -= aHR[allpasstemp]*constallpass;
+				aHR[alpHR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpHR--; if (alpHR < 0 || alpHR > delayH) {alpHR = delayH;}
+				inputSampleR += (aHR[alpHR]);
+				//allpass filter H
+				
+				dHR[2] = dHR[1];
+				dHR[1] = inputSampleR;
+				inputSampleR = (dHR[1] + dHR[2])/2.0;
+				
+				allpasstemp = alpIR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;}
+				inputSampleR -= aIR[allpasstemp]*constallpass;
+				aIR[alpIR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpIR--; if (alpIR < 0 || alpIR > delayI) {alpIR = delayI;}
+				inputSampleR += (aIR[alpIR]);
+				//allpass filter I
+				
+				dIR[2] = dIR[1];
+				dIR[1] = inputSampleR;
+				inputSampleR = (dIR[1] + dIR[2])/2.0;
+				
+				allpasstemp = alpJR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;}
+				inputSampleR -= aJR[allpasstemp]*constallpass;
+				aJR[alpJR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpJR--; if (alpJR < 0 || alpJR > delayJ) {alpJR = delayJ;}
+				inputSampleR += (aJR[alpJR]);
+				//allpass filter J
+				
+				dJR[2] = dJR[1];
+				dJR[1] = inputSampleR;
+				inputSampleR = (dJR[1] + dJR[2])/2.0;
+				
+				allpasstemp = alpKR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;}
+				inputSampleR -= aKR[allpasstemp]*constallpass;
+				aKR[alpKR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpKR--; if (alpKR < 0 || alpKR > delayK) {alpKR = delayK;}
+				inputSampleR += (aKR[alpKR]);
+				//allpass filter K
+				
+				dKR[2] = dKR[1];
+				dKR[1] = inputSampleR;
+				inputSampleR = (dKR[1] + dKR[2])/2.0;
+				
+				allpasstemp = alpLR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;}
+				inputSampleR -= aLR[allpasstemp]*constallpass;
+				aLR[alpLR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpLR--; if (alpLR < 0 || alpLR > delayL) {alpLR = delayL;}
+				inputSampleR += (aLR[alpLR]);
+				//allpass filter L
+				
+				dLR[2] = dLR[1];
+				dLR[1] = inputSampleR;
+				inputSampleR = (dLR[1] + dLR[2])/2.0;
+				
+				allpasstemp = alpMR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;}
+				inputSampleR -= aMR[allpasstemp]*constallpass;
+				aMR[alpMR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpMR--; if (alpMR < 0 || alpMR > delayM) {alpMR = delayM;}
+				inputSampleR += (aMR[alpMR]);
+				//allpass filter M
+				
+				dMR[2] = dMR[1];
+				dMR[1] = inputSampleR;
+				inputSampleR = (dMR[1] + dMR[2])/2.0;
+				
+				allpasstemp = alpNR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;}
+				inputSampleR -= aNR[allpasstemp]*constallpass;
+				aNR[alpNR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpNR--; if (alpNR < 0 || alpNR > delayN) {alpNR = delayN;}
+				inputSampleR += (aNR[alpNR]);
+				//allpass filter N
+				
+				dNR[2] = dNR[1];
+				dNR[1] = inputSampleR;
+				inputSampleR = (dNR[1] + dNR[2])/2.0;
+				
+				allpasstemp = alpOR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;}
+				inputSampleR -= aOR[allpasstemp]*constallpass;
+				aOR[alpOR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpOR--; if (alpOR < 0 || alpOR > delayO) {alpOR = delayO;}
+				inputSampleR += (aOR[alpOR]);
+				//allpass filter O
+				
+				dOR[2] = dOR[1];
+				dOR[1] = inputSampleR;
+				inputSampleR = (dOR[1] + dOR[2])/2.0;
+				
+				allpasstemp = alpPR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;}
+				inputSampleR -= aPR[allpasstemp]*constallpass;
+				aPR[alpPR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpPR--; if (alpPR < 0 || alpPR > delayP) {alpPR = delayP;}
+				inputSampleR += (aPR[alpPR]);
+				//allpass filter P
+				
+				dPR[2] = dPR[1];
+				dPR[1] = inputSampleR;
+				inputSampleR = (dPR[1] + dPR[2])/2.0;
+				
+				allpasstemp = alpQR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;}
+				inputSampleR -= aQR[allpasstemp]*constallpass;
+				aQR[alpQR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpQR--; if (alpQR < 0 || alpQR > delayQ) {alpQR = delayQ;}
+				inputSampleR += (aQR[alpQR]);
+				//allpass filter Q
+				
+				dQR[2] = dQR[1];
+				dQR[1] = inputSampleR;
+				inputSampleR = (dQR[1] + dQR[2])/2.0;
+				
+				allpasstemp = alpRR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;}
+				inputSampleR -= aRR[allpasstemp]*constallpass;
+				aRR[alpRR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpRR--; if (alpRR < 0 || alpRR > delayR) {alpRR = delayR;}
+				inputSampleR += (aRR[alpRR]);
+				//allpass filter R
+				
+				dRR[2] = dRR[1];
+				dRR[1] = inputSampleR;
+				inputSampleR = (dRR[1] + dRR[2])/2.0;
+				
+				allpasstemp = alpSR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;}
+				inputSampleR -= aSR[allpasstemp]*constallpass;
+				aSR[alpSR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpSR--; if (alpSR < 0 || alpSR > delayS) {alpSR = delayS;}
+				inputSampleR += (aSR[alpSR]);
+				//allpass filter S
+				
+				dSR[2] = dSR[1];
+				dSR[1] = inputSampleR;
+				inputSampleR = (dSR[1] + dSR[2])/2.0;
+				
+				allpasstemp = alpTR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;}
+				inputSampleR -= aTR[allpasstemp]*constallpass;
+				aTR[alpTR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpTR--; if (alpTR < 0 || alpTR > delayT) {alpTR = delayT;}
+				inputSampleR += (aTR[alpTR]);
+				//allpass filter T
+				
+				dTR[2] = dTR[1];
+				dTR[1] = inputSampleR;
+				inputSampleR = (dTR[1] + dTR[2])/2.0;
+				
+				allpasstemp = alpUR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;}
+				inputSampleR -= aUR[allpasstemp]*constallpass;
+				aUR[alpUR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpUR--; if (alpUR < 0 || alpUR > delayU) {alpUR = delayU;}
+				inputSampleR += (aUR[alpUR]);
+				//allpass filter U
+				
+				dUR[2] = dUR[1];
+				dUR[1] = inputSampleR;
+				inputSampleR = (dUR[1] + dUR[2])/2.0;
+				
+				allpasstemp = alpVR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;}
+				inputSampleR -= aVR[allpasstemp]*constallpass;
+				aVR[alpVR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpVR--; if (alpVR < 0 || alpVR > delayV) {alpVR = delayV;}
+				inputSampleR += (aVR[alpVR]);
+				//allpass filter V
+				
+				dVR[2] = dVR[1];
+				dVR[1] = inputSampleR;
+				inputSampleR = (dVR[1] + dVR[2])/2.0;
+				
+				allpasstemp = alpWR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;}
+				inputSampleR -= aWR[allpasstemp]*constallpass;
+				aWR[alpWR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpWR--; if (alpWR < 0 || alpWR > delayW) {alpWR = delayW;}
+				inputSampleR += (aWR[alpWR]);
+				//allpass filter W
+				
+				dWR[2] = dWR[1];
+				dWR[1] = inputSampleR;
+				inputSampleR = (dWR[1] + dWR[2])/2.0;
+				
+				allpasstemp = alpXR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;}
+				inputSampleR -= aXR[allpasstemp]*constallpass;
+				aXR[alpXR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpXR--; if (alpXR < 0 || alpXR > delayX) {alpXR = delayX;}
+				inputSampleR += (aXR[alpXR]);
+				//allpass filter X
+				
+				dXR[2] = dXR[1];
+				dXR[1] = inputSampleR;
+				inputSampleR = (dXR[1] + dXR[2])/2.0;
+				
+				allpasstemp = alpYR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;}
+				inputSampleR -= aYR[allpasstemp]*constallpass;
+				aYR[alpYR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpYR--; if (alpYR < 0 || alpYR > delayY) {alpYR = delayY;}
+				inputSampleR += (aYR[alpYR]);
+				//allpass filter Y
+				
+				dYR[2] = dYR[1];
+				dYR[1] = inputSampleR;
+				inputSampleR = (dYR[1] + dYR[2])/2.0;
+				
+				allpasstemp = alpZR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;}
+				inputSampleR -= aZR[allpasstemp]*constallpass;
+				aZR[alpZR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpZR--; if (alpZR < 0 || alpZR > delayZ) {alpZR = delayZ;}
+				inputSampleR += (aZR[alpZR]);
+				//allpass filter Z
+				
+				dZR[2] = dZR[1];
+				dZR[1] = inputSampleR;
+				inputSampleR = (dZR[1] + dZR[2])/2.0;
+				
+				// now the second stage using the 'out' bank of allpasses		
+				
+				allpasstemp = outAR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;}
+				inputSampleR -= oAR[allpasstemp]*constallpass;
+				oAR[outAR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outAR--; if (outAR < 0 || outAR > delayA) {outAR = delayA;}
+				inputSampleR += (oAR[outAR]);
+				//allpass filter A		
+				
+				dAR[5] = dAR[4];
+				dAR[4] = inputSampleR;
+				inputSampleR = (dAR[4] + dAR[5])/2.0;
+				
+				allpasstemp = outBR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;}
+				inputSampleR -= oBR[allpasstemp]*constallpass;
+				oBR[outBR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outBR--; if (outBR < 0 || outBR > delayB) {outBR = delayB;}
+				inputSampleR += (oBR[outBR]);
+				//allpass filter B
+				
+				dBR[5] = dBR[4];
+				dBR[4] = inputSampleR;
+				inputSampleR = (dBR[4] + dBR[5])/2.0;
+				
+				allpasstemp = outCR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;}
+				inputSampleR -= oCR[allpasstemp]*constallpass;
+				oCR[outCR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outCR--; if (outCR < 0 || outCR > delayC) {outCR = delayC;}
+				inputSampleR += (oCR[outCR]);
+				//allpass filter C
+				
+				dCR[5] = dCR[4];
+				dCR[4] = inputSampleR;
+				inputSampleR = (dCR[4] + dCR[5])/2.0;
+				
+				allpasstemp = outDR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;}
+				inputSampleR -= oDR[allpasstemp]*constallpass;
+				oDR[outDR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outDR--; if (outDR < 0 || outDR > delayD) {outDR = delayD;}
+				inputSampleR += (oDR[outDR]);
+				//allpass filter D
+				
+				dDR[5] = dDR[4];
+				dDR[4] = inputSampleR;
+				inputSampleR = (dDR[4] + dDR[5])/2.0;
+				
+				allpasstemp = outER - 1;
+				if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;}
+				inputSampleR -= oER[allpasstemp]*constallpass;
+				oER[outER] = inputSampleR;
+				inputSampleR *= constallpass;
+				outER--; if (outER < 0 || outER > delayE) {outER = delayE;}
+				inputSampleR += (oER[outER]);
+				//allpass filter E
+				
+				dER[5] = dER[4];
+				dER[4] = inputSampleR;
+				inputSampleR = (dER[4] + dER[5])/2.0;
+				
+				allpasstemp = outFR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;}
+				inputSampleR -= oFR[allpasstemp]*constallpass;
+				oFR[outFR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outFR--; if (outFR < 0 || outFR > delayF) {outFR = delayF;}
+				inputSampleR += (oFR[outFR]);
+				//allpass filter F
+				
+				dFR[5] = dFR[4];
+				dFR[4] = inputSampleR;
+				inputSampleR = (dFR[4] + dFR[5])/2.0;
+				
+				allpasstemp = outGR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;}
+				inputSampleR -= oGR[allpasstemp]*constallpass;
+				oGR[outGR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outGR--; if (outGR < 0 || outGR > delayG) {outGR = delayG;}
+				inputSampleR += (oGR[outGR]);
+				//allpass filter G
+				
+				dGR[5] = dGR[4];
+				dGR[4] = inputSampleR;
+				inputSampleR = (dGR[4] + dGR[5])/2.0;
+				
+				allpasstemp = outHR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;}
+				inputSampleR -= oHR[allpasstemp]*constallpass;
+				oHR[outHR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outHR--; if (outHR < 0 || outHR > delayH) {outHR = delayH;}
+				inputSampleR += (oHR[outHR]);
+				//allpass filter H
+				
+				dHR[5] = dHR[4];
+				dHR[4] = inputSampleR;
+				inputSampleR = (dHR[4] + dHR[5])/2.0;
+				
+				allpasstemp = outIR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;}
+				inputSampleR -= oIR[allpasstemp]*constallpass;
+				oIR[outIR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outIR--; if (outIR < 0 || outIR > delayI) {outIR = delayI;}
+				inputSampleR += (oIR[outIR]);
+				//allpass filter I
+				
+				dIR[5] = dIR[4];
+				dIR[4] = inputSampleR;
+				inputSampleR = (dIR[4] + dIR[5])/2.0;
+				
+				allpasstemp = outJR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;}
+				inputSampleR -= oJR[allpasstemp]*constallpass;
+				oJR[outJR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outJR--; if (outJR < 0 || outJR > delayJ) {outJR = delayJ;}
+				inputSampleR += (oJR[outJR]);
+				//allpass filter J
+				
+				dJR[5] = dJR[4];
+				dJR[4] = inputSampleR;
+				inputSampleR = (dJR[4] + dJR[5])/2.0;
+				
+				allpasstemp = outKR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;}
+				inputSampleR -= oKR[allpasstemp]*constallpass;
+				oKR[outKR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outKR--; if (outKR < 0 || outKR > delayK) {outKR = delayK;}
+				inputSampleR += (oKR[outKR]);
+				//allpass filter K
+				
+				dKR[5] = dKR[4];
+				dKR[4] = inputSampleR;
+				inputSampleR = (dKR[4] + dKR[5])/2.0;
+				
+				allpasstemp = outLR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;}
+				inputSampleR -= oLR[allpasstemp]*constallpass;
+				oLR[outLR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outLR--; if (outLR < 0 || outLR > delayL) {outLR = delayL;}
+				inputSampleR += (oLR[outLR]);
+				//allpass filter L
+				
+				dLR[5] = dLR[4];
+				dLR[4] = inputSampleR;
+				inputSampleR = (dLR[4] + dLR[5])/2.0;
+				
+				allpasstemp = outMR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;}
+				inputSampleR -= oMR[allpasstemp]*constallpass;
+				oMR[outMR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outMR--; if (outMR < 0 || outMR > delayM) {outMR = delayM;}
+				inputSampleR += (oMR[outMR]);
+				//allpass filter M
+				
+				dMR[5] = dMR[4];
+				dMR[4] = inputSampleR;
+				inputSampleR = (dMR[4] + dMR[5])/2.0;
+				
+				allpasstemp = outNR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;}
+				inputSampleR -= oNR[allpasstemp]*constallpass;
+				oNR[outNR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outNR--; if (outNR < 0 || outNR > delayN) {outNR = delayN;}
+				inputSampleR += (oNR[outNR]);
+				//allpass filter N
+				
+				dNR[5] = dNR[4];
+				dNR[4] = inputSampleR;
+				inputSampleR = (dNR[4] + dNR[5])/2.0;
+				
+				allpasstemp = outOR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;}
+				inputSampleR -= oOR[allpasstemp]*constallpass;
+				oOR[outOR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outOR--; if (outOR < 0 || outOR > delayO) {outOR = delayO;}
+				inputSampleR += (oOR[outOR]);
+				//allpass filter O
+				
+				dOR[5] = dOR[4];
+				dOR[4] = inputSampleR;
+				inputSampleR = (dOR[4] + dOR[5])/2.0;
+				
+				allpasstemp = outPR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;}
+				inputSampleR -= oPR[allpasstemp]*constallpass;
+				oPR[outPR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outPR--; if (outPR < 0 || outPR > delayP) {outPR = delayP;}
+				inputSampleR += (oPR[outPR]);
+				//allpass filter P
+				
+				dPR[5] = dPR[4];
+				dPR[4] = inputSampleR;
+				inputSampleR = (dPR[4] + dPR[5])/2.0;
+				
+				allpasstemp = outQR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;}
+				inputSampleR -= oQR[allpasstemp]*constallpass;
+				oQR[outQR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outQR--; if (outQR < 0 || outQR > delayQ) {outQR = delayQ;}
+				inputSampleR += (oQR[outQR]);
+				//allpass filter Q
+				
+				dQR[5] = dQR[4];
+				dQR[4] = inputSampleR;
+				inputSampleR = (dQR[4] + dQR[5])/2.0;
+				
+				allpasstemp = outRR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;}
+				inputSampleR -= oRR[allpasstemp]*constallpass;
+				oRR[outRR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outRR--; if (outRR < 0 || outRR > delayR) {outRR = delayR;}
+				inputSampleR += (oRR[outRR]);
+				//allpass filter R
+				
+				dRR[5] = dRR[4];
+				dRR[4] = inputSampleR;
+				inputSampleR = (dRR[4] + dRR[5])/2.0;
+				
+				allpasstemp = outSR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;}
+				inputSampleR -= oSR[allpasstemp]*constallpass;
+				oSR[outSR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outSR--; if (outSR < 0 || outSR > delayS) {outSR = delayS;}
+				inputSampleR += (oSR[outSR]);
+				//allpass filter S
+				
+				dSR[5] = dSR[4];
+				dSR[4] = inputSampleR;
+				inputSampleR = (dSR[4] + dSR[5])/2.0;
+				
+				allpasstemp = outTR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;}
+				inputSampleR -= oTR[allpasstemp]*constallpass;
+				oTR[outTR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outTR--; if (outTR < 0 || outTR > delayT) {outTR = delayT;}
+				inputSampleR += (oTR[outTR]);
+				//allpass filter T
+				
+				dTR[5] = dTR[4];
+				dTR[4] = inputSampleR;
+				inputSampleR = (dTR[4] + dTR[5])/2.0;
+				
+				allpasstemp = outUR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;}
+				inputSampleR -= oUR[allpasstemp]*constallpass;
+				oUR[outUR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outUR--; if (outUR < 0 || outUR > delayU) {outUR = delayU;}
+				inputSampleR += (oUR[outUR]);
+				//allpass filter U
+				
+				dUR[5] = dUR[4];
+				dUR[4] = inputSampleR;
+				inputSampleR = (dUR[4] + dUR[5])/2.0;
+				
+				allpasstemp = outVR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;}
+				inputSampleR -= oVR[allpasstemp]*constallpass;
+				oVR[outVR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outVR--; if (outVR < 0 || outVR > delayV) {outVR = delayV;}
+				inputSampleR += (oVR[outVR]);
+				//allpass filter V
+				
+				dVR[5] = dVR[4];
+				dVR[4] = inputSampleR;
+				inputSampleR = (dVR[4] + dVR[5])/2.0;
+				
+				allpasstemp = outWR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;}
+				inputSampleR -= oWR[allpasstemp]*constallpass;
+				oWR[outWR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outWR--; if (outWR < 0 || outWR > delayW) {outWR = delayW;}
+				inputSampleR += (oWR[outWR]);
+				//allpass filter W
+				
+				dWR[5] = dWR[4];
+				dWR[4] = inputSampleR;
+				inputSampleR = (dWR[4] + dWR[5])/2.0;
+				
+				allpasstemp = outXR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;}
+				inputSampleR -= oXR[allpasstemp]*constallpass;
+				oXR[outXR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outXR--; if (outXR < 0 || outXR > delayX) {outXR = delayX;}
+				inputSampleR += (oXR[outXR]);
+				//allpass filter X
+				
+				dXR[5] = dXR[4];
+				dXR[4] = inputSampleR;
+				inputSampleR = (dXR[4] + dXR[5])/2.0;
+				
+				allpasstemp = outYR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;}
+				inputSampleR -= oYR[allpasstemp]*constallpass;
+				oYR[outYR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outYR--; if (outYR < 0 || outYR > delayY) {outYR = delayY;}
+				inputSampleR += (oYR[outYR]);
+				//allpass filter Y
+				
+				dYR[5] = dYR[4];
+				dYR[4] = inputSampleR;
+				inputSampleR = (dYR[4] + dYR[5])/2.0;
+				
+				allpasstemp = outZR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;}
+				inputSampleR -= oZR[allpasstemp]*constallpass;
+				oZR[outZR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outZR--; if (outZR < 0 || outZR > delayZ) {outZR = delayZ;}
+				inputSampleR += (oZR[outZR]);
+				//allpass filter Z
+				
+				dZR[5] = dZR[4];
+				dZR[4] = inputSampleR;
+				inputSampleR = (dZR[4] + dZR[5])/2.0;		
+				//output Stretch unrealistic but smooth fake Paulstretch
+				break;				
+				
+				
+			case 6:	//Zarathustra	
+				allpasstemp = alpAR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;}
+				inputSampleR -= aAR[allpasstemp]*constallpass;
+				aAR[alpAR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpAR--; if (alpAR < 0 || alpAR > delayA) {alpAR = delayA;}
+				inputSampleR += (aAR[alpAR]);
+				//allpass filter A		
+				
+				dAR[3] = dAR[2];
+				dAR[2] = dAR[1];
+				dAR[1] = inputSampleR;
+				inputSampleR = (dAR[1] + dAR[2] + dZR[3])/3.0; //add feedback
+				
+				allpasstemp = alpBR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;}
+				inputSampleR -= aBR[allpasstemp]*constallpass;
+				aBR[alpBR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpBR--; if (alpBR < 0 || alpBR > delayB) {alpBR = delayB;}
+				inputSampleR += (aBR[alpBR]);
+				//allpass filter B
+				
+				dBR[3] = dBR[2];
+				dBR[2] = dBR[1];
+				dBR[1] = inputSampleR;
+				inputSampleR = (dBR[1] + dBR[2] + dBR[3])/3.0;
+				
+				allpasstemp = alpCR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;}
+				inputSampleR -= aCR[allpasstemp]*constallpass;
+				aCR[alpCR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpCR--; if (alpCR < 0 || alpCR > delayC) {alpCR = delayC;}
+				inputSampleR += (aCR[alpCR]);
+				//allpass filter C
+				
+				dCR[3] = dCR[2];
+				dCR[2] = dCR[1];
+				dCR[1] = inputSampleR;
+				inputSampleR = (dCR[1] + dCR[2] + dCR[3])/3.0;
+				
+				allpasstemp = alpDR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;}
+				inputSampleR -= aDR[allpasstemp]*constallpass;
+				aDR[alpDR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpDR--; if (alpDR < 0 || alpDR > delayD) {alpDR = delayD;}
+				inputSampleR += (aDR[alpDR]);
+				//allpass filter D
+				
+				dDR[3] = dDR[2];
+				dDR[2] = dDR[1];
+				dDR[1] = inputSampleR;
+				inputSampleR = (dDR[1] + dDR[2] + dDR[3])/3.0;
+				
+				allpasstemp = alpER - 1;
+				if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;}
+				inputSampleR -= aER[allpasstemp]*constallpass;
+				aER[alpER] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpER--; if (alpER < 0 || alpER > delayE) {alpER = delayE;}
+				inputSampleR += (aER[alpER]);
+				//allpass filter E
+				
+				dER[3] = dER[2];
+				dER[2] = dER[1];
+				dER[1] = inputSampleR;
+				inputSampleR = (dER[1] + dER[2] + dER[3])/3.0;
+				
+				allpasstemp = alpFR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;}
+				inputSampleR -= aFR[allpasstemp]*constallpass;
+				aFR[alpFR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpFR--; if (alpFR < 0 || alpFR > delayF) {alpFR = delayF;}
+				inputSampleR += (aFR[alpFR]);
+				//allpass filter F
+				
+				dFR[3] = dFR[2];
+				dFR[2] = dFR[1];
+				dFR[1] = inputSampleR;
+				inputSampleR = (dFR[1] + dFR[2] + dFR[3])/3.0;
+				
+				allpasstemp = alpGR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;}
+				inputSampleR -= aGR[allpasstemp]*constallpass;
+				aGR[alpGR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpGR--; if (alpGR < 0 || alpGR > delayG) {alpGR = delayG;}
+				inputSampleR += (aGR[alpGR]);
+				//allpass filter G
+				
+				dGR[3] = dGR[2];
+				dGR[2] = dGR[1];
+				dGR[1] = inputSampleR;
+				inputSampleR = (dGR[1] + dGR[2] + dGR[3])/3.0;
+				
+				allpasstemp = alpHR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;}
+				inputSampleR -= aHR[allpasstemp]*constallpass;
+				aHR[alpHR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpHR--; if (alpHR < 0 || alpHR > delayH) {alpHR = delayH;}
+				inputSampleR += (aHR[alpHR]);
+				//allpass filter H
+				
+				dHR[3] = dHR[2];
+				dHR[2] = dHR[1];
+				dHR[1] = inputSampleR;
+				inputSampleR = (dHR[1] + dHR[2] + dHR[3])/3.0;
+				
+				allpasstemp = alpIR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;}
+				inputSampleR -= aIR[allpasstemp]*constallpass;
+				aIR[alpIR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpIR--; if (alpIR < 0 || alpIR > delayI) {alpIR = delayI;}
+				inputSampleR += (aIR[alpIR]);
+				//allpass filter I
+				
+				dIR[3] = dIR[2];
+				dIR[2] = dIR[1];
+				dIR[1] = inputSampleR;
+				inputSampleR = (dIR[1] + dIR[2] + dIR[3])/3.0;
+				
+				allpasstemp = alpJR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;}
+				inputSampleR -= aJR[allpasstemp]*constallpass;
+				aJR[alpJR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpJR--; if (alpJR < 0 || alpJR > delayJ) {alpJR = delayJ;}
+				inputSampleR += (aJR[alpJR]);
+				//allpass filter J
+				
+				dJR[3] = dJR[2];
+				dJR[2] = dJR[1];
+				dJR[1] = inputSampleR;
+				inputSampleR = (dJR[1] + dJR[2] + dJR[3])/3.0;
+				
+				allpasstemp = alpKR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;}
+				inputSampleR -= aKR[allpasstemp]*constallpass;
+				aKR[alpKR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpKR--; if (alpKR < 0 || alpKR > delayK) {alpKR = delayK;}
+				inputSampleR += (aKR[alpKR]);
+				//allpass filter K
+				
+				dKR[3] = dKR[2];
+				dKR[2] = dKR[1];
+				dKR[1] = inputSampleR;
+				inputSampleR = (dKR[1] + dKR[2] + dKR[3])/3.0;
+				
+				allpasstemp = alpLR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;}
+				inputSampleR -= aLR[allpasstemp]*constallpass;
+				aLR[alpLR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpLR--; if (alpLR < 0 || alpLR > delayL) {alpLR = delayL;}
+				inputSampleR += (aLR[alpLR]);
+				//allpass filter L
+				
+				dLR[3] = dLR[2];
+				dLR[2] = dLR[1];
+				dLR[1] = inputSampleR;
+				inputSampleR = (dLR[1] + dLR[2] + dLR[3])/3.0;
+				
+				allpasstemp = alpMR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;}
+				inputSampleR -= aMR[allpasstemp]*constallpass;
+				aMR[alpMR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpMR--; if (alpMR < 0 || alpMR > delayM) {alpMR = delayM;}
+				inputSampleR += (aMR[alpMR]);
+				//allpass filter M
+				
+				dMR[3] = dMR[2];
+				dMR[2] = dMR[1];
+				dMR[1] = inputSampleR;
+				inputSampleR = (dMR[1] + dMR[2] + dMR[3])/3.0;
+				
+				allpasstemp = alpNR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;}
+				inputSampleR -= aNR[allpasstemp]*constallpass;
+				aNR[alpNR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpNR--; if (alpNR < 0 || alpNR > delayN) {alpNR = delayN;}
+				inputSampleR += (aNR[alpNR]);
+				//allpass filter N
+				
+				dNR[3] = dNR[2];
+				dNR[2] = dNR[1];
+				dNR[1] = inputSampleR;
+				inputSampleR = (dNR[1] + dNR[2] + dNR[3])/3.0;
+				
+				allpasstemp = alpOR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;}
+				inputSampleR -= aOR[allpasstemp]*constallpass;
+				aOR[alpOR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpOR--; if (alpOR < 0 || alpOR > delayO) {alpOR = delayO;}
+				inputSampleR += (aOR[alpOR]);
+				//allpass filter O
+				
+				dOR[3] = dOR[2];
+				dOR[2] = dOR[1];
+				dOR[1] = inputSampleR;
+				inputSampleR = (dOR[1] + dOR[2] + dOR[3])/3.0;
+				
+				allpasstemp = alpPR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;}
+				inputSampleR -= aPR[allpasstemp]*constallpass;
+				aPR[alpPR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpPR--; if (alpPR < 0 || alpPR > delayP) {alpPR = delayP;}
+				inputSampleR += (aPR[alpPR]);
+				//allpass filter P
+				
+				dPR[3] = dPR[2];
+				dPR[2] = dPR[1];
+				dPR[1] = inputSampleR;
+				inputSampleR = (dPR[1] + dPR[2] + dPR[3])/3.0;
+				
+				allpasstemp = alpQR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;}
+				inputSampleR -= aQR[allpasstemp]*constallpass;
+				aQR[alpQR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpQR--; if (alpQR < 0 || alpQR > delayQ) {alpQR = delayQ;}
+				inputSampleR += (aQR[alpQR]);
+				//allpass filter Q
+				
+				dQR[3] = dQR[2];
+				dQR[2] = dQR[1];
+				dQR[1] = inputSampleR;
+				inputSampleR = (dQR[1] + dQR[2] + dQR[3])/3.0;
+				
+				allpasstemp = alpRR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;}
+				inputSampleR -= aRR[allpasstemp]*constallpass;
+				aRR[alpRR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpRR--; if (alpRR < 0 || alpRR > delayR) {alpRR = delayR;}
+				inputSampleR += (aRR[alpRR]);
+				//allpass filter R
+				
+				dRR[3] = dRR[2];
+				dRR[2] = dRR[1];
+				dRR[1] = inputSampleR;
+				inputSampleR = (dRR[1] + dRR[2] + dRR[3])/3.0;
+				
+				allpasstemp = alpSR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;}
+				inputSampleR -= aSR[allpasstemp]*constallpass;
+				aSR[alpSR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpSR--; if (alpSR < 0 || alpSR > delayS) {alpSR = delayS;}
+				inputSampleR += (aSR[alpSR]);
+				//allpass filter S
+				
+				dSR[3] = dSR[2];
+				dSR[2] = dSR[1];
+				dSR[1] = inputSampleR;
+				inputSampleR = (dSR[1] + dSR[2] + dSR[3])/3.0;
+				
+				allpasstemp = alpTR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;}
+				inputSampleR -= aTR[allpasstemp]*constallpass;
+				aTR[alpTR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpTR--; if (alpTR < 0 || alpTR > delayT) {alpTR = delayT;}
+				inputSampleR += (aTR[alpTR]);
+				//allpass filter T
+				
+				dTR[3] = dTR[2];
+				dTR[2] = dTR[1];
+				dTR[1] = inputSampleR;
+				inputSampleR = (dTR[1] + dTR[2] + dTR[3])/3.0;
+				
+				allpasstemp = alpUR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;}
+				inputSampleR -= aUR[allpasstemp]*constallpass;
+				aUR[alpUR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpUR--; if (alpUR < 0 || alpUR > delayU) {alpUR = delayU;}
+				inputSampleR += (aUR[alpUR]);
+				//allpass filter U
+				
+				dUR[3] = dUR[2];
+				dUR[2] = dUR[1];
+				dUR[1] = inputSampleR;
+				inputSampleR = (dUR[1] + dUR[2] + dUR[3])/3.0;
+				
+				allpasstemp = alpVR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;}
+				inputSampleR -= aVR[allpasstemp]*constallpass;
+				aVR[alpVR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpVR--; if (alpVR < 0 || alpVR > delayV) {alpVR = delayV;}
+				inputSampleR += (aVR[alpVR]);
+				//allpass filter V
+				
+				dVR[3] = dVR[2];
+				dVR[2] = dVR[1];
+				dVR[1] = inputSampleR;
+				inputSampleR = (dVR[1] + dVR[2] + dVR[3])/3.0;
+				
+				allpasstemp = alpWR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;}
+				inputSampleR -= aWR[allpasstemp]*constallpass;
+				aWR[alpWR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpWR--; if (alpWR < 0 || alpWR > delayW) {alpWR = delayW;}
+				inputSampleR += (aWR[alpWR]);
+				//allpass filter W
+				
+				dWR[3] = dWR[2];
+				dWR[2] = dWR[1];
+				dWR[1] = inputSampleR;
+				inputSampleR = (dWR[1] + dWR[2] + dWR[3])/3.0;
+				
+				allpasstemp = alpXR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;}
+				inputSampleR -= aXR[allpasstemp]*constallpass;
+				aXR[alpXR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpXR--; if (alpXR < 0 || alpXR > delayX) {alpXR = delayX;}
+				inputSampleR += (aXR[alpXR]);
+				//allpass filter X
+				
+				dXR[3] = dXR[2];
+				dXR[2] = dXR[1];
+				dXR[1] = inputSampleR;
+				inputSampleR = (dXR[1] + dXR[2] + dXR[3])/3.0;
+				
+				allpasstemp = alpYR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;}
+				inputSampleR -= aYR[allpasstemp]*constallpass;
+				aYR[alpYR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpYR--; if (alpYR < 0 || alpYR > delayY) {alpYR = delayY;}
+				inputSampleR += (aYR[alpYR]);
+				//allpass filter Y
+				
+				dYR[3] = dYR[2];
+				dYR[2] = dYR[1];
+				dYR[1] = inputSampleR;
+				inputSampleR = (dYR[1] + dYR[2] + dYR[3])/3.0;
+				
+				allpasstemp = alpZR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;}
+				inputSampleR -= aZR[allpasstemp]*constallpass;
+				aZR[alpZR] = inputSampleR;
+				inputSampleR *= constallpass;
+				alpZR--; if (alpZR < 0 || alpZR > delayZ) {alpZR = delayZ;}
+				inputSampleR += (aZR[alpZR]);
+				//allpass filter Z
+				
+				dZR[3] = dZR[2];
+				dZR[2] = dZR[1];
+				dZR[1] = inputSampleR;
+				inputSampleR = (dZR[1] + dZR[2] + dZR[3])/3.0;
+				
+				// now the second stage using the 'out' bank of allpasses		
+				
+				allpasstemp = outAR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;}
+				inputSampleR -= oAR[allpasstemp]*constallpass;
+				oAR[outAR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outAR--; if (outAR < 0 || outAR > delayA) {outAR = delayA;}
+				inputSampleR += (oAR[outAR]);
+				//allpass filter A		
+				
+				dAR[6] = dAR[5];
+				dAR[5] = dAR[4];
+				dAR[4] = inputSampleR;
+				inputSampleR = (dCR[1] + dAR[5] + dAR[6])/3.0;  //note, feeding in dry again for a little more clarity!
+				
+				allpasstemp = outBR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;}
+				inputSampleR -= oBR[allpasstemp]*constallpass;
+				oBR[outBR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outBR--; if (outBR < 0 || outBR > delayB) {outBR = delayB;}
+				inputSampleR += (oBR[outBR]);
+				//allpass filter B
+				
+				dBR[6] = dBR[5];
+				dBR[5] = dBR[4];
+				dBR[4] = inputSampleR;
+				inputSampleR = (dBR[4] + dBR[5] + dBR[6])/3.0;
+				
+				allpasstemp = outCR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;}
+				inputSampleR -= oCR[allpasstemp]*constallpass;
+				oCR[outCR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outCR--; if (outCR < 0 || outCR > delayC) {outCR = delayC;}
+				inputSampleR += (oCR[outCR]);
+				//allpass filter C
+				
+				dCR[6] = dCR[5];
+				dCR[5] = dCR[4];
+				dCR[4] = inputSampleR;
+				inputSampleR = (dCR[4] + dCR[5] + dCR[6])/3.0;
+				
+				allpasstemp = outDR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;}
+				inputSampleR -= oDR[allpasstemp]*constallpass;
+				oDR[outDR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outDR--; if (outDR < 0 || outDR > delayD) {outDR = delayD;}
+				inputSampleR += (oDR[outDR]);
+				//allpass filter D
+				
+				dDR[6] = dDR[5];
+				dDR[5] = dDR[4];
+				dDR[4] = inputSampleR;
+				inputSampleR = (dDR[4] + dDR[5] + dDR[6])/3.0;
+				
+				allpasstemp = outER - 1;
+				if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;}
+				inputSampleR -= oER[allpasstemp]*constallpass;
+				oER[outER] = inputSampleR;
+				inputSampleR *= constallpass;
+				outER--; if (outER < 0 || outER > delayE) {outER = delayE;}
+				inputSampleR += (oER[outER]);
+				//allpass filter E
+				
+				dER[6] = dER[5];
+				dER[5] = dER[4];
+				dER[4] = inputSampleR;
+				inputSampleR = (dER[4] + dER[5] + dER[6])/3.0;
+				
+				allpasstemp = outFR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;}
+				inputSampleR -= oFR[allpasstemp]*constallpass;
+				oFR[outFR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outFR--; if (outFR < 0 || outFR > delayF) {outFR = delayF;}
+				inputSampleR += (oFR[outFR]);
+				//allpass filter F
+				
+				dFR[6] = dFR[5];
+				dFR[5] = dFR[4];
+				dFR[4] = inputSampleR;
+				inputSampleR = (dFR[4] + dFR[5] + dFR[6])/3.0;
+				
+				allpasstemp = outGR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;}
+				inputSampleR -= oGR[allpasstemp]*constallpass;
+				oGR[outGR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outGR--; if (outGR < 0 || outGR > delayG) {outGR = delayG;}
+				inputSampleR += (oGR[outGR]);
+				//allpass filter G
+				
+				dGR[6] = dGR[5];
+				dGR[5] = dGR[4];
+				dGR[4] = inputSampleR;
+				inputSampleR = (dGR[4] + dGR[5] + dGR[6])/3.0;
+				
+				allpasstemp = outHR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;}
+				inputSampleR -= oHR[allpasstemp]*constallpass;
+				oHR[outHR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outHR--; if (outHR < 0 || outHR > delayH) {outHR = delayH;}
+				inputSampleR += (oHR[outHR]);
+				//allpass filter H
+				
+				dHR[6] = dHR[5];
+				dHR[5] = dHR[4];
+				dHR[4] = inputSampleR;
+				inputSampleR = (dHR[4] + dHR[5] + dHR[6])/3.0;
+				
+				allpasstemp = outIR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;}
+				inputSampleR -= oIR[allpasstemp]*constallpass;
+				oIR[outIR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outIR--; if (outIR < 0 || outIR > delayI) {outIR = delayI;}
+				inputSampleR += (oIR[outIR]);
+				//allpass filter I
+				
+				dIR[6] = dIR[5];
+				dIR[5] = dIR[4];
+				dIR[4] = inputSampleR;
+				inputSampleR = (dIR[4] + dIR[5] + dIR[6])/3.0;
+				
+				allpasstemp = outJR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;}
+				inputSampleR -= oJR[allpasstemp]*constallpass;
+				oJR[outJR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outJR--; if (outJR < 0 || outJR > delayJ) {outJR = delayJ;}
+				inputSampleR += (oJR[outJR]);
+				//allpass filter J
+				
+				dJR[6] = dJR[5];
+				dJR[5] = dJR[4];
+				dJR[4] = inputSampleR;
+				inputSampleR = (dJR[4] + dJR[5] + dJR[6])/3.0;
+				
+				allpasstemp = outKR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;}
+				inputSampleR -= oKR[allpasstemp]*constallpass;
+				oKR[outKR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outKR--; if (outKR < 0 || outKR > delayK) {outKR = delayK;}
+				inputSampleR += (oKR[outKR]);
+				//allpass filter K
+				
+				dKR[6] = dKR[5];
+				dKR[5] = dKR[4];
+				dKR[4] = inputSampleR;
+				inputSampleR = (dKR[4] + dKR[5] + dKR[6])/3.0;
+				
+				allpasstemp = outLR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;}
+				inputSampleR -= oLR[allpasstemp]*constallpass;
+				oLR[outLR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outLR--; if (outLR < 0 || outLR > delayL) {outLR = delayL;}
+				inputSampleR += (oLR[outLR]);
+				//allpass filter L
+				
+				dLR[6] = dLR[5];
+				dLR[5] = dLR[4];
+				dLR[4] = inputSampleR;
+				inputSampleR = (dLR[4] + dLR[5] + dLR[6])/3.0;
+				
+				allpasstemp = outMR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;}
+				inputSampleR -= oMR[allpasstemp]*constallpass;
+				oMR[outMR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outMR--; if (outMR < 0 || outMR > delayM) {outMR = delayM;}
+				inputSampleR += (oMR[outMR]);
+				//allpass filter M
+				
+				dMR[6] = dMR[5];
+				dMR[5] = dMR[4];
+				dMR[4] = inputSampleR;
+				inputSampleR = (dMR[4] + dMR[5] + dMR[6])/3.0;
+				
+				allpasstemp = outNR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;}
+				inputSampleR -= oNR[allpasstemp]*constallpass;
+				oNR[outNR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outNR--; if (outNR < 0 || outNR > delayN) {outNR = delayN;}
+				inputSampleR += (oNR[outNR]);
+				//allpass filter N
+				
+				dNR[6] = dNR[5];
+				dNR[5] = dNR[4];
+				dNR[4] = inputSampleR;
+				inputSampleR = (dNR[4] + dNR[5] + dNR[6])/3.0;
+				
+				allpasstemp = outOR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;}
+				inputSampleR -= oOR[allpasstemp]*constallpass;
+				oOR[outOR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outOR--; if (outOR < 0 || outOR > delayO) {outOR = delayO;}
+				inputSampleR += (oOR[outOR]);
+				//allpass filter O
+				
+				dOR[6] = dOR[5];
+				dOR[5] = dOR[4];
+				dOR[4] = inputSampleR;
+				inputSampleR = (dOR[4] + dOR[5] + dOR[6])/3.0;
+				
+				allpasstemp = outPR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;}
+				inputSampleR -= oPR[allpasstemp]*constallpass;
+				oPR[outPR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outPR--; if (outPR < 0 || outPR > delayP) {outPR = delayP;}
+				inputSampleR += (oPR[outPR]);
+				//allpass filter P
+				
+				dPR[6] = dPR[5];
+				dPR[5] = dPR[4];
+				dPR[4] = inputSampleR;
+				inputSampleR = (dPR[4] + dPR[5] + dPR[6])/3.0;
+				
+				allpasstemp = outQR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;}
+				inputSampleR -= oQR[allpasstemp]*constallpass;
+				oQR[outQR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outQR--; if (outQR < 0 || outQR > delayQ) {outQR = delayQ;}
+				inputSampleR += (oQR[outQR]);
+				//allpass filter Q
+				
+				dQR[6] = dQR[5];
+				dQR[5] = dQR[4];
+				dQR[4] = inputSampleR;
+				inputSampleR = (dQR[4] + dQR[5] + dQR[6])/3.0;
+				
+				allpasstemp = outRR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;}
+				inputSampleR -= oRR[allpasstemp]*constallpass;
+				oRR[outRR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outRR--; if (outRR < 0 || outRR > delayR) {outRR = delayR;}
+				inputSampleR += (oRR[outRR]);
+				//allpass filter R
+				
+				dRR[6] = dRR[5];
+				dRR[5] = dRR[4];
+				dRR[4] = inputSampleR;
+				inputSampleR = (dRR[4] + dRR[5] + dRR[6])/3.0;
+				
+				allpasstemp = outSR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;}
+				inputSampleR -= oSR[allpasstemp]*constallpass;
+				oSR[outSR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outSR--; if (outSR < 0 || outSR > delayS) {outSR = delayS;}
+				inputSampleR += (oSR[outSR]);
+				//allpass filter S
+				
+				dSR[6] = dSR[5];
+				dSR[5] = dSR[4];
+				dSR[4] = inputSampleR;
+				inputSampleR = (dSR[4] + dSR[5] + dSR[6])/3.0;
+				
+				allpasstemp = outTR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;}
+				inputSampleR -= oTR[allpasstemp]*constallpass;
+				oTR[outTR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outTR--; if (outTR < 0 || outTR > delayT) {outTR = delayT;}
+				inputSampleR += (oTR[outTR]);
+				//allpass filter T
+				
+				dTR[6] = dTR[5];
+				dTR[5] = dTR[4];
+				dTR[4] = inputSampleR;
+				inputSampleR = (dTR[4] + dTR[5] + dTR[6])/3.0;
+				
+				allpasstemp = outUR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;}
+				inputSampleR -= oUR[allpasstemp]*constallpass;
+				oUR[outUR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outUR--; if (outUR < 0 || outUR > delayU) {outUR = delayU;}
+				inputSampleR += (oUR[outUR]);
+				//allpass filter U
+				
+				dUR[6] = dUR[5];
+				dUR[5] = dUR[4];
+				dUR[4] = inputSampleR;
+				inputSampleR = (dUR[4] + dUR[5] + dUR[6])/3.0;
+				
+				allpasstemp = outVR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;}
+				inputSampleR -= oVR[allpasstemp]*constallpass;
+				oVR[outVR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outVR--; if (outVR < 0 || outVR > delayV) {outVR = delayV;}
+				inputSampleR += (oVR[outVR]);
+				//allpass filter V
+				
+				dVR[6] = dVR[5];
+				dVR[5] = dVR[4];
+				dVR[4] = inputSampleR;
+				inputSampleR = (dVR[4] + dVR[5] + dVR[6])/3.0;
+				
+				allpasstemp = outWR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;}
+				inputSampleR -= oWR[allpasstemp]*constallpass;
+				oWR[outWR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outWR--; if (outWR < 0 || outWR > delayW) {outWR = delayW;}
+				inputSampleR += (oWR[outWR]);
+				//allpass filter W
+				
+				dWR[6] = dWR[5];
+				dWR[5] = dWR[4];
+				dWR[4] = inputSampleR;
+				inputSampleR = (dWR[4] + dWR[5] + dWR[6])/3.0;
+				
+				allpasstemp = outXR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;}
+				inputSampleR -= oXR[allpasstemp]*constallpass;
+				oXR[outXR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outXR--; if (outXR < 0 || outXR > delayX) {outXR = delayX;}
+				inputSampleR += (oXR[outXR]);
+				//allpass filter X
+				
+				dXR[6] = dXR[5];
+				dXR[5] = dXR[4];
+				dXR[4] = inputSampleR;
+				inputSampleR = (dXR[4] + dXR[5] + dXR[6])/3.0;
+				
+				allpasstemp = outYR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;}
+				inputSampleR -= oYR[allpasstemp]*constallpass;
+				oYR[outYR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outYR--; if (outYR < 0 || outYR > delayY) {outYR = delayY;}
+				inputSampleR += (oYR[outYR]);
+				//allpass filter Y
+				
+				dYR[6] = dYR[5];
+				dYR[5] = dYR[4];
+				dYR[4] = inputSampleR;
+				inputSampleR = (dYR[4] + dYR[5] + dYR[6])/3.0;
+				
+				allpasstemp = outZR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;}
+				inputSampleR -= oZR[allpasstemp]*constallpass;
+				oZR[outZR] = inputSampleR;
+				inputSampleR *= constallpass;
+				outZR--; if (outZR < 0 || outZR > delayZ) {outZR = delayZ;}
+				inputSampleR += (oZR[outZR]);
+				//allpass filter Z
+				
+				dZR[6] = dZR[5];
+				dZR[5] = dZR[4];
+				dZR[4] = inputSampleR;
+				inputSampleR = (dZR[4] + dZR[5] + dZR[6]);		
+				//output Zarathustra infinite space verb
+				break;
+				
+		}
+		//end big switch for verb type
+		
+		bridgerectifier = fabs(inputSampleL);
+		bridgerectifier = 1.0-cos(bridgerectifier);
+		if (inputSampleL > 0) inputSampleL -= bridgerectifier;
+		else inputSampleL += bridgerectifier;
+		inputSampleL /= gain;		
+		bridgerectifier = fabs(inputSampleR);
+		bridgerectifier = 1.0-cos(bridgerectifier);
+		if (inputSampleR > 0) inputSampleR -= bridgerectifier;
+		else inputSampleR += bridgerectifier;
+		inputSampleR /= gain;		
+		//here we apply the ADT2 'console on steroids' trick
+		
+		wetness = wetnesstarget;
+		//setting up verb wetness to be manipulated by gate and peak
+		
+		wetness *= peakL;
+		//but we only use peak (indirect) to deal with dry/wet, so that it'll manipulate the dry/wet like we want
+		
+		drySampleL *= (1.0-wetness);
+		inputSampleL *= wetness;
+		inputSampleL += drySampleL;
+		//here we combine the tanks with the dry signal
+		
+		wetness = wetnesstarget;
+		//setting up verb wetness to be manipulated by gate and peak
+		
+		wetness *= peakR;
+		//but we only use peak (indirect) to deal with dry/wet, so that it'll manipulate the dry/wet like we want
+		
+		drySampleR *= (1.0-wetness);
+		inputSampleR *= wetness;
+		inputSampleR += drySampleR;
+		//here we combine the tanks with the dry signal
+		
+		//begin 64 bit stereo floating point dither
+		int expon; frexp((double)inputSampleL, &expon);
+		fpd ^= fpd << 13; fpd ^= fpd >> 17; fpd ^= fpd << 5;
+		inputSampleL += ((double(fpd)-uint32_t(0x7fffffff)) * 1.1e-44l * pow(2,expon+62));
+		frexp((double)inputSampleR, &expon);
+		fpd ^= fpd << 13; fpd ^= fpd >> 17; fpd ^= fpd << 5;
+		inputSampleR += ((double(fpd)-uint32_t(0x7fffffff)) * 1.1e-44l * pow(2,expon+62));
+		//end 64 bit stereo floating point dither
+		
+		*out1 = inputSampleL;
+		*out2 = inputSampleR;
+		
+		*in1++;
+		*in2++;
+		*out1++;
+		*out2++;
+    }
+}
diff --git a/plugins/WinVST/PocketVerbs/VSTProject.sln b/plugins/WinVST/PocketVerbs/VSTProject.sln
new file mode 100755
index 0000000..694b424
--- /dev/null
+++ b/plugins/WinVST/PocketVerbs/VSTProject.sln
@@ -0,0 +1,28 @@
+

+Microsoft Visual Studio Solution File, Format Version 12.00

+# Visual Studio 14

+VisualStudioVersion = 14.0.25420.1

+MinimumVisualStudioVersion = 10.0.40219.1

+Project("{8BC9CEB8-8B4A-11D0-8D11-00A0C91BC942}") = "VSTProject", "VSTProject.vcxproj", "{16F7AB3C-1AE0-4574-B60C-7B4DED82938C}"

+EndProject

+Global

+	GlobalSection(SolutionConfigurationPlatforms) = preSolution

+		Debug|x64 = Debug|x64

+		Debug|x86 = Debug|x86

+		Release|x64 = Release|x64

+		Release|x86 = Release|x86

+	EndGlobalSection

+	GlobalSection(ProjectConfigurationPlatforms) = postSolution

+		{16F7AB3C-1AE0-4574-B60C-7B4DED82938C}.Debug|x64.ActiveCfg = Debug|x64

+		{16F7AB3C-1AE0-4574-B60C-7B4DED82938C}.Debug|x64.Build.0 = Debug|x64

+		{16F7AB3C-1AE0-4574-B60C-7B4DED82938C}.Debug|x86.ActiveCfg = Debug|Win32

+		{16F7AB3C-1AE0-4574-B60C-7B4DED82938C}.Debug|x86.Build.0 = Debug|Win32

+		{16F7AB3C-1AE0-4574-B60C-7B4DED82938C}.Release|x64.ActiveCfg = Release|x64

+		{16F7AB3C-1AE0-4574-B60C-7B4DED82938C}.Release|x64.Build.0 = Release|x64

+		{16F7AB3C-1AE0-4574-B60C-7B4DED82938C}.Release|x86.ActiveCfg = Release|Win32

+		{16F7AB3C-1AE0-4574-B60C-7B4DED82938C}.Release|x86.Build.0 = Release|Win32

+	EndGlobalSection

+	GlobalSection(SolutionProperties) = preSolution

+		HideSolutionNode = FALSE

+	EndGlobalSection

+EndGlobal

diff --git a/plugins/WinVST/PocketVerbs/VSTProject.vcxproj b/plugins/WinVST/PocketVerbs/VSTProject.vcxproj
new file mode 100755
index 0000000..5b73613
--- /dev/null
+++ b/plugins/WinVST/PocketVerbs/VSTProject.vcxproj
@@ -0,0 +1,183 @@
+<?xml version="1.0" encoding="utf-8"?>

+<Project DefaultTargets="Build" ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">

+  <ItemGroup Label="ProjectConfigurations">

+    <ProjectConfiguration Include="Debug|Win32">

+      <Configuration>Debug</Configuration>

+      <Platform>Win32</Platform>

+    </ProjectConfiguration>

+    <ProjectConfiguration Include="Release|Win32">

+      <Configuration>Release</Configuration>

+      <Platform>Win32</Platform>

+    </ProjectConfiguration>

+    <ProjectConfiguration Include="Debug|x64">

+      <Configuration>Debug</Configuration>

+      <Platform>x64</Platform>

+    </ProjectConfiguration>

+    <ProjectConfiguration Include="Release|x64">

+      <Configuration>Release</Configuration>

+      <Platform>x64</Platform>

+    </ProjectConfiguration>

+  </ItemGroup>

+  <ItemGroup>

+    <ClCompile Include="..\..\..\vstsdk2.4\public.sdk\source\vst2.x\audioeffect.cpp" />

+    <ClCompile Include="..\..\..\vstsdk2.4\public.sdk\source\vst2.x\audioeffectx.cpp" />

+    <ClCompile Include="..\..\..\vstsdk2.4\public.sdk\source\vst2.x\vstplugmain.cpp" />

+    <ClCompile Include="PocketVerbs.cpp" />

+    <ClCompile Include="PocketVerbsProc.cpp" />

+  </ItemGroup>

+  <ItemGroup>

+    <ClInclude Include="..\..\..\vstsdk2.4\public.sdk\source\vst2.x\aeffeditor.h" />

+    <ClInclude Include="..\..\..\vstsdk2.4\public.sdk\source\vst2.x\audioeffect.h" />

+    <ClInclude Include="..\..\..\vstsdk2.4\public.sdk\source\vst2.x\audioeffectx.h" />

+    <ClInclude Include="PocketVerbs.h" />

+  </ItemGroup>

+  <PropertyGroup Label="Globals">

+    <ProjectGuid>{16F7AB3C-1AE0-4574-B60C-7B4DED82938C}</ProjectGuid>

+    <RootNamespace>VSTProject</RootNamespace>

+    <WindowsTargetPlatformVersion>8.1</WindowsTargetPlatformVersion>

+    <ProjectName>PocketVerbs64</ProjectName>

+  </PropertyGroup>

+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.Default.props" />

+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'" Label="Configuration">

+    <ConfigurationType>DynamicLibrary</ConfigurationType>

+    <UseDebugLibraries>true</UseDebugLibraries>

+    <PlatformToolset>v140</PlatformToolset>

+    <CharacterSet>NotSet</CharacterSet>

+  </PropertyGroup>

+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'" Label="Configuration">

+    <ConfigurationType>DynamicLibrary</ConfigurationType>

+    <UseDebugLibraries>false</UseDebugLibraries>

+    <PlatformToolset>v140</PlatformToolset>

+    <WholeProgramOptimization>false</WholeProgramOptimization>

+    <CharacterSet>NotSet</CharacterSet>

+  </PropertyGroup>

+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'" Label="Configuration">

+    <ConfigurationType>DynamicLibrary</ConfigurationType>

+    <UseDebugLibraries>true</UseDebugLibraries>

+    <PlatformToolset>v140</PlatformToolset>

+    <CharacterSet>NotSet</CharacterSet>

+  </PropertyGroup>

+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'" Label="Configuration">

+    <ConfigurationType>DynamicLibrary</ConfigurationType>

+    <UseDebugLibraries>false</UseDebugLibraries>

+    <PlatformToolset>v140</PlatformToolset>

+    <WholeProgramOptimization>false</WholeProgramOptimization>

+    <CharacterSet>NotSet</CharacterSet>

+  </PropertyGroup>

+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.props" />

+  <ImportGroup Label="ExtensionSettings">

+  </ImportGroup>

+  <ImportGroup Label="Shared">

+  </ImportGroup>

+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">

+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />

+  </ImportGroup>

+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">

+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />

+  </ImportGroup>

+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">

+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />

+  </ImportGroup>

+  <ImportGroup Label="PropertySheets" Condition="'$(Configuration)|$(Platform)'=='Release|x64'">

+    <Import Project="$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props" Condition="exists('$(UserRootDir)\Microsoft.Cpp.$(Platform).user.props')" Label="LocalAppDataPlatform" />

+  </ImportGroup>

+  <PropertyGroup Label="UserMacros" />

+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">

+    <TargetExt>.dll</TargetExt>

+  </PropertyGroup>

+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">

+    <OutDir>$(SolutionDir)$(Configuration)\</OutDir>

+    <IntDir>$(Configuration)\</IntDir>

+    <ExecutablePath>$(VC_ExecutablePath_x64);$(WindowsSDK_ExecutablePath);$(VS_ExecutablePath);$(MSBuild_ExecutablePath);$(SystemRoot)\SysWow64;$(FxCopDir);$(PATH)</ExecutablePath>

+  </PropertyGroup>

+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">

+    <OutDir>$(SolutionDir)$(Configuration)\</OutDir>

+    <IntDir>$(Configuration)\</IntDir>

+    <ExecutablePath>$(VC_ExecutablePath_x64);$(WindowsSDK_ExecutablePath);$(VS_ExecutablePath);$(MSBuild_ExecutablePath);$(SystemRoot)\SysWow64;$(FxCopDir);$(PATH)</ExecutablePath>

+  </PropertyGroup>

+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">

+    <ClCompile>

+      <WarningLevel>Level3</WarningLevel>

+      <Optimization>MaxSpeed</Optimization>

+      <SDLCheck>true</SDLCheck>

+      <AdditionalIncludeDirectories>C:\Users\christopherjohnson\Documents\Visual Studio 2015\Projects\VSTProject\vst2.x;C:\Users\christopherjohnson\Documents\vstsdk2.4;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>

+      <PreprocessorDefinitions>WINDOWS;_WINDOWS;WIN32;_USRDLL;_USE_MATH_DEFINES;_CRT_SECURE_NO_DEPRECATE;VST_FORCE_DEPRECATED;%(PreprocessorDefinitions)</PreprocessorDefinitions>

+      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>

+      <FavorSizeOrSpeed>Speed</FavorSizeOrSpeed>

+      <MinimalRebuild>false</MinimalRebuild>

+      <BasicRuntimeChecks>Default</BasicRuntimeChecks>

+      <FunctionLevelLinking>false</FunctionLevelLinking>

+      <DebugInformationFormat>None</DebugInformationFormat>

+    </ClCompile>

+    <Link>

+      <ModuleDefinitionFile>vstplug.def</ModuleDefinitionFile>

+      <IgnoreSpecificDefaultLibraries>libcmt.dll;libcmtd.dll;msvcrt.lib;%(IgnoreSpecificDefaultLibraries)</IgnoreSpecificDefaultLibraries>

+      <AdditionalDependencies>kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies)</AdditionalDependencies>

+    </Link>

+  </ItemDefinitionGroup>

+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">

+    <ClCompile>

+      <WarningLevel>Level3</WarningLevel>

+      <Optimization>MaxSpeed</Optimization>

+      <SDLCheck>true</SDLCheck>

+      <AdditionalIncludeDirectories>C:\Users\christopherjohnson\Documents\Visual Studio 2015\Projects\VSTProject\vst2.x;C:\Users\christopherjohnson\Documents\vstsdk2.4;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>

+      <FavorSizeOrSpeed>Speed</FavorSizeOrSpeed>

+      <PreprocessorDefinitions>WINDOWS;_WINDOWS;WIN32;_USRDLL;_USE_MATH_DEFINES;_CRT_SECURE_NO_DEPRECATE;VST_FORCE_DEPRECATED;%(PreprocessorDefinitions)</PreprocessorDefinitions>

+      <MinimalRebuild>false</MinimalRebuild>

+      <RuntimeLibrary>MultiThreadedDebug</RuntimeLibrary>

+      <BasicRuntimeChecks>Default</BasicRuntimeChecks>

+      <FunctionLevelLinking>false</FunctionLevelLinking>

+      <DebugInformationFormat>None</DebugInformationFormat>

+    </ClCompile>

+    <Link>

+      <AdditionalDependencies>kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;uuid.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies)</AdditionalDependencies>

+      <IgnoreSpecificDefaultLibraries>libcmt.dll;libcmtd.dll;msvcrt.lib;%(IgnoreSpecificDefaultLibraries)</IgnoreSpecificDefaultLibraries>

+      <ModuleDefinitionFile>vstplug.def</ModuleDefinitionFile>

+    </Link>

+  </ItemDefinitionGroup>

+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">

+    <ClCompile>

+      <WarningLevel>Level3</WarningLevel>

+      <Optimization>MaxSpeed</Optimization>

+      <FunctionLevelLinking>false</FunctionLevelLinking>

+      <IntrinsicFunctions>false</IntrinsicFunctions>

+      <SDLCheck>true</SDLCheck>

+      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>

+      <AdditionalIncludeDirectories>C:\Users\christopherjohnson\Documents\Visual Studio 2015\Projects\VSTProject\vst2.x;C:\Users\christopherjohnson\Documents\vstsdk2.4;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>

+      <DebugInformationFormat>None</DebugInformationFormat>

+      <FavorSizeOrSpeed>Speed</FavorSizeOrSpeed>

+      <PreprocessorDefinitions>WINDOWS;_WINDOWS;WIN32;_USRDLL;_USE_MATH_DEFINES;_CRT_SECURE_NO_DEPRECATE;VST_FORCE_DEPRECATED;%(PreprocessorDefinitions)</PreprocessorDefinitions>

+    </ClCompile>

+    <Link>

+      <EnableCOMDATFolding>true</EnableCOMDATFolding>

+      <OptimizeReferences>true</OptimizeReferences>

+      <IgnoreSpecificDefaultLibraries>libcmt.dll;libcmtd.dll;msvcrt.lib;libc.lib;libcd.lib;libcmt.lib;msvcrtd.lib;%(IgnoreSpecificDefaultLibraries)</IgnoreSpecificDefaultLibraries>

+      <AdditionalDependencies>libcmt.lib;uuid.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies)</AdditionalDependencies>

+      <ModuleDefinitionFile>vstplug.def</ModuleDefinitionFile>

+    </Link>

+  </ItemDefinitionGroup>

+  <ItemDefinitionGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">

+    <ClCompile>

+      <WarningLevel>Level3</WarningLevel>

+      <Optimization>MaxSpeed</Optimization>

+      <FunctionLevelLinking>false</FunctionLevelLinking>

+      <IntrinsicFunctions>false</IntrinsicFunctions>

+      <SDLCheck>true</SDLCheck>

+      <AdditionalIncludeDirectories>C:\Users\christopherjohnson\Documents\Visual Studio 2015\Projects\VSTProject\vst2.x;C:\Users\christopherjohnson\Documents\vstsdk2.4;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>

+      <DebugInformationFormat>None</DebugInformationFormat>

+      <FavorSizeOrSpeed>Speed</FavorSizeOrSpeed>

+      <PreprocessorDefinitions>WINDOWS;_WINDOWS;WIN32;_USRDLL;_USE_MATH_DEFINES;_CRT_SECURE_NO_DEPRECATE;VST_FORCE_DEPRECATED;%(PreprocessorDefinitions)</PreprocessorDefinitions>

+      <RuntimeLibrary>MultiThreaded</RuntimeLibrary>

+    </ClCompile>

+    <Link>

+      <EnableCOMDATFolding>true</EnableCOMDATFolding>

+      <OptimizeReferences>true</OptimizeReferences>

+      <IgnoreSpecificDefaultLibraries>libcmt.dll;libcmtd.dll;msvcrt.lib;libc.lib;libcd.lib;libcmt.lib;msvcrtd.lib;%(IgnoreSpecificDefaultLibraries)</IgnoreSpecificDefaultLibraries>

+      <AdditionalDependencies>libcmt.lib;uuid.lib;kernel32.lib;user32.lib;gdi32.lib;winspool.lib;comdlg32.lib;advapi32.lib;shell32.lib;ole32.lib;oleaut32.lib;odbc32.lib;odbccp32.lib;%(AdditionalDependencies)</AdditionalDependencies>

+      <ModuleDefinitionFile>vstplug.def</ModuleDefinitionFile>

+    </Link>

+  </ItemDefinitionGroup>

+  <Import Project="$(VCTargetsPath)\Microsoft.Cpp.targets" />

+  <ImportGroup Label="ExtensionTargets">

+  </ImportGroup>

+</Project>
\ No newline at end of file
diff --git a/plugins/WinVST/PocketVerbs/VSTProject.vcxproj.filters b/plugins/WinVST/PocketVerbs/VSTProject.vcxproj.filters
new file mode 100755
index 0000000..55debca
--- /dev/null
+++ b/plugins/WinVST/PocketVerbs/VSTProject.vcxproj.filters
@@ -0,0 +1,48 @@
+<?xml version="1.0" encoding="utf-8"?>

+<Project ToolsVersion="4.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">

+  <ItemGroup>

+    <Filter Include="Source Files">

+      <UniqueIdentifier>{4FC737F1-C7A5-4376-A066-2A32D752A2FF}</UniqueIdentifier>

+      <Extensions>cpp;c;cc;cxx;def;odl;idl;hpj;bat;asm;asmx</Extensions>

+    </Filter>

+    <Filter Include="Header Files">

+      <UniqueIdentifier>{93995380-89BD-4b04-88EB-625FBE52EBFB}</UniqueIdentifier>

+      <Extensions>h;hh;hpp;hxx;hm;inl;inc;xsd</Extensions>

+    </Filter>

+    <Filter Include="Resource Files">

+      <UniqueIdentifier>{67DA6AB6-F800-4c08-8B7A-83BB121AAD01}</UniqueIdentifier>

+      <Extensions>rc;ico;cur;bmp;dlg;rc2;rct;bin;rgs;gif;jpg;jpeg;jpe;resx;tiff;tif;png;wav;mfcribbon-ms</Extensions>

+    </Filter>

+  </ItemGroup>

+  <ItemGroup>

+    <ClCompile Include="..\..\..\vstsdk2.4\public.sdk\source\vst2.x\audioeffect.cpp">

+      <Filter>Source Files</Filter>

+    </ClCompile>

+    <ClCompile Include="..\..\..\vstsdk2.4\public.sdk\source\vst2.x\audioeffectx.cpp">

+      <Filter>Source Files</Filter>

+    </ClCompile>

+    <ClCompile Include="..\..\..\vstsdk2.4\public.sdk\source\vst2.x\vstplugmain.cpp">

+      <Filter>Source Files</Filter>

+    </ClCompile>

+    <ClCompile Include="PocketVerbs.cpp">

+      <Filter>Source Files</Filter>

+    </ClCompile>

+    <ClCompile Include="PocketVerbsProc.cpp">

+      <Filter>Source Files</Filter>

+    </ClCompile>

+  </ItemGroup>

+  <ItemGroup>

+    <ClInclude Include="..\..\..\vstsdk2.4\public.sdk\source\vst2.x\aeffeditor.h">

+      <Filter>Header Files</Filter>

+    </ClInclude>

+    <ClInclude Include="..\..\..\vstsdk2.4\public.sdk\source\vst2.x\audioeffect.h">

+      <Filter>Header Files</Filter>

+    </ClInclude>

+    <ClInclude Include="..\..\..\vstsdk2.4\public.sdk\source\vst2.x\audioeffectx.h">

+      <Filter>Header Files</Filter>

+    </ClInclude>

+    <ClInclude Include="PocketVerbs.h">

+      <Filter>Header Files</Filter>

+    </ClInclude>

+  </ItemGroup>

+</Project>
\ No newline at end of file
diff --git a/plugins/WinVST/PocketVerbs/VSTProject.vcxproj.user b/plugins/WinVST/PocketVerbs/VSTProject.vcxproj.user
new file mode 100755
index 0000000..2216267
--- /dev/null
+++ b/plugins/WinVST/PocketVerbs/VSTProject.vcxproj.user
@@ -0,0 +1,19 @@
+<?xml version="1.0" encoding="utf-8"?>

+<Project ToolsVersion="14.0" xmlns="http://schemas.microsoft.com/developer/msbuild/2003">

+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|Win32'">

+    <LocalDebuggerAmpDefaultAccelerator>{ADEFF70D-84BF-47A1-91C3-FF6B0FC71218}</LocalDebuggerAmpDefaultAccelerator>

+    <DebuggerFlavor>WindowsLocalDebugger</DebuggerFlavor>

+  </PropertyGroup>

+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|Win32'">

+    <LocalDebuggerAmpDefaultAccelerator>{ADEFF70D-84BF-47A1-91C3-FF6B0FC71218}</LocalDebuggerAmpDefaultAccelerator>

+    <DebuggerFlavor>WindowsLocalDebugger</DebuggerFlavor>

+  </PropertyGroup>

+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|x64'">

+    <LocalDebuggerAmpDefaultAccelerator>{ADEFF70D-84BF-47A1-91C3-FF6B0FC71218}</LocalDebuggerAmpDefaultAccelerator>

+    <DebuggerFlavor>WindowsLocalDebugger</DebuggerFlavor>

+  </PropertyGroup>

+  <PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|x64'">

+    <LocalDebuggerAmpDefaultAccelerator>{ADEFF70D-84BF-47A1-91C3-FF6B0FC71218}</LocalDebuggerAmpDefaultAccelerator>

+    <DebuggerFlavor>WindowsLocalDebugger</DebuggerFlavor>

+  </PropertyGroup>

+</Project>
\ No newline at end of file
diff --git a/plugins/WinVST/PocketVerbs/vstplug.def b/plugins/WinVST/PocketVerbs/vstplug.def
new file mode 100755
index 0000000..5bf499a
--- /dev/null
+++ b/plugins/WinVST/PocketVerbs/vstplug.def
@@ -0,0 +1,3 @@
+EXPORTS

+	VSTPluginMain

+	main=VSTPluginMain
\ No newline at end of file