PocketVerbs

56 files changed, 71664 insertions, 0 deletions

diff --git a/plugins/LinuxVST/CMakeLists.txt b/plugins/LinuxVST/CMakeLists.txt
index 57ddebe..a2de68f 100755
--- a/plugins/LinuxVST/CMakeLists.txt
+++ b/plugins/LinuxVST/CMakeLists.txt
@@ -127,6 +127,7 @@ add_airwindows_plugin(PeaksOnly)
 add_airwindows_plugin(PDBuss)
 add_airwindows_plugin(PDChannel)
 add_airwindows_plugin(PhaseNudge)
+add_airwindows_plugin(PocketVerbs)
 add_airwindows_plugin(Podcast)
 add_airwindows_plugin(PodcastDeluxe)
 add_airwindows_plugin(Point)
diff --git a/plugins/LinuxVST/src/PocketVerbs/PocketVerbs.cpp b/plugins/LinuxVST/src/PocketVerbs/PocketVerbs.cpp
new file mode 100755
index 0000000..4426e4b
--- /dev/null
+++ b/plugins/LinuxVST/src/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/LinuxVST/src/PocketVerbs/PocketVerbs.h b/plugins/LinuxVST/src/PocketVerbs/PocketVerbs.h
new file mode 100755
index 0000000..7feaf8e
--- /dev/null
+++ b/plugins/LinuxVST/src/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/LinuxVST/src/PocketVerbs/PocketVerbsProc.cpp b/plugins/LinuxVST/src/PocketVerbs/PocketVerbsProc.cpp
new file mode 100755
index 0000000..4ea8f51
--- /dev/null
+++ b/plugins/LinuxVST/src/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/MacAU/PocketVerbs/English.lproj/InfoPlist.strings b/plugins/MacAU/PocketVerbs/English.lproj/InfoPlist.strings
new file mode 100755
index 0000000..eaeed1c
--- /dev/null
+++ b/plugins/MacAU/PocketVerbs/English.lproj/InfoPlist.strings
diff --git a/plugins/MacAU/PocketVerbs/Info.plist b/plugins/MacAU/PocketVerbs/Info.plist
new file mode 100755
index 0000000..12f0517
--- /dev/null
+++ b/plugins/MacAU/PocketVerbs/Info.plist
@@ -0,0 +1,28 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>CFBundleDevelopmentRegion</key>
+	<string>English</string>
+	<key>CFBundleExecutable</key>
+	<string>${EXECUTABLE_NAME}</string>
+	<key>CFBundleIconFile</key>
+	<string></string>
+	<key>CFBundleIdentifier</key>
+	<string>com.airwindows.audiounit.${PRODUCT_NAME:identifier}</string>
+	<key>CFBundleName</key>
+	<string>${PROJECTNAMEASIDENTIFIER}</string>
+	<key>CFBundleInfoDictionaryVersion</key>
+	<string>6.0</string>
+	<key>CFBundlePackageType</key>
+	<string>BNDL</string>
+	<key>CFBundleShortVersionString</key>
+	<string>1.0</string>
+	<key>CFBundleSignature</key>
+	<string>Dthr</string>
+	<key>CFBundleVersion</key>
+	<string>1.0</string>
+	<key>CSResourcesFileMapped</key>
+	<true/>
+</dict>
+</plist>
diff --git a/plugins/MacAU/PocketVerbs/PocketVerbs.cpp b/plugins/MacAU/PocketVerbs/PocketVerbs.cpp
new file mode 100755
index 0000000..741b94e
--- /dev/null
+++ b/plugins/MacAU/PocketVerbs/PocketVerbs.cpp
@@ -0,0 +1,4909 @@
+/*
+*	File:		PocketVerbs.cpp
+*	
+*	Version:	1.0
+* 
+*	Created:	8/19/12
+*	
+*	Copyright:  Copyright © 2012 Airwindows, All Rights Reserved
+* 
+*	Disclaimer:	IMPORTANT:  This Apple software is supplied to you by Apple Computer, Inc. ("Apple") in 
+*				consideration of your agreement to the following terms, and your use, installation, modification 
+*				or redistribution of this Apple software constitutes acceptance of these terms.  If you do 
+*				not agree with these terms, please do not use, install, modify or redistribute this Apple 
+*				software.
+*
+*				In consideration of your agreement to abide by the following terms, and subject to these terms, 
+*				Apple grants you a personal, non-exclusive license, under Apple's copyrights in this 
+*				original Apple software (the "Apple Software"), to use, reproduce, modify and redistribute the 
+*				Apple Software, with or without modifications, in source and/or binary forms; provided that if you 
+*				redistribute the Apple Software in its entirety and without modifications, you must retain this 
+*				notice and the following text and disclaimers in all such redistributions of the Apple Software. 
+*				Neither the name, trademarks, service marks or logos of Apple Computer, Inc. may be used to 
+*				endorse or promote products derived from the Apple Software without specific prior written 
+*				permission from Apple.  Except as expressly stated in this notice, no other rights or 
+*				licenses, express or implied, are granted by Apple herein, including but not limited to any 
+*				patent rights that may be infringed by your derivative works or by other works in which the 
+*				Apple Software may be incorporated.
+*
+*				The Apple Software is provided by Apple on an "AS IS" basis.  APPLE MAKES NO WARRANTIES, EXPRESS OR 
+*				IMPLIED, INCLUDING WITHOUT LIMITATION THE IMPLIED WARRANTIES OF NON-INFRINGEMENT, MERCHANTABILITY 
+*				AND FITNESS FOR A PARTICULAR PURPOSE, REGARDING THE APPLE SOFTWARE OR ITS USE AND OPERATION ALONE 
+*				OR IN COMBINATION WITH YOUR PRODUCTS.
+*
+*				IN NO EVENT SHALL APPLE BE LIABLE FOR ANY SPECIAL, INDIRECT, INCIDENTAL OR CONSEQUENTIAL 
+*				DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS 
+*				OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ARISING IN ANY WAY OUT OF THE USE, 
+*				REPRODUCTION, MODIFICATION AND/OR DISTRIBUTION OF THE APPLE SOFTWARE, HOWEVER CAUSED AND WHETHER 
+*				UNDER THEORY OF CONTRACT, TORT (INCLUDING NEGLIGENCE), STRICT LIABILITY OR OTHERWISE, EVEN 
+*				IF APPLE HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*
+*/
+/*=============================================================================
+	PocketVerbs.cpp
+	
+=============================================================================*/
+#include "PocketVerbs.h"
+
+
+//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+COMPONENT_ENTRY(PocketVerbs)
+
+
+//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//	PocketVerbs::PocketVerbs
+//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+PocketVerbs::PocketVerbs(AudioUnit component)
+	: AUEffectBase(component)
+{
+	CreateElements();
+	Globals()->UseIndexedParameters(kNumberOfParameters);
+	SetParameter(kParam_One, kDefaultValue_ParamOne );
+	SetParameter(kParam_Two, kDefaultValue_ParamTwo );
+	SetParameter(kParam_Three, kDefaultValue_ParamThree );
+	SetParameter(kParam_Four, kDefaultValue_ParamFour );
+         
+#if AU_DEBUG_DISPATCHER
+	mDebugDispatcher = new AUDebugDispatcher (this);
+#endif
+	
+}
+
+
+//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//	PocketVerbs::GetParameterValueStrings
+//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ComponentResult			PocketVerbs::GetParameterValueStrings(AudioUnitScope		inScope,
+                                                                AudioUnitParameterID	inParameterID,
+                                                                CFArrayRef *		outStrings)
+{
+    if ((inScope == kAudioUnitScope_Global) && (inParameterID == kParam_One)) //ID must be actual name of parameter identifier, not number
+	{
+		if (outStrings == NULL) return noErr;
+		CFStringRef strings [] =
+		{
+			kMenuItem_Chamber,
+			kMenuItem_Spring,
+			kMenuItem_Tiled,
+			kMenuItem_Room,
+			kMenuItem_Stretch,
+			kMenuItem_Zarathustra,
+		};
+		*outStrings = CFArrayCreate (
+									 NULL,
+									 (const void **) strings,
+									 (sizeof (strings) / sizeof (strings [0])),
+									 NULL
+									 );
+		return noErr;
+	}
+    return kAudioUnitErr_InvalidProperty;
+}
+
+
+
+//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//	PocketVerbs::GetParameterInfo
+//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ComponentResult			PocketVerbs::GetParameterInfo(AudioUnitScope		inScope,
+                                                        AudioUnitParameterID	inParameterID,
+                                                        AudioUnitParameterInfo	&outParameterInfo )
+{
+	ComponentResult result = noErr;
+
+	outParameterInfo.flags = 	kAudioUnitParameterFlag_IsWritable
+						|		kAudioUnitParameterFlag_IsReadable;
+    
+    if (inScope == kAudioUnitScope_Global) {
+        switch(inParameterID)
+        {
+           case kParam_One:
+                AUBase::FillInParameterName (outParameterInfo, kParameterOneName, false);
+                outParameterInfo.unit = kAudioUnitParameterUnit_Indexed;
+                outParameterInfo.minValue = kChamber;
+                outParameterInfo.maxValue = kZarathustra;
+                outParameterInfo.defaultValue = kDefaultValue_ParamOne;
+                break;
+            case kParam_Two:
+                AUBase::FillInParameterName (outParameterInfo, kParameterTwoName, false);
+                outParameterInfo.unit = kAudioUnitParameterUnit_Generic;
+                outParameterInfo.minValue = 0.0;
+                outParameterInfo.maxValue = 1.0;
+                outParameterInfo.defaultValue = kDefaultValue_ParamTwo;
+                break;
+            case kParam_Three:
+                AUBase::FillInParameterName (outParameterInfo, kParameterThreeName, false);
+                outParameterInfo.unit = kAudioUnitParameterUnit_Generic;
+                outParameterInfo.minValue = 0.0;
+                outParameterInfo.maxValue = 1.0;
+                outParameterInfo.defaultValue = kDefaultValue_ParamThree;
+                break;
+            case kParam_Four:
+                AUBase::FillInParameterName (outParameterInfo, kParameterFourName, false);
+                outParameterInfo.unit = kAudioUnitParameterUnit_Generic;
+                outParameterInfo.minValue = 0.0;
+                outParameterInfo.maxValue = 1.0;
+                outParameterInfo.defaultValue = kDefaultValue_ParamFour;
+                break;
+   		default:
+                result = kAudioUnitErr_InvalidParameter;
+                break;
+            }
+	} else {
+        result = kAudioUnitErr_InvalidParameter;
+    }
+    
+
+
+	return result;
+}
+
+//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//	PocketVerbs::GetPropertyInfo
+//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ComponentResult			PocketVerbs::GetPropertyInfo (AudioUnitPropertyID	inID,
+                                                        AudioUnitScope		inScope,
+                                                        AudioUnitElement	inElement,
+                                                        UInt32 &		outDataSize,
+                                                        Boolean &		outWritable)
+{
+	return AUEffectBase::GetPropertyInfo (inID, inScope, inElement, outDataSize, outWritable);
+}
+
+//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//	PocketVerbs::GetProperty
+//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ComponentResult			PocketVerbs::GetProperty(	AudioUnitPropertyID inID,
+                                                        AudioUnitScope 		inScope,
+                                                        AudioUnitElement 	inElement,
+                                                        void *			outData )
+{
+	return AUEffectBase::GetProperty (inID, inScope, inElement, outData);
+}
+
+//	PocketVerbs::Initialize
+//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ComponentResult PocketVerbs::Initialize()
+{
+    ComponentResult result = AUEffectBase::Initialize();
+    if (result == noErr)
+        Reset(kAudioUnitScope_Global, 0);
+    return result;
+}
+
+#pragma mark ____PocketVerbsEffectKernel
+
+
+
+//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//	PocketVerbs::PocketVerbsKernel::Reset()
+//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+void		PocketVerbs::PocketVerbsKernel::Reset()
+{
+	int count;
+	for(count = 0; count < 6; count++) {dA[count] = 0.0; dB[count] = 0.0; dC[count] = 0.0; dD[count] = 0.0; dE[count] = 0.0;
+	dF[count] = 0.0; dG[count] = 0.0; dH[count] = 0.0; dI[count] = 0.0; dJ[count] = 0.0; dK[count] = 0.0; dL[count] = 0.0;
+	dM[count] = 0.0; dN[count] = 0.0; dO[count] = 0.0; dP[count] = 0.0; dQ[count] = 0.0; dR[count] = 0.0; dS[count] = 0.0;
+	dT[count] = 0.0; dU[count] = 0.0; dV[count] = 0.0; dW[count] = 0.0; dX[count] = 0.0; dY[count] = 0.0; dZ[count] = 0.0;}
+	
+	for(count = 0; count < 15149; count++) {aA[count] = 0.0;}
+	for(count = 0; count < 15149; count++) {oA[count] = 0.0;}
+	for(count = 0; count < 14617; count++) {aB[count] = 0.0;}
+	for(count = 0; count < 14617; count++) {oB[count] = 0.0;}
+	for(count = 0; count < 14357; count++) {aC[count] = 0.0;}
+	for(count = 0; count < 14357; count++) {oC[count] = 0.0;}
+	for(count = 0; count < 13817; count++) {aD[count] = 0.0;}
+	for(count = 0; count < 13817; count++) {oD[count] = 0.0;}
+	for(count = 0; count < 13561; count++) {aE[count] = 0.0;}
+	for(count = 0; count < 13561; count++) {oE[count] = 0.0;}
+	for(count = 0; count < 13045; count++) {aF[count] = 0.0;}
+	for(count = 0; count < 13045; count++) {oF[count] = 0.0;}
+	for(count = 0; count < 11965; count++) {aG[count] = 0.0;}
+	for(count = 0; count < 11965; count++) {oG[count] = 0.0;}
+	for(count = 0; count < 11129; count++) {aH[count] = 0.0;}
+	for(count = 0; count < 11129; count++) {oH[count] = 0.0;}
+	for(count = 0; count < 10597; count++) {aI[count] = 0.0;}
+	for(count = 0; count < 10597; count++) {oI[count] = 0.0;}
+	for(count = 0; count < 9809; count++) {aJ[count] = 0.0;}
+	for(count = 0; count < 9809; count++) {oJ[count] = 0.0;}
+	for(count = 0; count < 9521; count++) {aK[count] = 0.0;}
+	for(count = 0; count < 9521; count++) {oK[count] = 0.0;}
+	for(count = 0; count < 8981; count++) {aL[count] = 0.0;}
+	for(count = 0; count < 8981; count++) {oL[count] = 0.0;}
+	for(count = 0; count < 8785; count++) {aM[count] = 0.0;}
+	for(count = 0; count < 8785; count++) {oM[count] = 0.0;}
+	for(count = 0; count < 8461; count++) {aN[count] = 0.0;}
+	for(count = 0; count < 8461; count++) {oN[count] = 0.0;}
+	for(count = 0; count < 8309; count++) {aO[count] = 0.0;}
+	for(count = 0; count < 8309; count++) {oO[count] = 0.0;}
+	for(count = 0; count < 7981; count++) {aP[count] = 0.0;}
+	for(count = 0; count < 7981; count++) {oP[count] = 0.0;}
+	for(count = 0; count < 7321; count++) {aQ[count] = 0.0;}
+	for(count = 0; count < 7321; count++) {oQ[count] = 0.0;}
+	for(count = 0; count < 6817; count++) {aR[count] = 0.0;}
+	for(count = 0; count < 6817; count++) {oR[count] = 0.0;}
+	for(count = 0; count < 6505; count++) {aS[count] = 0.0;}
+	for(count = 0; count < 6505; count++) {oS[count] = 0.0;}
+	for(count = 0; count < 6001; count++) {aT[count] = 0.0;}
+	for(count = 0; count < 6001; count++) {oT[count] = 0.0;}
+	for(count = 0; count < 5837; count++) {aU[count] = 0.0;}
+	for(count = 0; count < 5837; count++) {oU[count] = 0.0;}
+	for(count = 0; count < 5501; count++) {aV[count] = 0.0;}
+	for(count = 0; count < 5501; count++) {oV[count] = 0.0;}
+	for(count = 0; count < 5009; count++) {aW[count] = 0.0;}
+	for(count = 0; count < 5009; count++) {oW[count] = 0.0;}
+	for(count = 0; count < 4849; count++) {aX[count] = 0.0;}
+	for(count = 0; count < 4849; count++) {oX[count] = 0.0;}
+	for(count = 0; count < 4295; count++) {aY[count] = 0.0;}
+	for(count = 0; count < 4295; count++) {oY[count] = 0.0;}
+	for(count = 0; count < 4179; count++) {aZ[count] = 0.0;}	
+	for(count = 0; count < 4179; count++) {oZ[count] = 0.0;}
+	
+	
+	outA = 1; alpA = 1; delayA = 4; maxdelayA = 7573;
+	outB = 1; alpB = 1; delayB = 4; maxdelayB = 7307;
+	outC = 1; alpC = 1; delayC = 4; maxdelayC = 7177;
+	outD = 1; alpD = 1; delayD = 4; maxdelayD = 6907;
+	outE = 1; alpE = 1; delayE = 4; maxdelayE = 6779;
+	outF = 1; alpF = 1; delayF = 4; maxdelayF = 6521;
+	outG = 1; alpG = 1; delayG = 4; maxdelayG = 5981;
+	outH = 1; alpH = 1; delayH = 4; maxdelayH = 5563;
+	outI = 1; alpI = 1; delayI = 4; maxdelayI = 5297;
+	outJ = 1; alpJ = 1; delayJ = 4; maxdelayJ = 4903;
+	outK = 1; alpK = 1; delayK = 4; maxdelayK = 4759;
+	outL = 1; alpL = 1; delayL = 4; maxdelayL = 4489;
+	outM = 1; alpM = 1; delayM = 4; maxdelayM = 4391;
+	outN = 1; alpN = 1; delayN = 4; maxdelayN = 4229;
+	outO = 1; alpO = 1; delayO = 4; maxdelayO = 4153;
+	outP = 1; alpP = 1; delayP = 4; maxdelayP = 3989;
+	outQ = 1; alpQ = 1; delayQ = 4; maxdelayQ = 3659;
+	outR = 1; alpR = 1; delayR = 4; maxdelayR = 3407;
+	outS = 1; alpS = 1; delayS = 4; maxdelayS = 3251;
+	outT = 1; alpT = 1; delayT = 4; maxdelayT = 2999;
+	outU = 1; alpU = 1; delayU = 4; maxdelayU = 2917;
+	outV = 1; alpV = 1; delayV = 4; maxdelayV = 2749;
+	outW = 1; alpW = 1; delayW = 4; maxdelayW = 2503;
+	outX = 1; alpX = 1; delayX = 4; maxdelayX = 2423;
+	outY = 1; alpY = 1; delayY = 4; maxdelayY = 2146;
+	outZ = 1; alpZ = 1; delayZ = 4; maxdelayZ = 2088;
+	
+	savedRoomsize = -1.0; //force update to begin
+	countdown = -1;
+	peak = 1.0;
+	fpd = 17;
+}
+
+//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+//	PocketVerbs::PocketVerbsKernel::Process
+//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+void		PocketVerbs::PocketVerbsKernel::Process(	const Float32 	*inSourceP,
+                                                    Float32		 	*inDestP,
+                                                    UInt32 			inFramesToProcess,
+                                                    UInt32			inNumChannels, 
+                                                    bool			&ioSilence )
+{
+	UInt32 nSampleFrames = inFramesToProcess;
+	const Float32 *sourceP = inSourceP;
+	Float32 *destP = inDestP;
+	int verbtype = GetParameter( kParam_One );
+	Float64 roomsize = (pow(GetParameter( kParam_Two ),2)*1.9)+0.1;
+	
+	Float64 release = 0.00008 * pow(GetParameter( kParam_Three ),3);
+	if (release == 0.0) peak = 1.0;
+	Float64 wetnesstarget = GetParameter( kParam_Four );
+	Float64 dryness = (1.0 - wetnesstarget);
+	//verbs use base wetness value internally
+	Float64 wetness = wetnesstarget;
+	Float64 constallpass = 0.618033988749894848204586; //golden ratio!
+	int allpasstemp;
+	int count;
+	int max = 70; //biggest divisor to test primes against
+	Float64 bridgerectifier;
+	Float64 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 = alpA; count < 15149; count++) {aA[count] = 0.0;}
+				for(count = outA; count < 15149; count++) {oA[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 = alpB; count < 14617; count++) {aB[count] = 0.0;}
+				for(count = outB; count < 14617; count++) {oB[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 = alpC; count < 14357; count++) {aC[count] = 0.0;}
+				for(count = outC; count < 14357; count++) {oC[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 = alpD; count < 13817; count++) {aD[count] = 0.0;}
+				for(count = outD; count < 13817; count++) {oD[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 = alpE; count < 13561; count++) {aE[count] = 0.0;}
+				for(count = outE; count < 13561; count++) {oE[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 = alpF; count < 13045; count++) {aF[count] = 0.0;}
+				for(count = outF; count < 13045; count++) {oF[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 = alpG; count < 11965; count++) {aG[count] = 0.0;}
+				for(count = outG; count < 11965; count++) {oG[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 = alpH; count < 11129; count++) {aH[count] = 0.0;}
+				for(count = outH; count < 11129; count++) {oH[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 = alpI; count < 10597; count++) {aI[count] = 0.0;}
+				for(count = outI; count < 10597; count++) {oI[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 = alpJ; count < 9809; count++) {aJ[count] = 0.0;}
+				for(count = outJ; count < 9809; count++) {oJ[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 = alpK; count < 9521; count++) {aK[count] = 0.0;}
+				for(count = outK; count < 9521; count++) {oK[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 = alpL; count < 8981; count++) {aL[count] = 0.0;}
+				for(count = outL; count < 8981; count++) {oL[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 = alpM; count < 8785; count++) {aM[count] = 0.0;}
+				for(count = outM; count < 8785; count++) {oM[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 = alpN; count < 8461; count++) {aN[count] = 0.0;}
+				for(count = outN; count < 8461; count++) {oN[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 = alpO; count < 8309; count++) {aO[count] = 0.0;}
+				for(count = outO; count < 8309; count++) {oO[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 = alpP; count < 7981; count++) {aP[count] = 0.0;}
+				for(count = outP; count < 7981; count++) {oP[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 = alpQ; count < 7321; count++) {aQ[count] = 0.0;}
+				for(count = outQ; count < 7321; count++) {oQ[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 = alpR; count < 6817; count++) {aR[count] = 0.0;}
+				for(count = outR; count < 6817; count++) {oR[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 = alpS; count < 6505; count++) {aS[count] = 0.0;}
+				for(count = outS; count < 6505; count++) {oS[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 = alpT; count < 6001; count++) {aT[count] = 0.0;}
+				for(count = outT; count < 6001; count++) {oT[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 = alpU; count < 5837; count++) {aU[count] = 0.0;}
+				for(count = outU; count < 5837; count++) {oU[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 = alpV; count < 5501; count++) {aV[count] = 0.0;}
+				for(count = outV; count < 5501; count++) {oV[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 = alpW; count < 5009; count++) {aW[count] = 0.0;}
+				for(count = outW; count < 5009; count++) {oW[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 = alpX; count < 4849; count++) {aX[count] = 0.0;}
+				for(count = outX; count < 4849; count++) {oX[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 = alpY; count < 4295; count++) {aY[count] = 0.0;}
+				for(count = outY; count < 4295; count++) {oY[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 = alpZ; count < 4179; count++) {aZ[count] = 0.0;}	
+				for(count = outZ; count < 4179; count++) {oZ[count] = 0.0;}
+				break;
+		} //end of switch statement
+		countdown--;
+	}
+	
+	
+	while (nSampleFrames-- > 0) {
+		long double inputSample = *sourceP;
+		if (fabs(inputSample)<1.18e-37) inputSample = fpd * 1.18e-37;
+		long double drySample = inputSample;
+		
+		peak -= release;
+		if (peak < fabs(inputSample*2.0)) peak = fabs(inputSample*2.0);
+		if (peak > 1.0) peak = 1.0;
+		//chase the maximum signal to incorporate the wetter/louder behavior
+		//boost for more extreme effect when in use, cap it
+		
+		inputSample *= gain;
+		bridgerectifier = fabs(inputSample);
+		bridgerectifier = sin(bridgerectifier);
+		if (inputSample > 0) inputSample = bridgerectifier;
+		else inputSample = -bridgerectifier;
+		//here we apply the ADT2 console-on-steroids trick		
+						
+		switch (verbtype)
+		{
+
+				
+case 1://Chamber
+				allpasstemp = alpA - 1;
+				if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;}
+				inputSample -= aA[allpasstemp]*constallpass;
+				aA[alpA] = inputSample;
+				inputSample *= constallpass;
+				alpA--; if (alpA < 0 || alpA > delayA) {alpA = delayA;}
+				inputSample += (aA[alpA]);
+				//allpass filter A		
+				
+				dA[3] = dA[2];
+				dA[2] = dA[1];
+				dA[1] = inputSample;
+				inputSample = (dA[1] + dA[2] + dA[3])/3.0;
+				
+				allpasstemp = alpB - 1;
+				if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;}
+				inputSample -= aB[allpasstemp]*constallpass;
+				aB[alpB] = inputSample;
+				inputSample *= constallpass;
+				alpB--; if (alpB < 0 || alpB > delayB) {alpB = delayB;}
+				inputSample += (aB[alpB]);
+				//allpass filter B
+				
+				dB[3] = dB[2];
+				dB[2] = dB[1];
+				dB[1] = inputSample;
+				inputSample = (dB[1] + dB[2] + dB[3])/3.0;
+				
+				allpasstemp = alpC - 1;
+				if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;}
+				inputSample -= aC[allpasstemp]*constallpass;
+				aC[alpC] = inputSample;
+				inputSample *= constallpass;
+				alpC--; if (alpC < 0 || alpC > delayC) {alpC = delayC;}
+				inputSample += (aC[alpC]);
+				//allpass filter C
+				
+				dC[3] = dC[2];
+				dC[2] = dC[1];
+				dC[1] = inputSample;
+				inputSample = (dA[1] + dC[2] + dC[3])/3.0;
+				
+				allpasstemp = alpD - 1;
+				if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;}
+				inputSample -= aD[allpasstemp]*constallpass;
+				aD[alpD] = inputSample;
+				inputSample *= constallpass;
+				alpD--; if (alpD < 0 || alpD > delayD) {alpD = delayD;}
+				inputSample += (aD[alpD]);
+				//allpass filter D
+				
+				dD[3] = dD[2];
+				dD[2] = dD[1];
+				dD[1] = inputSample;
+				inputSample = (dD[1] + dD[2] + dD[3])/3.0;
+				
+				allpasstemp = alpE - 1;
+				if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;}
+				inputSample -= aE[allpasstemp]*constallpass;
+				aE[alpE] = inputSample;
+				inputSample *= constallpass;
+				alpE--; if (alpE < 0 || alpE > delayE) {alpE = delayE;}
+				inputSample += (aE[alpE]);
+				//allpass filter E
+				
+				dE[3] = dE[2];
+				dE[2] = dE[1];
+				dE[1] = inputSample;
+				inputSample = (dA[1] + dE[2] + dE[3])/3.0;
+				
+				allpasstemp = alpF - 1;
+				if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;}
+				inputSample -= aF[allpasstemp]*constallpass;
+				aF[alpF] = inputSample;
+				inputSample *= constallpass;
+				alpF--; if (alpF < 0 || alpF > delayF) {alpF = delayF;}
+				inputSample += (aF[alpF]);
+				//allpass filter F
+				
+				dF[3] = dF[2];
+				dF[2] = dF[1];
+				dF[1] = inputSample;
+				inputSample = (dF[1] + dF[2] + dF[3])/3.0;
+				
+				allpasstemp = alpG - 1;
+				if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;}
+				inputSample -= aG[allpasstemp]*constallpass;
+				aG[alpG] = inputSample;
+				inputSample *= constallpass;
+				alpG--; if (alpG < 0 || alpG > delayG) {alpG = delayG;}
+				inputSample += (aG[alpG]);
+				//allpass filter G
+				
+				dG[3] = dG[2];
+				dG[2] = dG[1];
+				dG[1] = inputSample;
+				inputSample = (dA[1] + dG[2] + dG[3])/3.0;
+				
+				allpasstemp = alpH - 1;
+				if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;}
+				inputSample -= aH[allpasstemp]*constallpass;
+				aH[alpH] = inputSample;
+				inputSample *= constallpass;
+				alpH--; if (alpH < 0 || alpH > delayH) {alpH = delayH;}
+				inputSample += (aH[alpH]);
+				//allpass filter H
+				
+				dH[3] = dH[2];
+				dH[2] = dH[1];
+				dH[1] = inputSample;
+				inputSample = (dH[1] + dH[2] + dH[3])/3.0;
+				
+				allpasstemp = alpI - 1;
+				if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;}
+				inputSample -= aI[allpasstemp]*constallpass;
+				aI[alpI] = inputSample;
+				inputSample *= constallpass;
+				alpI--; if (alpI < 0 || alpI > delayI) {alpI = delayI;}
+				inputSample += (aI[alpI]);
+				//allpass filter I
+				
+				dI[3] = dI[2];
+				dI[2] = dI[1];
+				dI[1] = inputSample;
+				inputSample = (dI[1] + dI[2] + dI[3])/3.0;
+				
+				allpasstemp = alpJ - 1;
+				if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;}
+				inputSample -= aJ[allpasstemp]*constallpass;
+				aJ[alpJ] = inputSample;
+				inputSample *= constallpass;
+				alpJ--; if (alpJ < 0 || alpJ > delayJ) {alpJ = delayJ;}
+				inputSample += (aJ[alpJ]);
+				//allpass filter J
+				
+				dJ[3] = dJ[2];
+				dJ[2] = dJ[1];
+				dJ[1] = inputSample;
+				inputSample = (dJ[1] + dJ[2] + dJ[3])/3.0;
+				
+				allpasstemp = alpK - 1;
+				if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;}
+				inputSample -= aK[allpasstemp]*constallpass;
+				aK[alpK] = inputSample;
+				inputSample *= constallpass;
+				alpK--; if (alpK < 0 || alpK > delayK) {alpK = delayK;}
+				inputSample += (aK[alpK]);
+				//allpass filter K
+				
+				dK[3] = dK[2];
+				dK[2] = dK[1];
+				dK[1] = inputSample;
+				inputSample = (dA[1] + dK[2] + dK[3])/3.0;
+				
+				allpasstemp = alpL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;}
+				inputSample -= aL[allpasstemp]*constallpass;
+				aL[alpL] = inputSample;
+				inputSample *= constallpass;
+				alpL--; if (alpL < 0 || alpL > delayL) {alpL = delayL;}
+				inputSample += (aL[alpL]);
+				//allpass filter L
+				
+				dL[3] = dL[2];
+				dL[2] = dL[1];
+				dL[1] = inputSample;
+				inputSample = (dL[1] + dL[2] + dL[3])/3.0;
+				
+				allpasstemp = alpM - 1;
+				if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;}
+				inputSample -= aM[allpasstemp]*constallpass;
+				aM[alpM] = inputSample;
+				inputSample *= constallpass;
+				alpM--; if (alpM < 0 || alpM > delayM) {alpM = delayM;}
+				inputSample += (aM[alpM]);
+				//allpass filter M
+				
+				dM[3] = dM[2];
+				dM[2] = dM[1];
+				dM[1] = inputSample;
+				inputSample = (dA[1] + dM[2] + dM[3])/3.0;
+				
+				allpasstemp = alpN - 1;
+				if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;}
+				inputSample -= aN[allpasstemp]*constallpass;
+				aN[alpN] = inputSample;
+				inputSample *= constallpass;
+				alpN--; if (alpN < 0 || alpN > delayN) {alpN = delayN;}
+				inputSample += (aN[alpN]);
+				//allpass filter N
+				
+				dN[3] = dN[2];
+				dN[2] = dN[1];
+				dN[1] = inputSample;
+				inputSample = (dN[1] + dN[2] + dN[3])/3.0;
+				
+				allpasstemp = alpO - 1;
+				if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;}
+				inputSample -= aO[allpasstemp]*constallpass;
+				aO[alpO] = inputSample;
+				inputSample *= constallpass;
+				alpO--; if (alpO < 0 || alpO > delayO) {alpO = delayO;}
+				inputSample += (aO[alpO]);
+				//allpass filter O
+				
+				dO[3] = dO[2];
+				dO[2] = dO[1];
+				dO[1] = inputSample;
+				inputSample = (dO[1] + dO[2] + dO[3])/3.0;
+				
+				allpasstemp = alpP - 1;
+				if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;}
+				inputSample -= aP[allpasstemp]*constallpass;
+				aP[alpP] = inputSample;
+				inputSample *= constallpass;
+				alpP--; if (alpP < 0 || alpP > delayP) {alpP = delayP;}
+				inputSample += (aP[alpP]);
+				//allpass filter P
+				
+				dP[3] = dP[2];
+				dP[2] = dP[1];
+				dP[1] = inputSample;
+				inputSample = (dP[1] + dP[2] + dP[3])/3.0;
+				
+				allpasstemp = alpQ - 1;
+				if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;}
+				inputSample -= aQ[allpasstemp]*constallpass;
+				aQ[alpQ] = inputSample;
+				inputSample *= constallpass;
+				alpQ--; if (alpQ < 0 || alpQ > delayQ) {alpQ = delayQ;}
+				inputSample += (aQ[alpQ]);
+				//allpass filter Q
+				
+				dQ[3] = dQ[2];
+				dQ[2] = dQ[1];
+				dQ[1] = inputSample;
+				inputSample = (dA[1] + dQ[2] + dQ[3])/3.0;
+				
+				allpasstemp = alpR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;}
+				inputSample -= aR[allpasstemp]*constallpass;
+				aR[alpR] = inputSample;
+				inputSample *= constallpass;
+				alpR--; if (alpR < 0 || alpR > delayR) {alpR = delayR;}
+				inputSample += (aR[alpR]);
+				//allpass filter R
+				
+				dR[3] = dR[2];
+				dR[2] = dR[1];
+				dR[1] = inputSample;
+				inputSample = (dR[1] + dR[2] + dR[3])/3.0;
+				
+				allpasstemp = alpS - 1;
+				if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;}
+				inputSample -= aS[allpasstemp]*constallpass;
+				aS[alpS] = inputSample;
+				inputSample *= constallpass;
+				alpS--; if (alpS < 0 || alpS > delayS) {alpS = delayS;}
+				inputSample += (aS[alpS]);
+				//allpass filter S
+				
+				dS[3] = dS[2];
+				dS[2] = dS[1];
+				dS[1] = inputSample;
+				inputSample = (dA[1] + dS[2] + dS[3])/3.0;
+				
+				allpasstemp = alpT - 1;
+				if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;}
+				inputSample -= aT[allpasstemp]*constallpass;
+				aT[alpT] = inputSample;
+				inputSample *= constallpass;
+				alpT--; if (alpT < 0 || alpT > delayT) {alpT = delayT;}
+				inputSample += (aT[alpT]);
+				//allpass filter T
+				
+				dT[3] = dT[2];
+				dT[2] = dT[1];
+				dT[1] = inputSample;
+				inputSample = (dT[1] + dT[2] + dT[3])/3.0;
+				
+				allpasstemp = alpU - 1;
+				if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;}
+				inputSample -= aU[allpasstemp]*constallpass;
+				aU[alpU] = inputSample;
+				inputSample *= constallpass;
+				alpU--; if (alpU < 0 || alpU > delayU) {alpU = delayU;}
+				inputSample += (aU[alpU]);
+				//allpass filter U
+				
+				dU[3] = dU[2];
+				dU[2] = dU[1];
+				dU[1] = inputSample;
+				inputSample = (dU[1] + dU[2] + dU[3])/3.0;
+				
+				allpasstemp = alpV - 1;
+				if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;}
+				inputSample -= aV[allpasstemp]*constallpass;
+				aV[alpV] = inputSample;
+				inputSample *= constallpass;
+				alpV--; if (alpV < 0 || alpV > delayV) {alpV = delayV;}
+				inputSample += (aV[alpV]);
+				//allpass filter V
+				
+				dV[3] = dV[2];
+				dV[2] = dV[1];
+				dV[1] = inputSample;
+				inputSample = (dV[1] + dV[2] + dV[3])/3.0;
+				
+				allpasstemp = alpW - 1;
+				if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;}
+				inputSample -= aW[allpasstemp]*constallpass;
+				aW[alpW] = inputSample;
+				inputSample *= constallpass;
+				alpW--; if (alpW < 0 || alpW > delayW) {alpW = delayW;}
+				inputSample += (aW[alpW]);
+				//allpass filter W
+				
+				dW[3] = dW[2];
+				dW[2] = dW[1];
+				dW[1] = inputSample;
+				inputSample = (dA[1] + dW[2] + dW[3])/3.0;
+				
+				allpasstemp = alpX - 1;
+				if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;}
+				inputSample -= aX[allpasstemp]*constallpass;
+				aX[alpX] = inputSample;
+				inputSample *= constallpass;
+				alpX--; if (alpX < 0 || alpX > delayX) {alpX = delayX;}
+				inputSample += (aX[alpX]);
+				//allpass filter X
+				
+				dX[3] = dX[2];
+				dX[2] = dX[1];
+				dX[1] = inputSample;
+				inputSample = (dX[1] + dX[2] + dX[3])/3.0;
+				
+				allpasstemp = alpY - 1;
+				if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;}
+				inputSample -= aY[allpasstemp]*constallpass;
+				aY[alpY] = inputSample;
+				inputSample *= constallpass;
+				alpY--; if (alpY < 0 || alpY > delayY) {alpY = delayY;}
+				inputSample += (aY[alpY]);
+				//allpass filter Y
+				
+				dY[3] = dY[2];
+				dY[2] = dY[1];
+				dY[1] = inputSample;
+				inputSample = (dY[1] + dY[2] + dY[3])/3.0;
+				
+				allpasstemp = alpZ - 1;
+				if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;}
+				inputSample -= aZ[allpasstemp]*constallpass;
+				aZ[alpZ] = inputSample;
+				inputSample *= constallpass;
+				alpZ--; if (alpZ < 0 || alpZ > delayZ) {alpZ = delayZ;}
+				inputSample += (aZ[alpZ]);
+				//allpass filter Z
+				
+				dZ[3] = dZ[2];
+				dZ[2] = dZ[1];
+				dZ[1] = inputSample;
+				inputSample = (dZ[1] + dZ[2] + dZ[3])/3.0;
+				
+				// now the second stage using the 'out' bank of allpasses		
+				
+				allpasstemp = outA - 1;
+				if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;}
+				inputSample -= oA[allpasstemp]*constallpass;
+				oA[outA] = inputSample;
+				inputSample *= constallpass;
+				outA--; if (outA < 0 || outA > delayA) {outA = delayA;}
+				inputSample += (oA[outA]);
+				//allpass filter A		
+				
+				dA[6] = dA[5];
+				dA[5] = dA[4];
+				dA[4] = inputSample;
+				inputSample = (dA[4] + dA[5] + dA[6])/3.0;
+				
+				allpasstemp = outB - 1;
+				if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;}
+				inputSample -= oB[allpasstemp]*constallpass;
+				oB[outB] = inputSample;
+				inputSample *= constallpass;
+				outB--; if (outB < 0 || outB > delayB) {outB = delayB;}
+				inputSample += (oB[outB]);
+				//allpass filter B
+				
+				dB[6] = dB[5];
+				dB[5] = dB[4];
+				dB[4] = inputSample;
+				inputSample = (dB[4] + dB[5] + dB[6])/3.0;
+				
+				allpasstemp = outC - 1;
+				if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;}
+				inputSample -= oC[allpasstemp]*constallpass;
+				oC[outC] = inputSample;
+				inputSample *= constallpass;
+				outC--; if (outC < 0 || outC > delayC) {outC = delayC;}
+				inputSample += (oC[outC]);
+				//allpass filter C
+				
+				dC[6] = dC[5];
+				dC[5] = dC[4];
+				dC[4] = inputSample;
+				inputSample = (dA[1] + dC[5] + dC[6])/3.0;
+				
+				allpasstemp = outD - 1;
+				if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;}
+				inputSample -= oD[allpasstemp]*constallpass;
+				oD[outD] = inputSample;
+				inputSample *= constallpass;
+				outD--; if (outD < 0 || outD > delayD) {outD = delayD;}
+				inputSample += (oD[outD]);
+				//allpass filter D
+				
+				dD[6] = dD[5];
+				dD[5] = dD[4];
+				dD[4] = inputSample;
+				inputSample = (dD[4] + dD[5] + dD[6])/3.0;
+				
+				allpasstemp = outE - 1;
+				if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;}
+				inputSample -= oE[allpasstemp]*constallpass;
+				oE[outE] = inputSample;
+				inputSample *= constallpass;
+				outE--; if (outE < 0 || outE > delayE) {outE = delayE;}
+				inputSample += (oE[outE]);
+				//allpass filter E
+				
+				dE[6] = dE[5];
+				dE[5] = dE[4];
+				dE[4] = inputSample;
+				inputSample = (dA[1] + dE[5] + dE[6])/3.0;
+				
+				allpasstemp = outF - 1;
+				if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;}
+				inputSample -= oF[allpasstemp]*constallpass;
+				oF[outF] = inputSample;
+				inputSample *= constallpass;
+				outF--; if (outF < 0 || outF > delayF) {outF = delayF;}
+				inputSample += (oF[outF]);
+				//allpass filter F
+				
+				dF[6] = dF[5];
+				dF[5] = dF[4];
+				dF[4] = inputSample;
+				inputSample = (dF[4] + dF[5] + dF[6])/3.0;
+				
+				allpasstemp = outG - 1;
+				if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;}
+				inputSample -= oG[allpasstemp]*constallpass;
+				oG[outG] = inputSample;
+				inputSample *= constallpass;
+				outG--; if (outG < 0 || outG > delayG) {outG = delayG;}
+				inputSample += (oG[outG]);
+				//allpass filter G
+				
+				dG[6] = dG[5];
+				dG[5] = dG[4];
+				dG[4] = inputSample;
+				inputSample = (dG[4] + dG[5] + dG[6])/3.0;
+				
+				allpasstemp = outH - 1;
+				if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;}
+				inputSample -= oH[allpasstemp]*constallpass;
+				oH[outH] = inputSample;
+				inputSample *= constallpass;
+				outH--; if (outH < 0 || outH > delayH) {outH = delayH;}
+				inputSample += (oH[outH]);
+				//allpass filter H
+				
+				dH[6] = dH[5];
+				dH[5] = dH[4];
+				dH[4] = inputSample;
+				inputSample = (dH[4] + dH[5] + dH[6])/3.0;
+				
+				allpasstemp = outI - 1;
+				if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;}
+				inputSample -= oI[allpasstemp]*constallpass;
+				oI[outI] = inputSample;
+				inputSample *= constallpass;
+				outI--; if (outI < 0 || outI > delayI) {outI = delayI;}
+				inputSample += (oI[outI]);
+				//allpass filter I
+				
+				dI[6] = dI[5];
+				dI[5] = dI[4];
+				dI[4] = inputSample;
+				inputSample = (dI[4] + dI[5] + dI[6])/3.0;
+				
+				allpasstemp = outJ - 1;
+				if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;}
+				inputSample -= oJ[allpasstemp]*constallpass;
+				oJ[outJ] = inputSample;
+				inputSample *= constallpass;
+				outJ--; if (outJ < 0 || outJ > delayJ) {outJ = delayJ;}
+				inputSample += (oJ[outJ]);
+				//allpass filter J
+				
+				dJ[6] = dJ[5];
+				dJ[5] = dJ[4];
+				dJ[4] = inputSample;
+				inputSample = (dJ[4] + dJ[5] + dJ[6])/3.0;
+				
+				allpasstemp = outK - 1;
+				if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;}
+				inputSample -= oK[allpasstemp]*constallpass;
+				oK[outK] = inputSample;
+				inputSample *= constallpass;
+				outK--; if (outK < 0 || outK > delayK) {outK = delayK;}
+				inputSample += (oK[outK]);
+				//allpass filter K
+				
+				dK[6] = dK[5];
+				dK[5] = dK[4];
+				dK[4] = inputSample;
+				inputSample = (dA[1] + dK[5] + dK[6])/3.0;
+				
+				allpasstemp = outL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;}
+				inputSample -= oL[allpasstemp]*constallpass;
+				oL[outL] = inputSample;
+				inputSample *= constallpass;
+				outL--; if (outL < 0 || outL > delayL) {outL = delayL;}
+				inputSample += (oL[outL]);
+				//allpass filter L
+				
+				dL[6] = dL[5];
+				dL[5] = dL[4];
+				dL[4] = inputSample;
+				inputSample = (dL[4] + dL[5] + dL[6])/3.0;
+				
+				allpasstemp = outM - 1;
+				if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;}
+				inputSample -= oM[allpasstemp]*constallpass;
+				oM[outM] = inputSample;
+				inputSample *= constallpass;
+				outM--; if (outM < 0 || outM > delayM) {outM = delayM;}
+				inputSample += (oM[outM]);
+				//allpass filter M
+				
+				dM[6] = dM[5];
+				dM[5] = dM[4];
+				dM[4] = inputSample;
+				inputSample = (dM[4] + dM[5] + dM[6])/3.0;
+				
+				allpasstemp = outN - 1;
+				if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;}
+				inputSample -= oN[allpasstemp]*constallpass;
+				oN[outN] = inputSample;
+				inputSample *= constallpass;
+				outN--; if (outN < 0 || outN > delayN) {outN = delayN;}
+				inputSample += (oN[outN]);
+				//allpass filter N
+				
+				dN[6] = dN[5];
+				dN[5] = dN[4];
+				dN[4] = inputSample;
+				inputSample = (dN[4] + dN[5] + dN[6])/3.0;
+				
+				allpasstemp = outO - 1;
+				if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;}
+				inputSample -= oO[allpasstemp]*constallpass;
+				oO[outO] = inputSample;
+				inputSample *= constallpass;
+				outO--; if (outO < 0 || outO > delayO) {outO = delayO;}
+				inputSample += (oO[outO]);
+				//allpass filter O
+				
+				dO[6] = dO[5];
+				dO[5] = dO[4];
+				dO[4] = inputSample;
+				inputSample = (dA[1] + dO[5] + dO[6])/3.0;
+				
+				allpasstemp = outP - 1;
+				if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;}
+				inputSample -= oP[allpasstemp]*constallpass;
+				oP[outP] = inputSample;
+				inputSample *= constallpass;
+				outP--; if (outP < 0 || outP > delayP) {outP = delayP;}
+				inputSample += (oP[outP]);
+				//allpass filter P
+				
+				dP[6] = dP[5];
+				dP[5] = dP[4];
+				dP[4] = inputSample;
+				inputSample = (dP[4] + dP[5] + dP[6])/3.0;
+				
+				allpasstemp = outQ - 1;
+				if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;}
+				inputSample -= oQ[allpasstemp]*constallpass;
+				oQ[outQ] = inputSample;
+				inputSample *= constallpass;
+				outQ--; if (outQ < 0 || outQ > delayQ) {outQ = delayQ;}
+				inputSample += (oQ[outQ]);
+				//allpass filter Q
+				
+				dQ[6] = dQ[5];
+				dQ[5] = dQ[4];
+				dQ[4] = inputSample;
+				inputSample = (dA[1] + dQ[5] + dQ[6])/3.0;
+				
+				allpasstemp = outR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;}
+				inputSample -= oR[allpasstemp]*constallpass;
+				oR[outR] = inputSample;
+				inputSample *= constallpass;
+				outR--; if (outR < 0 || outR > delayR) {outR = delayR;}
+				inputSample += (oR[outR]);
+				//allpass filter R
+				
+				dR[6] = dR[5];
+				dR[5] = dR[4];
+				dR[4] = inputSample;
+				inputSample = (dR[4] + dR[5] + dR[6])/3.0;
+				
+				allpasstemp = outS - 1;
+				if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;}
+				inputSample -= oS[allpasstemp]*constallpass;
+				oS[outS] = inputSample;
+				inputSample *= constallpass;
+				outS--; if (outS < 0 || outS > delayS) {outS = delayS;}
+				inputSample += (oS[outS]);
+				//allpass filter S
+				
+				dS[6] = dS[5];
+				dS[5] = dS[4];
+				dS[4] = inputSample;
+				inputSample = (dS[4] + dS[5] + dS[6])/3.0;
+				
+				allpasstemp = outT - 1;
+				if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;}
+				inputSample -= oT[allpasstemp]*constallpass;
+				oT[outT] = inputSample;
+				inputSample *= constallpass;
+				outT--; if (outT < 0 || outT > delayT) {outT = delayT;}
+				inputSample += (oT[outT]);
+				//allpass filter T
+				
+				dT[6] = dT[5];
+				dT[5] = dT[4];
+				dT[4] = inputSample;
+				inputSample = (dT[4] + dT[5] + dT[6])/3.0;
+				
+				allpasstemp = outU - 1;
+				if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;}
+				inputSample -= oU[allpasstemp]*constallpass;
+				oU[outU] = inputSample;
+				inputSample *= constallpass;
+				outU--; if (outU < 0 || outU > delayU) {outU = delayU;}
+				inputSample += (oU[outU]);
+				//allpass filter U
+				
+				dU[6] = dU[5];
+				dU[5] = dU[4];
+				dU[4] = inputSample;
+				inputSample = (dA[1] + dU[5] + dU[6])/3.0;
+				
+				allpasstemp = outV - 1;
+				if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;}
+				inputSample -= oV[allpasstemp]*constallpass;
+				oV[outV] = inputSample;
+				inputSample *= constallpass;
+				outV--; if (outV < 0 || outV > delayV) {outV = delayV;}
+				inputSample += (oV[outV]);
+				//allpass filter V
+				
+				dV[6] = dV[5];
+				dV[5] = dV[4];
+				dV[4] = inputSample;
+				inputSample = (dV[4] + dV[5] + dV[6])/3.0;
+				
+				allpasstemp = outW - 1;
+				if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;}
+				inputSample -= oW[allpasstemp]*constallpass;
+				oW[outW] = inputSample;
+				inputSample *= constallpass;
+				outW--; if (outW < 0 || outW > delayW) {outW = delayW;}
+				inputSample += (oW[outW]);
+				//allpass filter W
+				
+				dW[6] = dW[5];
+				dW[5] = dW[4];
+				dW[4] = inputSample;
+				inputSample = (dW[4] + dW[5] + dW[6])/3.0;
+				
+				allpasstemp = outX - 1;
+				if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;}
+				inputSample -= oX[allpasstemp]*constallpass;
+				oX[outX] = inputSample;
+				inputSample *= constallpass;
+				outX--; if (outX < 0 || outX > delayX) {outX = delayX;}
+				inputSample += (oX[outX]);
+				//allpass filter X
+				
+				dX[6] = dX[5];
+				dX[5] = dX[4];
+				dX[4] = inputSample;
+				inputSample = (dX[4] + dX[5] + dX[6])/3.0;
+				
+				allpasstemp = outY - 1;
+				if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;}
+				inputSample -= oY[allpasstemp]*constallpass;
+				oY[outY] = inputSample;
+				inputSample *= constallpass;
+				outY--; if (outY < 0 || outY > delayY) {outY = delayY;}
+				inputSample += (oY[outY]);
+				//allpass filter Y
+				
+				dY[6] = dY[5];
+				dY[5] = dY[4];
+				dY[4] = inputSample;
+				inputSample = (dY[4] + dY[5] + dY[6])/3.0;
+				
+				allpasstemp = outZ - 1;
+				if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;}
+				inputSample -= oZ[allpasstemp]*constallpass;
+				oZ[outZ] = inputSample;
+				inputSample *= constallpass;
+				outZ--; if (outZ < 0 || outZ > delayZ) {outZ = delayZ;}
+				inputSample += (oZ[outZ]);
+				//allpass filter Z
+				
+				dZ[6] = dZ[5];
+				dZ[5] = dZ[4];
+				dZ[4] = inputSample;
+				inputSample = (dZ[4] + dZ[5] + dZ[6]);		
+				//output Chamber
+				break;
+
+				
+				
+				
+				
+			case 2:	//Spring
+				
+				allpasstemp = alpA - 1;
+				if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;}
+				inputSample -= aA[allpasstemp]*constallpass;
+				aA[alpA] = inputSample;
+				inputSample *= constallpass;
+				alpA--; if (alpA < 0 || alpA > delayA) {alpA = delayA;}
+				inputSample += (aA[alpA]);
+				//allpass filter A		
+				
+				dA[3] = dA[2];
+				dA[2] = dA[1];
+				dA[1] = inputSample;
+				inputSample = (dA[1] + dA[2] + dA[3])/3.0;
+				
+				allpasstemp = alpB - 1;
+				if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;}
+				inputSample -= aB[allpasstemp]*constallpass;
+				aB[alpB] = inputSample;
+				inputSample *= constallpass;
+				alpB--; if (alpB < 0 || alpB > delayB) {alpB = delayB;}
+				inputSample += (aB[alpB]);
+				//allpass filter B
+				
+				dB[3] = dB[2];
+				dB[2] = dB[1];
+				dB[1] = inputSample;
+				inputSample = (dB[1] + dB[2] + dB[3])/3.0;
+				
+				allpasstemp = alpC - 1;
+				if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;}
+				inputSample -= aC[allpasstemp]*constallpass;
+				aC[alpC] = inputSample;
+				inputSample *= constallpass;
+				alpC--; if (alpC < 0 || alpC > delayC) {alpC = delayC;}
+				inputSample += (aC[alpC]);
+				//allpass filter C
+				
+				dC[3] = dC[2];
+				dC[2] = dC[1];
+				dC[1] = inputSample;
+				inputSample = (dC[1] + dC[2] + dC[3])/3.0;
+				
+				allpasstemp = alpD - 1;
+				if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;}
+				inputSample -= aD[allpasstemp]*constallpass;
+				aD[alpD] = inputSample;
+				inputSample *= constallpass;
+				alpD--; if (alpD < 0 || alpD > delayD) {alpD = delayD;}
+				inputSample += (aD[alpD]);
+				//allpass filter D
+				
+				dD[3] = dD[2];
+				dD[2] = dD[1];
+				dD[1] = inputSample;
+				inputSample = (dD[1] + dD[2] + dD[3])/3.0;
+				
+				allpasstemp = alpE - 1;
+				if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;}
+				inputSample -= aE[allpasstemp]*constallpass;
+				aE[alpE] = inputSample;
+				inputSample *= constallpass;
+				alpE--; if (alpE < 0 || alpE > delayE) {alpE = delayE;}
+				inputSample += (aE[alpE]);
+				//allpass filter E
+				
+				dE[3] = dE[2];
+				dE[2] = dE[1];
+				dE[1] = inputSample;
+				inputSample = (dE[1] + dE[2] + dE[3])/3.0;
+				
+				allpasstemp = alpF - 1;
+				if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;}
+				inputSample -= aF[allpasstemp]*constallpass;
+				aF[alpF] = inputSample;
+				inputSample *= constallpass;
+				alpF--; if (alpF < 0 || alpF > delayF) {alpF = delayF;}
+				inputSample += (aF[alpF]);
+				//allpass filter F
+				
+				dF[3] = dF[2];
+				dF[2] = dF[1];
+				dF[1] = inputSample;
+				inputSample = (dF[1] + dF[2] + dF[3])/3.0;
+				
+				allpasstemp = alpG - 1;
+				if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;}
+				inputSample -= aG[allpasstemp]*constallpass;
+				aG[alpG] = inputSample;
+				inputSample *= constallpass;
+				alpG--; if (alpG < 0 || alpG > delayG) {alpG = delayG;}
+				inputSample += (aG[alpG]);
+				//allpass filter G
+				
+				dG[3] = dG[2];
+				dG[2] = dG[1];
+				dG[1] = inputSample;
+				inputSample = (dG[1] + dG[2] + dG[3])/3.0;
+				
+				allpasstemp = alpH - 1;
+				if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;}
+				inputSample -= aH[allpasstemp]*constallpass;
+				aH[alpH] = inputSample;
+				inputSample *= constallpass;
+				alpH--; if (alpH < 0 || alpH > delayH) {alpH = delayH;}
+				inputSample += (aH[alpH]);
+				//allpass filter H
+				
+				dH[3] = dH[2];
+				dH[2] = dH[1];
+				dH[1] = inputSample;
+				inputSample = (dH[1] + dH[2] + dH[3])/3.0;
+				
+				allpasstemp = alpI - 1;
+				if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;}
+				inputSample -= aI[allpasstemp]*constallpass;
+				aI[alpI] = inputSample;
+				inputSample *= constallpass;
+				alpI--; if (alpI < 0 || alpI > delayI) {alpI = delayI;}
+				inputSample += (aI[alpI]);
+				//allpass filter I
+				
+				dI[3] = dI[2];
+				dI[2] = dI[1];
+				dI[1] = inputSample;
+				inputSample = (dI[1] + dI[2] + dI[3])/3.0;
+				
+				allpasstemp = alpJ - 1;
+				if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;}
+				inputSample -= aJ[allpasstemp]*constallpass;
+				aJ[alpJ] = inputSample;
+				inputSample *= constallpass;
+				alpJ--; if (alpJ < 0 || alpJ > delayJ) {alpJ = delayJ;}
+				inputSample += (aJ[alpJ]);
+				//allpass filter J
+				
+				dJ[3] = dJ[2];
+				dJ[2] = dJ[1];
+				dJ[1] = inputSample;
+				inputSample = (dJ[1] + dJ[2] + dJ[3])/3.0;
+				
+				allpasstemp = alpK - 1;
+				if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;}
+				inputSample -= aK[allpasstemp]*constallpass;
+				aK[alpK] = inputSample;
+				inputSample *= constallpass;
+				alpK--; if (alpK < 0 || alpK > delayK) {alpK = delayK;}
+				inputSample += (aK[alpK]);
+				//allpass filter K
+				
+				dK[3] = dK[2];
+				dK[2] = dK[1];
+				dK[1] = inputSample;
+				inputSample = (dK[1] + dK[2] + dK[3])/3.0;
+				
+				allpasstemp = alpL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;}
+				inputSample -= aL[allpasstemp]*constallpass;
+				aL[alpL] = inputSample;
+				inputSample *= constallpass;
+				alpL--; if (alpL < 0 || alpL > delayL) {alpL = delayL;}
+				inputSample += (aL[alpL]);
+				//allpass filter L
+				
+				dL[3] = dL[2];
+				dL[2] = dL[1];
+				dL[1] = inputSample;
+				inputSample = (dL[1] + dL[2] + dL[3])/3.0;
+				
+				allpasstemp = alpM - 1;
+				if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;}
+				inputSample -= aM[allpasstemp]*constallpass;
+				aM[alpM] = inputSample;
+				inputSample *= constallpass;
+				alpM--; if (alpM < 0 || alpM > delayM) {alpM = delayM;}
+				inputSample += (aM[alpM]);
+				//allpass filter M
+				
+				dM[3] = dM[2];
+				dM[2] = dM[1];
+				dM[1] = inputSample;
+				inputSample = (dM[1] + dM[2] + dM[3])/3.0;
+				
+				allpasstemp = alpN - 1;
+				if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;}
+				inputSample -= aN[allpasstemp]*constallpass;
+				aN[alpN] = inputSample;
+				inputSample *= constallpass;
+				alpN--; if (alpN < 0 || alpN > delayN) {alpN = delayN;}
+				inputSample += (aN[alpN]);
+				//allpass filter N
+				
+				dN[3] = dN[2];
+				dN[2] = dN[1];
+				dN[1] = inputSample;
+				inputSample = (dN[1] + dN[2] + dN[3])/3.0;
+				
+				allpasstemp = alpO - 1;
+				if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;}
+				inputSample -= aO[allpasstemp]*constallpass;
+				aO[alpO] = inputSample;
+				inputSample *= constallpass;
+				alpO--; if (alpO < 0 || alpO > delayO) {alpO = delayO;}
+				inputSample += (aO[alpO]);
+				//allpass filter O
+				
+				dO[3] = dO[2];
+				dO[2] = dO[1];
+				dO[1] = inputSample;
+				inputSample = (dO[1] + dO[2] + dO[3])/3.0;
+				
+				allpasstemp = alpP - 1;
+				if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;}
+				inputSample -= aP[allpasstemp]*constallpass;
+				aP[alpP] = inputSample;
+				inputSample *= constallpass;
+				alpP--; if (alpP < 0 || alpP > delayP) {alpP = delayP;}
+				inputSample += (aP[alpP]);
+				//allpass filter P
+				
+				dP[3] = dP[2];
+				dP[2] = dP[1];
+				dP[1] = inputSample;
+				inputSample = (dP[1] + dP[2] + dP[3])/3.0;
+				
+				allpasstemp = alpQ - 1;
+				if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;}
+				inputSample -= aQ[allpasstemp]*constallpass;
+				aQ[alpQ] = inputSample;
+				inputSample *= constallpass;
+				alpQ--; if (alpQ < 0 || alpQ > delayQ) {alpQ = delayQ;}
+				inputSample += (aQ[alpQ]);
+				//allpass filter Q
+				
+				dQ[3] = dQ[2];
+				dQ[2] = dQ[1];
+				dQ[1] = inputSample;
+				inputSample = (dQ[1] + dQ[2] + dQ[3])/3.0;
+				
+				allpasstemp = alpR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;}
+				inputSample -= aR[allpasstemp]*constallpass;
+				aR[alpR] = inputSample;
+				inputSample *= constallpass;
+				alpR--; if (alpR < 0 || alpR > delayR) {alpR = delayR;}
+				inputSample += (aR[alpR]);
+				//allpass filter R
+				
+				dR[3] = dR[2];
+				dR[2] = dR[1];
+				dR[1] = inputSample;
+				inputSample = (dR[1] + dR[2] + dR[3])/3.0;
+				
+				allpasstemp = alpS - 1;
+				if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;}
+				inputSample -= aS[allpasstemp]*constallpass;
+				aS[alpS] = inputSample;
+				inputSample *= constallpass;
+				alpS--; if (alpS < 0 || alpS > delayS) {alpS = delayS;}
+				inputSample += (aS[alpS]);
+				//allpass filter S
+				
+				dS[3] = dS[2];
+				dS[2] = dS[1];
+				dS[1] = inputSample;
+				inputSample = (dS[1] + dS[2] + dS[3])/3.0;
+				
+				allpasstemp = alpT - 1;
+				if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;}
+				inputSample -= aT[allpasstemp]*constallpass;
+				aT[alpT] = inputSample;
+				inputSample *= constallpass;
+				alpT--; if (alpT < 0 || alpT > delayT) {alpT = delayT;}
+				inputSample += (aT[alpT]);
+				//allpass filter T
+				
+				dT[3] = dT[2];
+				dT[2] = dT[1];
+				dT[1] = inputSample;
+				inputSample = (dT[1] + dT[2] + dT[3])/3.0;
+				
+				allpasstemp = alpU - 1;
+				if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;}
+				inputSample -= aU[allpasstemp]*constallpass;
+				aU[alpU] = inputSample;
+				inputSample *= constallpass;
+				alpU--; if (alpU < 0 || alpU > delayU) {alpU = delayU;}
+				inputSample += (aU[alpU]);
+				//allpass filter U
+				
+				dU[3] = dU[2];
+				dU[2] = dU[1];
+				dU[1] = inputSample;
+				inputSample = (dU[1] + dU[2] + dU[3])/3.0;
+				
+				allpasstemp = alpV - 1;
+				if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;}
+				inputSample -= aV[allpasstemp]*constallpass;
+				aV[alpV] = inputSample;
+				inputSample *= constallpass;
+				alpV--; if (alpV < 0 || alpV > delayV) {alpV = delayV;}
+				inputSample += (aV[alpV]);
+				//allpass filter V
+				
+				dV[3] = dV[2];
+				dV[2] = dV[1];
+				dV[1] = inputSample;
+				inputSample = (dV[1] + dV[2] + dV[3])/3.0;
+				
+				allpasstemp = alpW - 1;
+				if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;}
+				inputSample -= aW[allpasstemp]*constallpass;
+				aW[alpW] = inputSample;
+				inputSample *= constallpass;
+				alpW--; if (alpW < 0 || alpW > delayW) {alpW = delayW;}
+				inputSample += (aW[alpW]);
+				//allpass filter W
+				
+				dW[3] = dW[2];
+				dW[2] = dW[1];
+				dW[1] = inputSample;
+				inputSample = (dW[1] + dW[2] + dW[3])/3.0;
+				
+				allpasstemp = alpX - 1;
+				if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;}
+				inputSample -= aX[allpasstemp]*constallpass;
+				aX[alpX] = inputSample;
+				inputSample *= constallpass;
+				alpX--; if (alpX < 0 || alpX > delayX) {alpX = delayX;}
+				inputSample += (aX[alpX]);
+				//allpass filter X
+				
+				dX[3] = dX[2];
+				dX[2] = dX[1];
+				dX[1] = inputSample;
+				inputSample = (dX[1] + dX[2] + dX[3])/3.0;
+				
+				allpasstemp = alpY - 1;
+				if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;}
+				inputSample -= aY[allpasstemp]*constallpass;
+				aY[alpY] = inputSample;
+				inputSample *= constallpass;
+				alpY--; if (alpY < 0 || alpY > delayY) {alpY = delayY;}
+				inputSample += (aY[alpY]);
+				//allpass filter Y
+				
+				dY[3] = dY[2];
+				dY[2] = dY[1];
+				dY[1] = inputSample;
+				inputSample = (dY[1] + dY[2] + dY[3])/3.0;
+				
+				allpasstemp = alpZ - 1;
+				if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;}
+				inputSample -= aZ[allpasstemp]*constallpass;
+				aZ[alpZ] = inputSample;
+				inputSample *= constallpass;
+				alpZ--; if (alpZ < 0 || alpZ > delayZ) {alpZ = delayZ;}
+				inputSample += (aZ[alpZ]);
+				//allpass filter Z
+				
+				dZ[3] = dZ[2];
+				dZ[2] = dZ[1];
+				dZ[1] = inputSample;
+				inputSample = (dZ[1] + dZ[2] + dZ[3])/3.0;
+				
+				// now the second stage using the 'out' bank of allpasses		
+				
+				allpasstemp = outA - 1;
+				if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;}
+				inputSample -= oA[allpasstemp]*constallpass;
+				oA[outA] = inputSample;
+				inputSample *= constallpass;
+				outA--; if (outA < 0 || outA > delayA) {outA = delayA;}
+				inputSample += (oA[outA]);
+				//allpass filter A		
+				
+				dA[6] = dA[5];
+				dA[5] = dA[4];
+				dA[4] = inputSample;
+				inputSample = (dY[1] + dA[5] + dA[6])/3.0;
+				
+				allpasstemp = outB - 1;
+				if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;}
+				inputSample -= oB[allpasstemp]*constallpass;
+				oB[outB] = inputSample;
+				inputSample *= constallpass;
+				outB--; if (outB < 0 || outB > delayB) {outB = delayB;}
+				inputSample += (oB[outB]);
+				//allpass filter B
+				
+				dB[6] = dB[5];
+				dB[5] = dB[4];
+				dB[4] = inputSample;
+				inputSample = (dX[1] + dB[5] + dB[6])/3.0;
+				
+				allpasstemp = outC - 1;
+				if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;}
+				inputSample -= oC[allpasstemp]*constallpass;
+				oC[outC] = inputSample;
+				inputSample *= constallpass;
+				outC--; if (outC < 0 || outC > delayC) {outC = delayC;}
+				inputSample += (oC[outC]);
+				//allpass filter C
+				
+				dC[6] = dC[5];
+				dC[5] = dC[4];
+				dC[4] = inputSample;
+				inputSample = (dW[1] + dC[5] + dC[6])/3.0;
+				
+				allpasstemp = outD - 1;
+				if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;}
+				inputSample -= oD[allpasstemp]*constallpass;
+				oD[outD] = inputSample;
+				inputSample *= constallpass;
+				outD--; if (outD < 0 || outD > delayD) {outD = delayD;}
+				inputSample += (oD[outD]);
+				//allpass filter D
+				
+				dD[6] = dD[5];
+				dD[5] = dD[4];
+				dD[4] = inputSample;
+				inputSample = (dV[1] + dD[5] + dD[6])/3.0;
+				
+				allpasstemp = outE - 1;
+				if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;}
+				inputSample -= oE[allpasstemp]*constallpass;
+				oE[outE] = inputSample;
+				inputSample *= constallpass;
+				outE--; if (outE < 0 || outE > delayE) {outE = delayE;}
+				inputSample += (oE[outE]);
+				//allpass filter E
+				
+				dE[6] = dE[5];
+				dE[5] = dE[4];
+				dE[4] = inputSample;
+				inputSample = (dU[1] + dE[5] + dE[6])/3.0;
+				
+				allpasstemp = outF - 1;
+				if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;}
+				inputSample -= oF[allpasstemp]*constallpass;
+				oF[outF] = inputSample;
+				inputSample *= constallpass;
+				outF--; if (outF < 0 || outF > delayF) {outF = delayF;}
+				inputSample += (oF[outF]);
+				//allpass filter F
+				
+				dF[6] = dF[5];
+				dF[5] = dF[4];
+				dF[4] = inputSample;
+				inputSample = (dT[1] + dF[5] + dF[6])/3.0;
+				
+				allpasstemp = outG - 1;
+				if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;}
+				inputSample -= oG[allpasstemp]*constallpass;
+				oG[outG] = inputSample;
+				inputSample *= constallpass;
+				outG--; if (outG < 0 || outG > delayG) {outG = delayG;}
+				inputSample += (oG[outG]);
+				//allpass filter G
+				
+				dG[6] = dG[5];
+				dG[5] = dG[4];
+				dG[4] = inputSample;
+				inputSample = (dS[1] + dG[5] + dG[6])/3.0;
+				
+				allpasstemp = outH - 1;
+				if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;}
+				inputSample -= oH[allpasstemp]*constallpass;
+				oH[outH] = inputSample;
+				inputSample *= constallpass;
+				outH--; if (outH < 0 || outH > delayH) {outH = delayH;}
+				inputSample += (oH[outH]);
+				//allpass filter H
+				
+				dH[6] = dH[5];
+				dH[5] = dH[4];
+				dH[4] = inputSample;
+				inputSample = (dR[1] + dH[5] + dH[6])/3.0;
+				
+				allpasstemp = outI - 1;
+				if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;}
+				inputSample -= oI[allpasstemp]*constallpass;
+				oI[outI] = inputSample;
+				inputSample *= constallpass;
+				outI--; if (outI < 0 || outI > delayI) {outI = delayI;}
+				inputSample += (oI[outI]);
+				//allpass filter I
+				
+				dI[6] = dI[5];
+				dI[5] = dI[4];
+				dI[4] = inputSample;
+				inputSample = (dQ[1] + dI[5] + dI[6])/3.0;
+				
+				allpasstemp = outJ - 1;
+				if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;}
+				inputSample -= oJ[allpasstemp]*constallpass;
+				oJ[outJ] = inputSample;
+				inputSample *= constallpass;
+				outJ--; if (outJ < 0 || outJ > delayJ) {outJ = delayJ;}
+				inputSample += (oJ[outJ]);
+				//allpass filter J
+				
+				dJ[6] = dJ[5];
+				dJ[5] = dJ[4];
+				dJ[4] = inputSample;
+				inputSample = (dP[1] + dJ[5] + dJ[6])/3.0;
+				
+				allpasstemp = outK - 1;
+				if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;}
+				inputSample -= oK[allpasstemp]*constallpass;
+				oK[outK] = inputSample;
+				inputSample *= constallpass;
+				outK--; if (outK < 0 || outK > delayK) {outK = delayK;}
+				inputSample += (oK[outK]);
+				//allpass filter K
+				
+				dK[6] = dK[5];
+				dK[5] = dK[4];
+				dK[4] = inputSample;
+				inputSample = (dO[1] + dK[5] + dK[6])/3.0;
+				
+				allpasstemp = outL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;}
+				inputSample -= oL[allpasstemp]*constallpass;
+				oL[outL] = inputSample;
+				inputSample *= constallpass;
+				outL--; if (outL < 0 || outL > delayL) {outL = delayL;}
+				inputSample += (oL[outL]);
+				//allpass filter L
+				
+				dL[6] = dL[5];
+				dL[5] = dL[4];
+				dL[4] = inputSample;
+				inputSample = (dN[1] + dL[5] + dL[6])/3.0;
+				
+				allpasstemp = outM - 1;
+				if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;}
+				inputSample -= oM[allpasstemp]*constallpass;
+				oM[outM] = inputSample;
+				inputSample *= constallpass;
+				outM--; if (outM < 0 || outM > delayM) {outM = delayM;}
+				inputSample += (oM[outM]);
+				//allpass filter M
+				
+				dM[6] = dM[5];
+				dM[5] = dM[4];
+				dM[4] = inputSample;
+				inputSample = (dM[1] + dM[5] + dM[6])/3.0;
+				
+				allpasstemp = outN - 1;
+				if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;}
+				inputSample -= oN[allpasstemp]*constallpass;
+				oN[outN] = inputSample;
+				inputSample *= constallpass;
+				outN--; if (outN < 0 || outN > delayN) {outN = delayN;}
+				inputSample += (oN[outN]);
+				//allpass filter N
+				
+				dN[6] = dN[5];
+				dN[5] = dN[4];
+				dN[4] = inputSample;
+				inputSample = (dL[1] + dN[5] + dN[6])/3.0;
+				
+				allpasstemp = outO - 1;
+				if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;}
+				inputSample -= oO[allpasstemp]*constallpass;
+				oO[outO] = inputSample;
+				inputSample *= constallpass;
+				outO--; if (outO < 0 || outO > delayO) {outO = delayO;}
+				inputSample += (oO[outO]);
+				//allpass filter O
+				
+				dO[6] = dO[5];
+				dO[5] = dO[4];
+				dO[4] = inputSample;
+				inputSample = (dK[1] + dO[5] + dO[6])/3.0;
+				
+				allpasstemp = outP - 1;
+				if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;}
+				inputSample -= oP[allpasstemp]*constallpass;
+				oP[outP] = inputSample;
+				inputSample *= constallpass;
+				outP--; if (outP < 0 || outP > delayP) {outP = delayP;}
+				inputSample += (oP[outP]);
+				//allpass filter P
+				
+				dP[6] = dP[5];
+				dP[5] = dP[4];
+				dP[4] = inputSample;
+				inputSample = (dJ[1] + dP[5] + dP[6])/3.0;
+				
+				allpasstemp = outQ - 1;
+				if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;}
+				inputSample -= oQ[allpasstemp]*constallpass;
+				oQ[outQ] = inputSample;
+				inputSample *= constallpass;
+				outQ--; if (outQ < 0 || outQ > delayQ) {outQ = delayQ;}
+				inputSample += (oQ[outQ]);
+				//allpass filter Q
+				
+				dQ[6] = dQ[5];
+				dQ[5] = dQ[4];
+				dQ[4] = inputSample;
+				inputSample = (dI[1] + dQ[5] + dQ[6])/3.0;
+				
+				allpasstemp = outR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;}
+				inputSample -= oR[allpasstemp]*constallpass;
+				oR[outR] = inputSample;
+				inputSample *= constallpass;
+				outR--; if (outR < 0 || outR > delayR) {outR = delayR;}
+				inputSample += (oR[outR]);
+				//allpass filter R
+				
+				dR[6] = dR[5];
+				dR[5] = dR[4];
+				dR[4] = inputSample;
+				inputSample = (dH[1] + dR[5] + dR[6])/3.0;
+				
+				allpasstemp = outS - 1;
+				if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;}
+				inputSample -= oS[allpasstemp]*constallpass;
+				oS[outS] = inputSample;
+				inputSample *= constallpass;
+				outS--; if (outS < 0 || outS > delayS) {outS = delayS;}
+				inputSample += (oS[outS]);
+				//allpass filter S
+				
+				dS[6] = dS[5];
+				dS[5] = dS[4];
+				dS[4] = inputSample;
+				inputSample = (dG[1] + dS[5] + dS[6])/3.0;
+				
+				allpasstemp = outT - 1;
+				if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;}
+				inputSample -= oT[allpasstemp]*constallpass;
+				oT[outT] = inputSample;
+				inputSample *= constallpass;
+				outT--; if (outT < 0 || outT > delayT) {outT = delayT;}
+				inputSample += (oT[outT]);
+				//allpass filter T
+				
+				dT[6] = dT[5];
+				dT[5] = dT[4];
+				dT[4] = inputSample;
+				inputSample = (dF[1] + dT[5] + dT[6])/3.0;
+				
+				allpasstemp = outU - 1;
+				if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;}
+				inputSample -= oU[allpasstemp]*constallpass;
+				oU[outU] = inputSample;
+				inputSample *= constallpass;
+				outU--; if (outU < 0 || outU > delayU) {outU = delayU;}
+				inputSample += (oU[outU]);
+				//allpass filter U
+				
+				dU[6] = dU[5];
+				dU[5] = dU[4];
+				dU[4] = inputSample;
+				inputSample = (dE[1] + dU[5] + dU[6])/3.0;
+				
+				allpasstemp = outV - 1;
+				if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;}
+				inputSample -= oV[allpasstemp]*constallpass;
+				oV[outV] = inputSample;
+				inputSample *= constallpass;
+				outV--; if (outV < 0 || outV > delayV) {outV = delayV;}
+				inputSample += (oV[outV]);
+				//allpass filter V
+				
+				dV[6] = dV[5];
+				dV[5] = dV[4];
+				dV[4] = inputSample;
+				inputSample = (dD[1] + dV[5] + dV[6])/3.0;
+				
+				allpasstemp = outW - 1;
+				if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;}
+				inputSample -= oW[allpasstemp]*constallpass;
+				oW[outW] = inputSample;
+				inputSample *= constallpass;
+				outW--; if (outW < 0 || outW > delayW) {outW = delayW;}
+				inputSample += (oW[outW]);
+				//allpass filter W
+				
+				dW[6] = dW[5];
+				dW[5] = dW[4];
+				dW[4] = inputSample;
+				inputSample = (dC[1] + dW[5] + dW[6])/3.0;
+				
+				allpasstemp = outX - 1;
+				if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;}
+				inputSample -= oX[allpasstemp]*constallpass;
+				oX[outX] = inputSample;
+				inputSample *= constallpass;
+				outX--; if (outX < 0 || outX > delayX) {outX = delayX;}
+				inputSample += (oX[outX]);
+				//allpass filter X
+				
+				dX[6] = dX[5];
+				dX[5] = dX[4];
+				dX[4] = inputSample;
+				inputSample = (dA[1] + dX[5] + dX[6])/3.0;
+				
+				allpasstemp = outY - 1;
+				if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;}
+				inputSample -= oY[allpasstemp]*constallpass;
+				oY[outY] = inputSample;
+				inputSample *= constallpass;
+				outY--; if (outY < 0 || outY > delayY) {outY = delayY;}
+				inputSample += (oY[outY]);
+				//allpass filter Y
+				
+				dY[6] = dY[5];
+				dY[5] = dY[4];
+				dY[4] = inputSample;
+				inputSample = (dB[1] + dY[5] + dY[6])/3.0;
+				
+				allpasstemp = outZ - 1;
+				if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;}
+				inputSample -= oZ[allpasstemp]*constallpass;
+				oZ[outZ] = inputSample;
+				inputSample *= constallpass;
+				outZ--; if (outZ < 0 || outZ > delayZ) {outZ = delayZ;}
+				inputSample += (oZ[outZ]);
+				//allpass filter Z
+				
+				dZ[6] = dZ[5];
+				dZ[5] = dZ[4];
+				dZ[4] = inputSample;
+				inputSample = (dZ[5] + dZ[6]);
+				//output Spring
+				break;
+				
+				
+case 3:	//Tiled
+				allpasstemp = alpA - 1;
+				if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;}
+				inputSample -= aA[allpasstemp]*constallpass;
+				aA[alpA] = inputSample;
+				inputSample *= constallpass;
+				alpA--; if (alpA < 0 || alpA > delayA) {alpA = delayA;}
+				inputSample += (aA[alpA]);
+				//allpass filter A		
+				
+				dA[2] = dA[1];
+				dA[1] = inputSample;
+				inputSample = (dA[1] + dA[2])/2.0;
+				
+				allpasstemp = alpB - 1;
+				if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;}
+				inputSample -= aB[allpasstemp]*constallpass;
+				aB[alpB] = inputSample;
+				inputSample *= constallpass;
+				alpB--; if (alpB < 0 || alpB > delayB) {alpB = delayB;}
+				inputSample += (aB[alpB]);
+				//allpass filter B
+				
+				dB[2] = dB[1];
+				dB[1] = inputSample;
+				inputSample = (dB[1] + dB[2])/2.0;
+				
+				allpasstemp = alpC - 1;
+				if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;}
+				inputSample -= aC[allpasstemp]*constallpass;
+				aC[alpC] = inputSample;
+				inputSample *= constallpass;
+				alpC--; if (alpC < 0 || alpC > delayC) {alpC = delayC;}
+				inputSample += (aC[alpC]);
+				//allpass filter C
+				
+				dC[2] = dC[1];
+				dC[1] = inputSample;
+				inputSample = (dA[1] + dC[2])/2.0;
+				
+				allpasstemp = alpD - 1;
+				if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;}
+				inputSample -= aD[allpasstemp]*constallpass;
+				aD[alpD] = inputSample;
+				inputSample *= constallpass;
+				alpD--; if (alpD < 0 || alpD > delayD) {alpD = delayD;}
+				inputSample += (aD[alpD]);
+				//allpass filter D
+				
+				dD[2] = dD[1];
+				dD[1] = inputSample;
+				inputSample = (dD[1] + dD[2])/2.0;
+				
+				allpasstemp = alpE - 1;
+				if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;}
+				inputSample -= aE[allpasstemp]*constallpass;
+				aE[alpE] = inputSample;
+				inputSample *= constallpass;
+				alpE--; if (alpE < 0 || alpE > delayE) {alpE = delayE;}
+				inputSample += (aE[alpE]);
+				//allpass filter E
+				
+				dE[2] = dE[1];
+				dE[1] = inputSample;
+				inputSample = (dA[1] + dE[2])/2.0;
+				
+				allpasstemp = alpF - 1;
+				if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;}
+				inputSample -= aF[allpasstemp]*constallpass;
+				aF[alpF] = inputSample;
+				inputSample *= constallpass;
+				alpF--; if (alpF < 0 || alpF > delayF) {alpF = delayF;}
+				inputSample += (aF[alpF]);
+				//allpass filter F
+				
+				dF[2] = dF[1];
+				dF[1] = inputSample;
+				inputSample = (dF[1] + dF[2])/2.0;
+				
+				allpasstemp = alpG - 1;
+				if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;}
+				inputSample -= aG[allpasstemp]*constallpass;
+				aG[alpG] = inputSample;
+				inputSample *= constallpass;
+				alpG--; if (alpG < 0 || alpG > delayG) {alpG = delayG;}
+				inputSample += (aG[alpG]);
+				//allpass filter G
+				
+				dG[2] = dG[1];
+				dG[1] = inputSample;
+				inputSample = (dA[1] + dG[2])/2.0;
+				
+				allpasstemp = alpH - 1;
+				if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;}
+				inputSample -= aH[allpasstemp]*constallpass;
+				aH[alpH] = inputSample;
+				inputSample *= constallpass;
+				alpH--; if (alpH < 0 || alpH > delayH) {alpH = delayH;}
+				inputSample += (aH[alpH]);
+				//allpass filter H
+				
+				dH[2] = dH[1];
+				dH[1] = inputSample;
+				inputSample = (dH[1] + dH[2])/2.0;
+				
+				allpasstemp = alpI - 1;
+				if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;}
+				inputSample -= aI[allpasstemp]*constallpass;
+				aI[alpI] = inputSample;
+				inputSample *= constallpass;
+				alpI--; if (alpI < 0 || alpI > delayI) {alpI = delayI;}
+				inputSample += (aI[alpI]);
+				//allpass filter I
+				
+				dI[2] = dI[1];
+				dI[1] = inputSample;
+				inputSample = (dI[1] + dI[2])/2.0;
+				
+				allpasstemp = alpJ - 1;
+				if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;}
+				inputSample -= aJ[allpasstemp]*constallpass;
+				aJ[alpJ] = inputSample;
+				inputSample *= constallpass;
+				alpJ--; if (alpJ < 0 || alpJ > delayJ) {alpJ = delayJ;}
+				inputSample += (aJ[alpJ]);
+				//allpass filter J
+				
+				dJ[2] = dJ[1];
+				dJ[1] = inputSample;
+				inputSample = (dJ[1] + dJ[2])/2.0;
+				
+				allpasstemp = alpK - 1;
+				if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;}
+				inputSample -= aK[allpasstemp]*constallpass;
+				aK[alpK] = inputSample;
+				inputSample *= constallpass;
+				alpK--; if (alpK < 0 || alpK > delayK) {alpK = delayK;}
+				inputSample += (aK[alpK]);
+				//allpass filter K
+				
+				dK[2] = dK[1];
+				dK[1] = inputSample;
+				inputSample = (dA[1] + dK[2])/2.0;
+				
+				allpasstemp = alpL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;}
+				inputSample -= aL[allpasstemp]*constallpass;
+				aL[alpL] = inputSample;
+				inputSample *= constallpass;
+				alpL--; if (alpL < 0 || alpL > delayL) {alpL = delayL;}
+				inputSample += (aL[alpL]);
+				//allpass filter L
+				
+				dL[2] = dL[1];
+				dL[1] = inputSample;
+				inputSample = (dL[1] + dL[2])/2.0;
+				
+				allpasstemp = alpM - 1;
+				if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;}
+				inputSample -= aM[allpasstemp]*constallpass;
+				aM[alpM] = inputSample;
+				inputSample *= constallpass;
+				alpM--; if (alpM < 0 || alpM > delayM) {alpM = delayM;}
+				inputSample += (aM[alpM]);
+				//allpass filter M
+				
+				dM[2] = dM[1];
+				dM[1] = inputSample;
+				inputSample = (dA[1] + dM[2])/2.0;
+				
+				allpasstemp = alpN - 1;
+				if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;}
+				inputSample -= aN[allpasstemp]*constallpass;
+				aN[alpN] = inputSample;
+				inputSample *= constallpass;
+				alpN--; if (alpN < 0 || alpN > delayN) {alpN = delayN;}
+				inputSample += (aN[alpN]);
+				//allpass filter N
+				
+				dN[2] = dN[1];
+				dN[1] = inputSample;
+				inputSample = (dN[1] + dN[2])/2.0;
+				
+				allpasstemp = alpO - 1;
+				if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;}
+				inputSample -= aO[allpasstemp]*constallpass;
+				aO[alpO] = inputSample;
+				inputSample *= constallpass;
+				alpO--; if (alpO < 0 || alpO > delayO) {alpO = delayO;}
+				inputSample += (aO[alpO]);
+				//allpass filter O
+				
+				dO[2] = dO[1];
+				dO[1] = inputSample;
+				inputSample = (dO[1] + dO[2])/2.0;
+				
+				allpasstemp = alpP - 1;
+				if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;}
+				inputSample -= aP[allpasstemp]*constallpass;
+				aP[alpP] = inputSample;
+				inputSample *= constallpass;
+				alpP--; if (alpP < 0 || alpP > delayP) {alpP = delayP;}
+				inputSample += (aP[alpP]);
+				//allpass filter P
+				
+				dP[2] = dP[1];
+				dP[1] = inputSample;
+				inputSample = (dP[1] + dP[2])/2.0;
+				
+				allpasstemp = alpQ - 1;
+				if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;}
+				inputSample -= aQ[allpasstemp]*constallpass;
+				aQ[alpQ] = inputSample;
+				inputSample *= constallpass;
+				alpQ--; if (alpQ < 0 || alpQ > delayQ) {alpQ = delayQ;}
+				inputSample += (aQ[alpQ]);
+				//allpass filter Q
+				
+				dQ[2] = dQ[1];
+				dQ[1] = inputSample;
+				inputSample = (dA[1] + dQ[2])/2.0;
+				
+				allpasstemp = alpR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;}
+				inputSample -= aR[allpasstemp]*constallpass;
+				aR[alpR] = inputSample;
+				inputSample *= constallpass;
+				alpR--; if (alpR < 0 || alpR > delayR) {alpR = delayR;}
+				inputSample += (aR[alpR]);
+				//allpass filter R
+				
+				dR[2] = dR[1];
+				dR[1] = inputSample;
+				inputSample = (dR[1] + dR[2])/2.0;
+				
+				allpasstemp = alpS - 1;
+				if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;}
+				inputSample -= aS[allpasstemp]*constallpass;
+				aS[alpS] = inputSample;
+				inputSample *= constallpass;
+				alpS--; if (alpS < 0 || alpS > delayS) {alpS = delayS;}
+				inputSample += (aS[alpS]);
+				//allpass filter S
+				
+				dS[2] = dS[1];
+				dS[1] = inputSample;
+				inputSample = (dA[1] + dS[2])/2.0;
+				
+				allpasstemp = alpT - 1;
+				if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;}
+				inputSample -= aT[allpasstemp]*constallpass;
+				aT[alpT] = inputSample;
+				inputSample *= constallpass;
+				alpT--; if (alpT < 0 || alpT > delayT) {alpT = delayT;}
+				inputSample += (aT[alpT]);
+				//allpass filter T
+				
+				dT[2] = dT[1];
+				dT[1] = inputSample;
+				inputSample = (dT[1] + dT[2])/2.0;
+				
+				allpasstemp = alpU - 1;
+				if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;}
+				inputSample -= aU[allpasstemp]*constallpass;
+				aU[alpU] = inputSample;
+				inputSample *= constallpass;
+				alpU--; if (alpU < 0 || alpU > delayU) {alpU = delayU;}
+				inputSample += (aU[alpU]);
+				//allpass filter U
+				
+				dU[2] = dU[1];
+				dU[1] = inputSample;
+				inputSample = (dU[1] + dU[2])/2.0;
+				
+				allpasstemp = alpV - 1;
+				if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;}
+				inputSample -= aV[allpasstemp]*constallpass;
+				aV[alpV] = inputSample;
+				inputSample *= constallpass;
+				alpV--; if (alpV < 0 || alpV > delayV) {alpV = delayV;}
+				inputSample += (aV[alpV]);
+				//allpass filter V
+				
+				dV[2] = dV[1];
+				dV[1] = inputSample;
+				inputSample = (dV[1] + dV[2])/2.0;
+				
+				allpasstemp = alpW - 1;
+				if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;}
+				inputSample -= aW[allpasstemp]*constallpass;
+				aW[alpW] = inputSample;
+				inputSample *= constallpass;
+				alpW--; if (alpW < 0 || alpW > delayW) {alpW = delayW;}
+				inputSample += (aW[alpW]);
+				//allpass filter W
+				
+				dW[2] = dW[1];
+				dW[1] = inputSample;
+				inputSample = (dA[1] + dW[2])/2.0;
+				
+				allpasstemp = alpX - 1;
+				if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;}
+				inputSample -= aX[allpasstemp]*constallpass;
+				aX[alpX] = inputSample;
+				inputSample *= constallpass;
+				alpX--; if (alpX < 0 || alpX > delayX) {alpX = delayX;}
+				inputSample += (aX[alpX]);
+				//allpass filter X
+				
+				dX[2] = dX[1];
+				dX[1] = inputSample;
+				inputSample = (dX[1] + dX[2])/2.0;
+				
+				allpasstemp = alpY - 1;
+				if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;}
+				inputSample -= aY[allpasstemp]*constallpass;
+				aY[alpY] = inputSample;
+				inputSample *= constallpass;
+				alpY--; if (alpY < 0 || alpY > delayY) {alpY = delayY;}
+				inputSample += (aY[alpY]);
+				//allpass filter Y
+				
+				dY[2] = dY[1];
+				dY[1] = inputSample;
+				inputSample = (dY[1] + dY[2])/2.0;
+				
+				allpasstemp = alpZ - 1;
+				if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;}
+				inputSample -= aZ[allpasstemp]*constallpass;
+				aZ[alpZ] = inputSample;
+				inputSample *= constallpass;
+				alpZ--; if (alpZ < 0 || alpZ > delayZ) {alpZ = delayZ;}
+				inputSample += (aZ[alpZ]);
+				//allpass filter Z
+				
+				dZ[2] = dZ[1];
+				dZ[1] = inputSample;
+				inputSample = (dZ[1] + dZ[2])/2.0;
+				
+				// now the second stage using the 'out' bank of allpasses		
+				
+				allpasstemp = outA - 1;
+				if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;}
+				inputSample -= oA[allpasstemp]*constallpass;
+				oA[outA] = inputSample;
+				inputSample *= constallpass;
+				outA--; if (outA < 0 || outA > delayA) {outA = delayA;}
+				inputSample += (oA[outA]);
+				//allpass filter A		
+				
+				dA[5] = dA[4];
+				dA[4] = inputSample;
+				inputSample = (dA[4] + dA[5])/2.0;
+				
+				allpasstemp = outB - 1;
+				if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;}
+				inputSample -= oB[allpasstemp]*constallpass;
+				oB[outB] = inputSample;
+				inputSample *= constallpass;
+				outB--; if (outB < 0 || outB > delayB) {outB = delayB;}
+				inputSample += (oB[outB]);
+				//allpass filter B
+				
+				dB[5] = dB[4];
+				dB[4] = inputSample;
+				inputSample = (dB[4] + dB[5])/2.0;
+				
+				allpasstemp = outC - 1;
+				if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;}
+				inputSample -= oC[allpasstemp]*constallpass;
+				oC[outC] = inputSample;
+				inputSample *= constallpass;
+				outC--; if (outC < 0 || outC > delayC) {outC = delayC;}
+				inputSample += (oC[outC]);
+				//allpass filter C
+				
+				dC[5] = dC[4];
+				dC[4] = inputSample;
+				inputSample = (dA[1] + dC[5])/2.0;
+				
+				allpasstemp = outD - 1;
+				if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;}
+				inputSample -= oD[allpasstemp]*constallpass;
+				oD[outD] = inputSample;
+				inputSample *= constallpass;
+				outD--; if (outD < 0 || outD > delayD) {outD = delayD;}
+				inputSample += (oD[outD]);
+				//allpass filter D
+				
+				dD[5] = dD[4];
+				dD[4] = inputSample;
+				inputSample = (dD[4] + dD[5])/2.0;
+				
+				allpasstemp = outE - 1;
+				if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;}
+				inputSample -= oE[allpasstemp]*constallpass;
+				oE[outE] = inputSample;
+				inputSample *= constallpass;
+				outE--; if (outE < 0 || outE > delayE) {outE = delayE;}
+				inputSample += (oE[outE]);
+				//allpass filter E
+				
+				dE[5] = dE[4];
+				dE[4] = inputSample;
+				inputSample = (dA[1] + dE[5])/2.0;
+				
+				allpasstemp = outF - 1;
+				if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;}
+				inputSample -= oF[allpasstemp]*constallpass;
+				oF[outF] = inputSample;
+				inputSample *= constallpass;
+				outF--; if (outF < 0 || outF > delayF) {outF = delayF;}
+				inputSample += (oF[outF]);
+				//allpass filter F
+				
+				dF[5] = dF[4];
+				dF[4] = inputSample;
+				inputSample = (dF[4] + dF[5])/2.0;
+				
+				allpasstemp = outG - 1;
+				if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;}
+				inputSample -= oG[allpasstemp]*constallpass;
+				oG[outG] = inputSample;
+				inputSample *= constallpass;
+				outG--; if (outG < 0 || outG > delayG) {outG = delayG;}
+				inputSample += (oG[outG]);
+				//allpass filter G
+				
+				dG[5] = dG[4];
+				dG[4] = inputSample;
+				inputSample = (dG[4] + dG[5])/2.0;
+				
+				allpasstemp = outH - 1;
+				if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;}
+				inputSample -= oH[allpasstemp]*constallpass;
+				oH[outH] = inputSample;
+				inputSample *= constallpass;
+				outH--; if (outH < 0 || outH > delayH) {outH = delayH;}
+				inputSample += (oH[outH]);
+				//allpass filter H
+				
+				dH[5] = dH[4];
+				dH[4] = inputSample;
+				inputSample = (dH[4] + dH[5])/2.0;
+				
+				allpasstemp = outI - 1;
+				if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;}
+				inputSample -= oI[allpasstemp]*constallpass;
+				oI[outI] = inputSample;
+				inputSample *= constallpass;
+				outI--; if (outI < 0 || outI > delayI) {outI = delayI;}
+				inputSample += (oI[outI]);
+				//allpass filter I
+				
+				dI[5] = dI[4];
+				dI[4] = inputSample;
+				inputSample = (dI[4] + dI[5])/2.0;
+				
+				allpasstemp = outJ - 1;
+				if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;}
+				inputSample -= oJ[allpasstemp]*constallpass;
+				oJ[outJ] = inputSample;
+				inputSample *= constallpass;
+				outJ--; if (outJ < 0 || outJ > delayJ) {outJ = delayJ;}
+				inputSample += (oJ[outJ]);
+				//allpass filter J
+				
+				dJ[5] = dJ[4];
+				dJ[4] = inputSample;
+				inputSample = (dJ[4] + dJ[5])/2.0;
+				
+				allpasstemp = outK - 1;
+				if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;}
+				inputSample -= oK[allpasstemp]*constallpass;
+				oK[outK] = inputSample;
+				inputSample *= constallpass;
+				outK--; if (outK < 0 || outK > delayK) {outK = delayK;}
+				inputSample += (oK[outK]);
+				//allpass filter K
+				
+				dK[5] = dK[4];
+				dK[4] = inputSample;
+				inputSample = (dA[1] + dK[5])/2.0;
+				
+				allpasstemp = outL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;}
+				inputSample -= oL[allpasstemp]*constallpass;
+				oL[outL] = inputSample;
+				inputSample *= constallpass;
+				outL--; if (outL < 0 || outL > delayL) {outL = delayL;}
+				inputSample += (oL[outL]);
+				//allpass filter L
+				
+				dL[5] = dL[4];
+				dL[4] = inputSample;
+				inputSample = (dL[4] + dL[5])/2.0;
+				
+				allpasstemp = outM - 1;
+				if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;}
+				inputSample -= oM[allpasstemp]*constallpass;
+				oM[outM] = inputSample;
+				inputSample *= constallpass;
+				outM--; if (outM < 0 || outM > delayM) {outM = delayM;}
+				inputSample += (oM[outM]);
+				//allpass filter M
+				
+				dM[5] = dM[4];
+				dM[4] = inputSample;
+				inputSample = (dM[4] + dM[5])/2.0;
+				
+				allpasstemp = outN - 1;
+				if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;}
+				inputSample -= oN[allpasstemp]*constallpass;
+				oN[outN] = inputSample;
+				inputSample *= constallpass;
+				outN--; if (outN < 0 || outN > delayN) {outN = delayN;}
+				inputSample += (oN[outN]);
+				//allpass filter N
+				
+				dN[5] = dN[4];
+				dN[4] = inputSample;
+				inputSample = (dN[4] + dN[5])/2.0;
+				
+				allpasstemp = outO - 1;
+				if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;}
+				inputSample -= oO[allpasstemp]*constallpass;
+				oO[outO] = inputSample;
+				inputSample *= constallpass;
+				outO--; if (outO < 0 || outO > delayO) {outO = delayO;}
+				inputSample += (oO[outO]);
+				//allpass filter O
+				
+				dO[5] = dO[4];
+				dO[4] = inputSample;
+				inputSample = (dA[1] + dO[5])/2.0;
+				
+				allpasstemp = outP - 1;
+				if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;}
+				inputSample -= oP[allpasstemp]*constallpass;
+				oP[outP] = inputSample;
+				inputSample *= constallpass;
+				outP--; if (outP < 0 || outP > delayP) {outP = delayP;}
+				inputSample += (oP[outP]);
+				//allpass filter P
+				
+				dP[5] = dP[4];
+				dP[4] = inputSample;
+				inputSample = (dP[4] + dP[5])/2.0;
+				
+				allpasstemp = outQ - 1;
+				if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;}
+				inputSample -= oQ[allpasstemp]*constallpass;
+				oQ[outQ] = inputSample;
+				inputSample *= constallpass;
+				outQ--; if (outQ < 0 || outQ > delayQ) {outQ = delayQ;}
+				inputSample += (oQ[outQ]);
+				//allpass filter Q
+				
+				dQ[5] = dQ[4];
+				dQ[4] = inputSample;
+				inputSample = (dA[1] + dQ[5])/2.0;
+				
+				allpasstemp = outR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;}
+				inputSample -= oR[allpasstemp]*constallpass;
+				oR[outR] = inputSample;
+				inputSample *= constallpass;
+				outR--; if (outR < 0 || outR > delayR) {outR = delayR;}
+				inputSample += (oR[outR]);
+				//allpass filter R
+				
+				dR[5] = dR[4];
+				dR[4] = inputSample;
+				inputSample = (dR[4] + dR[5])/2.0;
+				
+				allpasstemp = outS - 1;
+				if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;}
+				inputSample -= oS[allpasstemp]*constallpass;
+				oS[outS] = inputSample;
+				inputSample *= constallpass;
+				outS--; if (outS < 0 || outS > delayS) {outS = delayS;}
+				inputSample += (oS[outS]);
+				//allpass filter S
+				
+				dS[5] = dS[4];
+				dS[4] = inputSample;
+				inputSample = (dS[4] + dS[5])/2.0;
+				
+				allpasstemp = outT - 1;
+				if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;}
+				inputSample -= oT[allpasstemp]*constallpass;
+				oT[outT] = inputSample;
+				inputSample *= constallpass;
+				outT--; if (outT < 0 || outT > delayT) {outT = delayT;}
+				inputSample += (oT[outT]);
+				//allpass filter T
+				
+				dT[5] = dT[4];
+				dT[4] = inputSample;
+				inputSample = (dT[4] + dT[5])/2.0;
+				
+				allpasstemp = outU - 1;
+				if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;}
+				inputSample -= oU[allpasstemp]*constallpass;
+				oU[outU] = inputSample;
+				inputSample *= constallpass;
+				outU--; if (outU < 0 || outU > delayU) {outU = delayU;}
+				inputSample += (oU[outU]);
+				//allpass filter U
+				
+				dU[5] = dU[4];
+				dU[4] = inputSample;
+				inputSample = (dA[1] + dU[5])/2.0;
+				
+				allpasstemp = outV - 1;
+				if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;}
+				inputSample -= oV[allpasstemp]*constallpass;
+				oV[outV] = inputSample;
+				inputSample *= constallpass;
+				outV--; if (outV < 0 || outV > delayV) {outV = delayV;}
+				inputSample += (oV[outV]);
+				//allpass filter V
+				
+				dV[5] = dV[4];
+				dV[4] = inputSample;
+				inputSample = (dV[4] + dV[5])/2.0;
+				
+				allpasstemp = outW - 1;
+				if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;}
+				inputSample -= oW[allpasstemp]*constallpass;
+				oW[outW] = inputSample;
+				inputSample *= constallpass;
+				outW--; if (outW < 0 || outW > delayW) {outW = delayW;}
+				inputSample += (oW[outW]);
+				//allpass filter W
+				
+				dW[5] = dW[4];
+				dW[4] = inputSample;
+				inputSample = (dW[4] + dW[5])/2.0;
+				
+				allpasstemp = outX - 1;
+				if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;}
+				inputSample -= oX[allpasstemp]*constallpass;
+				oX[outX] = inputSample;
+				inputSample *= constallpass;
+				outX--; if (outX < 0 || outX > delayX) {outX = delayX;}
+				inputSample += (oX[outX]);
+				//allpass filter X
+				
+				dX[5] = dX[4];
+				dX[4] = inputSample;
+				inputSample = (dX[4] + dX[5])/2.0;
+				
+				allpasstemp = outY - 1;
+				if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;}
+				inputSample -= oY[allpasstemp]*constallpass;
+				oY[outY] = inputSample;
+				inputSample *= constallpass;
+				outY--; if (outY < 0 || outY > delayY) {outY = delayY;}
+				inputSample += (oY[outY]);
+				//allpass filter Y
+				
+				dY[5] = dY[4];
+				dY[4] = inputSample;
+				inputSample = (dY[4] + dY[5])/2.0;
+				
+				allpasstemp = outZ - 1;
+				if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;}
+				inputSample -= oZ[allpasstemp]*constallpass;
+				oZ[outZ] = inputSample;
+				inputSample *= constallpass;
+				outZ--; if (outZ < 0 || outZ > delayZ) {outZ = delayZ;}
+				inputSample += (oZ[outZ]);
+				//allpass filter Z
+				
+				dZ[5] = dZ[4];
+				dZ[4] = inputSample;
+				inputSample = (dZ[4] + dZ[5]);		
+				//output Tiled
+				break;
+				
+
+case 4://Room
+				allpasstemp = alpA - 1;
+				if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;}
+				inputSample -= aA[allpasstemp]*constallpass;
+				aA[alpA] = inputSample;
+				inputSample *= constallpass;
+				alpA--; if (alpA < 0 || alpA > delayA) {alpA = delayA;}
+				inputSample += (aA[alpA]);
+				//allpass filter A		
+				
+				dA[2] = dA[1];
+				dA[1] = inputSample;
+				inputSample = drySample;
+				
+				allpasstemp = alpB - 1;
+				if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;}
+				inputSample -= aB[allpasstemp]*constallpass;
+				aB[alpB] = inputSample;
+				inputSample *= constallpass;
+				alpB--; if (alpB < 0 || alpB > delayB) {alpB = delayB;}
+				inputSample += (aB[alpB]);
+				//allpass filter B
+				
+				dB[2] = dB[1];
+				dB[1] = inputSample;
+				inputSample = drySample;
+				
+				allpasstemp = alpC - 1;
+				if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;}
+				inputSample -= aC[allpasstemp]*constallpass;
+				aC[alpC] = inputSample;
+				inputSample *= constallpass;
+				alpC--; if (alpC < 0 || alpC > delayC) {alpC = delayC;}
+				inputSample += (aC[alpC]);
+				//allpass filter C
+				
+				dC[2] = dC[1];
+				dC[1] = inputSample;
+				inputSample = drySample;
+				
+				allpasstemp = alpD - 1;
+				if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;}
+				inputSample -= aD[allpasstemp]*constallpass;
+				aD[alpD] = inputSample;
+				inputSample *= constallpass;
+				alpD--; if (alpD < 0 || alpD > delayD) {alpD = delayD;}
+				inputSample += (aD[alpD]);
+				//allpass filter D
+				
+				dD[2] = dD[1];
+				dD[1] = inputSample;
+				inputSample = drySample;
+				
+				allpasstemp = alpE - 1;
+				if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;}
+				inputSample -= aE[allpasstemp]*constallpass;
+				aE[alpE] = inputSample;
+				inputSample *= constallpass;
+				alpE--; if (alpE < 0 || alpE > delayE) {alpE = delayE;}
+				inputSample += (aE[alpE]);
+				//allpass filter E
+				
+				dE[2] = dE[1];
+				dE[1] = inputSample;
+				inputSample = drySample;
+				
+				allpasstemp = alpF - 1;
+				if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;}
+				inputSample -= aF[allpasstemp]*constallpass;
+				aF[alpF] = inputSample;
+				inputSample *= constallpass;
+				alpF--; if (alpF < 0 || alpF > delayF) {alpF = delayF;}
+				inputSample += (aF[alpF]);
+				//allpass filter F
+				
+				dF[2] = dF[1];
+				dF[1] = inputSample;
+				inputSample = drySample;
+				
+				allpasstemp = alpG - 1;
+				if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;}
+				inputSample -= aG[allpasstemp]*constallpass;
+				aG[alpG] = inputSample;
+				inputSample *= constallpass;
+				alpG--; if (alpG < 0 || alpG > delayG) {alpG = delayG;}
+				inputSample += (aG[alpG]);
+				//allpass filter G
+				
+				dG[2] = dG[1];
+				dG[1] = inputSample;
+				inputSample = drySample;
+				
+				allpasstemp = alpH - 1;
+				if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;}
+				inputSample -= aH[allpasstemp]*constallpass;
+				aH[alpH] = inputSample;
+				inputSample *= constallpass;
+				alpH--; if (alpH < 0 || alpH > delayH) {alpH = delayH;}
+				inputSample += (aH[alpH]);
+				//allpass filter H
+				
+				dH[2] = dH[1];
+				dH[1] = inputSample;
+				inputSample = drySample;
+				
+				allpasstemp = alpI - 1;
+				if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;}
+				inputSample -= aI[allpasstemp]*constallpass;
+				aI[alpI] = inputSample;
+				inputSample *= constallpass;
+				alpI--; if (alpI < 0 || alpI > delayI) {alpI = delayI;}
+				inputSample += (aI[alpI]);
+				//allpass filter I
+				
+				dI[2] = dI[1];
+				dI[1] = inputSample;
+				inputSample = drySample;
+				
+				allpasstemp = alpJ - 1;
+				if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;}
+				inputSample -= aJ[allpasstemp]*constallpass;
+				aJ[alpJ] = inputSample;
+				inputSample *= constallpass;
+				alpJ--; if (alpJ < 0 || alpJ > delayJ) {alpJ = delayJ;}
+				inputSample += (aJ[alpJ]);
+				//allpass filter J
+				
+				dJ[2] = dJ[1];
+				dJ[1] = inputSample;
+				inputSample = drySample;
+				
+				allpasstemp = alpK - 1;
+				if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;}
+				inputSample -= aK[allpasstemp]*constallpass;
+				aK[alpK] = inputSample;
+				inputSample *= constallpass;
+				alpK--; if (alpK < 0 || alpK > delayK) {alpK = delayK;}
+				inputSample += (aK[alpK]);
+				//allpass filter K
+				
+				dK[2] = dK[1];
+				dK[1] = inputSample;
+				inputSample = drySample;
+				
+				allpasstemp = alpL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;}
+				inputSample -= aL[allpasstemp]*constallpass;
+				aL[alpL] = inputSample;
+				inputSample *= constallpass;
+				alpL--; if (alpL < 0 || alpL > delayL) {alpL = delayL;}
+				inputSample += (aL[alpL]);
+				//allpass filter L
+				
+				dL[2] = dL[1];
+				dL[1] = inputSample;
+				inputSample = drySample;
+				
+				allpasstemp = alpM - 1;
+				if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;}
+				inputSample -= aM[allpasstemp]*constallpass;
+				aM[alpM] = inputSample;
+				inputSample *= constallpass;
+				alpM--; if (alpM < 0 || alpM > delayM) {alpM = delayM;}
+				inputSample += (aM[alpM]);
+				//allpass filter M
+				
+				dM[2] = dM[1];
+				dM[1] = inputSample;
+				inputSample = drySample;
+				
+				allpasstemp = alpN - 1;
+				if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;}
+				inputSample -= aN[allpasstemp]*constallpass;
+				aN[alpN] = inputSample;
+				inputSample *= constallpass;
+				alpN--; if (alpN < 0 || alpN > delayN) {alpN = delayN;}
+				inputSample += (aN[alpN]);
+				//allpass filter N
+				
+				dN[2] = dN[1];
+				dN[1] = inputSample;
+				inputSample = drySample;
+				
+				allpasstemp = alpO - 1;
+				if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;}
+				inputSample -= aO[allpasstemp]*constallpass;
+				aO[alpO] = inputSample;
+				inputSample *= constallpass;
+				alpO--; if (alpO < 0 || alpO > delayO) {alpO = delayO;}
+				inputSample += (aO[alpO]);
+				//allpass filter O
+				
+				dO[2] = dO[1];
+				dO[1] = inputSample;
+				inputSample = drySample;
+				
+				allpasstemp = alpP - 1;
+				if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;}
+				inputSample -= aP[allpasstemp]*constallpass;
+				aP[alpP] = inputSample;
+				inputSample *= constallpass;
+				alpP--; if (alpP < 0 || alpP > delayP) {alpP = delayP;}
+				inputSample += (aP[alpP]);
+				//allpass filter P
+				
+				dP[2] = dP[1];
+				dP[1] = inputSample;
+				inputSample = drySample;
+				
+				allpasstemp = alpQ - 1;
+				if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;}
+				inputSample -= aQ[allpasstemp]*constallpass;
+				aQ[alpQ] = inputSample;
+				inputSample *= constallpass;
+				alpQ--; if (alpQ < 0 || alpQ > delayQ) {alpQ = delayQ;}
+				inputSample += (aQ[alpQ]);
+				//allpass filter Q
+				
+				dQ[2] = dQ[1];
+				dQ[1] = inputSample;
+				inputSample = drySample;
+				
+				allpasstemp = alpR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;}
+				inputSample -= aR[allpasstemp]*constallpass;
+				aR[alpR] = inputSample;
+				inputSample *= constallpass;
+				alpR--; if (alpR < 0 || alpR > delayR) {alpR = delayR;}
+				inputSample += (aR[alpR]);
+				//allpass filter R
+				
+				dR[2] = dR[1];
+				dR[1] = inputSample;
+				inputSample = drySample;
+				
+				allpasstemp = alpS - 1;
+				if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;}
+				inputSample -= aS[allpasstemp]*constallpass;
+				aS[alpS] = inputSample;
+				inputSample *= constallpass;
+				alpS--; if (alpS < 0 || alpS > delayS) {alpS = delayS;}
+				inputSample += (aS[alpS]);
+				//allpass filter S
+				
+				dS[2] = dS[1];
+				dS[1] = inputSample;
+				inputSample = drySample;
+				
+				allpasstemp = alpT - 1;
+				if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;}
+				inputSample -= aT[allpasstemp]*constallpass;
+				aT[alpT] = inputSample;
+				inputSample *= constallpass;
+				alpT--; if (alpT < 0 || alpT > delayT) {alpT = delayT;}
+				inputSample += (aT[alpT]);
+				//allpass filter T
+				
+				dT[2] = dT[1];
+				dT[1] = inputSample;
+				inputSample = drySample;
+				
+				allpasstemp = alpU - 1;
+				if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;}
+				inputSample -= aU[allpasstemp]*constallpass;
+				aU[alpU] = inputSample;
+				inputSample *= constallpass;
+				alpU--; if (alpU < 0 || alpU > delayU) {alpU = delayU;}
+				inputSample += (aU[alpU]);
+				//allpass filter U
+				
+				dU[2] = dU[1];
+				dU[1] = inputSample;
+				inputSample = drySample;
+				
+				allpasstemp = alpV - 1;
+				if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;}
+				inputSample -= aV[allpasstemp]*constallpass;
+				aV[alpV] = inputSample;
+				inputSample *= constallpass;
+				alpV--; if (alpV < 0 || alpV > delayV) {alpV = delayV;}
+				inputSample += (aV[alpV]);
+				//allpass filter V
+				
+				dV[2] = dV[1];
+				dV[1] = inputSample;
+				inputSample = drySample;
+				
+				allpasstemp = alpW - 1;
+				if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;}
+				inputSample -= aW[allpasstemp]*constallpass;
+				aW[alpW] = inputSample;
+				inputSample *= constallpass;
+				alpW--; if (alpW < 0 || alpW > delayW) {alpW = delayW;}
+				inputSample += (aW[alpW]);
+				//allpass filter W
+				
+				dW[2] = dW[1];
+				dW[1] = inputSample;
+				inputSample = drySample;
+				
+				allpasstemp = alpX - 1;
+				if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;}
+				inputSample -= aX[allpasstemp]*constallpass;
+				aX[alpX] = inputSample;
+				inputSample *= constallpass;
+				alpX--; if (alpX < 0 || alpX > delayX) {alpX = delayX;}
+				inputSample += (aX[alpX]);
+				//allpass filter X
+				
+				dX[2] = dX[1];
+				dX[1] = inputSample;
+				inputSample = drySample;
+				
+				allpasstemp = alpY - 1;
+				if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;}
+				inputSample -= aY[allpasstemp]*constallpass;
+				aY[alpY] = inputSample;
+				inputSample *= constallpass;
+				alpY--; if (alpY < 0 || alpY > delayY) {alpY = delayY;}
+				inputSample += (aY[alpY]);
+				//allpass filter Y
+				
+				dY[2] = dY[1];
+				dY[1] = inputSample;
+				inputSample = drySample;
+				
+				allpasstemp = alpZ - 1;
+				if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;}
+				inputSample -= aZ[allpasstemp]*constallpass;
+				aZ[alpZ] = inputSample;
+				inputSample *= constallpass;
+				alpZ--; if (alpZ < 0 || alpZ > delayZ) {alpZ = delayZ;}
+				inputSample += (aZ[alpZ]);
+				//allpass filter Z
+				
+				dZ[2] = dZ[1];
+				dZ[1] = inputSample;
+				inputSample = drySample;
+				
+				// now the second stage using the 'out' bank of allpasses		
+				
+				allpasstemp = outA - 1;
+				if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;}
+				inputSample -= oA[allpasstemp]*constallpass;
+				oA[outA] = inputSample;
+				inputSample *= constallpass;
+				outA--; if (outA < 0 || outA > delayA) {outA = delayA;}
+				inputSample += (oA[outA]);
+				//allpass filter A		
+				
+				dA[5] = dA[4];
+				dA[4] = inputSample;
+				inputSample = (dA[1]+dA[2])/2.0;
+				
+				allpasstemp = outB - 1;
+				if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;}
+				inputSample -= oB[allpasstemp]*constallpass;
+				oB[outB] = inputSample;
+				inputSample *= constallpass;
+				outB--; if (outB < 0 || outB > delayB) {outB = delayB;}
+				inputSample += (oB[outB]);
+				//allpass filter B
+				
+				dB[5] = dB[4];
+				dB[4] = inputSample;
+				inputSample = (dB[1]+dB[2])/2.0;
+				
+				allpasstemp = outC - 1;
+				if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;}
+				inputSample -= oC[allpasstemp]*constallpass;
+				oC[outC] = inputSample;
+				inputSample *= constallpass;
+				outC--; if (outC < 0 || outC > delayC) {outC = delayC;}
+				inputSample += (oC[outC]);
+				//allpass filter C
+				
+				dC[5] = dC[4];
+				dC[4] = inputSample;
+				inputSample = (dC[1]+dC[2])/2.0;
+				
+				allpasstemp = outD - 1;
+				if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;}
+				inputSample -= oD[allpasstemp]*constallpass;
+				oD[outD] = inputSample;
+				inputSample *= constallpass;
+				outD--; if (outD < 0 || outD > delayD) {outD = delayD;}
+				inputSample += (oD[outD]);
+				//allpass filter D
+				
+				dD[5] = dD[4];
+				dD[4] = inputSample;
+				inputSample = (dD[1]+dD[2])/2.0;
+				
+				allpasstemp = outE - 1;
+				if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;}
+				inputSample -= oE[allpasstemp]*constallpass;
+				oE[outE] = inputSample;
+				inputSample *= constallpass;
+				outE--; if (outE < 0 || outE > delayE) {outE = delayE;}
+				inputSample += (oE[outE]);
+				//allpass filter E
+				
+				dE[5] = dE[4];
+				dE[4] = inputSample;
+				inputSample = (dE[1]+dE[2])/2.0;
+				
+				allpasstemp = outF - 1;
+				if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;}
+				inputSample -= oF[allpasstemp]*constallpass;
+				oF[outF] = inputSample;
+				inputSample *= constallpass;
+				outF--; if (outF < 0 || outF > delayF) {outF = delayF;}
+				inputSample += (oF[outF]);
+				//allpass filter F
+				
+				dF[5] = dF[4];
+				dF[4] = inputSample;
+				inputSample = (dF[1]+dF[2])/2.0;
+				
+				allpasstemp = outG - 1;
+				if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;}
+				inputSample -= oG[allpasstemp]*constallpass;
+				oG[outG] = inputSample;
+				inputSample *= constallpass;
+				outG--; if (outG < 0 || outG > delayG) {outG = delayG;}
+				inputSample += (oG[outG]);
+				//allpass filter G
+				
+				dG[5] = dG[4];
+				dG[4] = inputSample;
+				inputSample = (dG[1]+dG[2])/2.0;
+				
+				allpasstemp = outH - 1;
+				if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;}
+				inputSample -= oH[allpasstemp]*constallpass;
+				oH[outH] = inputSample;
+				inputSample *= constallpass;
+				outH--; if (outH < 0 || outH > delayH) {outH = delayH;}
+				inputSample += (oH[outH]);
+				//allpass filter H
+				
+				dH[5] = dH[4];
+				dH[4] = inputSample;
+				inputSample = (dH[1]+dH[2])/2.0;
+				
+				allpasstemp = outI - 1;
+				if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;}
+				inputSample -= oI[allpasstemp]*constallpass;
+				oI[outI] = inputSample;
+				inputSample *= constallpass;
+				outI--; if (outI < 0 || outI > delayI) {outI = delayI;}
+				inputSample += (oI[outI]);
+				//allpass filter I
+				
+				dI[5] = dI[4];
+				dI[4] = inputSample;
+				inputSample = (dI[1]+dI[2])/2.0;
+				
+				allpasstemp = outJ - 1;
+				if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;}
+				inputSample -= oJ[allpasstemp]*constallpass;
+				oJ[outJ] = inputSample;
+				inputSample *= constallpass;
+				outJ--; if (outJ < 0 || outJ > delayJ) {outJ = delayJ;}
+				inputSample += (oJ[outJ]);
+				//allpass filter J
+				
+				dJ[5] = dJ[4];
+				dJ[4] = inputSample;
+				inputSample = (dJ[1]+dJ[2])/2.0;
+				
+				allpasstemp = outK - 1;
+				if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;}
+				inputSample -= oK[allpasstemp]*constallpass;
+				oK[outK] = inputSample;
+				inputSample *= constallpass;
+				outK--; if (outK < 0 || outK > delayK) {outK = delayK;}
+				inputSample += (oK[outK]);
+				//allpass filter K
+				
+				dK[5] = dK[4];
+				dK[4] = inputSample;
+				inputSample = (dK[1]+dK[2])/2.0;
+				
+				allpasstemp = outL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;}
+				inputSample -= oL[allpasstemp]*constallpass;
+				oL[outL] = inputSample;
+				inputSample *= constallpass;
+				outL--; if (outL < 0 || outL > delayL) {outL = delayL;}
+				inputSample += (oL[outL]);
+				//allpass filter L
+				
+				dL[5] = dL[4];
+				dL[4] = inputSample;
+				inputSample = (dL[1]+dL[2])/2.0;
+				
+				allpasstemp = outM - 1;
+				if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;}
+				inputSample -= oM[allpasstemp]*constallpass;
+				oM[outM] = inputSample;
+				inputSample *= constallpass;
+				outM--; if (outM < 0 || outM > delayM) {outM = delayM;}
+				inputSample += (oM[outM]);
+				//allpass filter M
+				
+				dM[5] = dM[4];
+				dM[4] = inputSample;
+				inputSample = (dM[1]+dM[2])/2.0;
+				
+				allpasstemp = outN - 1;
+				if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;}
+				inputSample -= oN[allpasstemp]*constallpass;
+				oN[outN] = inputSample;
+				inputSample *= constallpass;
+				outN--; if (outN < 0 || outN > delayN) {outN = delayN;}
+				inputSample += (oN[outN]);
+				//allpass filter N
+				
+				dN[5] = dN[4];
+				dN[4] = inputSample;
+				inputSample = (dN[1]+dN[2])/2.0;
+				
+				allpasstemp = outO - 1;
+				if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;}
+				inputSample -= oO[allpasstemp]*constallpass;
+				oO[outO] = inputSample;
+				inputSample *= constallpass;
+				outO--; if (outO < 0 || outO > delayO) {outO = delayO;}
+				inputSample += (oO[outO]);
+				//allpass filter O
+				
+				dO[5] = dO[4];
+				dO[4] = inputSample;
+				inputSample = (dO[1]+dO[2])/2.0;
+				
+				allpasstemp = outP - 1;
+				if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;}
+				inputSample -= oP[allpasstemp]*constallpass;
+				oP[outP] = inputSample;
+				inputSample *= constallpass;
+				outP--; if (outP < 0 || outP > delayP) {outP = delayP;}
+				inputSample += (oP[outP]);
+				//allpass filter P
+				
+				dP[5] = dP[4];
+				dP[4] = inputSample;
+				inputSample = (dP[1]+dP[2])/2.0;
+				
+				allpasstemp = outQ - 1;
+				if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;}
+				inputSample -= oQ[allpasstemp]*constallpass;
+				oQ[outQ] = inputSample;
+				inputSample *= constallpass;
+				outQ--; if (outQ < 0 || outQ > delayQ) {outQ = delayQ;}
+				inputSample += (oQ[outQ]);
+				//allpass filter Q
+				
+				dQ[5] = dQ[4];
+				dQ[4] = inputSample;
+				inputSample = (dQ[1]+dQ[2])/2.0;
+				
+				allpasstemp = outR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;}
+				inputSample -= oR[allpasstemp]*constallpass;
+				oR[outR] = inputSample;
+				inputSample *= constallpass;
+				outR--; if (outR < 0 || outR > delayR) {outR = delayR;}
+				inputSample += (oR[outR]);
+				//allpass filter R
+				
+				dR[5] = dR[4];
+				dR[4] = inputSample;
+				inputSample = (dR[1]+dR[2])/2.0;
+				
+				allpasstemp = outS - 1;
+				if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;}
+				inputSample -= oS[allpasstemp]*constallpass;
+				oS[outS] = inputSample;
+				inputSample *= constallpass;
+				outS--; if (outS < 0 || outS > delayS) {outS = delayS;}
+				inputSample += (oS[outS]);
+				//allpass filter S
+				
+				dS[5] = dS[4];
+				dS[4] = inputSample;
+				inputSample = (dS[1]+dS[2])/2.0;
+				
+				allpasstemp = outT - 1;
+				if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;}
+				inputSample -= oT[allpasstemp]*constallpass;
+				oT[outT] = inputSample;
+				inputSample *= constallpass;
+				outT--; if (outT < 0 || outT > delayT) {outT = delayT;}
+				inputSample += (oT[outT]);
+				//allpass filter T
+				
+				dT[5] = dT[4];
+				dT[4] = inputSample;
+				inputSample = (dT[1]+dT[2])/2.0;
+				
+				allpasstemp = outU - 1;
+				if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;}
+				inputSample -= oU[allpasstemp]*constallpass;
+				oU[outU] = inputSample;
+				inputSample *= constallpass;
+				outU--; if (outU < 0 || outU > delayU) {outU = delayU;}
+				inputSample += (oU[outU]);
+				//allpass filter U
+				
+				dU[5] = dU[4];
+				dU[4] = inputSample;
+				inputSample = (dU[1]+dU[2])/2.0;
+				
+				allpasstemp = outV - 1;
+				if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;}
+				inputSample -= oV[allpasstemp]*constallpass;
+				oV[outV] = inputSample;
+				inputSample *= constallpass;
+				outV--; if (outV < 0 || outV > delayV) {outV = delayV;}
+				inputSample += (oV[outV]);
+				//allpass filter V
+				
+				dV[5] = dV[4];
+				dV[4] = inputSample;
+				inputSample = (dV[1]+dV[2])/2.0;
+				
+				allpasstemp = outW - 1;
+				if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;}
+				inputSample -= oW[allpasstemp]*constallpass;
+				oW[outW] = inputSample;
+				inputSample *= constallpass;
+				outW--; if (outW < 0 || outW > delayW) {outW = delayW;}
+				inputSample += (oW[outW]);
+				//allpass filter W
+				
+				dW[5] = dW[4];
+				dW[4] = inputSample;
+				inputSample = (dW[1]+dW[2])/2.0;
+				
+				allpasstemp = outX - 1;
+				if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;}
+				inputSample -= oX[allpasstemp]*constallpass;
+				oX[outX] = inputSample;
+				inputSample *= constallpass;
+				outX--; if (outX < 0 || outX > delayX) {outX = delayX;}
+				inputSample += (oX[outX]);
+				//allpass filter X
+				
+				dX[5] = dX[4];
+				dX[4] = inputSample;
+				inputSample = (dX[1]+dX[2])/2.0;
+				
+				allpasstemp = outY - 1;
+				if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;}
+				inputSample -= oY[allpasstemp]*constallpass;
+				oY[outY] = inputSample;
+				inputSample *= constallpass;
+				outY--; if (outY < 0 || outY > delayY) {outY = delayY;}
+				inputSample += (oY[outY]);
+				//allpass filter Y
+				
+				dY[5] = dY[4];
+				dY[4] = inputSample;
+				inputSample = (dY[1]+dY[2])/2.0;
+				
+				allpasstemp = outZ - 1;
+				if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;}
+				inputSample -= oZ[allpasstemp]*constallpass;
+				oZ[outZ] = inputSample;
+				inputSample *= constallpass;
+				outZ--; if (outZ < 0 || outZ > delayZ) {outZ = delayZ;}
+				inputSample += (oZ[outZ]);
+				//allpass filter Z
+				
+				dZ[5] = dZ[4];
+				dZ[4] = inputSample;
+				inputSample = (dB[4] * dryness);		
+				inputSample += (dC[4] * dryness);		
+				inputSample += dD[4];		
+				inputSample += dE[4];		
+				inputSample += dF[4];		
+				inputSample += dG[4];		
+				inputSample += dH[4];		
+				inputSample += dI[4];		
+				inputSample += dJ[4];		
+				inputSample += dK[4];		
+				inputSample += dL[4];		
+				inputSample += dM[4];		
+				inputSample += dN[4];		
+				inputSample += dO[4];		
+				inputSample += dP[4];		
+				inputSample += dQ[4];		
+				inputSample += dR[4];		
+				inputSample += dS[4];		
+				inputSample += dT[4];		
+				inputSample += dU[4];		
+				inputSample += dV[4];		
+				inputSample += dW[4];		
+				inputSample += dX[4];		
+				inputSample += dY[4];		
+				inputSample += (dZ[4] * wetness);
+				
+				inputSample += (dB[5] * dryness);		
+				inputSample += (dC[5] * dryness);		
+				inputSample += dD[5];		
+				inputSample += dE[5];		
+				inputSample += dF[5];		
+				inputSample += dG[5];		
+				inputSample += dH[5];		
+				inputSample += dI[5];		
+				inputSample += dJ[5];		
+				inputSample += dK[5];		
+				inputSample += dL[5];		
+				inputSample += dM[5];		
+				inputSample += dN[5];		
+				inputSample += dO[5];		
+				inputSample += dP[5];		
+				inputSample += dQ[5];		
+				inputSample += dR[5];		
+				inputSample += dS[5];		
+				inputSample += dT[5];		
+				inputSample += dU[5];		
+				inputSample += dV[5];		
+				inputSample += dW[5];		
+				inputSample += dX[5];		
+				inputSample += dY[5];		
+				inputSample += (dZ[5] * wetness);
+				
+				inputSample /= (26.0 + (wetness * 4.0));
+				//output Room effect
+				break;
+				
+				
+				
+				
+				
+				
+case 5:	//Stretch	
+				allpasstemp = alpA - 1;
+				if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;}
+				inputSample -= aA[allpasstemp]*constallpass;
+				aA[alpA] = inputSample;
+				inputSample *= constallpass;
+				alpA--; if (alpA < 0 || alpA > delayA) {alpA = delayA;}
+				inputSample += (aA[alpA]);
+				//allpass filter A		
+				
+				dA[2] = dA[1];
+				dA[1] = inputSample;
+				inputSample = (dA[1] + dA[2])/2.0;
+				
+				allpasstemp = alpB - 1;
+				if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;}
+				inputSample -= aB[allpasstemp]*constallpass;
+				aB[alpB] = inputSample;
+				inputSample *= constallpass;
+				alpB--; if (alpB < 0 || alpB > delayB) {alpB = delayB;}
+				inputSample += (aB[alpB]);
+				//allpass filter B
+				
+				dB[2] = dB[1];
+				dB[1] = inputSample;
+				inputSample = (dB[1] + dB[2])/2.0;
+				
+				allpasstemp = alpC - 1;
+				if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;}
+				inputSample -= aC[allpasstemp]*constallpass;
+				aC[alpC] = inputSample;
+				inputSample *= constallpass;
+				alpC--; if (alpC < 0 || alpC > delayC) {alpC = delayC;}
+				inputSample += (aC[alpC]);
+				//allpass filter C
+				
+				dC[2] = dC[1];
+				dC[1] = inputSample;
+				inputSample = (dC[1] + dC[2])/2.0;
+				
+				allpasstemp = alpD - 1;
+				if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;}
+				inputSample -= aD[allpasstemp]*constallpass;
+				aD[alpD] = inputSample;
+				inputSample *= constallpass;
+				alpD--; if (alpD < 0 || alpD > delayD) {alpD = delayD;}
+				inputSample += (aD[alpD]);
+				//allpass filter D
+				
+				dD[2] = dD[1];
+				dD[1] = inputSample;
+				inputSample = (dD[1] + dD[2])/2.0;
+				
+				allpasstemp = alpE - 1;
+				if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;}
+				inputSample -= aE[allpasstemp]*constallpass;
+				aE[alpE] = inputSample;
+				inputSample *= constallpass;
+				alpE--; if (alpE < 0 || alpE > delayE) {alpE = delayE;}
+				inputSample += (aE[alpE]);
+				//allpass filter E
+				
+				dE[2] = dE[1];
+				dE[1] = inputSample;
+				inputSample = (dE[1] + dE[2])/2.0;
+				
+				allpasstemp = alpF - 1;
+				if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;}
+				inputSample -= aF[allpasstemp]*constallpass;
+				aF[alpF] = inputSample;
+				inputSample *= constallpass;
+				alpF--; if (alpF < 0 || alpF > delayF) {alpF = delayF;}
+				inputSample += (aF[alpF]);
+				//allpass filter F
+				
+				dF[2] = dF[1];
+				dF[1] = inputSample;
+				inputSample = (dF[1] + dF[2])/2.0;
+				
+				allpasstemp = alpG - 1;
+				if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;}
+				inputSample -= aG[allpasstemp]*constallpass;
+				aG[alpG] = inputSample;
+				inputSample *= constallpass;
+				alpG--; if (alpG < 0 || alpG > delayG) {alpG = delayG;}
+				inputSample += (aG[alpG]);
+				//allpass filter G
+				
+				dG[2] = dG[1];
+				dG[1] = inputSample;
+				inputSample = (dG[1] + dG[2])/2.0;
+				
+				allpasstemp = alpH - 1;
+				if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;}
+				inputSample -= aH[allpasstemp]*constallpass;
+				aH[alpH] = inputSample;
+				inputSample *= constallpass;
+				alpH--; if (alpH < 0 || alpH > delayH) {alpH = delayH;}
+				inputSample += (aH[alpH]);
+				//allpass filter H
+				
+				dH[2] = dH[1];
+				dH[1] = inputSample;
+				inputSample = (dH[1] + dH[2])/2.0;
+				
+				allpasstemp = alpI - 1;
+				if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;}
+				inputSample -= aI[allpasstemp]*constallpass;
+				aI[alpI] = inputSample;
+				inputSample *= constallpass;
+				alpI--; if (alpI < 0 || alpI > delayI) {alpI = delayI;}
+				inputSample += (aI[alpI]);
+				//allpass filter I
+				
+				dI[2] = dI[1];
+				dI[1] = inputSample;
+				inputSample = (dI[1] + dI[2])/2.0;
+				
+				allpasstemp = alpJ - 1;
+				if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;}
+				inputSample -= aJ[allpasstemp]*constallpass;
+				aJ[alpJ] = inputSample;
+				inputSample *= constallpass;
+				alpJ--; if (alpJ < 0 || alpJ > delayJ) {alpJ = delayJ;}
+				inputSample += (aJ[alpJ]);
+				//allpass filter J
+				
+				dJ[2] = dJ[1];
+				dJ[1] = inputSample;
+				inputSample = (dJ[1] + dJ[2])/2.0;
+				
+				allpasstemp = alpK - 1;
+				if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;}
+				inputSample -= aK[allpasstemp]*constallpass;
+				aK[alpK] = inputSample;
+				inputSample *= constallpass;
+				alpK--; if (alpK < 0 || alpK > delayK) {alpK = delayK;}
+				inputSample += (aK[alpK]);
+				//allpass filter K
+				
+				dK[2] = dK[1];
+				dK[1] = inputSample;
+				inputSample = (dK[1] + dK[2])/2.0;
+				
+				allpasstemp = alpL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;}
+				inputSample -= aL[allpasstemp]*constallpass;
+				aL[alpL] = inputSample;
+				inputSample *= constallpass;
+				alpL--; if (alpL < 0 || alpL > delayL) {alpL = delayL;}
+				inputSample += (aL[alpL]);
+				//allpass filter L
+				
+				dL[2] = dL[1];
+				dL[1] = inputSample;
+				inputSample = (dL[1] + dL[2])/2.0;
+				
+				allpasstemp = alpM - 1;
+				if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;}
+				inputSample -= aM[allpasstemp]*constallpass;
+				aM[alpM] = inputSample;
+				inputSample *= constallpass;
+				alpM--; if (alpM < 0 || alpM > delayM) {alpM = delayM;}
+				inputSample += (aM[alpM]);
+				//allpass filter M
+				
+				dM[2] = dM[1];
+				dM[1] = inputSample;
+				inputSample = (dM[1] + dM[2])/2.0;
+				
+				allpasstemp = alpN - 1;
+				if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;}
+				inputSample -= aN[allpasstemp]*constallpass;
+				aN[alpN] = inputSample;
+				inputSample *= constallpass;
+				alpN--; if (alpN < 0 || alpN > delayN) {alpN = delayN;}
+				inputSample += (aN[alpN]);
+				//allpass filter N
+				
+				dN[2] = dN[1];
+				dN[1] = inputSample;
+				inputSample = (dN[1] + dN[2])/2.0;
+				
+				allpasstemp = alpO - 1;
+				if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;}
+				inputSample -= aO[allpasstemp]*constallpass;
+				aO[alpO] = inputSample;
+				inputSample *= constallpass;
+				alpO--; if (alpO < 0 || alpO > delayO) {alpO = delayO;}
+				inputSample += (aO[alpO]);
+				//allpass filter O
+				
+				dO[2] = dO[1];
+				dO[1] = inputSample;
+				inputSample = (dO[1] + dO[2])/2.0;
+				
+				allpasstemp = alpP - 1;
+				if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;}
+				inputSample -= aP[allpasstemp]*constallpass;
+				aP[alpP] = inputSample;
+				inputSample *= constallpass;
+				alpP--; if (alpP < 0 || alpP > delayP) {alpP = delayP;}
+				inputSample += (aP[alpP]);
+				//allpass filter P
+				
+				dP[2] = dP[1];
+				dP[1] = inputSample;
+				inputSample = (dP[1] + dP[2])/2.0;
+				
+				allpasstemp = alpQ - 1;
+				if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;}
+				inputSample -= aQ[allpasstemp]*constallpass;
+				aQ[alpQ] = inputSample;
+				inputSample *= constallpass;
+				alpQ--; if (alpQ < 0 || alpQ > delayQ) {alpQ = delayQ;}
+				inputSample += (aQ[alpQ]);
+				//allpass filter Q
+				
+				dQ[2] = dQ[1];
+				dQ[1] = inputSample;
+				inputSample = (dQ[1] + dQ[2])/2.0;
+				
+				allpasstemp = alpR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;}
+				inputSample -= aR[allpasstemp]*constallpass;
+				aR[alpR] = inputSample;
+				inputSample *= constallpass;
+				alpR--; if (alpR < 0 || alpR > delayR) {alpR = delayR;}
+				inputSample += (aR[alpR]);
+				//allpass filter R
+				
+				dR[2] = dR[1];
+				dR[1] = inputSample;
+				inputSample = (dR[1] + dR[2])/2.0;
+				
+				allpasstemp = alpS - 1;
+				if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;}
+				inputSample -= aS[allpasstemp]*constallpass;
+				aS[alpS] = inputSample;
+				inputSample *= constallpass;
+				alpS--; if (alpS < 0 || alpS > delayS) {alpS = delayS;}
+				inputSample += (aS[alpS]);
+				//allpass filter S
+				
+				dS[2] = dS[1];
+				dS[1] = inputSample;
+				inputSample = (dS[1] + dS[2])/2.0;
+				
+				allpasstemp = alpT - 1;
+				if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;}
+				inputSample -= aT[allpasstemp]*constallpass;
+				aT[alpT] = inputSample;
+				inputSample *= constallpass;
+				alpT--; if (alpT < 0 || alpT > delayT) {alpT = delayT;}
+				inputSample += (aT[alpT]);
+				//allpass filter T
+				
+				dT[2] = dT[1];
+				dT[1] = inputSample;
+				inputSample = (dT[1] + dT[2])/2.0;
+				
+				allpasstemp = alpU - 1;
+				if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;}
+				inputSample -= aU[allpasstemp]*constallpass;
+				aU[alpU] = inputSample;
+				inputSample *= constallpass;
+				alpU--; if (alpU < 0 || alpU > delayU) {alpU = delayU;}
+				inputSample += (aU[alpU]);
+				//allpass filter U
+				
+				dU[2] = dU[1];
+				dU[1] = inputSample;
+				inputSample = (dU[1] + dU[2])/2.0;
+				
+				allpasstemp = alpV - 1;
+				if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;}
+				inputSample -= aV[allpasstemp]*constallpass;
+				aV[alpV] = inputSample;
+				inputSample *= constallpass;
+				alpV--; if (alpV < 0 || alpV > delayV) {alpV = delayV;}
+				inputSample += (aV[alpV]);
+				//allpass filter V
+				
+				dV[2] = dV[1];
+				dV[1] = inputSample;
+				inputSample = (dV[1] + dV[2])/2.0;
+				
+				allpasstemp = alpW - 1;
+				if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;}
+				inputSample -= aW[allpasstemp]*constallpass;
+				aW[alpW] = inputSample;
+				inputSample *= constallpass;
+				alpW--; if (alpW < 0 || alpW > delayW) {alpW = delayW;}
+				inputSample += (aW[alpW]);
+				//allpass filter W
+				
+				dW[2] = dW[1];
+				dW[1] = inputSample;
+				inputSample = (dW[1] + dW[2])/2.0;
+				
+				allpasstemp = alpX - 1;
+				if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;}
+				inputSample -= aX[allpasstemp]*constallpass;
+				aX[alpX] = inputSample;
+				inputSample *= constallpass;
+				alpX--; if (alpX < 0 || alpX > delayX) {alpX = delayX;}
+				inputSample += (aX[alpX]);
+				//allpass filter X
+				
+				dX[2] = dX[1];
+				dX[1] = inputSample;
+				inputSample = (dX[1] + dX[2])/2.0;
+				
+				allpasstemp = alpY - 1;
+				if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;}
+				inputSample -= aY[allpasstemp]*constallpass;
+				aY[alpY] = inputSample;
+				inputSample *= constallpass;
+				alpY--; if (alpY < 0 || alpY > delayY) {alpY = delayY;}
+				inputSample += (aY[alpY]);
+				//allpass filter Y
+				
+				dY[2] = dY[1];
+				dY[1] = inputSample;
+				inputSample = (dY[1] + dY[2])/2.0;
+				
+				allpasstemp = alpZ - 1;
+				if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;}
+				inputSample -= aZ[allpasstemp]*constallpass;
+				aZ[alpZ] = inputSample;
+				inputSample *= constallpass;
+				alpZ--; if (alpZ < 0 || alpZ > delayZ) {alpZ = delayZ;}
+				inputSample += (aZ[alpZ]);
+				//allpass filter Z
+				
+				dZ[2] = dZ[1];
+				dZ[1] = inputSample;
+				inputSample = (dZ[1] + dZ[2])/2.0;
+				
+				// now the second stage using the 'out' bank of allpasses		
+				
+				allpasstemp = outA - 1;
+				if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;}
+				inputSample -= oA[allpasstemp]*constallpass;
+				oA[outA] = inputSample;
+				inputSample *= constallpass;
+				outA--; if (outA < 0 || outA > delayA) {outA = delayA;}
+				inputSample += (oA[outA]);
+				//allpass filter A		
+				
+				dA[5] = dA[4];
+				dA[4] = inputSample;
+				inputSample = (dA[4] + dA[5])/2.0;
+				
+				allpasstemp = outB - 1;
+				if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;}
+				inputSample -= oB[allpasstemp]*constallpass;
+				oB[outB] = inputSample;
+				inputSample *= constallpass;
+				outB--; if (outB < 0 || outB > delayB) {outB = delayB;}
+				inputSample += (oB[outB]);
+				//allpass filter B
+				
+				dB[5] = dB[4];
+				dB[4] = inputSample;
+				inputSample = (dB[4] + dB[5])/2.0;
+				
+				allpasstemp = outC - 1;
+				if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;}
+				inputSample -= oC[allpasstemp]*constallpass;
+				oC[outC] = inputSample;
+				inputSample *= constallpass;
+				outC--; if (outC < 0 || outC > delayC) {outC = delayC;}
+				inputSample += (oC[outC]);
+				//allpass filter C
+				
+				dC[5] = dC[4];
+				dC[4] = inputSample;
+				inputSample = (dC[4] + dC[5])/2.0;
+				
+				allpasstemp = outD - 1;
+				if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;}
+				inputSample -= oD[allpasstemp]*constallpass;
+				oD[outD] = inputSample;
+				inputSample *= constallpass;
+				outD--; if (outD < 0 || outD > delayD) {outD = delayD;}
+				inputSample += (oD[outD]);
+				//allpass filter D
+				
+				dD[5] = dD[4];
+				dD[4] = inputSample;
+				inputSample = (dD[4] + dD[5])/2.0;
+				
+				allpasstemp = outE - 1;
+				if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;}
+				inputSample -= oE[allpasstemp]*constallpass;
+				oE[outE] = inputSample;
+				inputSample *= constallpass;
+				outE--; if (outE < 0 || outE > delayE) {outE = delayE;}
+				inputSample += (oE[outE]);
+				//allpass filter E
+				
+				dE[5] = dE[4];
+				dE[4] = inputSample;
+				inputSample = (dE[4] + dE[5])/2.0;
+				
+				allpasstemp = outF - 1;
+				if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;}
+				inputSample -= oF[allpasstemp]*constallpass;
+				oF[outF] = inputSample;
+				inputSample *= constallpass;
+				outF--; if (outF < 0 || outF > delayF) {outF = delayF;}
+				inputSample += (oF[outF]);
+				//allpass filter F
+				
+				dF[5] = dF[4];
+				dF[4] = inputSample;
+				inputSample = (dF[4] + dF[5])/2.0;
+				
+				allpasstemp = outG - 1;
+				if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;}
+				inputSample -= oG[allpasstemp]*constallpass;
+				oG[outG] = inputSample;
+				inputSample *= constallpass;
+				outG--; if (outG < 0 || outG > delayG) {outG = delayG;}
+				inputSample += (oG[outG]);
+				//allpass filter G
+				
+				dG[5] = dG[4];
+				dG[4] = inputSample;
+				inputSample = (dG[4] + dG[5])/2.0;
+				
+				allpasstemp = outH - 1;
+				if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;}
+				inputSample -= oH[allpasstemp]*constallpass;
+				oH[outH] = inputSample;
+				inputSample *= constallpass;
+				outH--; if (outH < 0 || outH > delayH) {outH = delayH;}
+				inputSample += (oH[outH]);
+				//allpass filter H
+				
+				dH[5] = dH[4];
+				dH[4] = inputSample;
+				inputSample = (dH[4] + dH[5])/2.0;
+				
+				allpasstemp = outI - 1;
+				if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;}
+				inputSample -= oI[allpasstemp]*constallpass;
+				oI[outI] = inputSample;
+				inputSample *= constallpass;
+				outI--; if (outI < 0 || outI > delayI) {outI = delayI;}
+				inputSample += (oI[outI]);
+				//allpass filter I
+				
+				dI[5] = dI[4];
+				dI[4] = inputSample;
+				inputSample = (dI[4] + dI[5])/2.0;
+				
+				allpasstemp = outJ - 1;
+				if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;}
+				inputSample -= oJ[allpasstemp]*constallpass;
+				oJ[outJ] = inputSample;
+				inputSample *= constallpass;
+				outJ--; if (outJ < 0 || outJ > delayJ) {outJ = delayJ;}
+				inputSample += (oJ[outJ]);
+				//allpass filter J
+				
+				dJ[5] = dJ[4];
+				dJ[4] = inputSample;
+				inputSample = (dJ[4] + dJ[5])/2.0;
+				
+				allpasstemp = outK - 1;
+				if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;}
+				inputSample -= oK[allpasstemp]*constallpass;
+				oK[outK] = inputSample;
+				inputSample *= constallpass;
+				outK--; if (outK < 0 || outK > delayK) {outK = delayK;}
+				inputSample += (oK[outK]);
+				//allpass filter K
+				
+				dK[5] = dK[4];
+				dK[4] = inputSample;
+				inputSample = (dK[4] + dK[5])/2.0;
+				
+				allpasstemp = outL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;}
+				inputSample -= oL[allpasstemp]*constallpass;
+				oL[outL] = inputSample;
+				inputSample *= constallpass;
+				outL--; if (outL < 0 || outL > delayL) {outL = delayL;}
+				inputSample += (oL[outL]);
+				//allpass filter L
+				
+				dL[5] = dL[4];
+				dL[4] = inputSample;
+				inputSample = (dL[4] + dL[5])/2.0;
+				
+				allpasstemp = outM - 1;
+				if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;}
+				inputSample -= oM[allpasstemp]*constallpass;
+				oM[outM] = inputSample;
+				inputSample *= constallpass;
+				outM--; if (outM < 0 || outM > delayM) {outM = delayM;}
+				inputSample += (oM[outM]);
+				//allpass filter M
+				
+				dM[5] = dM[4];
+				dM[4] = inputSample;
+				inputSample = (dM[4] + dM[5])/2.0;
+				
+				allpasstemp = outN - 1;
+				if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;}
+				inputSample -= oN[allpasstemp]*constallpass;
+				oN[outN] = inputSample;
+				inputSample *= constallpass;
+				outN--; if (outN < 0 || outN > delayN) {outN = delayN;}
+				inputSample += (oN[outN]);
+				//allpass filter N
+				
+				dN[5] = dN[4];
+				dN[4] = inputSample;
+				inputSample = (dN[4] + dN[5])/2.0;
+				
+				allpasstemp = outO - 1;
+				if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;}
+				inputSample -= oO[allpasstemp]*constallpass;
+				oO[outO] = inputSample;
+				inputSample *= constallpass;
+				outO--; if (outO < 0 || outO > delayO) {outO = delayO;}
+				inputSample += (oO[outO]);
+				//allpass filter O
+				
+				dO[5] = dO[4];
+				dO[4] = inputSample;
+				inputSample = (dO[4] + dO[5])/2.0;
+				
+				allpasstemp = outP - 1;
+				if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;}
+				inputSample -= oP[allpasstemp]*constallpass;
+				oP[outP] = inputSample;
+				inputSample *= constallpass;
+				outP--; if (outP < 0 || outP > delayP) {outP = delayP;}
+				inputSample += (oP[outP]);
+				//allpass filter P
+				
+				dP[5] = dP[4];
+				dP[4] = inputSample;
+				inputSample = (dP[4] + dP[5])/2.0;
+				
+				allpasstemp = outQ - 1;
+				if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;}
+				inputSample -= oQ[allpasstemp]*constallpass;
+				oQ[outQ] = inputSample;
+				inputSample *= constallpass;
+				outQ--; if (outQ < 0 || outQ > delayQ) {outQ = delayQ;}
+				inputSample += (oQ[outQ]);
+				//allpass filter Q
+				
+				dQ[5] = dQ[4];
+				dQ[4] = inputSample;
+				inputSample = (dQ[4] + dQ[5])/2.0;
+				
+				allpasstemp = outR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;}
+				inputSample -= oR[allpasstemp]*constallpass;
+				oR[outR] = inputSample;
+				inputSample *= constallpass;
+				outR--; if (outR < 0 || outR > delayR) {outR = delayR;}
+				inputSample += (oR[outR]);
+				//allpass filter R
+				
+				dR[5] = dR[4];
+				dR[4] = inputSample;
+				inputSample = (dR[4] + dR[5])/2.0;
+				
+				allpasstemp = outS - 1;
+				if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;}
+				inputSample -= oS[allpasstemp]*constallpass;
+				oS[outS] = inputSample;
+				inputSample *= constallpass;
+				outS--; if (outS < 0 || outS > delayS) {outS = delayS;}
+				inputSample += (oS[outS]);
+				//allpass filter S
+				
+				dS[5] = dS[4];
+				dS[4] = inputSample;
+				inputSample = (dS[4] + dS[5])/2.0;
+				
+				allpasstemp = outT - 1;
+				if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;}
+				inputSample -= oT[allpasstemp]*constallpass;
+				oT[outT] = inputSample;
+				inputSample *= constallpass;
+				outT--; if (outT < 0 || outT > delayT) {outT = delayT;}
+				inputSample += (oT[outT]);
+				//allpass filter T
+				
+				dT[5] = dT[4];
+				dT[4] = inputSample;
+				inputSample = (dT[4] + dT[5])/2.0;
+				
+				allpasstemp = outU - 1;
+				if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;}
+				inputSample -= oU[allpasstemp]*constallpass;
+				oU[outU] = inputSample;
+				inputSample *= constallpass;
+				outU--; if (outU < 0 || outU > delayU) {outU = delayU;}
+				inputSample += (oU[outU]);
+				//allpass filter U
+				
+				dU[5] = dU[4];
+				dU[4] = inputSample;
+				inputSample = (dU[4] + dU[5])/2.0;
+				
+				allpasstemp = outV - 1;
+				if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;}
+				inputSample -= oV[allpasstemp]*constallpass;
+				oV[outV] = inputSample;
+				inputSample *= constallpass;
+				outV--; if (outV < 0 || outV > delayV) {outV = delayV;}
+				inputSample += (oV[outV]);
+				//allpass filter V
+				
+				dV[5] = dV[4];
+				dV[4] = inputSample;
+				inputSample = (dV[4] + dV[5])/2.0;
+				
+				allpasstemp = outW - 1;
+				if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;}
+				inputSample -= oW[allpasstemp]*constallpass;
+				oW[outW] = inputSample;
+				inputSample *= constallpass;
+				outW--; if (outW < 0 || outW > delayW) {outW = delayW;}
+				inputSample += (oW[outW]);
+				//allpass filter W
+				
+				dW[5] = dW[4];
+				dW[4] = inputSample;
+				inputSample = (dW[4] + dW[5])/2.0;
+				
+				allpasstemp = outX - 1;
+				if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;}
+				inputSample -= oX[allpasstemp]*constallpass;
+				oX[outX] = inputSample;
+				inputSample *= constallpass;
+				outX--; if (outX < 0 || outX > delayX) {outX = delayX;}
+				inputSample += (oX[outX]);
+				//allpass filter X
+				
+				dX[5] = dX[4];
+				dX[4] = inputSample;
+				inputSample = (dX[4] + dX[5])/2.0;
+				
+				allpasstemp = outY - 1;
+				if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;}
+				inputSample -= oY[allpasstemp]*constallpass;
+				oY[outY] = inputSample;
+				inputSample *= constallpass;
+				outY--; if (outY < 0 || outY > delayY) {outY = delayY;}
+				inputSample += (oY[outY]);
+				//allpass filter Y
+				
+				dY[5] = dY[4];
+				dY[4] = inputSample;
+				inputSample = (dY[4] + dY[5])/2.0;
+				
+				allpasstemp = outZ - 1;
+				if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;}
+				inputSample -= oZ[allpasstemp]*constallpass;
+				oZ[outZ] = inputSample;
+				inputSample *= constallpass;
+				outZ--; if (outZ < 0 || outZ > delayZ) {outZ = delayZ;}
+				inputSample += (oZ[outZ]);
+				//allpass filter Z
+				
+				dZ[5] = dZ[4];
+				dZ[4] = inputSample;
+				inputSample = (dZ[4] + dZ[5])/2.0;		
+				//output Stretch unrealistic but smooth fake Paulstretch
+				break;				
+				
+			
+case 6:	//Zarathustra	
+				allpasstemp = alpA - 1;
+				if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;}
+				inputSample -= aA[allpasstemp]*constallpass;
+				aA[alpA] = inputSample;
+				inputSample *= constallpass;
+				alpA--; if (alpA < 0 || alpA > delayA) {alpA = delayA;}
+				inputSample += (aA[alpA]);
+				//allpass filter A		
+				
+				dA[3] = dA[2];
+				dA[2] = dA[1];
+				dA[1] = inputSample;
+				inputSample = (dA[1] + dA[2] + dZ[3])/3.0; //add feedback
+				
+				allpasstemp = alpB - 1;
+				if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;}
+				inputSample -= aB[allpasstemp]*constallpass;
+				aB[alpB] = inputSample;
+				inputSample *= constallpass;
+				alpB--; if (alpB < 0 || alpB > delayB) {alpB = delayB;}
+				inputSample += (aB[alpB]);
+				//allpass filter B
+				
+				dB[3] = dB[2];
+				dB[2] = dB[1];
+				dB[1] = inputSample;
+				inputSample = (dB[1] + dB[2] + dB[3])/3.0;
+				
+				allpasstemp = alpC - 1;
+				if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;}
+				inputSample -= aC[allpasstemp]*constallpass;
+				aC[alpC] = inputSample;
+				inputSample *= constallpass;
+				alpC--; if (alpC < 0 || alpC > delayC) {alpC = delayC;}
+				inputSample += (aC[alpC]);
+				//allpass filter C
+				
+				dC[3] = dC[2];
+				dC[2] = dC[1];
+				dC[1] = inputSample;
+				inputSample = (dC[1] + dC[2] + dC[3])/3.0;
+				
+				allpasstemp = alpD - 1;
+				if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;}
+				inputSample -= aD[allpasstemp]*constallpass;
+				aD[alpD] = inputSample;
+				inputSample *= constallpass;
+				alpD--; if (alpD < 0 || alpD > delayD) {alpD = delayD;}
+				inputSample += (aD[alpD]);
+				//allpass filter D
+				
+				dD[3] = dD[2];
+				dD[2] = dD[1];
+				dD[1] = inputSample;
+				inputSample = (dD[1] + dD[2] + dD[3])/3.0;
+				
+				allpasstemp = alpE - 1;
+				if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;}
+				inputSample -= aE[allpasstemp]*constallpass;
+				aE[alpE] = inputSample;
+				inputSample *= constallpass;
+				alpE--; if (alpE < 0 || alpE > delayE) {alpE = delayE;}
+				inputSample += (aE[alpE]);
+				//allpass filter E
+				
+				dE[3] = dE[2];
+				dE[2] = dE[1];
+				dE[1] = inputSample;
+				inputSample = (dE[1] + dE[2] + dE[3])/3.0;
+				
+				allpasstemp = alpF - 1;
+				if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;}
+				inputSample -= aF[allpasstemp]*constallpass;
+				aF[alpF] = inputSample;
+				inputSample *= constallpass;
+				alpF--; if (alpF < 0 || alpF > delayF) {alpF = delayF;}
+				inputSample += (aF[alpF]);
+				//allpass filter F
+				
+				dF[3] = dF[2];
+				dF[2] = dF[1];
+				dF[1] = inputSample;
+				inputSample = (dF[1] + dF[2] + dF[3])/3.0;
+				
+				allpasstemp = alpG - 1;
+				if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;}
+				inputSample -= aG[allpasstemp]*constallpass;
+				aG[alpG] = inputSample;
+				inputSample *= constallpass;
+				alpG--; if (alpG < 0 || alpG > delayG) {alpG = delayG;}
+				inputSample += (aG[alpG]);
+				//allpass filter G
+				
+				dG[3] = dG[2];
+				dG[2] = dG[1];
+				dG[1] = inputSample;
+				inputSample = (dG[1] + dG[2] + dG[3])/3.0;
+				
+				allpasstemp = alpH - 1;
+				if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;}
+				inputSample -= aH[allpasstemp]*constallpass;
+				aH[alpH] = inputSample;
+				inputSample *= constallpass;
+				alpH--; if (alpH < 0 || alpH > delayH) {alpH = delayH;}
+				inputSample += (aH[alpH]);
+				//allpass filter H
+				
+				dH[3] = dH[2];
+				dH[2] = dH[1];
+				dH[1] = inputSample;
+				inputSample = (dH[1] + dH[2] + dH[3])/3.0;
+				
+				allpasstemp = alpI - 1;
+				if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;}
+				inputSample -= aI[allpasstemp]*constallpass;
+				aI[alpI] = inputSample;
+				inputSample *= constallpass;
+				alpI--; if (alpI < 0 || alpI > delayI) {alpI = delayI;}
+				inputSample += (aI[alpI]);
+				//allpass filter I
+				
+				dI[3] = dI[2];
+				dI[2] = dI[1];
+				dI[1] = inputSample;
+				inputSample = (dI[1] + dI[2] + dI[3])/3.0;
+				
+				allpasstemp = alpJ - 1;
+				if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;}
+				inputSample -= aJ[allpasstemp]*constallpass;
+				aJ[alpJ] = inputSample;
+				inputSample *= constallpass;
+				alpJ--; if (alpJ < 0 || alpJ > delayJ) {alpJ = delayJ;}
+				inputSample += (aJ[alpJ]);
+				//allpass filter J
+				
+				dJ[3] = dJ[2];
+				dJ[2] = dJ[1];
+				dJ[1] = inputSample;
+				inputSample = (dJ[1] + dJ[2] + dJ[3])/3.0;
+				
+				allpasstemp = alpK - 1;
+				if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;}
+				inputSample -= aK[allpasstemp]*constallpass;
+				aK[alpK] = inputSample;
+				inputSample *= constallpass;
+				alpK--; if (alpK < 0 || alpK > delayK) {alpK = delayK;}
+				inputSample += (aK[alpK]);
+				//allpass filter K
+				
+				dK[3] = dK[2];
+				dK[2] = dK[1];
+				dK[1] = inputSample;
+				inputSample = (dK[1] + dK[2] + dK[3])/3.0;
+				
+				allpasstemp = alpL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;}
+				inputSample -= aL[allpasstemp]*constallpass;
+				aL[alpL] = inputSample;
+				inputSample *= constallpass;
+				alpL--; if (alpL < 0 || alpL > delayL) {alpL = delayL;}
+				inputSample += (aL[alpL]);
+				//allpass filter L
+				
+				dL[3] = dL[2];
+				dL[2] = dL[1];
+				dL[1] = inputSample;
+				inputSample = (dL[1] + dL[2] + dL[3])/3.0;
+				
+				allpasstemp = alpM - 1;
+				if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;}
+				inputSample -= aM[allpasstemp]*constallpass;
+				aM[alpM] = inputSample;
+				inputSample *= constallpass;
+				alpM--; if (alpM < 0 || alpM > delayM) {alpM = delayM;}
+				inputSample += (aM[alpM]);
+				//allpass filter M
+				
+				dM[3] = dM[2];
+				dM[2] = dM[1];
+				dM[1] = inputSample;
+				inputSample = (dM[1] + dM[2] + dM[3])/3.0;
+				
+				allpasstemp = alpN - 1;
+				if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;}
+				inputSample -= aN[allpasstemp]*constallpass;
+				aN[alpN] = inputSample;
+				inputSample *= constallpass;
+				alpN--; if (alpN < 0 || alpN > delayN) {alpN = delayN;}
+				inputSample += (aN[alpN]);
+				//allpass filter N
+				
+				dN[3] = dN[2];
+				dN[2] = dN[1];
+				dN[1] = inputSample;
+				inputSample = (dN[1] + dN[2] + dN[3])/3.0;
+				
+				allpasstemp = alpO - 1;
+				if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;}
+				inputSample -= aO[allpasstemp]*constallpass;
+				aO[alpO] = inputSample;
+				inputSample *= constallpass;
+				alpO--; if (alpO < 0 || alpO > delayO) {alpO = delayO;}
+				inputSample += (aO[alpO]);
+				//allpass filter O
+				
+				dO[3] = dO[2];
+				dO[2] = dO[1];
+				dO[1] = inputSample;
+				inputSample = (dO[1] + dO[2] + dO[3])/3.0;
+				
+				allpasstemp = alpP - 1;
+				if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;}
+				inputSample -= aP[allpasstemp]*constallpass;
+				aP[alpP] = inputSample;
+				inputSample *= constallpass;
+				alpP--; if (alpP < 0 || alpP > delayP) {alpP = delayP;}
+				inputSample += (aP[alpP]);
+				//allpass filter P
+				
+				dP[3] = dP[2];
+				dP[2] = dP[1];
+				dP[1] = inputSample;
+				inputSample = (dP[1] + dP[2] + dP[3])/3.0;
+				
+				allpasstemp = alpQ - 1;
+				if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;}
+				inputSample -= aQ[allpasstemp]*constallpass;
+				aQ[alpQ] = inputSample;
+				inputSample *= constallpass;
+				alpQ--; if (alpQ < 0 || alpQ > delayQ) {alpQ = delayQ;}
+				inputSample += (aQ[alpQ]);
+				//allpass filter Q
+				
+				dQ[3] = dQ[2];
+				dQ[2] = dQ[1];
+				dQ[1] = inputSample;
+				inputSample = (dQ[1] + dQ[2] + dQ[3])/3.0;
+				
+				allpasstemp = alpR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;}
+				inputSample -= aR[allpasstemp]*constallpass;
+				aR[alpR] = inputSample;
+				inputSample *= constallpass;
+				alpR--; if (alpR < 0 || alpR > delayR) {alpR = delayR;}
+				inputSample += (aR[alpR]);
+				//allpass filter R
+				
+				dR[3] = dR[2];
+				dR[2] = dR[1];
+				dR[1] = inputSample;
+				inputSample = (dR[1] + dR[2] + dR[3])/3.0;
+				
+				allpasstemp = alpS - 1;
+				if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;}
+				inputSample -= aS[allpasstemp]*constallpass;
+				aS[alpS] = inputSample;
+				inputSample *= constallpass;
+				alpS--; if (alpS < 0 || alpS > delayS) {alpS = delayS;}
+				inputSample += (aS[alpS]);
+				//allpass filter S
+				
+				dS[3] = dS[2];
+				dS[2] = dS[1];
+				dS[1] = inputSample;
+				inputSample = (dS[1] + dS[2] + dS[3])/3.0;
+				
+				allpasstemp = alpT - 1;
+				if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;}
+				inputSample -= aT[allpasstemp]*constallpass;
+				aT[alpT] = inputSample;
+				inputSample *= constallpass;
+				alpT--; if (alpT < 0 || alpT > delayT) {alpT = delayT;}
+				inputSample += (aT[alpT]);
+				//allpass filter T
+				
+				dT[3] = dT[2];
+				dT[2] = dT[1];
+				dT[1] = inputSample;
+				inputSample = (dT[1] + dT[2] + dT[3])/3.0;
+				
+				allpasstemp = alpU - 1;
+				if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;}
+				inputSample -= aU[allpasstemp]*constallpass;
+				aU[alpU] = inputSample;
+				inputSample *= constallpass;
+				alpU--; if (alpU < 0 || alpU > delayU) {alpU = delayU;}
+				inputSample += (aU[alpU]);
+				//allpass filter U
+				
+				dU[3] = dU[2];
+				dU[2] = dU[1];
+				dU[1] = inputSample;
+				inputSample = (dU[1] + dU[2] + dU[3])/3.0;
+				
+				allpasstemp = alpV - 1;
+				if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;}
+				inputSample -= aV[allpasstemp]*constallpass;
+				aV[alpV] = inputSample;
+				inputSample *= constallpass;
+				alpV--; if (alpV < 0 || alpV > delayV) {alpV = delayV;}
+				inputSample += (aV[alpV]);
+				//allpass filter V
+				
+				dV[3] = dV[2];
+				dV[2] = dV[1];
+				dV[1] = inputSample;
+				inputSample = (dV[1] + dV[2] + dV[3])/3.0;
+				
+				allpasstemp = alpW - 1;
+				if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;}
+				inputSample -= aW[allpasstemp]*constallpass;
+				aW[alpW] = inputSample;
+				inputSample *= constallpass;
+				alpW--; if (alpW < 0 || alpW > delayW) {alpW = delayW;}
+				inputSample += (aW[alpW]);
+				//allpass filter W
+				
+				dW[3] = dW[2];
+				dW[2] = dW[1];
+				dW[1] = inputSample;
+				inputSample = (dW[1] + dW[2] + dW[3])/3.0;
+				
+				allpasstemp = alpX - 1;
+				if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;}
+				inputSample -= aX[allpasstemp]*constallpass;
+				aX[alpX] = inputSample;
+				inputSample *= constallpass;
+				alpX--; if (alpX < 0 || alpX > delayX) {alpX = delayX;}
+				inputSample += (aX[alpX]);
+				//allpass filter X
+				
+				dX[3] = dX[2];
+				dX[2] = dX[1];
+				dX[1] = inputSample;
+				inputSample = (dX[1] + dX[2] + dX[3])/3.0;
+				
+				allpasstemp = alpY - 1;
+				if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;}
+				inputSample -= aY[allpasstemp]*constallpass;
+				aY[alpY] = inputSample;
+				inputSample *= constallpass;
+				alpY--; if (alpY < 0 || alpY > delayY) {alpY = delayY;}
+				inputSample += (aY[alpY]);
+				//allpass filter Y
+				
+				dY[3] = dY[2];
+				dY[2] = dY[1];
+				dY[1] = inputSample;
+				inputSample = (dY[1] + dY[2] + dY[3])/3.0;
+				
+				allpasstemp = alpZ - 1;
+				if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;}
+				inputSample -= aZ[allpasstemp]*constallpass;
+				aZ[alpZ] = inputSample;
+				inputSample *= constallpass;
+				alpZ--; if (alpZ < 0 || alpZ > delayZ) {alpZ = delayZ;}
+				inputSample += (aZ[alpZ]);
+				//allpass filter Z
+				
+				dZ[3] = dZ[2];
+				dZ[2] = dZ[1];
+				dZ[1] = inputSample;
+				inputSample = (dZ[1] + dZ[2] + dZ[3])/3.0;
+				
+				// now the second stage using the 'out' bank of allpasses		
+				
+				allpasstemp = outA - 1;
+				if (allpasstemp < 0 || allpasstemp > delayA) {allpasstemp = delayA;}
+				inputSample -= oA[allpasstemp]*constallpass;
+				oA[outA] = inputSample;
+				inputSample *= constallpass;
+				outA--; if (outA < 0 || outA > delayA) {outA = delayA;}
+				inputSample += (oA[outA]);
+				//allpass filter A		
+				
+				dA[6] = dA[5];
+				dA[5] = dA[4];
+				dA[4] = inputSample;
+				inputSample = (dC[1] + dA[5] + dA[6])/3.0;  //note, feeding in dry again for a little more clarity!
+				
+				allpasstemp = outB - 1;
+				if (allpasstemp < 0 || allpasstemp > delayB) {allpasstemp = delayB;}
+				inputSample -= oB[allpasstemp]*constallpass;
+				oB[outB] = inputSample;
+				inputSample *= constallpass;
+				outB--; if (outB < 0 || outB > delayB) {outB = delayB;}
+				inputSample += (oB[outB]);
+				//allpass filter B
+				
+				dB[6] = dB[5];
+				dB[5] = dB[4];
+				dB[4] = inputSample;
+				inputSample = (dB[4] + dB[5] + dB[6])/3.0;
+				
+				allpasstemp = outC - 1;
+				if (allpasstemp < 0 || allpasstemp > delayC) {allpasstemp = delayC;}
+				inputSample -= oC[allpasstemp]*constallpass;
+				oC[outC] = inputSample;
+				inputSample *= constallpass;
+				outC--; if (outC < 0 || outC > delayC) {outC = delayC;}
+				inputSample += (oC[outC]);
+				//allpass filter C
+				
+				dC[6] = dC[5];
+				dC[5] = dC[4];
+				dC[4] = inputSample;
+				inputSample = (dC[4] + dC[5] + dC[6])/3.0;
+				
+				allpasstemp = outD - 1;
+				if (allpasstemp < 0 || allpasstemp > delayD) {allpasstemp = delayD;}
+				inputSample -= oD[allpasstemp]*constallpass;
+				oD[outD] = inputSample;
+				inputSample *= constallpass;
+				outD--; if (outD < 0 || outD > delayD) {outD = delayD;}
+				inputSample += (oD[outD]);
+				//allpass filter D
+				
+				dD[6] = dD[5];
+				dD[5] = dD[4];
+				dD[4] = inputSample;
+				inputSample = (dD[4] + dD[5] + dD[6])/3.0;
+				
+				allpasstemp = outE - 1;
+				if (allpasstemp < 0 || allpasstemp > delayE) {allpasstemp = delayE;}
+				inputSample -= oE[allpasstemp]*constallpass;
+				oE[outE] = inputSample;
+				inputSample *= constallpass;
+				outE--; if (outE < 0 || outE > delayE) {outE = delayE;}
+				inputSample += (oE[outE]);
+				//allpass filter E
+				
+				dE[6] = dE[5];
+				dE[5] = dE[4];
+				dE[4] = inputSample;
+				inputSample = (dE[4] + dE[5] + dE[6])/3.0;
+				
+				allpasstemp = outF - 1;
+				if (allpasstemp < 0 || allpasstemp > delayF) {allpasstemp = delayF;}
+				inputSample -= oF[allpasstemp]*constallpass;
+				oF[outF] = inputSample;
+				inputSample *= constallpass;
+				outF--; if (outF < 0 || outF > delayF) {outF = delayF;}
+				inputSample += (oF[outF]);
+				//allpass filter F
+				
+				dF[6] = dF[5];
+				dF[5] = dF[4];
+				dF[4] = inputSample;
+				inputSample = (dF[4] + dF[5] + dF[6])/3.0;
+				
+				allpasstemp = outG - 1;
+				if (allpasstemp < 0 || allpasstemp > delayG) {allpasstemp = delayG;}
+				inputSample -= oG[allpasstemp]*constallpass;
+				oG[outG] = inputSample;
+				inputSample *= constallpass;
+				outG--; if (outG < 0 || outG > delayG) {outG = delayG;}
+				inputSample += (oG[outG]);
+				//allpass filter G
+				
+				dG[6] = dG[5];
+				dG[5] = dG[4];
+				dG[4] = inputSample;
+				inputSample = (dG[4] + dG[5] + dG[6])/3.0;
+				
+				allpasstemp = outH - 1;
+				if (allpasstemp < 0 || allpasstemp > delayH) {allpasstemp = delayH;}
+				inputSample -= oH[allpasstemp]*constallpass;
+				oH[outH] = inputSample;
+				inputSample *= constallpass;
+				outH--; if (outH < 0 || outH > delayH) {outH = delayH;}
+				inputSample += (oH[outH]);
+				//allpass filter H
+				
+				dH[6] = dH[5];
+				dH[5] = dH[4];
+				dH[4] = inputSample;
+				inputSample = (dH[4] + dH[5] + dH[6])/3.0;
+				
+				allpasstemp = outI - 1;
+				if (allpasstemp < 0 || allpasstemp > delayI) {allpasstemp = delayI;}
+				inputSample -= oI[allpasstemp]*constallpass;
+				oI[outI] = inputSample;
+				inputSample *= constallpass;
+				outI--; if (outI < 0 || outI > delayI) {outI = delayI;}
+				inputSample += (oI[outI]);
+				//allpass filter I
+				
+				dI[6] = dI[5];
+				dI[5] = dI[4];
+				dI[4] = inputSample;
+				inputSample = (dI[4] + dI[5] + dI[6])/3.0;
+				
+				allpasstemp = outJ - 1;
+				if (allpasstemp < 0 || allpasstemp > delayJ) {allpasstemp = delayJ;}
+				inputSample -= oJ[allpasstemp]*constallpass;
+				oJ[outJ] = inputSample;
+				inputSample *= constallpass;
+				outJ--; if (outJ < 0 || outJ > delayJ) {outJ = delayJ;}
+				inputSample += (oJ[outJ]);
+				//allpass filter J
+				
+				dJ[6] = dJ[5];
+				dJ[5] = dJ[4];
+				dJ[4] = inputSample;
+				inputSample = (dJ[4] + dJ[5] + dJ[6])/3.0;
+				
+				allpasstemp = outK - 1;
+				if (allpasstemp < 0 || allpasstemp > delayK) {allpasstemp = delayK;}
+				inputSample -= oK[allpasstemp]*constallpass;
+				oK[outK] = inputSample;
+				inputSample *= constallpass;
+				outK--; if (outK < 0 || outK > delayK) {outK = delayK;}
+				inputSample += (oK[outK]);
+				//allpass filter K
+				
+				dK[6] = dK[5];
+				dK[5] = dK[4];
+				dK[4] = inputSample;
+				inputSample = (dK[4] + dK[5] + dK[6])/3.0;
+				
+				allpasstemp = outL - 1;
+				if (allpasstemp < 0 || allpasstemp > delayL) {allpasstemp = delayL;}
+				inputSample -= oL[allpasstemp]*constallpass;
+				oL[outL] = inputSample;
+				inputSample *= constallpass;
+				outL--; if (outL < 0 || outL > delayL) {outL = delayL;}
+				inputSample += (oL[outL]);
+				//allpass filter L
+				
+				dL[6] = dL[5];
+				dL[5] = dL[4];
+				dL[4] = inputSample;
+				inputSample = (dL[4] + dL[5] + dL[6])/3.0;
+				
+				allpasstemp = outM - 1;
+				if (allpasstemp < 0 || allpasstemp > delayM) {allpasstemp = delayM;}
+				inputSample -= oM[allpasstemp]*constallpass;
+				oM[outM] = inputSample;
+				inputSample *= constallpass;
+				outM--; if (outM < 0 || outM > delayM) {outM = delayM;}
+				inputSample += (oM[outM]);
+				//allpass filter M
+				
+				dM[6] = dM[5];
+				dM[5] = dM[4];
+				dM[4] = inputSample;
+				inputSample = (dM[4] + dM[5] + dM[6])/3.0;
+				
+				allpasstemp = outN - 1;
+				if (allpasstemp < 0 || allpasstemp > delayN) {allpasstemp = delayN;}
+				inputSample -= oN[allpasstemp]*constallpass;
+				oN[outN] = inputSample;
+				inputSample *= constallpass;
+				outN--; if (outN < 0 || outN > delayN) {outN = delayN;}
+				inputSample += (oN[outN]);
+				//allpass filter N
+				
+				dN[6] = dN[5];
+				dN[5] = dN[4];
+				dN[4] = inputSample;
+				inputSample = (dN[4] + dN[5] + dN[6])/3.0;
+				
+				allpasstemp = outO - 1;
+				if (allpasstemp < 0 || allpasstemp > delayO) {allpasstemp = delayO;}
+				inputSample -= oO[allpasstemp]*constallpass;
+				oO[outO] = inputSample;
+				inputSample *= constallpass;
+				outO--; if (outO < 0 || outO > delayO) {outO = delayO;}
+				inputSample += (oO[outO]);
+				//allpass filter O
+				
+				dO[6] = dO[5];
+				dO[5] = dO[4];
+				dO[4] = inputSample;
+				inputSample = (dO[4] + dO[5] + dO[6])/3.0;
+				
+				allpasstemp = outP - 1;
+				if (allpasstemp < 0 || allpasstemp > delayP) {allpasstemp = delayP;}
+				inputSample -= oP[allpasstemp]*constallpass;
+				oP[outP] = inputSample;
+				inputSample *= constallpass;
+				outP--; if (outP < 0 || outP > delayP) {outP = delayP;}
+				inputSample += (oP[outP]);
+				//allpass filter P
+				
+				dP[6] = dP[5];
+				dP[5] = dP[4];
+				dP[4] = inputSample;
+				inputSample = (dP[4] + dP[5] + dP[6])/3.0;
+				
+				allpasstemp = outQ - 1;
+				if (allpasstemp < 0 || allpasstemp > delayQ) {allpasstemp = delayQ;}
+				inputSample -= oQ[allpasstemp]*constallpass;
+				oQ[outQ] = inputSample;
+				inputSample *= constallpass;
+				outQ--; if (outQ < 0 || outQ > delayQ) {outQ = delayQ;}
+				inputSample += (oQ[outQ]);
+				//allpass filter Q
+				
+				dQ[6] = dQ[5];
+				dQ[5] = dQ[4];
+				dQ[4] = inputSample;
+				inputSample = (dQ[4] + dQ[5] + dQ[6])/3.0;
+				
+				allpasstemp = outR - 1;
+				if (allpasstemp < 0 || allpasstemp > delayR) {allpasstemp = delayR;}
+				inputSample -= oR[allpasstemp]*constallpass;
+				oR[outR] = inputSample;
+				inputSample *= constallpass;
+				outR--; if (outR < 0 || outR > delayR) {outR = delayR;}
+				inputSample += (oR[outR]);
+				//allpass filter R
+				
+				dR[6] = dR[5];
+				dR[5] = dR[4];
+				dR[4] = inputSample;
+				inputSample = (dR[4] + dR[5] + dR[6])/3.0;
+				
+				allpasstemp = outS - 1;
+				if (allpasstemp < 0 || allpasstemp > delayS) {allpasstemp = delayS;}
+				inputSample -= oS[allpasstemp]*constallpass;
+				oS[outS] = inputSample;
+				inputSample *= constallpass;
+				outS--; if (outS < 0 || outS > delayS) {outS = delayS;}
+				inputSample += (oS[outS]);
+				//allpass filter S
+				
+				dS[6] = dS[5];
+				dS[5] = dS[4];
+				dS[4] = inputSample;
+				inputSample = (dS[4] + dS[5] + dS[6])/3.0;
+				
+				allpasstemp = outT - 1;
+				if (allpasstemp < 0 || allpasstemp > delayT) {allpasstemp = delayT;}
+				inputSample -= oT[allpasstemp]*constallpass;
+				oT[outT] = inputSample;
+				inputSample *= constallpass;
+				outT--; if (outT < 0 || outT > delayT) {outT = delayT;}
+				inputSample += (oT[outT]);
+				//allpass filter T
+				
+				dT[6] = dT[5];
+				dT[5] = dT[4];
+				dT[4] = inputSample;
+				inputSample = (dT[4] + dT[5] + dT[6])/3.0;
+				
+				allpasstemp = outU - 1;
+				if (allpasstemp < 0 || allpasstemp > delayU) {allpasstemp = delayU;}
+				inputSample -= oU[allpasstemp]*constallpass;
+				oU[outU] = inputSample;
+				inputSample *= constallpass;
+				outU--; if (outU < 0 || outU > delayU) {outU = delayU;}
+				inputSample += (oU[outU]);
+				//allpass filter U
+				
+				dU[6] = dU[5];
+				dU[5] = dU[4];
+				dU[4] = inputSample;
+				inputSample = (dU[4] + dU[5] + dU[6])/3.0;
+				
+				allpasstemp = outV - 1;
+				if (allpasstemp < 0 || allpasstemp > delayV) {allpasstemp = delayV;}
+				inputSample -= oV[allpasstemp]*constallpass;
+				oV[outV] = inputSample;
+				inputSample *= constallpass;
+				outV--; if (outV < 0 || outV > delayV) {outV = delayV;}
+				inputSample += (oV[outV]);
+				//allpass filter V
+				
+				dV[6] = dV[5];
+				dV[5] = dV[4];
+				dV[4] = inputSample;
+				inputSample = (dV[4] + dV[5] + dV[6])/3.0;
+				
+				allpasstemp = outW - 1;
+				if (allpasstemp < 0 || allpasstemp > delayW) {allpasstemp = delayW;}
+				inputSample -= oW[allpasstemp]*constallpass;
+				oW[outW] = inputSample;
+				inputSample *= constallpass;
+				outW--; if (outW < 0 || outW > delayW) {outW = delayW;}
+				inputSample += (oW[outW]);
+				//allpass filter W
+				
+				dW[6] = dW[5];
+				dW[5] = dW[4];
+				dW[4] = inputSample;
+				inputSample = (dW[4] + dW[5] + dW[6])/3.0;
+				
+				allpasstemp = outX - 1;
+				if (allpasstemp < 0 || allpasstemp > delayX) {allpasstemp = delayX;}
+				inputSample -= oX[allpasstemp]*constallpass;
+				oX[outX] = inputSample;
+				inputSample *= constallpass;
+				outX--; if (outX < 0 || outX > delayX) {outX = delayX;}
+				inputSample += (oX[outX]);
+				//allpass filter X
+				
+				dX[6] = dX[5];
+				dX[5] = dX[4];
+				dX[4] = inputSample;
+				inputSample = (dX[4] + dX[5] + dX[6])/3.0;
+				
+				allpasstemp = outY - 1;
+				if (allpasstemp < 0 || allpasstemp > delayY) {allpasstemp = delayY;}
+				inputSample -= oY[allpasstemp]*constallpass;
+				oY[outY] = inputSample;
+				inputSample *= constallpass;
+				outY--; if (outY < 0 || outY > delayY) {outY = delayY;}
+				inputSample += (oY[outY]);
+				//allpass filter Y
+				
+				dY[6] = dY[5];
+				dY[5] = dY[4];
+				dY[4] = inputSample;
+				inputSample = (dY[4] + dY[5] + dY[6])/3.0;
+				
+				allpasstemp = outZ - 1;
+				if (allpasstemp < 0 || allpasstemp > delayZ) {allpasstemp = delayZ;}
+				inputSample -= oZ[allpasstemp]*constallpass;
+				oZ[outZ] = inputSample;
+				inputSample *= constallpass;
+				outZ--; if (outZ < 0 || outZ > delayZ) {outZ = delayZ;}
+				inputSample += (oZ[outZ]);
+				//allpass filter Z
+				
+				dZ[6] = dZ[5];
+				dZ[5] = dZ[4];
+				dZ[4] = inputSample;
+				inputSample = (dZ[4] + dZ[5] + dZ[6]);		
+				//output Zarathustra infinite space verb
+				break;
+				
+		}
+		//end big switch for verb type
+		
+		
+		
+		bridgerectifier = fabs(inputSample);
+		bridgerectifier = 1.0-cos(bridgerectifier);
+		if (inputSample > 0) inputSample -= bridgerectifier;
+		else inputSample += bridgerectifier;
+		inputSample /= gain;		
+		//here we apply the ADT2 'console on steroids' trick
+
+		wetness = wetnesstarget;
+		//setting up verb wetness to be manipulated by gate and peak
+		
+		wetness *= peak;
+		//but we only use peak (indirect) to deal with dry/wet, so that it'll manipulate the dry/wet like we want
+		
+		drySample *= (1.0-wetness);
+		inputSample *= wetness;
+		inputSample += drySample;
+		//here we combine the tanks with the dry signal
+
+		
+		//begin 32 bit floating point dither
+		int expon; frexpf((float)inputSample, &expon);
+		fpd ^= fpd << 13; fpd ^= fpd >> 17; fpd ^= fpd << 5;
+		inputSample += static_cast<int32_t>(fpd) * 5.960464655174751e-36L * pow(2,expon+62);
+		//end 32 bit floating point dither
+
+		*destP = inputSample;
+		sourceP += inNumChannels; destP += inNumChannels;
+	}
+}
+
diff --git a/plugins/MacAU/PocketVerbs/PocketVerbs.exp b/plugins/MacAU/PocketVerbs/PocketVerbs.exp
new file mode 100755
index 0000000..41b0949
--- /dev/null
+++ b/plugins/MacAU/PocketVerbs/PocketVerbs.exp
@@ -0,0 +1 @@
+_PocketVerbsEntry
diff --git a/plugins/MacAU/PocketVerbs/PocketVerbs.h b/plugins/MacAU/PocketVerbs/PocketVerbs.h
new file mode 100755
index 0000000..c713f82
--- /dev/null
+++ b/plugins/MacAU/PocketVerbs/PocketVerbs.h
@@ -0,0 +1,271 @@
+/*
+*	File:		PocketVerbs.h
+*	
+*	Version:	1.0
+* 
+*	Created:	8/19/12
+*	
+*	Copyright:  Copyright © 2012 Airwindows, All Rights Reserved
+* 
+*	Disclaimer:	IMPORTANT:  This Apple software is supplied to you by Apple Computer, Inc. ("Apple") in 
+*				consideration of your agreement to the following terms, and your use, installation, modification 
+*				or redistribution of this Apple software constitutes acceptance of these terms.  If you do 
+*				not agree with these terms, please do not use, install, modify or redistribute this Apple 
+*				software.
+*
+*				In consideration of your agreement to abide by the following terms, and subject to these terms, 
+*				Apple grants you a personal, non-exclusive license, under Apple's copyrights in this 
+*				original Apple software (the "Apple Software"), to use, reproduce, modify and redistribute the 
+*				Apple Software, with or without modifications, in source and/or binary forms; provided that if you 
+*				redistribute the Apple Software in its entirety and without modifications, you must retain this 
+*				notice and the following text and disclaimers in all such redistributions of the Apple Software. 
+*				Neither the name, trademarks, service marks or logos of Apple Computer, Inc. may be used to 
+*				endorse or promote products derived from the Apple Software without specific prior written 
+*				permission from Apple.  Except as expressly stated in this notice, no other rights or 
+*				licenses, express or implied, are granted by Apple herein, including but not limited to any 
+*				patent rights that may be infringed by your derivative works or by other works in which the 
+*				Apple Software may be incorporated.
+*
+*				The Apple Software is provided by Apple on an "AS IS" basis.  APPLE MAKES NO WARRANTIES, EXPRESS OR 
+*				IMPLIED, INCLUDING WITHOUT LIMITATION THE IMPLIED WARRANTIES OF NON-INFRINGEMENT, MERCHANTABILITY 
+*				AND FITNESS FOR A PARTICULAR PURPOSE, REGARDING THE APPLE SOFTWARE OR ITS USE AND OPERATION ALONE 
+*				OR IN COMBINATION WITH YOUR PRODUCTS.
+*
+*				IN NO EVENT SHALL APPLE BE LIABLE FOR ANY SPECIAL, INDIRECT, INCIDENTAL OR CONSEQUENTIAL 
+*				DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS 
+*				OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ARISING IN ANY WAY OUT OF THE USE, 
+*				REPRODUCTION, MODIFICATION AND/OR DISTRIBUTION OF THE APPLE SOFTWARE, HOWEVER CAUSED AND WHETHER 
+*				UNDER THEORY OF CONTRACT, TORT (INCLUDING NEGLIGENCE), STRICT LIABILITY OR OTHERWISE, EVEN 
+*				IF APPLE HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*
+*/
+#include "AUEffectBase.h"
+#include "PocketVerbsVersion.h"
+
+#if AU_DEBUG_DISPATCHER
+	#include "AUDebugDispatcher.h"
+#endif
+
+
+#ifndef __PocketVerbs_h__
+#define __PocketVerbs_h__
+
+
+#pragma mark ____PocketVerbs Parameters
+
+// parameters
+static CFStringRef kParameterOneName = CFSTR("Type");
+static const int kChamber = 1;
+static const int kSpring = 2;
+static const int kTiled = 3;
+static const int kRoom = 4;
+static const int kStretch = 5;
+static const int kZarathustra = 6;
+static const int kDefaultValue_ParamOne = kChamber;
+
+static CFStringRef kMenuItem_Chamber = CFSTR ("Chamber");
+static CFStringRef kMenuItem_Spring = CFSTR ("Spring");
+static CFStringRef kMenuItem_Tiled = CFSTR ("Tiled");
+static CFStringRef kMenuItem_Room = CFSTR ("Room");
+static CFStringRef kMenuItem_Stretch = CFSTR ("Stretch");
+static CFStringRef kMenuItem_Zarathustra = CFSTR ("Zarathustra");
+
+
+static const float kDefaultValue_ParamTwo = 0.5;
+static const float kDefaultValue_ParamThree = 0.0;
+static const float kDefaultValue_ParamFour = 0.5;
+
+static CFStringRef kParameterTwoName = CFSTR("Size");
+static CFStringRef kParameterThreeName = CFSTR("Gating");
+static CFStringRef kParameterFourName = CFSTR("Dry/Wet");
+//Alter the name if desired, but using the plugin name is a start
+
+enum {
+	kParam_One =0,
+	kParam_Two =1,
+	kParam_Three =2,
+	kParam_Four =3,
+	//Add your parameters here...
+	kNumberOfParameters=4
+};
+
+#pragma mark ____PocketVerbs
+class PocketVerbs : public AUEffectBase
+{
+public:
+	PocketVerbs(AudioUnit component);
+#if AU_DEBUG_DISPATCHER
+	virtual ~PocketVerbs () { delete mDebugDispatcher; }
+#endif
+	
+	virtual AUKernelBase *		NewKernel() { return new PocketVerbsKernel(this); }
+	
+	virtual	ComponentResult		GetParameterValueStrings(AudioUnitScope			inScope,
+														 AudioUnitParameterID		inParameterID,
+														 CFArrayRef *			outStrings);
+    
+	virtual	ComponentResult		GetParameterInfo(AudioUnitScope			inScope,
+												 AudioUnitParameterID	inParameterID,
+												 AudioUnitParameterInfo	&outParameterInfo);
+    
+	virtual ComponentResult		GetPropertyInfo(AudioUnitPropertyID		inID,
+												AudioUnitScope			inScope,
+												AudioUnitElement		inElement,
+												UInt32 &			outDataSize,
+												Boolean	&			outWritable );
+	
+	virtual ComponentResult		GetProperty(AudioUnitPropertyID inID,
+											AudioUnitScope 		inScope,
+											AudioUnitElement 		inElement,
+											void *			outData);
+	
+	virtual ComponentResult    Initialize();
+	virtual bool				SupportsTail () { return true; }
+    virtual Float64				GetTailTime() {return 1.0/GetSampleRate()*220000.0;} //in SECONDS! gsr * a number = in samples
+    virtual Float64				GetLatency() {return (1.0/GetSampleRate())*0.0;}	// in SECONDS! gsr * a number = in samples
+	
+	/*! @method Version */
+	virtual ComponentResult		Version() { return kPocketVerbsVersion; }
+	
+    
+	
+protected:
+		class PocketVerbsKernel : public AUKernelBase		// most of the real work happens here
+	{
+public:
+		PocketVerbsKernel(AUEffectBase *inAudioUnit )
+		: AUKernelBase(inAudioUnit)
+	{
+	}
+		
+		// *Required* overides for the process method for this effect
+		// processes one channel of interleaved samples
+        virtual void 		Process(	const Float32 	*inSourceP,
+										Float32		 	*inDestP,
+										UInt32 			inFramesToProcess,
+										UInt32			inNumChannels,
+										bool			&ioSilence);
+		
+        virtual void		Reset();
+		
+		private: 
+		Float64 dA[7];
+		Float64 dB[7];
+		Float64 dC[7];
+		Float64 dD[7];		
+		Float64 dE[7];
+		Float64 dF[7];
+		Float64 dG[7];
+		Float64 dH[7];
+		Float64 dI[7];
+		Float64 dJ[7];
+		Float64 dK[7];
+		Float64 dL[7];
+		Float64 dM[7];
+		Float64 dN[7];
+		Float64 dO[7];
+		Float64 dP[7];
+		Float64 dQ[7];
+		Float64 dR[7];
+		Float64 dS[7];
+		Float64 dT[7];
+		Float64 dU[7];
+		Float64 dV[7];
+		Float64 dW[7];
+		Float64 dX[7];
+		Float64 dY[7];
+		Float64 dZ[7];
+		
+		Float64 aA[15150];
+		Float64 aB[14618];
+		Float64 aC[14358];
+		Float64 aD[13818];		
+		Float64 aE[13562];
+		Float64 aF[13046];
+		Float64 aG[11966];
+		Float64 aH[11130];
+		Float64 aI[10598];
+		Float64 aJ[9810];
+		Float64 aK[9522];
+		Float64 aL[8982];
+		Float64 aM[8786];
+		Float64 aN[8462];
+		Float64 aO[8310];
+		Float64 aP[7982];
+		Float64 aQ[7322];
+		Float64 aR[6818];
+		Float64 aS[6506];
+		Float64 aT[6002];
+		Float64 aU[5838];
+		Float64 aV[5502];
+		Float64 aW[5010];
+		Float64 aX[4850];
+		Float64 aY[4296];
+		Float64 aZ[4180];
+		
+		Float64 oA[15150];
+		Float64 oB[14618];
+		Float64 oC[14358];
+		Float64 oD[13818];		
+		Float64 oE[13562];
+		Float64 oF[13046];
+		Float64 oG[11966];
+		Float64 oH[11130];
+		Float64 oI[10598];
+		Float64 oJ[9810];
+		Float64 oK[9522];
+		Float64 oL[8982];
+		Float64 oM[8786];
+		Float64 oN[8462];
+		Float64 oO[8310];
+		Float64 oP[7982];
+		Float64 oQ[7322];
+		Float64 oR[6818];
+		Float64 oS[6506];
+		Float64 oT[6002];
+		Float64 oU[5838];
+		Float64 oV[5502];
+		Float64 oW[5010];
+		Float64 oX[4850];
+		Float64 oY[4296];
+		Float64 oZ[4180];
+		
+		int outA, alpA, maxdelayA, delayA;
+		int outB, alpB, maxdelayB, delayB;
+		int outC, alpC, maxdelayC, delayC;
+		int outD, alpD, maxdelayD, delayD;
+		int outE, alpE, maxdelayE, delayE;
+		int outF, alpF, maxdelayF, delayF;
+		int outG, alpG, maxdelayG, delayG;
+		int outH, alpH, maxdelayH, delayH;
+		int outI, alpI, maxdelayI, delayI;
+		int outJ, alpJ, maxdelayJ, delayJ;
+		int outK, alpK, maxdelayK, delayK;
+		int outL, alpL, maxdelayL, delayL;
+		int outM, alpM, maxdelayM, delayM;
+		int outN, alpN, maxdelayN, delayN;
+		int outO, alpO, maxdelayO, delayO;
+		int outP, alpP, maxdelayP, delayP;
+		int outQ, alpQ, maxdelayQ, delayQ;
+		int outR, alpR, maxdelayR, delayR;
+		int outS, alpS, maxdelayS, delayS;
+		int outT, alpT, maxdelayT, delayT;
+		int outU, alpU, maxdelayU, delayU;
+		int outV, alpV, maxdelayV, delayV;
+		int outW, alpW, maxdelayW, delayW;
+		int outX, alpX, maxdelayX, delayX;
+		int outY, alpY, maxdelayY, delayY;
+		int outZ, alpZ, maxdelayZ, delayZ;
+		
+		Float64 savedRoomsize;
+		int countdown;
+		Float64 peak;
+		uint32_t fpd;
+
+	};
+													   };
+													   
+													   //~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+													   
+													   
+#endif
\ No newline at end of file
diff --git a/plugins/MacAU/PocketVerbs/PocketVerbs.r b/plugins/MacAU/PocketVerbs/PocketVerbs.r
new file mode 100755
index 0000000..07090e6
--- /dev/null
+++ b/plugins/MacAU/PocketVerbs/PocketVerbs.r
@@ -0,0 +1,61 @@
+/*
+*	File:		PocketVerbs.r
+*	
+*	Version:	1.0
+* 
+*	Created:	8/19/12
+*	
+*	Copyright:  Copyright © 2012 Airwindows, All Rights Reserved
+* 
+*	Disclaimer:	IMPORTANT:  This Apple software is supplied to you by Apple Computer, Inc. ("Apple") in 
+*				consideration of your agreement to the following terms, and your use, installation, modification 
+*				or redistribution of this Apple software constitutes acceptance of these terms.  If you do 
+*				not agree with these terms, please do not use, install, modify or redistribute this Apple 
+*				software.
+*
+*				In consideration of your agreement to abide by the following terms, and subject to these terms, 
+*				Apple grants you a personal, non-exclusive license, under Apple's copyrights in this 
+*				original Apple software (the "Apple Software"), to use, reproduce, modify and redistribute the 
+*				Apple Software, with or without modifications, in source and/or binary forms; provided that if you 
+*				redistribute the Apple Software in its entirety and without modifications, you must retain this 
+*				notice and the following text and disclaimers in all such redistributions of the Apple Software. 
+*				Neither the name, trademarks, service marks or logos of Apple Computer, Inc. may be used to 
+*				endorse or promote products derived from the Apple Software without specific prior written 
+*				permission from Apple.  Except as expressly stated in this notice, no other rights or 
+*				licenses, express or implied, are granted by Apple herein, including but not limited to any 
+*				patent rights that may be infringed by your derivative works or by other works in which the 
+*				Apple Software may be incorporated.
+*
+*				The Apple Software is provided by Apple on an "AS IS" basis.  APPLE MAKES NO WARRANTIES, EXPRESS OR 
+*				IMPLIED, INCLUDING WITHOUT LIMITATION THE IMPLIED WARRANTIES OF NON-INFRINGEMENT, MERCHANTABILITY 
+*				AND FITNESS FOR A PARTICULAR PURPOSE, REGARDING THE APPLE SOFTWARE OR ITS USE AND OPERATION ALONE 
+*				OR IN COMBINATION WITH YOUR PRODUCTS.
+*
+*				IN NO EVENT SHALL APPLE BE LIABLE FOR ANY SPECIAL, INDIRECT, INCIDENTAL OR CONSEQUENTIAL 
+*				DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS 
+*				OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ARISING IN ANY WAY OUT OF THE USE, 
+*				REPRODUCTION, MODIFICATION AND/OR DISTRIBUTION OF THE APPLE SOFTWARE, HOWEVER CAUSED AND WHETHER 
+*				UNDER THEORY OF CONTRACT, TORT (INCLUDING NEGLIGENCE), STRICT LIABILITY OR OTHERWISE, EVEN 
+*				IF APPLE HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*
+*/
+#include <AudioUnit/AudioUnit.r>
+
+#include "PocketVerbsVersion.h"
+
+// Note that resource IDs must be spaced 2 apart for the 'STR ' name and description
+#define kAudioUnitResID_PocketVerbs				1000
+
+//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ PocketVerbs~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+
+#define RES_ID			kAudioUnitResID_PocketVerbs
+#define COMP_TYPE		kAudioUnitType_Effect
+#define COMP_SUBTYPE	PocketVerbs_COMP_SUBTYPE
+#define COMP_MANUF		PocketVerbs_COMP_MANF	
+
+#define VERSION			kPocketVerbsVersion
+#define NAME			"Airwindows: PocketVerbs"
+#define DESCRIPTION		"PocketVerbs AU"
+#define ENTRY_POINT		"PocketVerbsEntry"
+
+#include "AUResources.r"
\ No newline at end of file
diff --git a/plugins/MacAU/PocketVerbs/PocketVerbs.xcodeproj/christopherjohnson.mode1v3 b/plugins/MacAU/PocketVerbs/PocketVerbs.xcodeproj/christopherjohnson.mode1v3
new file mode 100755
index 0000000..4bbeff6
--- /dev/null
+++ b/plugins/MacAU/PocketVerbs/PocketVerbs.xcodeproj/christopherjohnson.mode1v3
@@ -0,0 +1,1374 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>ActivePerspectiveName</key>
+	<string>Project</string>
+	<key>AllowedModules</key>
+	<array>
+		<dict>
+			<key>BundleLoadPath</key>
+			<string></string>
+			<key>MaxInstances</key>
+			<string>n</string>
+			<key>Module</key>
+			<string>PBXSmartGroupTreeModule</string>
+			<key>Name</key>
+			<string>Groups and Files Outline View</string>
+		</dict>
+		<dict>
+			<key>BundleLoadPath</key>
+			<string></string>
+			<key>MaxInstances</key>
+			<string>n</string>
+			<key>Module</key>
+			<string>PBXNavigatorGroup</string>
+			<key>Name</key>
+			<string>Editor</string>
+		</dict>
+		<dict>
+			<key>BundleLoadPath</key>
+			<string></string>
+			<key>MaxInstances</key>
+			<string>n</string>
+			<key>Module</key>
+			<string>XCTaskListModule</string>
+			<key>Name</key>
+			<string>Task List</string>
+		</dict>
+		<dict>
+			<key>BundleLoadPath</key>
+			<string></string>
+			<key>MaxInstances</key>
+			<string>n</string>
+			<key>Module</key>
+			<string>XCDetailModule</string>
+			<key>Name</key>
+			<string>File and Smart Group Detail Viewer</string>
+		</dict>
+		<dict>
+			<key>BundleLoadPath</key>
+			<string></string>
+			<key>MaxInstances</key>
+			<string>1</string>
+			<key>Module</key>
+			<string>PBXBuildResultsModule</string>
+			<key>Name</key>
+			<string>Detailed Build Results Viewer</string>
+		</dict>
+		<dict>
+			<key>BundleLoadPath</key>
+			<string></string>
+			<key>MaxInstances</key>
+			<string>1</string>
+			<key>Module</key>
+			<string>PBXProjectFindModule</string>
+			<key>Name</key>
+			<string>Project Batch Find Tool</string>
+		</dict>
+		<dict>
+			<key>BundleLoadPath</key>
+			<string></string>
+			<key>MaxInstances</key>
+			<string>n</string>
+			<key>Module</key>
+			<string>XCProjectFormatConflictsModule</string>
+			<key>Name</key>
+			<string>Project Format Conflicts List</string>
+		</dict>
+		<dict>
+			<key>BundleLoadPath</key>
+			<string></string>
+			<key>MaxInstances</key>
+			<string>n</string>
+			<key>Module</key>
+			<string>PBXBookmarksModule</string>
+			<key>Name</key>
+			<string>Bookmarks Tool</string>
+		</dict>
+		<dict>
+			<key>BundleLoadPath</key>
+			<string></string>
+			<key>MaxInstances</key>
+			<string>n</string>
+			<key>Module</key>
+			<string>PBXClassBrowserModule</string>
+			<key>Name</key>
+			<string>Class Browser</string>
+		</dict>
+		<dict>
+			<key>BundleLoadPath</key>
+			<string></string>
+			<key>MaxInstances</key>
+			<string>n</string>
+			<key>Module</key>
+			<string>PBXCVSModule</string>
+			<key>Name</key>
+			<string>Source Code Control Tool</string>
+		</dict>
+		<dict>
+			<key>BundleLoadPath</key>
+			<string></string>
+			<key>MaxInstances</key>
+			<string>n</string>
+			<key>Module</key>
+			<string>PBXDebugBreakpointsModule</string>
+			<key>Name</key>
+			<string>Debug Breakpoints Tool</string>
+		</dict>
+		<dict>
+			<key>BundleLoadPath</key>
+			<string></string>
+			<key>MaxInstances</key>
+			<string>n</string>
+			<key>Module</key>
+			<string>XCDockableInspector</string>
+			<key>Name</key>
+			<string>Inspector</string>
+		</dict>
+		<dict>
+			<key>BundleLoadPath</key>
+			<string></string>
+			<key>MaxInstances</key>
+			<string>n</string>
+			<key>Module</key>
+			<string>PBXOpenQuicklyModule</string>
+			<key>Name</key>
+			<string>Open Quickly Tool</string>
+		</dict>
+		<dict>
+			<key>BundleLoadPath</key>
+			<string></string>
+			<key>MaxInstances</key>
+			<string>1</string>
+			<key>Module</key>
+			<string>PBXDebugSessionModule</string>
+			<key>Name</key>
+			<string>Debugger</string>
+		</dict>
+		<dict>
+			<key>BundleLoadPath</key>
+			<string></string>
+			<key>MaxInstances</key>
+			<string>1</string>
+			<key>Module</key>
+			<string>PBXDebugCLIModule</string>
+			<key>Name</key>
+			<string>Debug Console</string>
+		</dict>
+		<dict>
+			<key>BundleLoadPath</key>
+			<string></string>
+			<key>MaxInstances</key>
+			<string>n</string>
+			<key>Module</key>
+			<string>XCSnapshotModule</string>
+			<key>Name</key>
+			<string>Snapshots Tool</string>
+		</dict>
+	</array>
+	<key>BundlePath</key>
+	<string>/Developer/Library/PrivateFrameworks/DevToolsInterface.framework/Resources</string>
+	<key>Description</key>
+	<string>DefaultDescriptionKey</string>
+	<key>DockingSystemVisible</key>
+	<false/>
+	<key>Extension</key>
+	<string>mode1v3</string>
+	<key>FavBarConfig</key>
+	<dict>
+		<key>PBXProjectModuleGUID</key>
+		<string>8BD3CCBC148831C90062E48C</string>
+		<key>XCBarModuleItemNames</key>
+		<dict/>
+		<key>XCBarModuleItems</key>
+		<array/>
+	</dict>
+	<key>FirstTimeWindowDisplayed</key>
+	<false/>
+	<key>Identifier</key>
+	<string>com.apple.perspectives.project.mode1v3</string>
+	<key>MajorVersion</key>
+	<integer>33</integer>
+	<key>MinorVersion</key>
+	<integer>0</integer>
+	<key>Name</key>
+	<string>Default</string>
+	<key>Notifications</key>
+	<array/>
+	<key>OpenEditors</key>
+	<array/>
+	<key>PerspectiveWidths</key>
+	<array>
+		<integer>-1</integer>
+		<integer>-1</integer>
+	</array>
+	<key>Perspectives</key>
+	<array>
+		<dict>
+			<key>ChosenToolbarItems</key>
+			<array>
+				<string>active-combo-popup</string>
+				<string>action</string>
+				<string>build</string>
+				<string>debugger-enable-breakpoints</string>
+				<string>get-info</string>
+				<string>com.apple.pbx.toolbar.searchfield</string>
+			</array>
+			<key>ControllerClassBaseName</key>
+			<string></string>
+			<key>IconName</key>
+			<string>WindowOfProjectWithEditor</string>
+			<key>Identifier</key>
+			<string>perspective.project</string>
+			<key>IsVertical</key>
+			<false/>
+			<key>Layout</key>
+			<array>
+				<dict>
+					<key>BecomeActive</key>
+					<true/>
+					<key>ContentConfiguration</key>
+					<dict>
+						<key>PBXBottomSmartGroupGIDs</key>
+						<array>
+							<string>1C37FBAC04509CD000000102</string>
+							<string>1C37FAAC04509CD000000102</string>
+							<string>1C37FABC05509CD000000102</string>
+							<string>1C37FABC05539CD112110102</string>
+							<string>E2644B35053B69B200211256</string>
+							<string>1C37FABC04509CD000100104</string>
+							<string>1CC0EA4004350EF90044410B</string>
+							<string>1CC0EA4004350EF90041110B</string>
+						</array>
+						<key>PBXProjectModuleGUID</key>
+						<string>1CE0B1FE06471DED0097A5F4</string>
+						<key>PBXProjectModuleLabel</key>
+						<string>Files</string>
+						<key>PBXProjectStructureProvided</key>
+						<string>yes</string>
+						<key>PBXSmartGroupTreeModuleColumnData</key>
+						<dict>
+							<key>PBXSmartGroupTreeModuleColumnWidthsKey</key>
+							<array>
+								<real>186</real>
+							</array>
+							<key>PBXSmartGroupTreeModuleColumnsKey_v4</key>
+							<array>
+								<string>MainColumn</string>
+							</array>
+						</dict>
+						<key>PBXSmartGroupTreeModuleOutlineStateKey_v7</key>
+						<dict>
+							<key>PBXSmartGroupTreeModuleOutlineStateExpansionKey</key>
+							<array>
+								<string>089C166AFE841209C02AAC07</string>
+								<string>08FB77ADFE841716C02AAC07</string>
+								<string>8BA05A56072072A900365D66</string>
+								<string>1C37FBAC04509CD000000102</string>
+								<string>1C37FABC05509CD000000102</string>
+							</array>
+							<key>PBXSmartGroupTreeModuleOutlineStateSelectionKey</key>
+							<array>
+								<array>
+									<integer>4</integer>
+									<integer>2</integer>
+									<integer>1</integer>
+									<integer>0</integer>
+								</array>
+							</array>
+							<key>PBXSmartGroupTreeModuleOutlineStateVisibleRectKey</key>
+							<string>{{0, 0}, {186, 647}}</string>
+						</dict>
+						<key>PBXTopSmartGroupGIDs</key>
+						<array/>
+						<key>XCIncludePerspectivesSwitch</key>
+						<true/>
+						<key>XCSharingToken</key>
+						<string>com.apple.Xcode.GFSharingToken</string>
+					</dict>
+					<key>GeometryConfiguration</key>
+					<dict>
+						<key>Frame</key>
+						<string>{{0, 0}, {203, 665}}</string>
+						<key>GroupTreeTableConfiguration</key>
+						<array>
+							<string>MainColumn</string>
+							<real>186</real>
+						</array>
+						<key>RubberWindowFrame</key>
+						<string>547 163 857 706 0 0 1440 878 </string>
+					</dict>
+					<key>Module</key>
+					<string>PBXSmartGroupTreeModule</string>
+					<key>Proportion</key>
+					<string>203pt</string>
+				</dict>
+				<dict>
+					<key>Dock</key>
+					<array>
+						<dict>
+							<key>ContentConfiguration</key>
+							<dict>
+								<key>PBXProjectModuleGUID</key>
+								<string>1CE0B20306471E060097A5F4</string>
+								<key>PBXProjectModuleLabel</key>
+								<string>PocketVerbsVersion.h</string>
+								<key>PBXSplitModuleInNavigatorKey</key>
+								<dict>
+									<key>Split0</key>
+									<dict>
+										<key>PBXProjectModuleGUID</key>
+										<string>1CE0B20406471E060097A5F4</string>
+										<key>PBXProjectModuleLabel</key>
+										<string>PocketVerbsVersion.h</string>
+										<key>_historyCapacity</key>
+										<integer>0</integer>
+										<key>bookmark</key>
+										<string>8B4223CF189BDBA000BD9C44</string>
+										<key>history</key>
+										<array>
+											<string>8B21D7851745523400E1943E</string>
+											<string>8B35583517455FF2009B6944</string>
+											<string>8B9B2A791779C31C0061D2E0</string>
+											<string>8B9B2A7A1779C31C0061D2E0</string>
+											<string>8B9B2A7B1779C31C0061D2E0</string>
+											<string>8B464AE617E3574500CFD7BE</string>
+										</array>
+									</dict>
+									<key>SplitCount</key>
+									<string>1</string>
+								</dict>
+								<key>StatusBarVisibility</key>
+								<true/>
+							</dict>
+							<key>GeometryConfiguration</key>
+							<dict>
+								<key>Frame</key>
+								<string>{{0, 0}, {649, 267}}</string>
+								<key>RubberWindowFrame</key>
+								<string>547 163 857 706 0 0 1440 878 </string>
+							</dict>
+							<key>Module</key>
+							<string>PBXNavigatorGroup</string>
+							<key>Proportion</key>
+							<string>267pt</string>
+						</dict>
+						<dict>
+							<key>ContentConfiguration</key>
+							<dict>
+								<key>PBXProjectModuleGUID</key>
+								<string>1CE0B20506471E060097A5F4</string>
+								<key>PBXProjectModuleLabel</key>
+								<string>Detail</string>
+							</dict>
+							<key>GeometryConfiguration</key>
+							<dict>
+								<key>Frame</key>
+								<string>{{0, 272}, {649, 393}}</string>
+								<key>RubberWindowFrame</key>
+								<string>547 163 857 706 0 0 1440 878 </string>
+							</dict>
+							<key>Module</key>
+							<string>XCDetailModule</string>
+							<key>Proportion</key>
+							<string>393pt</string>
+						</dict>
+					</array>
+					<key>Proportion</key>
+					<string>649pt</string>
+				</dict>
+			</array>
+			<key>Name</key>
+			<string>Project</string>
+			<key>ServiceClasses</key>
+			<array>
+				<string>XCModuleDock</string>
+				<string>PBXSmartGroupTreeModule</string>
+				<string>XCModuleDock</string>
+				<string>PBXNavigatorGroup</string>
+				<string>XCDetailModule</string>
+			</array>
+			<key>TableOfContents</key>
+			<array>
+				<string>8B4223D0189BDBA000BD9C44</string>
+				<string>1CE0B1FE06471DED0097A5F4</string>
+				<string>8B4223D1189BDBA000BD9C44</string>
+				<string>1CE0B20306471E060097A5F4</string>
+				<string>1CE0B20506471E060097A5F4</string>
+			</array>
+			<key>ToolbarConfigUserDefaultsMinorVersion</key>
+			<string>2</string>
+			<key>ToolbarConfiguration</key>
+			<string>xcode.toolbar.config.defaultV3</string>
+		</dict>
+		<dict>
+			<key>ControllerClassBaseName</key>
+			<string></string>
+			<key>IconName</key>
+			<string>WindowOfProject</string>
+			<key>Identifier</key>
+			<string>perspective.morph</string>
+			<key>IsVertical</key>
+			<integer>0</integer>
+			<key>Layout</key>
+			<array>
+				<dict>
+					<key>BecomeActive</key>
+					<integer>1</integer>
+					<key>ContentConfiguration</key>
+					<dict>
+						<key>PBXBottomSmartGroupGIDs</key>
+						<array>
+							<string>1C37FBAC04509CD000000102</string>
+							<string>1C37FAAC04509CD000000102</string>
+							<string>1C08E77C0454961000C914BD</string>
+							<string>1C37FABC05509CD000000102</string>
+							<string>1C37FABC05539CD112110102</string>
+							<string>E2644B35053B69B200211256</string>
+							<string>1C37FABC04509CD000100104</string>
+							<string>1CC0EA4004350EF90044410B</string>
+							<string>1CC0EA4004350EF90041110B</string>
+						</array>
+						<key>PBXProjectModuleGUID</key>
+						<string>11E0B1FE06471DED0097A5F4</string>
+						<key>PBXProjectModuleLabel</key>
+						<string>Files</string>
+						<key>PBXProjectStructureProvided</key>
+						<string>yes</string>
+						<key>PBXSmartGroupTreeModuleColumnData</key>
+						<dict>
+							<key>PBXSmartGroupTreeModuleColumnWidthsKey</key>
+							<array>
+								<real>186</real>
+							</array>
+							<key>PBXSmartGroupTreeModuleColumnsKey_v4</key>
+							<array>
+								<string>MainColumn</string>
+							</array>
+						</dict>
+						<key>PBXSmartGroupTreeModuleOutlineStateKey_v7</key>
+						<dict>
+							<key>PBXSmartGroupTreeModuleOutlineStateExpansionKey</key>
+							<array>
+								<string>29B97314FDCFA39411CA2CEA</string>
+								<string>1C37FABC05509CD000000102</string>
+							</array>
+							<key>PBXSmartGroupTreeModuleOutlineStateSelectionKey</key>
+							<array>
+								<array>
+									<integer>0</integer>
+								</array>
+							</array>
+							<key>PBXSmartGroupTreeModuleOutlineStateVisibleRectKey</key>
+							<string>{{0, 0}, {186, 337}}</string>
+						</dict>
+						<key>PBXTopSmartGroupGIDs</key>
+						<array/>
+						<key>XCIncludePerspectivesSwitch</key>
+						<integer>1</integer>
+						<key>XCSharingToken</key>
+						<string>com.apple.Xcode.GFSharingToken</string>
+					</dict>
+					<key>GeometryConfiguration</key>
+					<dict>
+						<key>Frame</key>
+						<string>{{0, 0}, {203, 355}}</string>
+						<key>GroupTreeTableConfiguration</key>
+						<array>
+							<string>MainColumn</string>
+							<real>186</real>
+						</array>
+						<key>RubberWindowFrame</key>
+						<string>373 269 690 397 0 0 1440 878 </string>
+					</dict>
+					<key>Module</key>
+					<string>PBXSmartGroupTreeModule</string>
+					<key>Proportion</key>
+					<string>100%</string>
+				</dict>
+			</array>
+			<key>Name</key>
+			<string>Morph</string>
+			<key>PreferredWidth</key>
+			<integer>300</integer>
+			<key>ServiceClasses</key>
+			<array>
+				<string>XCModuleDock</string>
+				<string>PBXSmartGroupTreeModule</string>
+			</array>
+			<key>TableOfContents</key>
+			<array>
+				<string>11E0B1FE06471DED0097A5F4</string>
+			</array>
+			<key>ToolbarConfiguration</key>
+			<string>xcode.toolbar.config.default.shortV3</string>
+		</dict>
+	</array>
+	<key>PerspectivesBarVisible</key>
+	<false/>
+	<key>ShelfIsVisible</key>
+	<false/>
+	<key>SourceDescription</key>
+	<string>file at '/Developer/Library/PrivateFrameworks/DevToolsInterface.framework/Resources/XCPerspectivesSpecificationMode1.xcperspec'</string>
+	<key>StatusbarIsVisible</key>
+	<true/>
+	<key>TimeStamp</key>
+	<real>0.0</real>
+	<key>ToolbarConfigUserDefaultsMinorVersion</key>
+	<string>2</string>
+	<key>ToolbarDisplayMode</key>
+	<integer>1</integer>
+	<key>ToolbarIsVisible</key>
+	<true/>
+	<key>ToolbarSizeMode</key>
+	<integer>2</integer>
+	<key>Type</key>
+	<string>Perspectives</string>
+	<key>UpdateMessage</key>
+	<string>The Default Workspace in this version of Xcode now includes support to hide and show the detail view (what has been referred to as the "Metro-Morph" feature).  You must discard your current Default Workspace settings and update to the latest Default Workspace in order to gain this feature.  Do you wish to update to the latest Workspace defaults for project '%@'?</string>
+	<key>WindowJustification</key>
+	<integer>5</integer>
+	<key>WindowOrderList</key>
+	<array>
+		<string>8B4223D3189BDBA000BD9C44</string>
+		<string>8BD3CCBD148831C90062E48C</string>
+		<string>/Users/christopherjohnson/Desktop/Dropbox/AU/PocketVerbs/PocketVerbs.xcodeproj</string>
+	</array>
+	<key>WindowString</key>
+	<string>547 163 857 706 0 0 1440 878 </string>
+	<key>WindowToolsV3</key>
+	<array>
+		<dict>
+			<key>FirstTimeWindowDisplayed</key>
+			<false/>
+			<key>Identifier</key>
+			<string>windowTool.build</string>
+			<key>IsVertical</key>
+			<true/>
+			<key>Layout</key>
+			<array>
+				<dict>
+					<key>Dock</key>
+					<array>
+						<dict>
+							<key>ContentConfiguration</key>
+							<dict>
+								<key>PBXProjectModuleGUID</key>
+								<string>1CD0528F0623707200166675</string>
+								<key>PBXProjectModuleLabel</key>
+								<string></string>
+								<key>StatusBarVisibility</key>
+								<true/>
+							</dict>
+							<key>GeometryConfiguration</key>
+							<dict>
+								<key>Frame</key>
+								<string>{{0, 0}, {500, 218}}</string>
+								<key>RubberWindowFrame</key>
+								<string>668 222 500 500 0 0 1440 878 </string>
+							</dict>
+							<key>Module</key>
+							<string>PBXNavigatorGroup</string>
+							<key>Proportion</key>
+							<string>218pt</string>
+						</dict>
+						<dict>
+							<key>ContentConfiguration</key>
+							<dict>
+								<key>PBXProjectModuleGUID</key>
+								<string>XCMainBuildResultsModuleGUID</string>
+								<key>PBXProjectModuleLabel</key>
+								<string>Build Results</string>
+								<key>XCBuildResultsTrigger_Collapse</key>
+								<integer>1021</integer>
+								<key>XCBuildResultsTrigger_Open</key>
+								<integer>1011</integer>
+							</dict>
+							<key>GeometryConfiguration</key>
+							<dict>
+								<key>Frame</key>
+								<string>{{0, 223}, {500, 236}}</string>
+								<key>RubberWindowFrame</key>
+								<string>668 222 500 500 0 0 1440 878 </string>
+							</dict>
+							<key>Module</key>
+							<string>PBXBuildResultsModule</string>
+							<key>Proportion</key>
+							<string>236pt</string>
+						</dict>
+					</array>
+					<key>Proportion</key>
+					<string>459pt</string>
+				</dict>
+			</array>
+			<key>Name</key>
+			<string>Build Results</string>
+			<key>ServiceClasses</key>
+			<array>
+				<string>PBXBuildResultsModule</string>
+			</array>
+			<key>StatusbarIsVisible</key>
+			<true/>
+			<key>TableOfContents</key>
+			<array>
+				<string>8BD3CCBD148831C90062E48C</string>
+				<string>8B4223D2189BDBA000BD9C44</string>
+				<string>1CD0528F0623707200166675</string>
+				<string>XCMainBuildResultsModuleGUID</string>
+			</array>
+			<key>ToolbarConfiguration</key>
+			<string>xcode.toolbar.config.buildV3</string>
+			<key>WindowContentMinSize</key>
+			<string>486 300</string>
+			<key>WindowString</key>
+			<string>668 222 500 500 0 0 1440 878 </string>
+			<key>WindowToolGUID</key>
+			<string>8BD3CCBD148831C90062E48C</string>
+			<key>WindowToolIsVisible</key>
+			<false/>
+		</dict>
+		<dict>
+			<key>Identifier</key>
+			<string>windowTool.debugger</string>
+			<key>Layout</key>
+			<array>
+				<dict>
+					<key>Dock</key>
+					<array>
+						<dict>
+							<key>ContentConfiguration</key>
+							<dict>
+								<key>Debugger</key>
+								<dict>
+									<key>HorizontalSplitView</key>
+									<dict>
+										<key>_collapsingFrameDimension</key>
+										<real>0.0</real>
+										<key>_indexOfCollapsedView</key>
+										<integer>0</integer>
+										<key>_percentageOfCollapsedView</key>
+										<real>0.0</real>
+										<key>isCollapsed</key>
+										<string>yes</string>
+										<key>sizes</key>
+										<array>
+											<string>{{0, 0}, {317, 164}}</string>
+											<string>{{317, 0}, {377, 164}}</string>
+										</array>
+									</dict>
+									<key>VerticalSplitView</key>
+									<dict>
+										<key>_collapsingFrameDimension</key>
+										<real>0.0</real>
+										<key>_indexOfCollapsedView</key>
+										<integer>0</integer>
+										<key>_percentageOfCollapsedView</key>
+										<real>0.0</real>
+										<key>isCollapsed</key>
+										<string>yes</string>
+										<key>sizes</key>
+										<array>
+											<string>{{0, 0}, {694, 164}}</string>
+											<string>{{0, 164}, {694, 216}}</string>
+										</array>
+									</dict>
+								</dict>
+								<key>LauncherConfigVersion</key>
+								<string>8</string>
+								<key>PBXProjectModuleGUID</key>
+								<string>1C162984064C10D400B95A72</string>
+								<key>PBXProjectModuleLabel</key>
+								<string>Debug - GLUTExamples (Underwater)</string>
+							</dict>
+							<key>GeometryConfiguration</key>
+							<dict>
+								<key>DebugConsoleDrawerSize</key>
+								<string>{100, 120}</string>
+								<key>DebugConsoleVisible</key>
+								<string>None</string>
+								<key>DebugConsoleWindowFrame</key>
+								<string>{{200, 200}, {500, 300}}</string>
+								<key>DebugSTDIOWindowFrame</key>
+								<string>{{200, 200}, {500, 300}}</string>
+								<key>Frame</key>
+								<string>{{0, 0}, {694, 380}}</string>
+								<key>RubberWindowFrame</key>
+								<string>321 238 694 422 0 0 1440 878 </string>
+							</dict>
+							<key>Module</key>
+							<string>PBXDebugSessionModule</string>
+							<key>Proportion</key>
+							<string>100%</string>
+						</dict>
+					</array>
+					<key>Proportion</key>
+					<string>100%</string>
+				</dict>
+			</array>
+			<key>Name</key>
+			<string>Debugger</string>
+			<key>ServiceClasses</key>
+			<array>
+				<string>PBXDebugSessionModule</string>
+			</array>
+			<key>StatusbarIsVisible</key>
+			<integer>1</integer>
+			<key>TableOfContents</key>
+			<array>
+				<string>1CD10A99069EF8BA00B06720</string>
+				<string>1C0AD2AB069F1E9B00FABCE6</string>
+				<string>1C162984064C10D400B95A72</string>
+				<string>1C0AD2AC069F1E9B00FABCE6</string>
+			</array>
+			<key>ToolbarConfiguration</key>
+			<string>xcode.toolbar.config.debugV3</string>
+			<key>WindowString</key>
+			<string>321 238 694 422 0 0 1440 878 </string>
+			<key>WindowToolGUID</key>
+			<string>1CD10A99069EF8BA00B06720</string>
+			<key>WindowToolIsVisible</key>
+			<integer>0</integer>
+		</dict>
+		<dict>
+			<key>Identifier</key>
+			<string>windowTool.find</string>
+			<key>Layout</key>
+			<array>
+				<dict>
+					<key>Dock</key>
+					<array>
+						<dict>
+							<key>Dock</key>
+							<array>
+								<dict>
+									<key>ContentConfiguration</key>
+									<dict>
+										<key>PBXProjectModuleGUID</key>
+										<string>1CDD528C0622207200134675</string>
+										<key>PBXProjectModuleLabel</key>
+										<string>&lt;No Editor&gt;</string>
+										<key>PBXSplitModuleInNavigatorKey</key>
+										<dict>
+											<key>Split0</key>
+											<dict>
+												<key>PBXProjectModuleGUID</key>
+												<string>1CD0528D0623707200166675</string>
+											</dict>
+											<key>SplitCount</key>
+											<string>1</string>
+										</dict>
+										<key>StatusBarVisibility</key>
+										<integer>1</integer>
+									</dict>
+									<key>GeometryConfiguration</key>
+									<dict>
+										<key>Frame</key>
+										<string>{{0, 0}, {781, 167}}</string>
+										<key>RubberWindowFrame</key>
+										<string>62 385 781 470 0 0 1440 878 </string>
+									</dict>
+									<key>Module</key>
+									<string>PBXNavigatorGroup</string>
+									<key>Proportion</key>
+									<string>781pt</string>
+								</dict>
+							</array>
+							<key>Proportion</key>
+							<string>50%</string>
+						</dict>
+						<dict>
+							<key>BecomeActive</key>
+							<integer>1</integer>
+							<key>ContentConfiguration</key>
+							<dict>
+								<key>PBXProjectModuleGUID</key>
+								<string>1CD0528E0623707200166675</string>
+								<key>PBXProjectModuleLabel</key>
+								<string>Project Find</string>
+							</dict>
+							<key>GeometryConfiguration</key>
+							<dict>
+								<key>Frame</key>
+								<string>{{8, 0}, {773, 254}}</string>
+								<key>RubberWindowFrame</key>
+								<string>62 385 781 470 0 0 1440 878 </string>
+							</dict>
+							<key>Module</key>
+							<string>PBXProjectFindModule</string>
+							<key>Proportion</key>
+							<string>50%</string>
+						</dict>
+					</array>
+					<key>Proportion</key>
+					<string>428pt</string>
+				</dict>
+			</array>
+			<key>Name</key>
+			<string>Project Find</string>
+			<key>ServiceClasses</key>
+			<array>
+				<string>PBXProjectFindModule</string>
+			</array>
+			<key>StatusbarIsVisible</key>
+			<integer>1</integer>
+			<key>TableOfContents</key>
+			<array>
+				<string>1C530D57069F1CE1000CFCEE</string>
+				<string>1C530D58069F1CE1000CFCEE</string>
+				<string>1C530D59069F1CE1000CFCEE</string>
+				<string>1CDD528C0622207200134675</string>
+				<string>1C530D5A069F1CE1000CFCEE</string>
+				<string>1CE0B1FE06471DED0097A5F4</string>
+				<string>1CD0528E0623707200166675</string>
+			</array>
+			<key>WindowString</key>
+			<string>62 385 781 470 0 0 1440 878 </string>
+			<key>WindowToolGUID</key>
+			<string>1C530D57069F1CE1000CFCEE</string>
+			<key>WindowToolIsVisible</key>
+			<integer>0</integer>
+		</dict>
+		<dict>
+			<key>Identifier</key>
+			<string>MENUSEPARATOR</string>
+		</dict>
+		<dict>
+			<key>Identifier</key>
+			<string>windowTool.debuggerConsole</string>
+			<key>Layout</key>
+			<array>
+				<dict>
+					<key>Dock</key>
+					<array>
+						<dict>
+							<key>BecomeActive</key>
+							<integer>1</integer>
+							<key>ContentConfiguration</key>
+							<dict>
+								<key>PBXProjectModuleGUID</key>
+								<string>1C78EAAC065D492600B07095</string>
+								<key>PBXProjectModuleLabel</key>
+								<string>Debugger Console</string>
+							</dict>
+							<key>GeometryConfiguration</key>
+							<dict>
+								<key>Frame</key>
+								<string>{{0, 0}, {650, 250}}</string>
+								<key>RubberWindowFrame</key>
+								<string>516 632 650 250 0 0 1680 1027 </string>
+							</dict>
+							<key>Module</key>
+							<string>PBXDebugCLIModule</string>
+							<key>Proportion</key>
+							<string>209pt</string>
+						</dict>
+					</array>
+					<key>Proportion</key>
+					<string>209pt</string>
+				</dict>
+			</array>
+			<key>Name</key>
+			<string>Debugger Console</string>
+			<key>ServiceClasses</key>
+			<array>
+				<string>PBXDebugCLIModule</string>
+			</array>
+			<key>StatusbarIsVisible</key>
+			<integer>1</integer>
+			<key>TableOfContents</key>
+			<array>
+				<string>1C78EAAD065D492600B07095</string>
+				<string>1C78EAAE065D492600B07095</string>
+				<string>1C78EAAC065D492600B07095</string>
+			</array>
+			<key>ToolbarConfiguration</key>
+			<string>xcode.toolbar.config.consoleV3</string>
+			<key>WindowString</key>
+			<string>650 41 650 250 0 0 1280 1002 </string>
+			<key>WindowToolGUID</key>
+			<string>1C78EAAD065D492600B07095</string>
+			<key>WindowToolIsVisible</key>
+			<integer>0</integer>
+		</dict>
+		<dict>
+			<key>Identifier</key>
+			<string>windowTool.snapshots</string>
+			<key>Layout</key>
+			<array>
+				<dict>
+					<key>Dock</key>
+					<array>
+						<dict>
+							<key>Module</key>
+							<string>XCSnapshotModule</string>
+							<key>Proportion</key>
+							<string>100%</string>
+						</dict>
+					</array>
+					<key>Proportion</key>
+					<string>100%</string>
+				</dict>
+			</array>
+			<key>Name</key>
+			<string>Snapshots</string>
+			<key>ServiceClasses</key>
+			<array>
+				<string>XCSnapshotModule</string>
+			</array>
+			<key>StatusbarIsVisible</key>
+			<string>Yes</string>
+			<key>ToolbarConfiguration</key>
+			<string>xcode.toolbar.config.snapshots</string>
+			<key>WindowString</key>
+			<string>315 824 300 550 0 0 1440 878 </string>
+			<key>WindowToolIsVisible</key>
+			<string>Yes</string>
+		</dict>
+		<dict>
+			<key>Identifier</key>
+			<string>windowTool.scm</string>
+			<key>Layout</key>
+			<array>
+				<dict>
+					<key>Dock</key>
+					<array>
+						<dict>
+							<key>ContentConfiguration</key>
+							<dict>
+								<key>PBXProjectModuleGUID</key>
+								<string>1C78EAB2065D492600B07095</string>
+								<key>PBXProjectModuleLabel</key>
+								<string>&lt;No Editor&gt;</string>
+								<key>PBXSplitModuleInNavigatorKey</key>
+								<dict>
+									<key>Split0</key>
+									<dict>
+										<key>PBXProjectModuleGUID</key>
+										<string>1C78EAB3065D492600B07095</string>
+									</dict>
+									<key>SplitCount</key>
+									<string>1</string>
+								</dict>
+								<key>StatusBarVisibility</key>
+								<integer>1</integer>
+							</dict>
+							<key>GeometryConfiguration</key>
+							<dict>
+								<key>Frame</key>
+								<string>{{0, 0}, {452, 0}}</string>
+								<key>RubberWindowFrame</key>
+								<string>743 379 452 308 0 0 1280 1002 </string>
+							</dict>
+							<key>Module</key>
+							<string>PBXNavigatorGroup</string>
+							<key>Proportion</key>
+							<string>0pt</string>
+						</dict>
+						<dict>
+							<key>BecomeActive</key>
+							<integer>1</integer>
+							<key>ContentConfiguration</key>
+							<dict>
+								<key>PBXProjectModuleGUID</key>
+								<string>1CD052920623707200166675</string>
+								<key>PBXProjectModuleLabel</key>
+								<string>SCM</string>
+							</dict>
+							<key>GeometryConfiguration</key>
+							<dict>
+								<key>ConsoleFrame</key>
+								<string>{{0, 259}, {452, 0}}</string>
+								<key>Frame</key>
+								<string>{{0, 7}, {452, 259}}</string>
+								<key>RubberWindowFrame</key>
+								<string>743 379 452 308 0 0 1280 1002 </string>
+								<key>TableConfiguration</key>
+								<array>
+									<string>Status</string>
+									<real>30</real>
+									<string>FileName</string>
+									<real>199</real>
+									<string>Path</string>
+									<real>197.0950012207031</real>
+								</array>
+								<key>TableFrame</key>
+								<string>{{0, 0}, {452, 250}}</string>
+							</dict>
+							<key>Module</key>
+							<string>PBXCVSModule</string>
+							<key>Proportion</key>
+							<string>262pt</string>
+						</dict>
+					</array>
+					<key>Proportion</key>
+					<string>266pt</string>
+				</dict>
+			</array>
+			<key>Name</key>
+			<string>SCM</string>
+			<key>ServiceClasses</key>
+			<array>
+				<string>PBXCVSModule</string>
+			</array>
+			<key>StatusbarIsVisible</key>
+			<integer>1</integer>
+			<key>TableOfContents</key>
+			<array>
+				<string>1C78EAB4065D492600B07095</string>
+				<string>1C78EAB5065D492600B07095</string>
+				<string>1C78EAB2065D492600B07095</string>
+				<string>1CD052920623707200166675</string>
+			</array>
+			<key>ToolbarConfiguration</key>
+			<string>xcode.toolbar.config.scm</string>
+			<key>WindowString</key>
+			<string>743 379 452 308 0 0 1280 1002 </string>
+		</dict>
+		<dict>
+			<key>Identifier</key>
+			<string>windowTool.breakpoints</string>
+			<key>IsVertical</key>
+			<integer>0</integer>
+			<key>Layout</key>
+			<array>
+				<dict>
+					<key>Dock</key>
+					<array>
+						<dict>
+							<key>BecomeActive</key>
+							<integer>1</integer>
+							<key>ContentConfiguration</key>
+							<dict>
+								<key>PBXBottomSmartGroupGIDs</key>
+								<array>
+									<string>1C77FABC04509CD000000102</string>
+								</array>
+								<key>PBXProjectModuleGUID</key>
+								<string>1CE0B1FE06471DED0097A5F4</string>
+								<key>PBXProjectModuleLabel</key>
+								<string>Files</string>
+								<key>PBXProjectStructureProvided</key>
+								<string>no</string>
+								<key>PBXSmartGroupTreeModuleColumnData</key>
+								<dict>
+									<key>PBXSmartGroupTreeModuleColumnWidthsKey</key>
+									<array>
+										<real>168</real>
+									</array>
+									<key>PBXSmartGroupTreeModuleColumnsKey_v4</key>
+									<array>
+										<string>MainColumn</string>
+									</array>
+								</dict>
+								<key>PBXSmartGroupTreeModuleOutlineStateKey_v7</key>
+								<dict>
+									<key>PBXSmartGroupTreeModuleOutlineStateExpansionKey</key>
+									<array>
+										<string>1C77FABC04509CD000000102</string>
+									</array>
+									<key>PBXSmartGroupTreeModuleOutlineStateSelectionKey</key>
+									<array>
+										<array>
+											<integer>0</integer>
+										</array>
+									</array>
+									<key>PBXSmartGroupTreeModuleOutlineStateVisibleRectKey</key>
+									<string>{{0, 0}, {168, 350}}</string>
+								</dict>
+								<key>PBXTopSmartGroupGIDs</key>
+								<array/>
+								<key>XCIncludePerspectivesSwitch</key>
+								<integer>0</integer>
+							</dict>
+							<key>GeometryConfiguration</key>
+							<dict>
+								<key>Frame</key>
+								<string>{{0, 0}, {185, 368}}</string>
+								<key>GroupTreeTableConfiguration</key>
+								<array>
+									<string>MainColumn</string>
+									<real>168</real>
+								</array>
+								<key>RubberWindowFrame</key>
+								<string>315 424 744 409 0 0 1440 878 </string>
+							</dict>
+							<key>Module</key>
+							<string>PBXSmartGroupTreeModule</string>
+							<key>Proportion</key>
+							<string>185pt</string>
+						</dict>
+						<dict>
+							<key>ContentConfiguration</key>
+							<dict>
+								<key>PBXProjectModuleGUID</key>
+								<string>1CA1AED706398EBD00589147</string>
+								<key>PBXProjectModuleLabel</key>
+								<string>Detail</string>
+							</dict>
+							<key>GeometryConfiguration</key>
+							<dict>
+								<key>Frame</key>
+								<string>{{190, 0}, {554, 368}}</string>
+								<key>RubberWindowFrame</key>
+								<string>315 424 744 409 0 0 1440 878 </string>
+							</dict>
+							<key>Module</key>
+							<string>XCDetailModule</string>
+							<key>Proportion</key>
+							<string>554pt</string>
+						</dict>
+					</array>
+					<key>Proportion</key>
+					<string>368pt</string>
+				</dict>
+			</array>
+			<key>MajorVersion</key>
+			<integer>3</integer>
+			<key>MinorVersion</key>
+			<integer>0</integer>
+			<key>Name</key>
+			<string>Breakpoints</string>
+			<key>ServiceClasses</key>
+			<array>
+				<string>PBXSmartGroupTreeModule</string>
+				<string>XCDetailModule</string>
+			</array>
+			<key>StatusbarIsVisible</key>
+			<integer>1</integer>
+			<key>TableOfContents</key>
+			<array>
+				<string>1CDDB66807F98D9800BB5817</string>
+				<string>1CDDB66907F98D9800BB5817</string>
+				<string>1CE0B1FE06471DED0097A5F4</string>
+				<string>1CA1AED706398EBD00589147</string>
+			</array>
+			<key>ToolbarConfiguration</key>
+			<string>xcode.toolbar.config.breakpointsV3</string>
+			<key>WindowString</key>
+			<string>315 424 744 409 0 0 1440 878 </string>
+			<key>WindowToolGUID</key>
+			<string>1CDDB66807F98D9800BB5817</string>
+			<key>WindowToolIsVisible</key>
+			<integer>1</integer>
+		</dict>
+		<dict>
+			<key>Identifier</key>
+			<string>windowTool.debugAnimator</string>
+			<key>Layout</key>
+			<array>
+				<dict>
+					<key>Dock</key>
+					<array>
+						<dict>
+							<key>Module</key>
+							<string>PBXNavigatorGroup</string>
+							<key>Proportion</key>
+							<string>100%</string>
+						</dict>
+					</array>
+					<key>Proportion</key>
+					<string>100%</string>
+				</dict>
+			</array>
+			<key>Name</key>
+			<string>Debug Visualizer</string>
+			<key>ServiceClasses</key>
+			<array>
+				<string>PBXNavigatorGroup</string>
+			</array>
+			<key>StatusbarIsVisible</key>
+			<integer>1</integer>
+			<key>ToolbarConfiguration</key>
+			<string>xcode.toolbar.config.debugAnimatorV3</string>
+			<key>WindowString</key>
+			<string>100 100 700 500 0 0 1280 1002 </string>
+		</dict>
+		<dict>
+			<key>Identifier</key>
+			<string>windowTool.bookmarks</string>
+			<key>Layout</key>
+			<array>
+				<dict>
+					<key>Dock</key>
+					<array>
+						<dict>
+							<key>Module</key>
+							<string>PBXBookmarksModule</string>
+							<key>Proportion</key>
+							<string>100%</string>
+						</dict>
+					</array>
+					<key>Proportion</key>
+					<string>100%</string>
+				</dict>
+			</array>
+			<key>Name</key>
+			<string>Bookmarks</string>
+			<key>ServiceClasses</key>
+			<array>
+				<string>PBXBookmarksModule</string>
+			</array>
+			<key>StatusbarIsVisible</key>
+			<integer>0</integer>
+			<key>WindowString</key>
+			<string>538 42 401 187 0 0 1280 1002 </string>
+		</dict>
+		<dict>
+			<key>Identifier</key>
+			<string>windowTool.projectFormatConflicts</string>
+			<key>Layout</key>
+			<array>
+				<dict>
+					<key>Dock</key>
+					<array>
+						<dict>
+							<key>Module</key>
+							<string>XCProjectFormatConflictsModule</string>
+							<key>Proportion</key>
+							<string>100%</string>
+						</dict>
+					</array>
+					<key>Proportion</key>
+					<string>100%</string>
+				</dict>
+			</array>
+			<key>Name</key>
+			<string>Project Format Conflicts</string>
+			<key>ServiceClasses</key>
+			<array>
+				<string>XCProjectFormatConflictsModule</string>
+			</array>
+			<key>StatusbarIsVisible</key>
+			<integer>0</integer>
+			<key>WindowContentMinSize</key>
+			<string>450 300</string>
+			<key>WindowString</key>
+			<string>50 850 472 307 0 0 1440 877</string>
+		</dict>
+		<dict>
+			<key>Identifier</key>
+			<string>windowTool.classBrowser</string>
+			<key>Layout</key>
+			<array>
+				<dict>
+					<key>Dock</key>
+					<array>
+						<dict>
+							<key>BecomeActive</key>
+							<integer>1</integer>
+							<key>ContentConfiguration</key>
+							<dict>
+								<key>OptionsSetName</key>
+								<string>Hierarchy, all classes</string>
+								<key>PBXProjectModuleGUID</key>
+								<string>1CA6456E063B45B4001379D8</string>
+								<key>PBXProjectModuleLabel</key>
+								<string>Class Browser - NSObject</string>
+							</dict>
+							<key>GeometryConfiguration</key>
+							<dict>
+								<key>ClassesFrame</key>
+								<string>{{0, 0}, {374, 96}}</string>
+								<key>ClassesTreeTableConfiguration</key>
+								<array>
+									<string>PBXClassNameColumnIdentifier</string>
+									<real>208</real>
+									<string>PBXClassBookColumnIdentifier</string>
+									<real>22</real>
+								</array>
+								<key>Frame</key>
+								<string>{{0, 0}, {630, 331}}</string>
+								<key>MembersFrame</key>
+								<string>{{0, 105}, {374, 395}}</string>
+								<key>MembersTreeTableConfiguration</key>
+								<array>
+									<string>PBXMemberTypeIconColumnIdentifier</string>
+									<real>22</real>
+									<string>PBXMemberNameColumnIdentifier</string>
+									<real>216</real>
+									<string>PBXMemberTypeColumnIdentifier</string>
+									<real>97</real>
+									<string>PBXMemberBookColumnIdentifier</string>
+									<real>22</real>
+								</array>
+								<key>PBXModuleWindowStatusBarHidden2</key>
+								<integer>1</integer>
+								<key>RubberWindowFrame</key>
+								<string>385 179 630 352 0 0 1440 878 </string>
+							</dict>
+							<key>Module</key>
+							<string>PBXClassBrowserModule</string>
+							<key>Proportion</key>
+							<string>332pt</string>
+						</dict>
+					</array>
+					<key>Proportion</key>
+					<string>332pt</string>
+				</dict>
+			</array>
+			<key>Name</key>
+			<string>Class Browser</string>
+			<key>ServiceClasses</key>
+			<array>
+				<string>PBXClassBrowserModule</string>
+			</array>
+			<key>StatusbarIsVisible</key>
+			<integer>0</integer>
+			<key>TableOfContents</key>
+			<array>
+				<string>1C0AD2AF069F1E9B00FABCE6</string>
+				<string>1C0AD2B0069F1E9B00FABCE6</string>
+				<string>1CA6456E063B45B4001379D8</string>
+			</array>
+			<key>ToolbarConfiguration</key>
+			<string>xcode.toolbar.config.classbrowser</string>
+			<key>WindowString</key>
+			<string>385 179 630 352 0 0 1440 878 </string>
+			<key>WindowToolGUID</key>
+			<string>1C0AD2AF069F1E9B00FABCE6</string>
+			<key>WindowToolIsVisible</key>
+			<integer>0</integer>
+		</dict>
+		<dict>
+			<key>Identifier</key>
+			<string>windowTool.refactoring</string>
+			<key>IncludeInToolsMenu</key>
+			<integer>0</integer>
+			<key>Layout</key>
+			<array>
+				<dict>
+					<key>Dock</key>
+					<array>
+						<dict>
+							<key>BecomeActive</key>
+							<integer>1</integer>
+							<key>GeometryConfiguration</key>
+							<dict>
+								<key>Frame</key>
+								<string>{0, 0}, {500, 335}</string>
+								<key>RubberWindowFrame</key>
+								<string>{0, 0}, {500, 335}</string>
+							</dict>
+							<key>Module</key>
+							<string>XCRefactoringModule</string>
+							<key>Proportion</key>
+							<string>100%</string>
+						</dict>
+					</array>
+					<key>Proportion</key>
+					<string>100%</string>
+				</dict>
+			</array>
+			<key>Name</key>
+			<string>Refactoring</string>
+			<key>ServiceClasses</key>
+			<array>
+				<string>XCRefactoringModule</string>
+			</array>
+			<key>WindowString</key>
+			<string>200 200 500 356 0 0 1920 1200 </string>
+		</dict>
+	</array>
+</dict>
+</plist>
diff --git a/plugins/MacAU/PocketVerbs/PocketVerbs.xcodeproj/christopherjohnson.pbxuser b/plugins/MacAU/PocketVerbs/PocketVerbs.xcodeproj/christopherjohnson.pbxuser
new file mode 100755
index 0000000..7fbbf18
--- /dev/null
+++ b/plugins/MacAU/PocketVerbs/PocketVerbs.xcodeproj/christopherjohnson.pbxuser
@@ -0,0 +1,149 @@
+// !$*UTF8*$!
+{
+	089C1669FE841209C02AAC07 /* Project object */ = {
+		activeBuildConfigurationName = Release;
+		activeTarget = 8D01CCC60486CAD60068D4B7 /* PocketVerbs */;
+		codeSenseManager = 8BD3CCB9148830B20062E48C /* Code sense */;
+		perUserDictionary = {
+			PBXConfiguration.PBXFileTableDataSource3.PBXFileTableDataSource = {
+				PBXFileTableDataSourceColumnSortingDirectionKey = "-1";
+				PBXFileTableDataSourceColumnSortingKey = PBXFileDataSource_Filename_ColumnID;
+				PBXFileTableDataSourceColumnWidthsKey = (
+					20,
+					364,
+					20,
+					48,
+					43,
+					43,
+					20,
+				);
+				PBXFileTableDataSourceColumnsKey = (
+					PBXFileDataSource_FiletypeID,
+					PBXFileDataSource_Filename_ColumnID,
+					PBXFileDataSource_Built_ColumnID,
+					PBXFileDataSource_ObjectSize_ColumnID,
+					PBXFileDataSource_Errors_ColumnID,
+					PBXFileDataSource_Warnings_ColumnID,
+					PBXFileDataSource_Target_ColumnID,
+				);
+			};
+			PBXConfiguration.PBXTargetDataSource.PBXTargetDataSource = {
+				PBXFileTableDataSourceColumnSortingDirectionKey = "-1";
+				PBXFileTableDataSourceColumnSortingKey = PBXFileDataSource_Filename_ColumnID;
+				PBXFileTableDataSourceColumnWidthsKey = (
+					20,
+					301,
+					60,
+					20,
+					48,
+					43,
+					43,
+				);
+				PBXFileTableDataSourceColumnsKey = (
+					PBXFileDataSource_FiletypeID,
+					PBXFileDataSource_Filename_ColumnID,
+					PBXTargetDataSource_PrimaryAttribute,
+					PBXFileDataSource_Built_ColumnID,
+					PBXFileDataSource_ObjectSize_ColumnID,
+					PBXFileDataSource_Errors_ColumnID,
+					PBXFileDataSource_Warnings_ColumnID,
+				);
+			};
+			PBXPerProjectTemplateStateSaveDate = 595625819;
+			PBXWorkspaceStateSaveDate = 595625819;
+		};
+		perUserProjectItems = {
+			8B0639D12380A76700606DBC /* PBXTextBookmark */ = 8B0639D12380A76700606DBC /* PBXTextBookmark */;
+			8B0639D22380A76700606DBC /* PBXTextBookmark */ = 8B0639D22380A76700606DBC /* PBXTextBookmark */;
+			8B0639D32380A76700606DBC /* PBXTextBookmark */ = 8B0639D32380A76700606DBC /* PBXTextBookmark */;
+		};
+		sourceControlManager = 8BD3CCB8148830B20062E48C /* Source Control */;
+		userBuildSettings = {
+		};
+	};
+	8B0639D12380A76700606DBC /* PBXTextBookmark */ = {
+		isa = PBXTextBookmark;
+		fRef = 8BA05A690720730100365D66 /* PocketVerbsVersion.h */;
+		name = "PocketVerbsVersion.h: 48";
+		rLen = 0;
+		rLoc = 2728;
+		rType = 0;
+		vrLen = 87;
+		vrLoc = 2683;
+	};
+	8B0639D22380A76700606DBC /* PBXTextBookmark */ = {
+		isa = PBXTextBookmark;
+		fRef = 8BA05A660720730100365D66 /* PocketVerbs.cpp */;
+		name = "PocketVerbs.cpp: 325";
+		rLen = 0;
+		rLoc = 15455;
+		rType = 0;
+		vrLen = 87;
+		vrLoc = 14950;
+	};
+	8B0639D32380A76700606DBC /* PBXTextBookmark */ = {
+		isa = PBXTextBookmark;
+		fRef = 8BA05A660720730100365D66 /* PocketVerbs.cpp */;
+		name = "PocketVerbs.cpp: 325";
+		rLen = 0;
+		rLoc = 15455;
+		rType = 0;
+		vrLen = 87;
+		vrLoc = 14950;
+	};
+	8BA05A660720730100365D66 /* PocketVerbs.cpp */ = {
+		uiCtxt = {
+			sepNavIntBoundsRect = "{{0, 0}, {1111, 62803}}";
+			sepNavSelRange = "{15455, 0}";
+			sepNavVisRange = "{14950, 87}";
+			sepNavWindowFrame = "{{518, 57}, {908, 821}}";
+		};
+	};
+	8BA05A670720730100365D66 /* PocketVerbs.exp */ = {
+		uiCtxt = {
+			sepNavIntBoundsRect = "{{0, 0}, {588, 259}}";
+			sepNavSelRange = "{0, 0}";
+			sepNavVisRange = "{0, 18}";
+		};
+	};
+	8BA05A680720730100365D66 /* PocketVerbs.r */ = {
+		uiCtxt = {
+			sepNavIntBoundsRect = "{{0, 0}, {702, 627}}";
+			sepNavSelRange = "{0, 0}";
+			sepNavVisRange = "{0, 1442}";
+		};
+	};
+	8BA05A690720730100365D66 /* PocketVerbsVersion.h */ = {
+		uiCtxt = {
+			sepNavIntBoundsRect = "{{0, 0}, {803, 936}}";
+			sepNavSelRange = "{2728, 0}";
+			sepNavVisRange = "{2683, 87}";
+			sepNavWindowFrame = "{{575, 67}, {834, 801}}";
+		};
+	};
+	8BC6025B073B072D006C4272 /* PocketVerbs.h */ = {
+		uiCtxt = {
+			sepNavIntBoundsRect = "{{0, 0}, {1041, 3523}}";
+			sepNavSelRange = "{5987, 0}";
+			sepNavVisRange = "{3031, 1879}";
+			sepNavWindowFrame = "{{546, 57}, {885, 821}}";
+		};
+	};
+	8BD3CCB8148830B20062E48C /* Source Control */ = {
+		isa = PBXSourceControlManager;
+		fallbackIsa = XCSourceControlManager;
+		isSCMEnabled = 0;
+		scmConfiguration = {
+			repositoryNamesForRoots = {
+				"" = "";
+			};
+		};
+	};
+	8BD3CCB9148830B20062E48C /* Code sense */ = {
+		isa = PBXCodeSenseManager;
+		indexTemplatePath = "";
+	};
+	8D01CCC60486CAD60068D4B7 /* PocketVerbs */ = {
+		activeExec = 0;
+	};
+}
diff --git a/plugins/MacAU/PocketVerbs/PocketVerbs.xcodeproj/christopherjohnson.perspectivev3 b/plugins/MacAU/PocketVerbs/PocketVerbs.xcodeproj/christopherjohnson.perspectivev3
new file mode 100755
index 0000000..37ac50e
--- /dev/null
+++ b/plugins/MacAU/PocketVerbs/PocketVerbs.xcodeproj/christopherjohnson.perspectivev3
@@ -0,0 +1,1485 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>ActivePerspectiveName</key>
+	<string>Project</string>
+	<key>AllowedModules</key>
+	<array>
+		<dict>
+			<key>BundleLoadPath</key>
+			<string></string>
+			<key>MaxInstances</key>
+			<string>n</string>
+			<key>Module</key>
+			<string>PBXSmartGroupTreeModule</string>
+			<key>Name</key>
+			<string>Groups and Files Outline View</string>
+		</dict>
+		<dict>
+			<key>BundleLoadPath</key>
+			<string></string>
+			<key>MaxInstances</key>
+			<string>n</string>
+			<key>Module</key>
+			<string>PBXNavigatorGroup</string>
+			<key>Name</key>
+			<string>Editor</string>
+		</dict>
+		<dict>
+			<key>BundleLoadPath</key>
+			<string></string>
+			<key>MaxInstances</key>
+			<string>n</string>
+			<key>Module</key>
+			<string>XCTaskListModule</string>
+			<key>Name</key>
+			<string>Task List</string>
+		</dict>
+		<dict>
+			<key>BundleLoadPath</key>
+			<string></string>
+			<key>MaxInstances</key>
+			<string>n</string>
+			<key>Module</key>
+			<string>XCDetailModule</string>
+			<key>Name</key>
+			<string>File and Smart Group Detail Viewer</string>
+		</dict>
+		<dict>
+			<key>BundleLoadPath</key>
+			<string></string>
+			<key>MaxInstances</key>
+			<string>1</string>
+			<key>Module</key>
+			<string>PBXBuildResultsModule</string>
+			<key>Name</key>
+			<string>Detailed Build Results Viewer</string>
+		</dict>
+		<dict>
+			<key>BundleLoadPath</key>
+			<string></string>
+			<key>MaxInstances</key>
+			<string>1</string>
+			<key>Module</key>
+			<string>PBXProjectFindModule</string>
+			<key>Name</key>
+			<string>Project Batch Find Tool</string>
+		</dict>
+		<dict>
+			<key>BundleLoadPath</key>
+			<string></string>
+			<key>MaxInstances</key>
+			<string>n</string>
+			<key>Module</key>
+			<string>XCProjectFormatConflictsModule</string>
+			<key>Name</key>
+			<string>Project Format Conflicts List</string>
+		</dict>
+		<dict>
+			<key>BundleLoadPath</key>
+			<string></string>
+			<key>MaxInstances</key>
+			<string>n</string>
+			<key>Module</key>
+			<string>PBXBookmarksModule</string>
+			<key>Name</key>
+			<string>Bookmarks Tool</string>
+		</dict>
+		<dict>
+			<key>BundleLoadPath</key>
+			<string></string>
+			<key>MaxInstances</key>
+			<string>n</string>
+			<key>Module</key>
+			<string>PBXClassBrowserModule</string>
+			<key>Name</key>
+			<string>Class Browser</string>
+		</dict>
+		<dict>
+			<key>BundleLoadPath</key>
+			<string></string>
+			<key>MaxInstances</key>
+			<string>n</string>
+			<key>Module</key>
+			<string>PBXCVSModule</string>
+			<key>Name</key>
+			<string>Source Code Control Tool</string>
+		</dict>
+		<dict>
+			<key>BundleLoadPath</key>
+			<string></string>
+			<key>MaxInstances</key>
+			<string>n</string>
+			<key>Module</key>
+			<string>PBXDebugBreakpointsModule</string>
+			<key>Name</key>
+			<string>Debug Breakpoints Tool</string>
+		</dict>
+		<dict>
+			<key>BundleLoadPath</key>
+			<string></string>
+			<key>MaxInstances</key>
+			<string>n</string>
+			<key>Module</key>
+			<string>XCDockableInspector</string>
+			<key>Name</key>
+			<string>Inspector</string>
+		</dict>
+		<dict>
+			<key>BundleLoadPath</key>
+			<string></string>
+			<key>MaxInstances</key>
+			<string>n</string>
+			<key>Module</key>
+			<string>PBXOpenQuicklyModule</string>
+			<key>Name</key>
+			<string>Open Quickly Tool</string>
+		</dict>
+		<dict>
+			<key>BundleLoadPath</key>
+			<string></string>
+			<key>MaxInstances</key>
+			<string>1</string>
+			<key>Module</key>
+			<string>PBXDebugSessionModule</string>
+			<key>Name</key>
+			<string>Debugger</string>
+		</dict>
+		<dict>
+			<key>BundleLoadPath</key>
+			<string></string>
+			<key>MaxInstances</key>
+			<string>1</string>
+			<key>Module</key>
+			<string>PBXDebugCLIModule</string>
+			<key>Name</key>
+			<string>Debug Console</string>
+		</dict>
+		<dict>
+			<key>BundleLoadPath</key>
+			<string></string>
+			<key>MaxInstances</key>
+			<string>n</string>
+			<key>Module</key>
+			<string>XCSnapshotModule</string>
+			<key>Name</key>
+			<string>Snapshots Tool</string>
+		</dict>
+	</array>
+	<key>BundlePath</key>
+	<string>/Developer/Library/PrivateFrameworks/DevToolsInterface.framework/Resources</string>
+	<key>Description</key>
+	<string>AIODescriptionKey</string>
+	<key>DockingSystemVisible</key>
+	<false/>
+	<key>Extension</key>
+	<string>perspectivev3</string>
+	<key>FavBarConfig</key>
+	<dict>
+		<key>PBXProjectModuleGUID</key>
+		<string>8BEED1FF1EA54DCA0094708A</string>
+		<key>XCBarModuleItemNames</key>
+		<dict/>
+		<key>XCBarModuleItems</key>
+		<array/>
+	</dict>
+	<key>FirstTimeWindowDisplayed</key>
+	<false/>
+	<key>Identifier</key>
+	<string>com.apple.perspectives.project.defaultV3</string>
+	<key>MajorVersion</key>
+	<integer>34</integer>
+	<key>MinorVersion</key>
+	<integer>0</integer>
+	<key>Name</key>
+	<string>All-In-One</string>
+	<key>Notifications</key>
+	<array>
+		<dict>
+			<key>XCObserverAutoDisconnectKey</key>
+			<true/>
+			<key>XCObserverDefintionKey</key>
+			<dict>
+				<key>PBXStatusErrorsKey</key>
+				<integer>0</integer>
+			</dict>
+			<key>XCObserverFactoryKey</key>
+			<string>XCPerspectivesSpecificationIdentifier</string>
+			<key>XCObserverGUIDKey</key>
+			<string>XCObserverProjectIdentifier</string>
+			<key>XCObserverNotificationKey</key>
+			<string>PBXStatusBuildStateMessageNotification</string>
+			<key>XCObserverTargetKey</key>
+			<string>XCMainBuildResultsModuleGUID</string>
+			<key>XCObserverTriggerKey</key>
+			<string>awakenModuleWithObserver:</string>
+			<key>XCObserverValidationKey</key>
+			<dict>
+				<key>PBXStatusErrorsKey</key>
+				<integer>2</integer>
+			</dict>
+		</dict>
+	</array>
+	<key>OpenEditors</key>
+	<array/>
+	<key>PerspectiveWidths</key>
+	<array>
+		<integer>-1</integer>
+		<integer>-1</integer>
+	</array>
+	<key>Perspectives</key>
+	<array>
+		<dict>
+			<key>ChosenToolbarItems</key>
+			<array>
+				<string>XCToolbarPerspectiveControl</string>
+				<string>NSToolbarSeparatorItem</string>
+				<string>active-combo-popup</string>
+				<string>action</string>
+				<string>NSToolbarFlexibleSpaceItem</string>
+				<string>debugger-enable-breakpoints</string>
+				<string>build-and-go</string>
+				<string>com.apple.ide.PBXToolbarStopButton</string>
+				<string>get-info</string>
+				<string>NSToolbarFlexibleSpaceItem</string>
+				<string>com.apple.pbx.toolbar.searchfield</string>
+			</array>
+			<key>ControllerClassBaseName</key>
+			<string></string>
+			<key>IconName</key>
+			<string>WindowOfProject</string>
+			<key>Identifier</key>
+			<string>perspective.project</string>
+			<key>IsVertical</key>
+			<false/>
+			<key>Layout</key>
+			<array>
+				<dict>
+					<key>BecomeActive</key>
+					<true/>
+					<key>ContentConfiguration</key>
+					<dict>
+						<key>PBXBottomSmartGroupGIDs</key>
+						<array>
+							<string>1C37FBAC04509CD000000102</string>
+							<string>1C37FAAC04509CD000000102</string>
+							<string>1C37FABC05509CD000000102</string>
+							<string>1C37FABC05539CD112110102</string>
+							<string>E2644B35053B69B200211256</string>
+							<string>1C37FABC04509CD000100104</string>
+							<string>1CC0EA4004350EF90044410B</string>
+							<string>1CC0EA4004350EF90041110B</string>
+							<string>1C77FABC04509CD000000102</string>
+						</array>
+						<key>PBXProjectModuleGUID</key>
+						<string>1CA23ED40692098700951B8B</string>
+						<key>PBXProjectModuleLabel</key>
+						<string>Files</string>
+						<key>PBXProjectStructureProvided</key>
+						<string>yes</string>
+						<key>PBXSmartGroupTreeModuleColumnData</key>
+						<dict>
+							<key>PBXSmartGroupTreeModuleColumnWidthsKey</key>
+							<array>
+								<real>185</real>
+							</array>
+							<key>PBXSmartGroupTreeModuleColumnsKey_v4</key>
+							<array>
+								<string>MainColumn</string>
+							</array>
+						</dict>
+						<key>PBXSmartGroupTreeModuleOutlineStateKey_v7</key>
+						<dict>
+							<key>PBXSmartGroupTreeModuleOutlineStateExpansionKey</key>
+							<array>
+								<string>089C166AFE841209C02AAC07</string>
+								<string>08FB77ADFE841716C02AAC07</string>
+								<string>8BA05A56072072A900365D66</string>
+							</array>
+							<key>PBXSmartGroupTreeModuleOutlineStateSelectionKey</key>
+							<array>
+								<array>
+									<integer>4</integer>
+									<integer>2</integer>
+									<integer>1</integer>
+									<integer>0</integer>
+								</array>
+							</array>
+							<key>PBXSmartGroupTreeModuleOutlineStateVisibleRectKey</key>
+							<string>{{0, 0}, {185, 428}}</string>
+						</dict>
+						<key>PBXTopSmartGroupGIDs</key>
+						<array/>
+						<key>XCIncludePerspectivesSwitch</key>
+						<false/>
+					</dict>
+					<key>GeometryConfiguration</key>
+					<dict>
+						<key>Frame</key>
+						<string>{{0, 0}, {202, 446}}</string>
+						<key>GroupTreeTableConfiguration</key>
+						<array>
+							<string>MainColumn</string>
+							<real>185</real>
+						</array>
+						<key>RubberWindowFrame</key>
+						<string>620 386 810 487 0 0 1440 878 </string>
+					</dict>
+					<key>Module</key>
+					<string>PBXSmartGroupTreeModule</string>
+					<key>Proportion</key>
+					<string>202pt</string>
+				</dict>
+				<dict>
+					<key>Dock</key>
+					<array>
+						<dict>
+							<key>ContentConfiguration</key>
+							<dict>
+								<key>PBXProjectModuleGUID</key>
+								<string>8BEED1FA1EA54DCA0094708A</string>
+								<key>PBXProjectModuleLabel</key>
+								<string>PocketVerbs.cpp</string>
+								<key>PBXSplitModuleInNavigatorKey</key>
+								<dict>
+									<key>Split0</key>
+									<dict>
+										<key>PBXProjectModuleGUID</key>
+										<string>8BEED1FB1EA54DCA0094708A</string>
+										<key>PBXProjectModuleLabel</key>
+										<string>PocketVerbs.cpp</string>
+										<key>_historyCapacity</key>
+										<integer>0</integer>
+										<key>bookmark</key>
+										<string>8B0639D32380A76700606DBC</string>
+										<key>history</key>
+										<array>
+											<string>8B0639D12380A76700606DBC</string>
+											<string>8B0639D22380A76700606DBC</string>
+										</array>
+									</dict>
+									<key>SplitCount</key>
+									<string>1</string>
+								</dict>
+								<key>StatusBarVisibility</key>
+								<true/>
+								<key>XCSharingToken</key>
+								<string>com.apple.Xcode.CommonNavigatorGroupSharingToken</string>
+							</dict>
+							<key>GeometryConfiguration</key>
+							<dict>
+								<key>Frame</key>
+								<string>{{0, 0}, {603, 51}}</string>
+								<key>RubberWindowFrame</key>
+								<string>620 386 810 487 0 0 1440 878 </string>
+							</dict>
+							<key>Module</key>
+							<string>PBXNavigatorGroup</string>
+							<key>Proportion</key>
+							<string>51pt</string>
+						</dict>
+						<dict>
+							<key>Proportion</key>
+							<string>390pt</string>
+							<key>Tabs</key>
+							<array>
+								<dict>
+									<key>ContentConfiguration</key>
+									<dict>
+										<key>PBXProjectModuleGUID</key>
+										<string>1CA23EDF0692099D00951B8B</string>
+										<key>PBXProjectModuleLabel</key>
+										<string>Detail</string>
+									</dict>
+									<key>GeometryConfiguration</key>
+									<dict>
+										<key>Frame</key>
+										<string>{{10, 27}, {603, 363}}</string>
+										<key>RubberWindowFrame</key>
+										<string>620 386 810 487 0 0 1440 878 </string>
+									</dict>
+									<key>Module</key>
+									<string>XCDetailModule</string>
+								</dict>
+								<dict>
+									<key>ContentConfiguration</key>
+									<dict>
+										<key>PBXProjectModuleGUID</key>
+										<string>1CA23EE00692099D00951B8B</string>
+										<key>PBXProjectModuleLabel</key>
+										<string>Project Find</string>
+									</dict>
+									<key>GeometryConfiguration</key>
+									<dict>
+										<key>Frame</key>
+										<string>{{10, 31}, {603, 297}}</string>
+									</dict>
+									<key>Module</key>
+									<string>PBXProjectFindModule</string>
+								</dict>
+								<dict>
+									<key>ContentConfiguration</key>
+									<dict>
+										<key>PBXCVSModuleFilterTypeKey</key>
+										<integer>1032</integer>
+										<key>PBXProjectModuleGUID</key>
+										<string>1CA23EE10692099D00951B8B</string>
+										<key>PBXProjectModuleLabel</key>
+										<string>SCM Results</string>
+									</dict>
+									<key>GeometryConfiguration</key>
+									<dict>
+										<key>Frame</key>
+										<string>{{10, 31}, {603, 297}}</string>
+									</dict>
+									<key>Module</key>
+									<string>PBXCVSModule</string>
+								</dict>
+								<dict>
+									<key>ContentConfiguration</key>
+									<dict>
+										<key>PBXProjectModuleGUID</key>
+										<string>XCMainBuildResultsModuleGUID</string>
+										<key>PBXProjectModuleLabel</key>
+										<string>Build Results</string>
+										<key>XCBuildResultsTrigger_Collapse</key>
+										<integer>1023</integer>
+										<key>XCBuildResultsTrigger_Open</key>
+										<integer>1012</integer>
+									</dict>
+									<key>GeometryConfiguration</key>
+									<dict>
+										<key>Frame</key>
+										<string>{{10, 31}, {603, 297}}</string>
+									</dict>
+									<key>Module</key>
+									<string>PBXBuildResultsModule</string>
+								</dict>
+							</array>
+						</dict>
+					</array>
+					<key>Proportion</key>
+					<string>603pt</string>
+				</dict>
+			</array>
+			<key>Name</key>
+			<string>Project</string>
+			<key>ServiceClasses</key>
+			<array>
+				<string>XCModuleDock</string>
+				<string>PBXSmartGroupTreeModule</string>
+				<string>XCModuleDock</string>
+				<string>PBXNavigatorGroup</string>
+				<string>XCDockableTabModule</string>
+				<string>XCDetailModule</string>
+				<string>PBXProjectFindModule</string>
+				<string>PBXCVSModule</string>
+				<string>PBXBuildResultsModule</string>
+			</array>
+			<key>TableOfContents</key>
+			<array>
+				<string>8B0639D42380A76700606DBC</string>
+				<string>1CA23ED40692098700951B8B</string>
+				<string>8B0639D52380A76700606DBC</string>
+				<string>8BEED1FA1EA54DCA0094708A</string>
+				<string>8B0639D62380A76700606DBC</string>
+				<string>1CA23EDF0692099D00951B8B</string>
+				<string>1CA23EE00692099D00951B8B</string>
+				<string>1CA23EE10692099D00951B8B</string>
+				<string>XCMainBuildResultsModuleGUID</string>
+			</array>
+			<key>ToolbarConfigUserDefaultsMinorVersion</key>
+			<string>2</string>
+			<key>ToolbarConfiguration</key>
+			<string>xcode.toolbar.config.defaultV3</string>
+		</dict>
+		<dict>
+			<key>ChosenToolbarItems</key>
+			<array>
+				<string>XCToolbarPerspectiveControl</string>
+				<string>NSToolbarSeparatorItem</string>
+				<string>active-combo-popup</string>
+				<string>NSToolbarFlexibleSpaceItem</string>
+				<string>debugger-enable-breakpoints</string>
+				<string>build-and-go</string>
+				<string>com.apple.ide.PBXToolbarStopButton</string>
+				<string>debugger-restart-executable</string>
+				<string>debugger-pause</string>
+				<string>debugger-step-over</string>
+				<string>debugger-step-into</string>
+				<string>debugger-step-out</string>
+				<string>NSToolbarFlexibleSpaceItem</string>
+				<string>servicesModulebreakpoints</string>
+				<string>debugger-show-console-window</string>
+			</array>
+			<key>ControllerClassBaseName</key>
+			<string>PBXDebugSessionModule</string>
+			<key>IconName</key>
+			<string>DebugTabIcon</string>
+			<key>Identifier</key>
+			<string>perspective.debug</string>
+			<key>IsVertical</key>
+			<integer>1</integer>
+			<key>Layout</key>
+			<array>
+				<dict>
+					<key>ContentConfiguration</key>
+					<dict>
+						<key>PBXProjectModuleGUID</key>
+						<string>1CCC7628064C1048000F2A68</string>
+						<key>PBXProjectModuleLabel</key>
+						<string>Debugger Console</string>
+					</dict>
+					<key>GeometryConfiguration</key>
+					<dict>
+						<key>Frame</key>
+						<string>{{0, 0}, {810, 0}}</string>
+					</dict>
+					<key>Module</key>
+					<string>PBXDebugCLIModule</string>
+					<key>Proportion</key>
+					<string>0%</string>
+				</dict>
+				<dict>
+					<key>ContentConfiguration</key>
+					<dict>
+						<key>Debugger</key>
+						<dict>
+							<key>HorizontalSplitView</key>
+							<dict>
+								<key>_collapsingFrameDimension</key>
+								<real>0.0</real>
+								<key>_indexOfCollapsedView</key>
+								<integer>0</integer>
+								<key>_percentageOfCollapsedView</key>
+								<real>0.0</real>
+								<key>isCollapsed</key>
+								<string>yes</string>
+								<key>sizes</key>
+								<array>
+									<string>{{0, 0}, {395, 213}}</string>
+									<string>{{395, 0}, {415, 213}}</string>
+								</array>
+							</dict>
+							<key>VerticalSplitView</key>
+							<dict>
+								<key>_collapsingFrameDimension</key>
+								<real>0.0</real>
+								<key>_indexOfCollapsedView</key>
+								<integer>0</integer>
+								<key>_percentageOfCollapsedView</key>
+								<real>0.0</real>
+								<key>isCollapsed</key>
+								<string>yes</string>
+								<key>sizes</key>
+								<array>
+									<string>{{0, 0}, {810, 213}}</string>
+									<string>{{0, 213}, {810, 225}}</string>
+								</array>
+							</dict>
+						</dict>
+						<key>LauncherConfigVersion</key>
+						<string>8</string>
+						<key>PBXProjectModuleGUID</key>
+						<string>1CCC7629064C1048000F2A68</string>
+						<key>PBXProjectModuleLabel</key>
+						<string>Debug</string>
+					</dict>
+					<key>GeometryConfiguration</key>
+					<dict>
+						<key>DebugConsoleDrawerSize</key>
+						<string>{100, 120}</string>
+						<key>DebugConsoleVisible</key>
+						<string>None</string>
+						<key>DebugConsoleWindowFrame</key>
+						<string>{{200, 200}, {500, 300}}</string>
+						<key>DebugSTDIOWindowFrame</key>
+						<string>{{200, 200}, {500, 300}}</string>
+						<key>Frame</key>
+						<string>{{0, 7}, {810, 438}}</string>
+					</dict>
+					<key>Module</key>
+					<string>PBXDebugSessionModule</string>
+					<key>Proportion</key>
+					<string>443pt</string>
+				</dict>
+			</array>
+			<key>Name</key>
+			<string>Debug</string>
+			<key>ServiceClasses</key>
+			<array>
+				<string>XCModuleDock</string>
+				<string>XCModuleDock</string>
+				<string>PBXDebugCLIModule</string>
+				<string>PBXDebugSessionModule</string>
+				<string>XCConsole</string>
+			</array>
+			<key>TableOfContents</key>
+			<array>
+				<string>1CC8E6A5069209BD00BB180A</string>
+				<string>1CC8E6A6069209BD00BB180A</string>
+				<string>1CCC7628064C1048000F2A68</string>
+				<string>1CCC7629064C1048000F2A68</string>
+				<string>1CC8E6A7069209BD00BB180A</string>
+			</array>
+			<key>ToolbarConfiguration</key>
+			<string>xcode.toolbar.config.debugV3</string>
+		</dict>
+	</array>
+	<key>PerspectivesBarVisible</key>
+	<true/>
+	<key>ShelfIsVisible</key>
+	<false/>
+	<key>SourceDescription</key>
+	<string>file at '/Developer/Library/PrivateFrameworks/DevToolsInterface.framework/Resources/XCPerspectivesSpecification.xcperspec'</string>
+	<key>StatusbarIsVisible</key>
+	<true/>
+	<key>TimeStamp</key>
+	<real>595634023.18682003</real>
+	<key>ToolbarConfigUserDefaultsMinorVersion</key>
+	<string>2</string>
+	<key>ToolbarDisplayMode</key>
+	<integer>1</integer>
+	<key>ToolbarIsVisible</key>
+	<true/>
+	<key>ToolbarSizeMode</key>
+	<integer>2</integer>
+	<key>Type</key>
+	<string>Perspectives</string>
+	<key>UpdateMessage</key>
+	<string></string>
+	<key>WindowJustification</key>
+	<integer>5</integer>
+	<key>WindowOrderList</key>
+	<array>
+		<string>8B0639D72380A76700606DBC</string>
+		<string>/Users/christopherjohnson/Desktop/Plugins/MacAU/PocketVerbs/PocketVerbs.xcodeproj</string>
+	</array>
+	<key>WindowString</key>
+	<string>620 386 810 487 0 0 1440 878 </string>
+	<key>WindowToolsV3</key>
+	<array>
+		<dict>
+			<key>Identifier</key>
+			<string>windowTool.debugger</string>
+			<key>Layout</key>
+			<array>
+				<dict>
+					<key>Dock</key>
+					<array>
+						<dict>
+							<key>ContentConfiguration</key>
+							<dict>
+								<key>Debugger</key>
+								<dict>
+									<key>HorizontalSplitView</key>
+									<dict>
+										<key>_collapsingFrameDimension</key>
+										<real>0.0</real>
+										<key>_indexOfCollapsedView</key>
+										<integer>0</integer>
+										<key>_percentageOfCollapsedView</key>
+										<real>0.0</real>
+										<key>isCollapsed</key>
+										<string>yes</string>
+										<key>sizes</key>
+										<array>
+											<string>{{0, 0}, {317, 164}}</string>
+											<string>{{317, 0}, {377, 164}}</string>
+										</array>
+									</dict>
+									<key>VerticalSplitView</key>
+									<dict>
+										<key>_collapsingFrameDimension</key>
+										<real>0.0</real>
+										<key>_indexOfCollapsedView</key>
+										<integer>0</integer>
+										<key>_percentageOfCollapsedView</key>
+										<real>0.0</real>
+										<key>isCollapsed</key>
+										<string>yes</string>
+										<key>sizes</key>
+										<array>
+											<string>{{0, 0}, {694, 164}}</string>
+											<string>{{0, 164}, {694, 216}}</string>
+										</array>
+									</dict>
+								</dict>
+								<key>LauncherConfigVersion</key>
+								<string>8</string>
+								<key>PBXProjectModuleGUID</key>
+								<string>1C162984064C10D400B95A72</string>
+								<key>PBXProjectModuleLabel</key>
+								<string>Debug - GLUTExamples (Underwater)</string>
+							</dict>
+							<key>GeometryConfiguration</key>
+							<dict>
+								<key>DebugConsoleDrawerSize</key>
+								<string>{100, 120}</string>
+								<key>DebugConsoleVisible</key>
+								<string>None</string>
+								<key>DebugConsoleWindowFrame</key>
+								<string>{{200, 200}, {500, 300}}</string>
+								<key>DebugSTDIOWindowFrame</key>
+								<string>{{200, 200}, {500, 300}}</string>
+								<key>Frame</key>
+								<string>{{0, 0}, {694, 380}}</string>
+								<key>RubberWindowFrame</key>
+								<string>321 238 694 422 0 0 1440 878 </string>
+							</dict>
+							<key>Module</key>
+							<string>PBXDebugSessionModule</string>
+							<key>Proportion</key>
+							<string>100%</string>
+						</dict>
+					</array>
+					<key>Proportion</key>
+					<string>100%</string>
+				</dict>
+			</array>
+			<key>Name</key>
+			<string>Debugger</string>
+			<key>ServiceClasses</key>
+			<array>
+				<string>PBXDebugSessionModule</string>
+			</array>
+			<key>StatusbarIsVisible</key>
+			<integer>1</integer>
+			<key>TableOfContents</key>
+			<array>
+				<string>1CD10A99069EF8BA00B06720</string>
+				<string>1C0AD2AB069F1E9B00FABCE6</string>
+				<string>1C162984064C10D400B95A72</string>
+				<string>1C0AD2AC069F1E9B00FABCE6</string>
+			</array>
+			<key>ToolbarConfiguration</key>
+			<string>xcode.toolbar.config.debugV3</string>
+			<key>WindowString</key>
+			<string>321 238 694 422 0 0 1440 878 </string>
+			<key>WindowToolGUID</key>
+			<string>1CD10A99069EF8BA00B06720</string>
+			<key>WindowToolIsVisible</key>
+			<integer>0</integer>
+		</dict>
+		<dict>
+			<key>Identifier</key>
+			<string>windowTool.build</string>
+			<key>Layout</key>
+			<array>
+				<dict>
+					<key>Dock</key>
+					<array>
+						<dict>
+							<key>ContentConfiguration</key>
+							<dict>
+								<key>PBXProjectModuleGUID</key>
+								<string>1CD0528F0623707200166675</string>
+								<key>PBXProjectModuleLabel</key>
+								<string>&lt;No Editor&gt;</string>
+								<key>PBXSplitModuleInNavigatorKey</key>
+								<dict>
+									<key>Split0</key>
+									<dict>
+										<key>PBXProjectModuleGUID</key>
+										<string>1CD052900623707200166675</string>
+									</dict>
+									<key>SplitCount</key>
+									<string>1</string>
+								</dict>
+								<key>StatusBarVisibility</key>
+								<integer>1</integer>
+							</dict>
+							<key>GeometryConfiguration</key>
+							<dict>
+								<key>Frame</key>
+								<string>{{0, 0}, {500, 215}}</string>
+								<key>RubberWindowFrame</key>
+								<string>192 257 500 500 0 0 1280 1002 </string>
+							</dict>
+							<key>Module</key>
+							<string>PBXNavigatorGroup</string>
+							<key>Proportion</key>
+							<string>218pt</string>
+						</dict>
+						<dict>
+							<key>BecomeActive</key>
+							<integer>1</integer>
+							<key>ContentConfiguration</key>
+							<dict>
+								<key>PBXProjectModuleGUID</key>
+								<string>XCMainBuildResultsModuleGUID</string>
+								<key>PBXProjectModuleLabel</key>
+								<string>Build Results</string>
+							</dict>
+							<key>GeometryConfiguration</key>
+							<dict>
+								<key>Frame</key>
+								<string>{{0, 222}, {500, 236}}</string>
+								<key>RubberWindowFrame</key>
+								<string>192 257 500 500 0 0 1280 1002 </string>
+							</dict>
+							<key>Module</key>
+							<string>PBXBuildResultsModule</string>
+							<key>Proportion</key>
+							<string>236pt</string>
+						</dict>
+					</array>
+					<key>Proportion</key>
+					<string>458pt</string>
+				</dict>
+			</array>
+			<key>Name</key>
+			<string>Build Results</string>
+			<key>ServiceClasses</key>
+			<array>
+				<string>PBXBuildResultsModule</string>
+			</array>
+			<key>StatusbarIsVisible</key>
+			<integer>1</integer>
+			<key>TableOfContents</key>
+			<array>
+				<string>1C78EAA5065D492600B07095</string>
+				<string>1C78EAA6065D492600B07095</string>
+				<string>1CD0528F0623707200166675</string>
+				<string>XCMainBuildResultsModuleGUID</string>
+			</array>
+			<key>ToolbarConfiguration</key>
+			<string>xcode.toolbar.config.buildV3</string>
+			<key>WindowString</key>
+			<string>192 257 500 500 0 0 1280 1002 </string>
+		</dict>
+		<dict>
+			<key>Identifier</key>
+			<string>windowTool.find</string>
+			<key>Layout</key>
+			<array>
+				<dict>
+					<key>Dock</key>
+					<array>
+						<dict>
+							<key>Dock</key>
+							<array>
+								<dict>
+									<key>ContentConfiguration</key>
+									<dict>
+										<key>PBXProjectModuleGUID</key>
+										<string>1CDD528C0622207200134675</string>
+										<key>PBXProjectModuleLabel</key>
+										<string>&lt;No Editor&gt;</string>
+										<key>PBXSplitModuleInNavigatorKey</key>
+										<dict>
+											<key>Split0</key>
+											<dict>
+												<key>PBXProjectModuleGUID</key>
+												<string>1CD0528D0623707200166675</string>
+											</dict>
+											<key>SplitCount</key>
+											<string>1</string>
+										</dict>
+										<key>StatusBarVisibility</key>
+										<integer>1</integer>
+									</dict>
+									<key>GeometryConfiguration</key>
+									<dict>
+										<key>Frame</key>
+										<string>{{0, 0}, {781, 167}}</string>
+										<key>RubberWindowFrame</key>
+										<string>62 385 781 470 0 0 1440 878 </string>
+									</dict>
+									<key>Module</key>
+									<string>PBXNavigatorGroup</string>
+									<key>Proportion</key>
+									<string>781pt</string>
+								</dict>
+							</array>
+							<key>Proportion</key>
+							<string>50%</string>
+						</dict>
+						<dict>
+							<key>BecomeActive</key>
+							<integer>1</integer>
+							<key>ContentConfiguration</key>
+							<dict>
+								<key>PBXProjectModuleGUID</key>
+								<string>1CD0528E0623707200166675</string>
+								<key>PBXProjectModuleLabel</key>
+								<string>Project Find</string>
+							</dict>
+							<key>GeometryConfiguration</key>
+							<dict>
+								<key>Frame</key>
+								<string>{{8, 0}, {773, 254}}</string>
+								<key>RubberWindowFrame</key>
+								<string>62 385 781 470 0 0 1440 878 </string>
+							</dict>
+							<key>Module</key>
+							<string>PBXProjectFindModule</string>
+							<key>Proportion</key>
+							<string>50%</string>
+						</dict>
+					</array>
+					<key>Proportion</key>
+					<string>428pt</string>
+				</dict>
+			</array>
+			<key>Name</key>
+			<string>Project Find</string>
+			<key>ServiceClasses</key>
+			<array>
+				<string>PBXProjectFindModule</string>
+			</array>
+			<key>StatusbarIsVisible</key>
+			<integer>1</integer>
+			<key>TableOfContents</key>
+			<array>
+				<string>1C530D57069F1CE1000CFCEE</string>
+				<string>1C530D58069F1CE1000CFCEE</string>
+				<string>1C530D59069F1CE1000CFCEE</string>
+				<string>1CDD528C0622207200134675</string>
+				<string>1C530D5A069F1CE1000CFCEE</string>
+				<string>1CE0B1FE06471DED0097A5F4</string>
+				<string>1CD0528E0623707200166675</string>
+			</array>
+			<key>WindowString</key>
+			<string>62 385 781 470 0 0 1440 878 </string>
+			<key>WindowToolGUID</key>
+			<string>1C530D57069F1CE1000CFCEE</string>
+			<key>WindowToolIsVisible</key>
+			<integer>0</integer>
+		</dict>
+		<dict>
+			<key>Identifier</key>
+			<string>windowTool.snapshots</string>
+			<key>Layout</key>
+			<array>
+				<dict>
+					<key>Dock</key>
+					<array>
+						<dict>
+							<key>Module</key>
+							<string>XCSnapshotModule</string>
+							<key>Proportion</key>
+							<string>100%</string>
+						</dict>
+					</array>
+					<key>Proportion</key>
+					<string>100%</string>
+				</dict>
+			</array>
+			<key>Name</key>
+			<string>Snapshots</string>
+			<key>ServiceClasses</key>
+			<array>
+				<string>XCSnapshotModule</string>
+			</array>
+			<key>StatusbarIsVisible</key>
+			<string>Yes</string>
+			<key>ToolbarConfiguration</key>
+			<string>xcode.toolbar.config.snapshots</string>
+			<key>WindowString</key>
+			<string>315 824 300 550 0 0 1440 878 </string>
+			<key>WindowToolIsVisible</key>
+			<string>Yes</string>
+		</dict>
+		<dict>
+			<key>Identifier</key>
+			<string>windowTool.debuggerConsole</string>
+			<key>Layout</key>
+			<array>
+				<dict>
+					<key>Dock</key>
+					<array>
+						<dict>
+							<key>BecomeActive</key>
+							<integer>1</integer>
+							<key>ContentConfiguration</key>
+							<dict>
+								<key>PBXProjectModuleGUID</key>
+								<string>1C78EAAC065D492600B07095</string>
+								<key>PBXProjectModuleLabel</key>
+								<string>Debugger Console</string>
+							</dict>
+							<key>GeometryConfiguration</key>
+							<dict>
+								<key>Frame</key>
+								<string>{{0, 0}, {700, 358}}</string>
+								<key>RubberWindowFrame</key>
+								<string>149 87 700 400 0 0 1440 878 </string>
+							</dict>
+							<key>Module</key>
+							<string>PBXDebugCLIModule</string>
+							<key>Proportion</key>
+							<string>358pt</string>
+						</dict>
+					</array>
+					<key>Proportion</key>
+					<string>358pt</string>
+				</dict>
+			</array>
+			<key>Name</key>
+			<string>Debugger Console</string>
+			<key>ServiceClasses</key>
+			<array>
+				<string>PBXDebugCLIModule</string>
+			</array>
+			<key>StatusbarIsVisible</key>
+			<integer>1</integer>
+			<key>TableOfContents</key>
+			<array>
+				<string>1C530D5B069F1CE1000CFCEE</string>
+				<string>1C530D5C069F1CE1000CFCEE</string>
+				<string>1C78EAAC065D492600B07095</string>
+			</array>
+			<key>ToolbarConfiguration</key>
+			<string>xcode.toolbar.config.consoleV3</string>
+			<key>WindowString</key>
+			<string>149 87 440 400 0 0 1440 878 </string>
+			<key>WindowToolGUID</key>
+			<string>1C530D5B069F1CE1000CFCEE</string>
+			<key>WindowToolIsVisible</key>
+			<integer>0</integer>
+		</dict>
+		<dict>
+			<key>Identifier</key>
+			<string>windowTool.scm</string>
+			<key>Layout</key>
+			<array>
+				<dict>
+					<key>Dock</key>
+					<array>
+						<dict>
+							<key>ContentConfiguration</key>
+							<dict>
+								<key>PBXProjectModuleGUID</key>
+								<string>1C78EAB2065D492600B07095</string>
+								<key>PBXProjectModuleLabel</key>
+								<string>&lt;No Editor&gt;</string>
+								<key>PBXSplitModuleInNavigatorKey</key>
+								<dict>
+									<key>Split0</key>
+									<dict>
+										<key>PBXProjectModuleGUID</key>
+										<string>1C78EAB3065D492600B07095</string>
+									</dict>
+									<key>SplitCount</key>
+									<string>1</string>
+								</dict>
+								<key>StatusBarVisibility</key>
+								<integer>1</integer>
+							</dict>
+							<key>GeometryConfiguration</key>
+							<dict>
+								<key>Frame</key>
+								<string>{{0, 0}, {452, 0}}</string>
+								<key>RubberWindowFrame</key>
+								<string>743 379 452 308 0 0 1280 1002 </string>
+							</dict>
+							<key>Module</key>
+							<string>PBXNavigatorGroup</string>
+							<key>Proportion</key>
+							<string>0pt</string>
+						</dict>
+						<dict>
+							<key>BecomeActive</key>
+							<integer>1</integer>
+							<key>ContentConfiguration</key>
+							<dict>
+								<key>PBXProjectModuleGUID</key>
+								<string>1CD052920623707200166675</string>
+								<key>PBXProjectModuleLabel</key>
+								<string>SCM</string>
+							</dict>
+							<key>GeometryConfiguration</key>
+							<dict>
+								<key>ConsoleFrame</key>
+								<string>{{0, 259}, {452, 0}}</string>
+								<key>Frame</key>
+								<string>{{0, 7}, {452, 259}}</string>
+								<key>RubberWindowFrame</key>
+								<string>743 379 452 308 0 0 1280 1002 </string>
+								<key>TableConfiguration</key>
+								<array>
+									<string>Status</string>
+									<real>30</real>
+									<string>FileName</string>
+									<real>199</real>
+									<string>Path</string>
+									<real>197.09500122070312</real>
+								</array>
+								<key>TableFrame</key>
+								<string>{{0, 0}, {452, 250}}</string>
+							</dict>
+							<key>Module</key>
+							<string>PBXCVSModule</string>
+							<key>Proportion</key>
+							<string>262pt</string>
+						</dict>
+					</array>
+					<key>Proportion</key>
+					<string>266pt</string>
+				</dict>
+			</array>
+			<key>Name</key>
+			<string>SCM</string>
+			<key>ServiceClasses</key>
+			<array>
+				<string>PBXCVSModule</string>
+			</array>
+			<key>StatusbarIsVisible</key>
+			<integer>1</integer>
+			<key>TableOfContents</key>
+			<array>
+				<string>1C78EAB4065D492600B07095</string>
+				<string>1C78EAB5065D492600B07095</string>
+				<string>1C78EAB2065D492600B07095</string>
+				<string>1CD052920623707200166675</string>
+			</array>
+			<key>ToolbarConfiguration</key>
+			<string>xcode.toolbar.config.scmV3</string>
+			<key>WindowString</key>
+			<string>743 379 452 308 0 0 1280 1002 </string>
+		</dict>
+		<dict>
+			<key>Identifier</key>
+			<string>windowTool.breakpoints</string>
+			<key>IsVertical</key>
+			<integer>0</integer>
+			<key>Layout</key>
+			<array>
+				<dict>
+					<key>Dock</key>
+					<array>
+						<dict>
+							<key>BecomeActive</key>
+							<integer>1</integer>
+							<key>ContentConfiguration</key>
+							<dict>
+								<key>PBXBottomSmartGroupGIDs</key>
+								<array>
+									<string>1C77FABC04509CD000000102</string>
+								</array>
+								<key>PBXProjectModuleGUID</key>
+								<string>1CE0B1FE06471DED0097A5F4</string>
+								<key>PBXProjectModuleLabel</key>
+								<string>Files</string>
+								<key>PBXProjectStructureProvided</key>
+								<string>no</string>
+								<key>PBXSmartGroupTreeModuleColumnData</key>
+								<dict>
+									<key>PBXSmartGroupTreeModuleColumnWidthsKey</key>
+									<array>
+										<real>168</real>
+									</array>
+									<key>PBXSmartGroupTreeModuleColumnsKey_v4</key>
+									<array>
+										<string>MainColumn</string>
+									</array>
+								</dict>
+								<key>PBXSmartGroupTreeModuleOutlineStateKey_v7</key>
+								<dict>
+									<key>PBXSmartGroupTreeModuleOutlineStateExpansionKey</key>
+									<array>
+										<string>1C77FABC04509CD000000102</string>
+									</array>
+									<key>PBXSmartGroupTreeModuleOutlineStateSelectionKey</key>
+									<array>
+										<array>
+											<integer>0</integer>
+										</array>
+									</array>
+									<key>PBXSmartGroupTreeModuleOutlineStateVisibleRectKey</key>
+									<string>{{0, 0}, {168, 350}}</string>
+								</dict>
+								<key>PBXTopSmartGroupGIDs</key>
+								<array/>
+								<key>XCIncludePerspectivesSwitch</key>
+								<integer>0</integer>
+							</dict>
+							<key>GeometryConfiguration</key>
+							<dict>
+								<key>Frame</key>
+								<string>{{0, 0}, {185, 368}}</string>
+								<key>GroupTreeTableConfiguration</key>
+								<array>
+									<string>MainColumn</string>
+									<real>168</real>
+								</array>
+								<key>RubberWindowFrame</key>
+								<string>315 424 744 409 0 0 1440 878 </string>
+							</dict>
+							<key>Module</key>
+							<string>PBXSmartGroupTreeModule</string>
+							<key>Proportion</key>
+							<string>185pt</string>
+						</dict>
+						<dict>
+							<key>ContentConfiguration</key>
+							<dict>
+								<key>PBXProjectModuleGUID</key>
+								<string>1CA1AED706398EBD00589147</string>
+								<key>PBXProjectModuleLabel</key>
+								<string>Detail</string>
+							</dict>
+							<key>GeometryConfiguration</key>
+							<dict>
+								<key>Frame</key>
+								<string>{{190, 0}, {554, 368}}</string>
+								<key>RubberWindowFrame</key>
+								<string>315 424 744 409 0 0 1440 878 </string>
+							</dict>
+							<key>Module</key>
+							<string>XCDetailModule</string>
+							<key>Proportion</key>
+							<string>554pt</string>
+						</dict>
+					</array>
+					<key>Proportion</key>
+					<string>368pt</string>
+				</dict>
+			</array>
+			<key>MajorVersion</key>
+			<integer>3</integer>
+			<key>MinorVersion</key>
+			<integer>0</integer>
+			<key>Name</key>
+			<string>Breakpoints</string>
+			<key>ServiceClasses</key>
+			<array>
+				<string>PBXSmartGroupTreeModule</string>
+				<string>XCDetailModule</string>
+			</array>
+			<key>StatusbarIsVisible</key>
+			<integer>1</integer>
+			<key>TableOfContents</key>
+			<array>
+				<string>1CDDB66807F98D9800BB5817</string>
+				<string>1CDDB66907F98D9800BB5817</string>
+				<string>1CE0B1FE06471DED0097A5F4</string>
+				<string>1CA1AED706398EBD00589147</string>
+			</array>
+			<key>ToolbarConfiguration</key>
+			<string>xcode.toolbar.config.breakpointsV3</string>
+			<key>WindowString</key>
+			<string>315 424 744 409 0 0 1440 878 </string>
+			<key>WindowToolGUID</key>
+			<string>1CDDB66807F98D9800BB5817</string>
+			<key>WindowToolIsVisible</key>
+			<integer>1</integer>
+		</dict>
+		<dict>
+			<key>Identifier</key>
+			<string>windowTool.debugAnimator</string>
+			<key>Layout</key>
+			<array>
+				<dict>
+					<key>Dock</key>
+					<array>
+						<dict>
+							<key>Module</key>
+							<string>PBXNavigatorGroup</string>
+							<key>Proportion</key>
+							<string>100%</string>
+						</dict>
+					</array>
+					<key>Proportion</key>
+					<string>100%</string>
+				</dict>
+			</array>
+			<key>Name</key>
+			<string>Debug Visualizer</string>
+			<key>ServiceClasses</key>
+			<array>
+				<string>PBXNavigatorGroup</string>
+			</array>
+			<key>StatusbarIsVisible</key>
+			<integer>1</integer>
+			<key>ToolbarConfiguration</key>
+			<string>xcode.toolbar.config.debugAnimatorV3</string>
+			<key>WindowString</key>
+			<string>100 100 700 500 0 0 1280 1002 </string>
+		</dict>
+		<dict>
+			<key>Identifier</key>
+			<string>windowTool.bookmarks</string>
+			<key>Layout</key>
+			<array>
+				<dict>
+					<key>Dock</key>
+					<array>
+						<dict>
+							<key>Module</key>
+							<string>PBXBookmarksModule</string>
+							<key>Proportion</key>
+							<string>166pt</string>
+						</dict>
+					</array>
+					<key>Proportion</key>
+					<string>166pt</string>
+				</dict>
+			</array>
+			<key>Name</key>
+			<string>Bookmarks</string>
+			<key>ServiceClasses</key>
+			<array>
+				<string>PBXBookmarksModule</string>
+			</array>
+			<key>StatusbarIsVisible</key>
+			<integer>0</integer>
+			<key>WindowString</key>
+			<string>538 42 401 187 0 0 1280 1002 </string>
+		</dict>
+		<dict>
+			<key>Identifier</key>
+			<string>windowTool.projectFormatConflicts</string>
+			<key>Layout</key>
+			<array>
+				<dict>
+					<key>Dock</key>
+					<array>
+						<dict>
+							<key>Module</key>
+							<string>XCProjectFormatConflictsModule</string>
+							<key>Proportion</key>
+							<string>100%</string>
+						</dict>
+					</array>
+					<key>Proportion</key>
+					<string>100%</string>
+				</dict>
+			</array>
+			<key>Name</key>
+			<string>Project Format Conflicts</string>
+			<key>ServiceClasses</key>
+			<array>
+				<string>XCProjectFormatConflictsModule</string>
+			</array>
+			<key>StatusbarIsVisible</key>
+			<integer>0</integer>
+			<key>WindowContentMinSize</key>
+			<string>450 300</string>
+			<key>WindowString</key>
+			<string>50 850 472 307 0 0 1440 877</string>
+		</dict>
+		<dict>
+			<key>Identifier</key>
+			<string>windowTool.classBrowser</string>
+			<key>Layout</key>
+			<array>
+				<dict>
+					<key>Dock</key>
+					<array>
+						<dict>
+							<key>BecomeActive</key>
+							<integer>1</integer>
+							<key>ContentConfiguration</key>
+							<dict>
+								<key>OptionsSetName</key>
+								<string>Hierarchy, all classes</string>
+								<key>PBXProjectModuleGUID</key>
+								<string>1CA6456E063B45B4001379D8</string>
+								<key>PBXProjectModuleLabel</key>
+								<string>Class Browser - NSObject</string>
+							</dict>
+							<key>GeometryConfiguration</key>
+							<dict>
+								<key>ClassesFrame</key>
+								<string>{{0, 0}, {369, 96}}</string>
+								<key>ClassesTreeTableConfiguration</key>
+								<array>
+									<string>PBXClassNameColumnIdentifier</string>
+									<real>208</real>
+									<string>PBXClassBookColumnIdentifier</string>
+									<real>22</real>
+								</array>
+								<key>Frame</key>
+								<string>{{0, 0}, {616, 353}}</string>
+								<key>MembersFrame</key>
+								<string>{{0, 105}, {369, 395}}</string>
+								<key>MembersTreeTableConfiguration</key>
+								<array>
+									<string>PBXMemberTypeIconColumnIdentifier</string>
+									<real>22</real>
+									<string>PBXMemberNameColumnIdentifier</string>
+									<real>216</real>
+									<string>PBXMemberTypeColumnIdentifier</string>
+									<real>94</real>
+									<string>PBXMemberBookColumnIdentifier</string>
+									<real>22</real>
+								</array>
+								<key>PBXModuleWindowStatusBarHidden2</key>
+								<integer>1</integer>
+								<key>RubberWindowFrame</key>
+								<string>597 125 616 374 0 0 1280 1002 </string>
+							</dict>
+							<key>Module</key>
+							<string>PBXClassBrowserModule</string>
+							<key>Proportion</key>
+							<string>354pt</string>
+						</dict>
+					</array>
+					<key>Proportion</key>
+					<string>354pt</string>
+				</dict>
+			</array>
+			<key>Name</key>
+			<string>Class Browser</string>
+			<key>ServiceClasses</key>
+			<array>
+				<string>PBXClassBrowserModule</string>
+			</array>
+			<key>StatusbarIsVisible</key>
+			<integer>0</integer>
+			<key>TableOfContents</key>
+			<array>
+				<string>1C78EABA065D492600B07095</string>
+				<string>1C78EABB065D492600B07095</string>
+				<string>1CA6456E063B45B4001379D8</string>
+			</array>
+			<key>ToolbarConfiguration</key>
+			<string>xcode.toolbar.config.classbrowser</string>
+			<key>WindowString</key>
+			<string>597 125 616 374 0 0 1280 1002 </string>
+		</dict>
+		<dict>
+			<key>Identifier</key>
+			<string>windowTool.refactoring</string>
+			<key>IncludeInToolsMenu</key>
+			<integer>0</integer>
+			<key>Layout</key>
+			<array>
+				<dict>
+					<key>Dock</key>
+					<array>
+						<dict>
+							<key>BecomeActive</key>
+							<integer>1</integer>
+							<key>GeometryConfiguration</key>
+							<dict>
+								<key>Frame</key>
+								<string>{0, 0}, {500, 335}</string>
+								<key>RubberWindowFrame</key>
+								<string>{0, 0}, {500, 335}</string>
+							</dict>
+							<key>Module</key>
+							<string>XCRefactoringModule</string>
+							<key>Proportion</key>
+							<string>100%</string>
+						</dict>
+					</array>
+					<key>Proportion</key>
+					<string>100%</string>
+				</dict>
+			</array>
+			<key>Name</key>
+			<string>Refactoring</string>
+			<key>ServiceClasses</key>
+			<array>
+				<string>XCRefactoringModule</string>
+			</array>
+			<key>WindowString</key>
+			<string>200 200 500 356 0 0 1920 1200 </string>
+		</dict>
+	</array>
+</dict>
+</plist>
diff --git a/plugins/MacAU/PocketVerbs/PocketVerbs.xcodeproj/project.pbxproj b/plugins/MacAU/PocketVerbs/PocketVerbs.xcodeproj/project.pbxproj
new file mode 100755
index 0000000..b874a8f
--- /dev/null
+++ b/plugins/MacAU/PocketVerbs/PocketVerbs.xcodeproj/project.pbxproj
@@ -0,0 +1,490 @@
+// !$*UTF8*$!
+{
+	archiveVersion = 1;
+	classes = {
+	};
+	objectVersion = 45;
+	objects = {
+
+/* Begin PBXBuildFile section */
+		3EEA126E089847F5002C6BFC /* CAVectorUnit.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 3EEA126B089847F5002C6BFC /* CAVectorUnit.cpp */; };
+		3EEA126F089847F5002C6BFC /* CAVectorUnit.h in Headers */ = {isa = PBXBuildFile; fileRef = 3EEA126C089847F5002C6BFC /* CAVectorUnit.h */; };
+		3EEA1270089847F5002C6BFC /* CAVectorUnitTypes.h in Headers */ = {isa = PBXBuildFile; fileRef = 3EEA126D089847F5002C6BFC /* CAVectorUnitTypes.h */; };
+		8B4119B70749654200361ABE /* PocketVerbs.r in Rez */ = {isa = PBXBuildFile; fileRef = 8BA05A680720730100365D66 /* PocketVerbs.r */; };
+		8BA05A6B0720730100365D66 /* PocketVerbs.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 8BA05A660720730100365D66 /* PocketVerbs.cpp */; };
+		8BA05A6E0720730100365D66 /* PocketVerbsVersion.h in Headers */ = {isa = PBXBuildFile; fileRef = 8BA05A690720730100365D66 /* PocketVerbsVersion.h */; };
+		8BA05AAE072073D300365D66 /* AUBase.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 8BA05A7F072073D200365D66 /* AUBase.cpp */; };
+		8BA05AAF072073D300365D66 /* AUBase.h in Headers */ = {isa = PBXBuildFile; fileRef = 8BA05A80072073D200365D66 /* AUBase.h */; };
+		8BA05AB0072073D300365D66 /* AUDispatch.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 8BA05A81072073D200365D66 /* AUDispatch.cpp */; };
+		8BA05AB1072073D300365D66 /* AUDispatch.h in Headers */ = {isa = PBXBuildFile; fileRef = 8BA05A82072073D200365D66 /* AUDispatch.h */; };
+		8BA05AB2072073D300365D66 /* AUInputElement.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 8BA05A83072073D200365D66 /* AUInputElement.cpp */; };
+		8BA05AB3072073D300365D66 /* AUInputElement.h in Headers */ = {isa = PBXBuildFile; fileRef = 8BA05A84072073D200365D66 /* AUInputElement.h */; };
+		8BA05AB4072073D300365D66 /* AUOutputElement.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 8BA05A85072073D200365D66 /* AUOutputElement.cpp */; };
+		8BA05AB5072073D300365D66 /* AUOutputElement.h in Headers */ = {isa = PBXBuildFile; fileRef = 8BA05A86072073D200365D66 /* AUOutputElement.h */; };
+		8BA05AB7072073D300365D66 /* AUScopeElement.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 8BA05A88072073D200365D66 /* AUScopeElement.cpp */; };
+		8BA05AB8072073D300365D66 /* AUScopeElement.h in Headers */ = {isa = PBXBuildFile; fileRef = 8BA05A89072073D200365D66 /* AUScopeElement.h */; };
+		8BA05AB9072073D300365D66 /* ComponentBase.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 8BA05A8A072073D200365D66 /* ComponentBase.cpp */; };
+		8BA05ABA072073D300365D66 /* ComponentBase.h in Headers */ = {isa = PBXBuildFile; fileRef = 8BA05A8B072073D200365D66 /* ComponentBase.h */; };
+		8BA05AC6072073D300365D66 /* AUEffectBase.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 8BA05A9A072073D200365D66 /* AUEffectBase.cpp */; };
+		8BA05AC7072073D300365D66 /* AUEffectBase.h in Headers */ = {isa = PBXBuildFile; fileRef = 8BA05A9B072073D200365D66 /* AUEffectBase.h */; };
+		8BA05AD2072073D300365D66 /* AUBuffer.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 8BA05AA7072073D200365D66 /* AUBuffer.cpp */; };
+		8BA05AD3072073D300365D66 /* AUBuffer.h in Headers */ = {isa = PBXBuildFile; fileRef = 8BA05AA8072073D200365D66 /* AUBuffer.h */; };
+		8BA05AD4072073D300365D66 /* AUDebugDispatcher.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 8BA05AA9072073D200365D66 /* AUDebugDispatcher.cpp */; };
+		8BA05AD5072073D300365D66 /* AUDebugDispatcher.h in Headers */ = {isa = PBXBuildFile; fileRef = 8BA05AAA072073D200365D66 /* AUDebugDispatcher.h */; };
+		8BA05AD6072073D300365D66 /* AUInputFormatConverter.h in Headers */ = {isa = PBXBuildFile; fileRef = 8BA05AAB072073D200365D66 /* AUInputFormatConverter.h */; };
+		8BA05AD7072073D300365D66 /* AUSilentTimeout.h in Headers */ = {isa = PBXBuildFile; fileRef = 8BA05AAC072073D200365D66 /* AUSilentTimeout.h */; };
+		8BA05AD8072073D300365D66 /* AUTimestampGenerator.h in Headers */ = {isa = PBXBuildFile; fileRef = 8BA05AAD072073D200365D66 /* AUTimestampGenerator.h */; };
+		8BA05AE50720742100365D66 /* CAAudioChannelLayout.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 8BA05ADF0720742100365D66 /* CAAudioChannelLayout.cpp */; };
+		8BA05AE60720742100365D66 /* CAAudioChannelLayout.h in Headers */ = {isa = PBXBuildFile; fileRef = 8BA05AE00720742100365D66 /* CAAudioChannelLayout.h */; };
+		8BA05AE70720742100365D66 /* CAMutex.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 8BA05AE10720742100365D66 /* CAMutex.cpp */; };
+		8BA05AE80720742100365D66 /* CAMutex.h in Headers */ = {isa = PBXBuildFile; fileRef = 8BA05AE20720742100365D66 /* CAMutex.h */; };
+		8BA05AE90720742100365D66 /* CAStreamBasicDescription.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 8BA05AE30720742100365D66 /* CAStreamBasicDescription.cpp */; };
+		8BA05AEA0720742100365D66 /* CAStreamBasicDescription.h in Headers */ = {isa = PBXBuildFile; fileRef = 8BA05AE40720742100365D66 /* CAStreamBasicDescription.h */; };
+		8BA05AFC072074E100365D66 /* AudioToolbox.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 8BA05AF9072074E100365D66 /* AudioToolbox.framework */; };
+		8BA05AFD072074E100365D66 /* AudioUnit.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 8BA05AFA072074E100365D66 /* AudioUnit.framework */; };
+		8BA05B02072074F900365D66 /* CoreServices.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 8BA05B01072074F900365D66 /* CoreServices.framework */; };
+		8BA05B070720754400365D66 /* CAAUParameter.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 8BA05B050720754400365D66 /* CAAUParameter.cpp */; };
+		8BA05B080720754400365D66 /* CAAUParameter.h in Headers */ = {isa = PBXBuildFile; fileRef = 8BA05B060720754400365D66 /* CAAUParameter.h */; };
+		8BC6025C073B072D006C4272 /* PocketVerbs.h in Headers */ = {isa = PBXBuildFile; fileRef = 8BC6025B073B072D006C4272 /* PocketVerbs.h */; };
+		8D01CCCA0486CAD60068D4B7 /* InfoPlist.strings in Resources */ = {isa = PBXBuildFile; fileRef = 089C167DFE841241C02AAC07 /* InfoPlist.strings */; };
+		F7C347F00ECE5AF8008ADFB6 /* AUBaseHelper.cpp in Sources */ = {isa = PBXBuildFile; fileRef = F7C347EE0ECE5AF8008ADFB6 /* AUBaseHelper.cpp */; };
+		F7C347F10ECE5AF8008ADFB6 /* AUBaseHelper.h in Headers */ = {isa = PBXBuildFile; fileRef = F7C347EF0ECE5AF8008ADFB6 /* AUBaseHelper.h */; };
+/* End PBXBuildFile section */
+
+/* Begin PBXFileReference section */
+		089C167EFE841241C02AAC07 /* English */ = {isa = PBXFileReference; fileEncoding = 10; lastKnownFileType = text.plist.strings; name = English; path = English.lproj/InfoPlist.strings; sourceTree = "<group>"; };
+		3EEA126B089847F5002C6BFC /* CAVectorUnit.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = CAVectorUnit.cpp; sourceTree = "<group>"; };
+		3EEA126C089847F5002C6BFC /* CAVectorUnit.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = CAVectorUnit.h; sourceTree = "<group>"; };
+		3EEA126D089847F5002C6BFC /* CAVectorUnitTypes.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = CAVectorUnitTypes.h; sourceTree = "<group>"; };
+		8B5C7FBF076FB2C200A15F61 /* CoreAudio.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = CoreAudio.framework; path = /System/Library/Frameworks/CoreAudio.framework; sourceTree = "<absolute>"; };
+		8BA05A660720730100365D66 /* PocketVerbs.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = PocketVerbs.cpp; sourceTree = "<group>"; };
+		8BA05A670720730100365D66 /* PocketVerbs.exp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.exports; path = PocketVerbs.exp; sourceTree = "<group>"; };
+		8BA05A680720730100365D66 /* PocketVerbs.r */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.rez; path = PocketVerbs.r; sourceTree = "<group>"; };
+		8BA05A690720730100365D66 /* PocketVerbsVersion.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = PocketVerbsVersion.h; sourceTree = "<group>"; };
+		8BA05A7F072073D200365D66 /* AUBase.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = AUBase.cpp; sourceTree = "<group>"; };
+		8BA05A80072073D200365D66 /* AUBase.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = AUBase.h; sourceTree = "<group>"; };
+		8BA05A81072073D200365D66 /* AUDispatch.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = AUDispatch.cpp; sourceTree = "<group>"; };
+		8BA05A82072073D200365D66 /* AUDispatch.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = AUDispatch.h; sourceTree = "<group>"; };
+		8BA05A83072073D200365D66 /* AUInputElement.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = AUInputElement.cpp; sourceTree = "<group>"; };
+		8BA05A84072073D200365D66 /* AUInputElement.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = AUInputElement.h; sourceTree = "<group>"; };
+		8BA05A85072073D200365D66 /* AUOutputElement.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = AUOutputElement.cpp; sourceTree = "<group>"; };
+		8BA05A86072073D200365D66 /* AUOutputElement.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = AUOutputElement.h; sourceTree = "<group>"; };
+		8BA05A87072073D200365D66 /* AUResources.r */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.rez; path = AUResources.r; sourceTree = "<group>"; };
+		8BA05A88072073D200365D66 /* AUScopeElement.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = AUScopeElement.cpp; sourceTree = "<group>"; };
+		8BA05A89072073D200365D66 /* AUScopeElement.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = AUScopeElement.h; sourceTree = "<group>"; };
+		8BA05A8A072073D200365D66 /* ComponentBase.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = ComponentBase.cpp; sourceTree = "<group>"; };
+		8BA05A8B072073D200365D66 /* ComponentBase.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = ComponentBase.h; sourceTree = "<group>"; };
+		8BA05A9A072073D200365D66 /* AUEffectBase.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = AUEffectBase.cpp; sourceTree = "<group>"; };
+		8BA05A9B072073D200365D66 /* AUEffectBase.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = AUEffectBase.h; sourceTree = "<group>"; };
+		8BA05AA7072073D200365D66 /* AUBuffer.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = AUBuffer.cpp; sourceTree = "<group>"; };
+		8BA05AA8072073D200365D66 /* AUBuffer.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = AUBuffer.h; sourceTree = "<group>"; };
+		8BA05AA9072073D200365D66 /* AUDebugDispatcher.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = AUDebugDispatcher.cpp; sourceTree = "<group>"; };
+		8BA05AAA072073D200365D66 /* AUDebugDispatcher.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = AUDebugDispatcher.h; sourceTree = "<group>"; };
+		8BA05AAB072073D200365D66 /* AUInputFormatConverter.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = AUInputFormatConverter.h; sourceTree = "<group>"; };
+		8BA05AAC072073D200365D66 /* AUSilentTimeout.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = AUSilentTimeout.h; sourceTree = "<group>"; };
+		8BA05AAD072073D200365D66 /* AUTimestampGenerator.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = AUTimestampGenerator.h; sourceTree = "<group>"; };
+		8BA05ADF0720742100365D66 /* CAAudioChannelLayout.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = CAAudioChannelLayout.cpp; sourceTree = "<group>"; };
+		8BA05AE00720742100365D66 /* CAAudioChannelLayout.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = CAAudioChannelLayout.h; sourceTree = "<group>"; };
+		8BA05AE10720742100365D66 /* CAMutex.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = CAMutex.cpp; sourceTree = "<group>"; };
+		8BA05AE20720742100365D66 /* CAMutex.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = CAMutex.h; sourceTree = "<group>"; };
+		8BA05AE30720742100365D66 /* CAStreamBasicDescription.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = CAStreamBasicDescription.cpp; sourceTree = "<group>"; };
+		8BA05AE40720742100365D66 /* CAStreamBasicDescription.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = CAStreamBasicDescription.h; sourceTree = "<group>"; };
+		8BA05AF9072074E100365D66 /* AudioToolbox.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = AudioToolbox.framework; path = /System/Library/Frameworks/AudioToolbox.framework; sourceTree = "<absolute>"; };
+		8BA05AFA072074E100365D66 /* AudioUnit.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = AudioUnit.framework; path = /System/Library/Frameworks/AudioUnit.framework; sourceTree = "<absolute>"; };
+		8BA05B01072074F900365D66 /* CoreServices.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = CoreServices.framework; path = /System/Library/Frameworks/CoreServices.framework; sourceTree = "<absolute>"; };
+		8BA05B050720754400365D66 /* CAAUParameter.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; path = CAAUParameter.cpp; sourceTree = "<group>"; };
+		8BA05B060720754400365D66 /* CAAUParameter.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = CAAUParameter.h; sourceTree = "<group>"; };
+		8BC6025B073B072D006C4272 /* PocketVerbs.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; path = PocketVerbs.h; sourceTree = "<group>"; };
+		8D01CCD10486CAD60068D4B7 /* Info.plist */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.plist; path = Info.plist; sourceTree = "<group>"; };
+		8D01CCD20486CAD60068D4B7 /* PocketVerbs.component */ = {isa = PBXFileReference; explicitFileType = wrapper.cfbundle; includeInIndex = 0; path = PocketVerbs.component; sourceTree = BUILT_PRODUCTS_DIR; };
+		F7C347EE0ECE5AF8008ADFB6 /* AUBaseHelper.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = AUBaseHelper.cpp; path = Extras/CoreAudio/AudioUnits/AUPublic/Utility/AUBaseHelper.cpp; sourceTree = SYSTEM_DEVELOPER_DIR; };
+		F7C347EF0ECE5AF8008ADFB6 /* AUBaseHelper.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = AUBaseHelper.h; path = Extras/CoreAudio/AudioUnits/AUPublic/Utility/AUBaseHelper.h; sourceTree = SYSTEM_DEVELOPER_DIR; };
+/* End PBXFileReference section */
+
+/* Begin PBXFrameworksBuildPhase section */
+		8D01CCCD0486CAD60068D4B7 /* Frameworks */ = {
+			isa = PBXFrameworksBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				8BA05AFC072074E100365D66 /* AudioToolbox.framework in Frameworks */,
+				8BA05AFD072074E100365D66 /* AudioUnit.framework in Frameworks */,
+				8BA05B02072074F900365D66 /* CoreServices.framework in Frameworks */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXFrameworksBuildPhase section */
+
+/* Begin PBXGroup section */
+		089C166AFE841209C02AAC07 /* PocketVerbs */ = {
+			isa = PBXGroup;
+			children = (
+				08FB77ADFE841716C02AAC07 /* Source */,
+				089C167CFE841241C02AAC07 /* Resources */,
+				089C1671FE841209C02AAC07 /* External Frameworks and Libraries */,
+				19C28FB4FE9D528D11CA2CBB /* Products */,
+			);
+			name = PocketVerbs;
+			sourceTree = "<group>";
+		};
+		089C1671FE841209C02AAC07 /* External Frameworks and Libraries */ = {
+			isa = PBXGroup;
+			children = (
+				8B5C7FBF076FB2C200A15F61 /* CoreAudio.framework */,
+				8BA05B01072074F900365D66 /* CoreServices.framework */,
+				8BA05AF9072074E100365D66 /* AudioToolbox.framework */,
+				8BA05AFA072074E100365D66 /* AudioUnit.framework */,
+			);
+			name = "External Frameworks and Libraries";
+			sourceTree = "<group>";
+		};
+		089C167CFE841241C02AAC07 /* Resources */ = {
+			isa = PBXGroup;
+			children = (
+				8D01CCD10486CAD60068D4B7 /* Info.plist */,
+				089C167DFE841241C02AAC07 /* InfoPlist.strings */,
+			);
+			name = Resources;
+			sourceTree = "<group>";
+		};
+		08FB77ADFE841716C02AAC07 /* Source */ = {
+			isa = PBXGroup;
+			children = (
+				8BA05A56072072A900365D66 /* AU Source */,
+				8BA05AEB0720742700365D66 /* PublicUtility */,
+				8BA05A7D072073D200365D66 /* AUPublic */,
+			);
+			name = Source;
+			sourceTree = "<group>";
+		};
+		19C28FB4FE9D528D11CA2CBB /* Products */ = {
+			isa = PBXGroup;
+			children = (
+				8D01CCD20486CAD60068D4B7 /* PocketVerbs.component */,
+			);
+			name = Products;
+			sourceTree = "<group>";
+		};
+		8BA05A56072072A900365D66 /* AU Source */ = {
+			isa = PBXGroup;
+			children = (
+				8BC6025B073B072D006C4272 /* PocketVerbs.h */,
+				8BA05A660720730100365D66 /* PocketVerbs.cpp */,
+				8BA05A670720730100365D66 /* PocketVerbs.exp */,
+				8BA05A680720730100365D66 /* PocketVerbs.r */,
+				8BA05A690720730100365D66 /* PocketVerbsVersion.h */,
+			);
+			name = "AU Source";
+			sourceTree = "<group>";
+		};
+		8BA05A7D072073D200365D66 /* AUPublic */ = {
+			isa = PBXGroup;
+			children = (
+				8BA05A7E072073D200365D66 /* AUBase */,
+				8BA05A99072073D200365D66 /* OtherBases */,
+				8BA05AA6072073D200365D66 /* Utility */,
+			);
+			name = AUPublic;
+			path = Extras/CoreAudio/AudioUnits/AUPublic;
+			sourceTree = SYSTEM_DEVELOPER_DIR;
+		};
+		8BA05A7E072073D200365D66 /* AUBase */ = {
+			isa = PBXGroup;
+			children = (
+				8BA05A7F072073D200365D66 /* AUBase.cpp */,
+				8BA05A80072073D200365D66 /* AUBase.h */,
+				8BA05A81072073D200365D66 /* AUDispatch.cpp */,
+				8BA05A82072073D200365D66 /* AUDispatch.h */,
+				8BA05A83072073D200365D66 /* AUInputElement.cpp */,
+				8BA05A84072073D200365D66 /* AUInputElement.h */,
+				8BA05A85072073D200365D66 /* AUOutputElement.cpp */,
+				8BA05A86072073D200365D66 /* AUOutputElement.h */,
+				8BA05A87072073D200365D66 /* AUResources.r */,
+				8BA05A88072073D200365D66 /* AUScopeElement.cpp */,
+				8BA05A89072073D200365D66 /* AUScopeElement.h */,
+				8BA05A8A072073D200365D66 /* ComponentBase.cpp */,
+				8BA05A8B072073D200365D66 /* ComponentBase.h */,
+			);
+			path = AUBase;
+			sourceTree = "<group>";
+		};
+		8BA05A99072073D200365D66 /* OtherBases */ = {
+			isa = PBXGroup;
+			children = (
+				8BA05A9A072073D200365D66 /* AUEffectBase.cpp */,
+				8BA05A9B072073D200365D66 /* AUEffectBase.h */,
+			);
+			path = OtherBases;
+			sourceTree = "<group>";
+		};
+		8BA05AA6072073D200365D66 /* Utility */ = {
+			isa = PBXGroup;
+			children = (
+				F7C347EE0ECE5AF8008ADFB6 /* AUBaseHelper.cpp */,
+				F7C347EF0ECE5AF8008ADFB6 /* AUBaseHelper.h */,
+				8BA05AA7072073D200365D66 /* AUBuffer.cpp */,
+				8BA05AA8072073D200365D66 /* AUBuffer.h */,
+				8BA05AA9072073D200365D66 /* AUDebugDispatcher.cpp */,
+				8BA05AAA072073D200365D66 /* AUDebugDispatcher.h */,
+				8BA05AAB072073D200365D66 /* AUInputFormatConverter.h */,
+				8BA05AAC072073D200365D66 /* AUSilentTimeout.h */,
+				8BA05AAD072073D200365D66 /* AUTimestampGenerator.h */,
+			);
+			path = Utility;
+			sourceTree = "<group>";
+		};
+		8BA05AEB0720742700365D66 /* PublicUtility */ = {
+			isa = PBXGroup;
+			children = (
+				8BA05B050720754400365D66 /* CAAUParameter.cpp */,
+				8BA05B060720754400365D66 /* CAAUParameter.h */,
+				8BA05ADF0720742100365D66 /* CAAudioChannelLayout.cpp */,
+				8BA05AE00720742100365D66 /* CAAudioChannelLayout.h */,
+				8BA05AE10720742100365D66 /* CAMutex.cpp */,
+				8BA05AE20720742100365D66 /* CAMutex.h */,
+				8BA05AE30720742100365D66 /* CAStreamBasicDescription.cpp */,
+				8BA05AE40720742100365D66 /* CAStreamBasicDescription.h */,
+				3EEA126D089847F5002C6BFC /* CAVectorUnitTypes.h */,
+				3EEA126B089847F5002C6BFC /* CAVectorUnit.cpp */,
+				3EEA126C089847F5002C6BFC /* CAVectorUnit.h */,
+			);
+			name = PublicUtility;
+			path = Extras/CoreAudio/PublicUtility;
+			sourceTree = SYSTEM_DEVELOPER_DIR;
+		};
+/* End PBXGroup section */
+
+/* Begin PBXHeadersBuildPhase section */
+		8D01CCC70486CAD60068D4B7 /* Headers */ = {
+			isa = PBXHeadersBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				8BA05A6E0720730100365D66 /* PocketVerbsVersion.h in Headers */,
+				8BA05AAF072073D300365D66 /* AUBase.h in Headers */,
+				8BA05AB1072073D300365D66 /* AUDispatch.h in Headers */,
+				8BA05AB3072073D300365D66 /* AUInputElement.h in Headers */,
+				8BA05AB5072073D300365D66 /* AUOutputElement.h in Headers */,
+				8BA05AB8072073D300365D66 /* AUScopeElement.h in Headers */,
+				8BA05ABA072073D300365D66 /* ComponentBase.h in Headers */,
+				8BA05AC7072073D300365D66 /* AUEffectBase.h in Headers */,
+				8BA05AD3072073D300365D66 /* AUBuffer.h in Headers */,
+				8BA05AD5072073D300365D66 /* AUDebugDispatcher.h in Headers */,
+				8BA05AD6072073D300365D66 /* AUInputFormatConverter.h in Headers */,
+				8BA05AD7072073D300365D66 /* AUSilentTimeout.h in Headers */,
+				8BA05AD8072073D300365D66 /* AUTimestampGenerator.h in Headers */,
+				8BA05AE60720742100365D66 /* CAAudioChannelLayout.h in Headers */,
+				8BA05AE80720742100365D66 /* CAMutex.h in Headers */,
+				8BA05AEA0720742100365D66 /* CAStreamBasicDescription.h in Headers */,
+				8BA05B080720754400365D66 /* CAAUParameter.h in Headers */,
+				8BC6025C073B072D006C4272 /* PocketVerbs.h in Headers */,
+				3EEA126F089847F5002C6BFC /* CAVectorUnit.h in Headers */,
+				3EEA1270089847F5002C6BFC /* CAVectorUnitTypes.h in Headers */,
+				F7C347F10ECE5AF8008ADFB6 /* AUBaseHelper.h in Headers */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXHeadersBuildPhase section */
+
+/* Begin PBXNativeTarget section */
+		8D01CCC60486CAD60068D4B7 /* PocketVerbs */ = {
+			isa = PBXNativeTarget;
+			buildConfigurationList = 3E4BA243089833B7007656EC /* Build configuration list for PBXNativeTarget "PocketVerbs" */;
+			buildPhases = (
+				8D01CCC70486CAD60068D4B7 /* Headers */,
+				8D01CCC90486CAD60068D4B7 /* Resources */,
+				8D01CCCB0486CAD60068D4B7 /* Sources */,
+				8D01CCCD0486CAD60068D4B7 /* Frameworks */,
+				8D01CCCF0486CAD60068D4B7 /* Rez */,
+			);
+			buildRules = (
+			);
+			dependencies = (
+			);
+			name = PocketVerbs;
+			productInstallPath = "$(HOME)/Library/Bundles";
+			productName = PocketVerbs;
+			productReference = 8D01CCD20486CAD60068D4B7 /* PocketVerbs.component */;
+			productType = "com.apple.product-type.bundle";
+		};
+/* End PBXNativeTarget section */
+
+/* Begin PBXProject section */
+		089C1669FE841209C02AAC07 /* Project object */ = {
+			isa = PBXProject;
+			buildConfigurationList = 3E4BA247089833B7007656EC /* Build configuration list for PBXProject "PocketVerbs" */;
+			compatibilityVersion = "Xcode 3.1";
+			developmentRegion = English;
+			hasScannedForEncodings = 1;
+			knownRegions = (
+				English,
+				Japanese,
+				French,
+				German,
+			);
+			mainGroup = 089C166AFE841209C02AAC07 /* PocketVerbs */;
+			projectDirPath = "";
+			projectRoot = "";
+			targets = (
+				8D01CCC60486CAD60068D4B7 /* PocketVerbs */,
+			);
+		};
+/* End PBXProject section */
+
+/* Begin PBXResourcesBuildPhase section */
+		8D01CCC90486CAD60068D4B7 /* Resources */ = {
+			isa = PBXResourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				8D01CCCA0486CAD60068D4B7 /* InfoPlist.strings in Resources */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXResourcesBuildPhase section */
+
+/* Begin PBXRezBuildPhase section */
+		8D01CCCF0486CAD60068D4B7 /* Rez */ = {
+			isa = PBXRezBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				8B4119B70749654200361ABE /* PocketVerbs.r in Rez */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXRezBuildPhase section */
+
+/* Begin PBXSourcesBuildPhase section */
+		8D01CCCB0486CAD60068D4B7 /* Sources */ = {
+			isa = PBXSourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				8BA05A6B0720730100365D66 /* PocketVerbs.cpp in Sources */,
+				8BA05AAE072073D300365D66 /* AUBase.cpp in Sources */,
+				8BA05AB0072073D300365D66 /* AUDispatch.cpp in Sources */,
+				8BA05AB2072073D300365D66 /* AUInputElement.cpp in Sources */,
+				8BA05AB4072073D300365D66 /* AUOutputElement.cpp in Sources */,
+				8BA05AB7072073D300365D66 /* AUScopeElement.cpp in Sources */,
+				8BA05AB9072073D300365D66 /* ComponentBase.cpp in Sources */,
+				8BA05AC6072073D300365D66 /* AUEffectBase.cpp in Sources */,
+				8BA05AD2072073D300365D66 /* AUBuffer.cpp in Sources */,
+				8BA05AD4072073D300365D66 /* AUDebugDispatcher.cpp in Sources */,
+				8BA05AE50720742100365D66 /* CAAudioChannelLayout.cpp in Sources */,
+				8BA05AE70720742100365D66 /* CAMutex.cpp in Sources */,
+				8BA05AE90720742100365D66 /* CAStreamBasicDescription.cpp in Sources */,
+				8BA05B070720754400365D66 /* CAAUParameter.cpp in Sources */,
+				3EEA126E089847F5002C6BFC /* CAVectorUnit.cpp in Sources */,
+				F7C347F00ECE5AF8008ADFB6 /* AUBaseHelper.cpp in Sources */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXSourcesBuildPhase section */
+
+/* Begin PBXVariantGroup section */
+		089C167DFE841241C02AAC07 /* InfoPlist.strings */ = {
+			isa = PBXVariantGroup;
+			children = (
+				089C167EFE841241C02AAC07 /* English */,
+			);
+			name = InfoPlist.strings;
+			sourceTree = "<group>";
+		};
+/* End PBXVariantGroup section */
+
+/* Begin XCBuildConfiguration section */
+		3E4BA244089833B7007656EC /* Debug */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				EXPORTED_SYMBOLS_FILE = PocketVerbs.exp;
+				GCC_ENABLE_FIX_AND_CONTINUE = YES;
+				GCC_OPTIMIZATION_LEVEL = 0;
+				GENERATE_PKGINFO_FILE = YES;
+				INFOPLIST_FILE = Info.plist;
+				INSTALL_PATH = "$(HOME)/Library/Audio/Plug-Ins/Components/";
+				LIBRARY_STYLE = Bundle;
+				OTHER_LDFLAGS = "-bundle";
+				OTHER_REZFLAGS = "-d ppc_$ppc -d i386_$i386 -d ppc64_$ppc64 -d x86_64_$x86_64 -I /System/Library/Frameworks/CoreServices.framework/Frameworks/CarbonCore.framework/Versions/A/Headers -I \"$(DEVELOPER_DIR)/Examples/CoreAudio/AudioUnits/AUPublic/AUBase\"";
+				PRODUCT_NAME = PocketVerbs;
+				WRAPPER_EXTENSION = component;
+			};
+			name = Debug;
+		};
+		3E4BA245089833B7007656EC /* Release */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ARCHS = (
+					ppc,
+					i386,
+					x86_64,
+				);
+				EXPORTED_SYMBOLS_FILE = PocketVerbs.exp;
+				GCC_ENABLE_FIX_AND_CONTINUE = NO;
+				GCC_GENERATE_DEBUGGING_SYMBOLS = NO;
+				GENERATE_PKGINFO_FILE = YES;
+				INFOPLIST_FILE = Info.plist;
+				INSTALL_PATH = "$(HOME)/Library/Audio/Plug-Ins/Components/";
+				LIBRARY_STYLE = Bundle;
+				MACOSX_DEPLOYMENT_TARGET = 10.4;
+				OTHER_LDFLAGS = "-bundle";
+				OTHER_REZFLAGS = "-d ppc_$ppc -d i386_$i386 -d x86_64_$x86_64 -I /System/Library/Frameworks/CoreServices.framework/Frameworks/CarbonCore.framework/Versions/A/Headers -I \"$(DEVELOPER_DIR)/Examples/CoreAudio/AudioUnits/AUPublic/AUBase\"";
+				PRODUCT_NAME = PocketVerbs;
+				SDKROOT = macosx10.5;
+				STRIP_INSTALLED_PRODUCT = YES;
+				STRIP_STYLE = all;
+				WRAPPER_EXTENSION = component;
+			};
+			name = Release;
+		};
+		3E4BA248089833B7007656EC /* Debug */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ARCHS = "$(ARCHS_STANDARD_32_64_BIT)";
+				COPY_PHASE_STRIP = NO;
+				DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym";
+				GCC_C_LANGUAGE_STANDARD = c99;
+				SDKROOT = macosx10.6;
+				WARNING_CFLAGS = (
+					"-Wmost",
+					"-Wno-four-char-constants",
+					"-Wno-unknown-pragmas",
+				);
+			};
+			name = Debug;
+		};
+		3E4BA249089833B7007656EC /* Release */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ARCHS = "$(ARCHS_STANDARD_32_64_BIT)";
+				DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym";
+				GCC_C_LANGUAGE_STANDARD = c99;
+				SDKROOT = macosx10.6;
+				WARNING_CFLAGS = (
+					"-Wmost",
+					"-Wno-four-char-constants",
+					"-Wno-unknown-pragmas",
+				);
+			};
+			name = Release;
+		};
+/* End XCBuildConfiguration section */
+
+/* Begin XCConfigurationList section */
+		3E4BA243089833B7007656EC /* Build configuration list for PBXNativeTarget "PocketVerbs" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				3E4BA244089833B7007656EC /* Debug */,
+				3E4BA245089833B7007656EC /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Debug;
+		};
+		3E4BA247089833B7007656EC /* Build configuration list for PBXProject "PocketVerbs" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				3E4BA248089833B7007656EC /* Debug */,
+				3E4BA249089833B7007656EC /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Debug;
+		};
+/* End XCConfigurationList section */
+	};
+	rootObject = 089C1669FE841209C02AAC07 /* Project object */;
+}
diff --git a/plugins/MacAU/PocketVerbs/PocketVerbsVersion.h b/plugins/MacAU/PocketVerbs/PocketVerbsVersion.h
new file mode 100755
index 0000000..b05ac2d
--- /dev/null
+++ b/plugins/MacAU/PocketVerbs/PocketVerbsVersion.h
@@ -0,0 +1,58 @@
+/*
+*	File:		PocketVerbsVersion.h
+*	
+*	Version:	1.0
+* 
+*	Created:	8/19/12
+*	
+*	Copyright:  Copyright © 2012 Airwindows, All Rights Reserved
+* 
+*	Disclaimer:	IMPORTANT:  This Apple software is supplied to you by Apple Computer, Inc. ("Apple") in 
+*				consideration of your agreement to the following terms, and your use, installation, modification 
+*				or redistribution of this Apple software constitutes acceptance of these terms.  If you do 
+*				not agree with these terms, please do not use, install, modify or redistribute this Apple 
+*				software.
+*
+*				In consideration of your agreement to abide by the following terms, and subject to these terms, 
+*				Apple grants you a personal, non-exclusive license, under Apple's copyrights in this 
+*				original Apple software (the "Apple Software"), to use, reproduce, modify and redistribute the 
+*				Apple Software, with or without modifications, in source and/or binary forms; provided that if you 
+*				redistribute the Apple Software in its entirety and without modifications, you must retain this 
+*				notice and the following text and disclaimers in all such redistributions of the Apple Software. 
+*				Neither the name, trademarks, service marks or logos of Apple Computer, Inc. may be used to 
+*				endorse or promote products derived from the Apple Software without specific prior written 
+*				permission from Apple.  Except as expressly stated in this notice, no other rights or 
+*				licenses, express or implied, are granted by Apple herein, including but not limited to any 
+*				patent rights that may be infringed by your derivative works or by other works in which the 
+*				Apple Software may be incorporated.
+*
+*				The Apple Software is provided by Apple on an "AS IS" basis.  APPLE MAKES NO WARRANTIES, EXPRESS OR 
+*				IMPLIED, INCLUDING WITHOUT LIMITATION THE IMPLIED WARRANTIES OF NON-INFRINGEMENT, MERCHANTABILITY 
+*				AND FITNESS FOR A PARTICULAR PURPOSE, REGARDING THE APPLE SOFTWARE OR ITS USE AND OPERATION ALONE 
+*				OR IN COMBINATION WITH YOUR PRODUCTS.
+*
+*				IN NO EVENT SHALL APPLE BE LIABLE FOR ANY SPECIAL, INDIRECT, INCIDENTAL OR CONSEQUENTIAL 
+*				DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS 
+*				OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) ARISING IN ANY WAY OUT OF THE USE, 
+*				REPRODUCTION, MODIFICATION AND/OR DISTRIBUTION OF THE APPLE SOFTWARE, HOWEVER CAUSED AND WHETHER 
+*				UNDER THEORY OF CONTRACT, TORT (INCLUDING NEGLIGENCE), STRICT LIABILITY OR OTHERWISE, EVEN 
+*				IF APPLE HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*
+*/
+#ifndef __PocketVerbsVersion_h__
+#define __PocketVerbsVersion_h__
+
+
+#ifdef DEBUG
+	#define kPocketVerbsVersion 0xFFFFFFFF
+#else
+	#define kPocketVerbsVersion 0x00010000	
+#endif
+
+//~~~~~~~~~~~~~~  Change!!! ~~~~~~~~~~~~~~~~~~~~~//
+#define PocketVerbs_COMP_MANF			'Dthr'
+#define PocketVerbs_COMP_SUBTYPE		'pkvb'
+//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~//
+
+#endif
+
diff --git a/plugins/MacAU/PocketVerbs/build/PocketVerbs.build/PocketVerbs.pbxindex/categories.pbxbtree b/plugins/MacAU/PocketVerbs/build/PocketVerbs.build/PocketVerbs.pbxindex/categories.pbxbtree
new file mode 100755
index 0000000..d3f6bb3
--- /dev/null
+++ b/plugins/MacAU/PocketVerbs/build/PocketVerbs.build/PocketVerbs.pbxindex/categories.pbxbtree
diff --git a/plugins/MacAU/PocketVerbs/build/PocketVerbs.build/PocketVerbs.pbxindex/cdecls.pbxbtree b/plugins/MacAU/PocketVerbs/build/PocketVerbs.build/PocketVerbs.pbxindex/cdecls.pbxbtree
new file mode 100755
index 0000000..4821b57
--- /dev/null
+++ b/plugins/MacAU/PocketVerbs/build/PocketVerbs.build/PocketVerbs.pbxindex/cdecls.pbxbtree
diff --git a/plugins/MacAU/PocketVerbs/build/PocketVerbs.build/PocketVerbs.pbxindex/decls.pbxbtree b/plugins/MacAU/PocketVerbs/build/PocketVerbs.build/PocketVerbs.pbxindex/decls.pbxbtree
new file mode 100755
index 0000000..4a40b5d
--- /dev/null
+++ b/plugins/MacAU/PocketVerbs/build/PocketVerbs.build/PocketVerbs.pbxindex/decls.pbxbtree
diff --git a/plugins/MacAU/PocketVerbs/build/PocketVerbs.build/PocketVerbs.pbxindex/files.pbxbtree b/plugins/MacAU/PocketVerbs/build/PocketVerbs.build/PocketVerbs.pbxindex/files.pbxbtree
new file mode 100755
index 0000000..f9bccaa
--- /dev/null
+++ b/plugins/MacAU/PocketVerbs/build/PocketVerbs.build/PocketVerbs.pbxindex/files.pbxbtree
diff --git a/plugins/MacAU/PocketVerbs/build/PocketVerbs.build/PocketVerbs.pbxindex/imports.pbxbtree b/plugins/MacAU/PocketVerbs/build/PocketVerbs.build/PocketVerbs.pbxindex/imports.pbxbtree
new file mode 100755
index 0000000..9d9ec0a
--- /dev/null
+++ b/plugins/MacAU/PocketVerbs/build/PocketVerbs.build/PocketVerbs.pbxindex/imports.pbxbtree
diff --git a/plugins/MacAU/PocketVerbs/build/PocketVerbs.build/PocketVerbs.pbxindex/pbxindex.header b/plugins/MacAU/PocketVerbs/build/PocketVerbs.build/PocketVerbs.pbxindex/pbxindex.header
new file mode 100755
index 0000000..6131daa
--- /dev/null
+++ b/plugins/MacAU/PocketVerbs/build/PocketVerbs.build/PocketVerbs.pbxindex/pbxindex.header
diff --git a/plugins/MacAU/PocketVerbs/build/PocketVerbs.build/PocketVerbs.pbxindex/protocols.pbxbtree b/plugins/MacAU/PocketVerbs/build/PocketVerbs.build/PocketVerbs.pbxindex/protocols.pbxbtree
new file mode 100755
index 0000000..d3f6bb3
--- /dev/null
+++ b/plugins/MacAU/PocketVerbs/build/PocketVerbs.build/PocketVerbs.pbxindex/protocols.pbxbtree
diff --git a/plugins/MacAU/PocketVerbs/build/PocketVerbs.build/PocketVerbs.pbxindex/refs.pbxbtree b/plugins/MacAU/PocketVerbs/build/PocketVerbs.build/PocketVerbs.pbxindex/refs.pbxbtree
new file mode 100755
index 0000000..aca451d
--- /dev/null
+++ b/plugins/MacAU/PocketVerbs/build/PocketVerbs.build/PocketVerbs.pbxindex/refs.pbxbtree
diff --git a/plugins/MacAU/PocketVerbs/build/PocketVerbs.build/PocketVerbs.pbxindex/strings.pbxstrings/control b/plugins/MacAU/PocketVerbs/build/PocketVerbs.build/PocketVerbs.pbxindex/strings.pbxstrings/control
new file mode 100755
index 0000000..d0d3ded
--- /dev/null
+++ b/plugins/MacAU/PocketVerbs/build/PocketVerbs.build/PocketVerbs.pbxindex/strings.pbxstrings/control
diff --git a/plugins/MacAU/PocketVerbs/build/PocketVerbs.build/PocketVerbs.pbxindex/strings.pbxstrings/strings b/plugins/MacAU/PocketVerbs/build/PocketVerbs.build/PocketVerbs.pbxindex/strings.pbxstrings/strings
new file mode 100755
index 0000000..8c8a0b1
--- /dev/null
+++ b/plugins/MacAU/PocketVerbs/build/PocketVerbs.build/PocketVerbs.pbxindex/strings.pbxstrings/strings
diff --git a/plugins/MacAU/PocketVerbs/build/PocketVerbs.build/PocketVerbs.pbxindex/subclasses.pbxbtree b/plugins/MacAU/PocketVerbs/build/PocketVerbs.build/PocketVerbs.pbxindex/subclasses.pbxbtree
new file mode 100755
index 0000000..712f37a
--- /dev/null
+++ b/plugins/MacAU/PocketVerbs/build/PocketVerbs.build/PocketVerbs.pbxindex/subclasses.pbxbtree
diff --git a/plugins/MacAU/PocketVerbs/build/PocketVerbs.build/PocketVerbs.pbxindex/symbols0.pbxsymbols b/plugins/MacAU/PocketVerbs/build/PocketVerbs.build/PocketVerbs.pbxindex/symbols0.pbxsymbols
new file mode 100755
index 0000000..46e93f5
--- /dev/null
+++ b/plugins/MacAU/PocketVerbs/build/PocketVerbs.build/PocketVerbs.pbxindex/symbols0.pbxsymbols
diff --git a/plugins/MacAU/PocketVerbs/version.plist b/plugins/MacAU/PocketVerbs/version.plist
new file mode 100755
index 0000000..11edf8a
--- /dev/null
+++ b/plugins/MacAU/PocketVerbs/version.plist
@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>BuildVersion</key>
+	<string>3</string>
+	<key>CFBundleShortVersionString</key>
+	<string>1.0</string>
+	<key>CFBundleVersion</key>
+	<string>1.0</string>
+	<key>ProjectName</key>
+	<string>${EXECUTABLE_NAME}</string>
+	<key>SourceVersion</key>
+	<string>590000</string>
+</dict>
+</plist>
diff --git a/plugins/MacVST/PocketVerbs/PocketVerbs.xcodeproj/christopherjohnson.pbxuser b/plugins/MacVST/PocketVerbs/PocketVerbs.xcodeproj/christopherjohnson.pbxuser
new file mode 100755
index 0000000..e737620
--- /dev/null
+++ b/plugins/MacVST/PocketVerbs/PocketVerbs.xcodeproj/christopherjohnson.pbxuser
@@ -0,0 +1,132 @@
+// !$*UTF8*$!
+{
+	089C1669FE841209C02AAC07 /* Project object */ = {
+		activeBuildConfigurationName = Release;
+		activeTarget = 8D01CCC60486CAD60068D4B7 /* PocketVerbs */;
+		codeSenseManager = 8B02375F1D42B1C400E1E8C8 /* Code sense */;
+		perUserDictionary = {
+			PBXConfiguration.PBXFileTableDataSource3.PBXFileTableDataSource = {
+				PBXFileTableDataSourceColumnSortingDirectionKey = "-1";
+				PBXFileTableDataSourceColumnSortingKey = PBXFileDataSource_Filename_ColumnID;
+				PBXFileTableDataSourceColumnWidthsKey = (
+					20,
+					364,
+					20,
+					48,
+					43,
+					43,
+					20,
+				);
+				PBXFileTableDataSourceColumnsKey = (
+					PBXFileDataSource_FiletypeID,
+					PBXFileDataSource_Filename_ColumnID,
+					PBXFileDataSource_Built_ColumnID,
+					PBXFileDataSource_ObjectSize_ColumnID,
+					PBXFileDataSource_Errors_ColumnID,
+					PBXFileDataSource_Warnings_ColumnID,
+					PBXFileDataSource_Target_ColumnID,
+				);
+			};
+			PBXConfiguration.PBXTargetDataSource.PBXTargetDataSource = {
+				PBXFileTableDataSourceColumnSortingDirectionKey = "-1";
+				PBXFileTableDataSourceColumnSortingKey = PBXFileDataSource_Filename_ColumnID;
+				PBXFileTableDataSourceColumnWidthsKey = (
+					20,
+					324,
+					60,
+					20,
+					48,
+					43,
+					43,
+				);
+				PBXFileTableDataSourceColumnsKey = (
+					PBXFileDataSource_FiletypeID,
+					PBXFileDataSource_Filename_ColumnID,
+					PBXTargetDataSource_PrimaryAttribute,
+					PBXFileDataSource_Built_ColumnID,
+					PBXFileDataSource_ObjectSize_ColumnID,
+					PBXFileDataSource_Errors_ColumnID,
+					PBXFileDataSource_Warnings_ColumnID,
+				);
+			};
+			PBXPerProjectTemplateStateSaveDate = 595640489;
+			PBXWorkspaceStateSaveDate = 595640489;
+		};
+		perUserProjectItems = {
+			8B063A4B2380C14D00606DBC /* PBXTextBookmark */ = 8B063A4B2380C14D00606DBC /* PBXTextBookmark */;
+			8B063A4C2380C14D00606DBC /* PBXTextBookmark */ = 8B063A4C2380C14D00606DBC /* PBXTextBookmark */;
+		};
+		sourceControlManager = 8B02375E1D42B1C400E1E8C8 /* Source Control */;
+		userBuildSettings = {
+		};
+	};
+	2407DEB6089929BA00EB68BF /* PocketVerbs.cpp */ = {
+		uiCtxt = {
+			sepNavIntBoundsRect = "{{0, 0}, {740, 5148}}";
+			sepNavSelRange = "{504, 0}";
+			sepNavVisRange = "{12728, 2478}";
+			sepNavWindowFrame = "{{53, 63}, {784, 815}}";
+		};
+	};
+	245463B80991757100464AD3 /* PocketVerbs.h */ = {
+		uiCtxt = {
+			sepNavIntBoundsRect = "{{0, 0}, {848, 3926}}";
+			sepNavSelRange = "{5331, 0}";
+			sepNavVisRange = "{3913, 931}";
+			sepNavWindowFrame = "{{8, 57}, {895, 821}}";
+		};
+	};
+	24A2FFDB0F90D1DD003BB5A7 /* audioeffectx.cpp */ = {
+		uiCtxt = {
+			sepNavIntBoundsRect = "{{0, 0}, {859, 20267}}";
+			sepNavSelRange = "{10616, 0}";
+			sepNavVisRange = "{9653, 2414}";
+			sepNavWindowFrame = "{{15, 42}, {895, 831}}";
+		};
+	};
+	24D8286F09A914000093AEF8 /* PocketVerbsProc.cpp */ = {
+		uiCtxt = {
+			sepNavIntBoundsRect = "{{0, 0}, {600, 239694}}";
+			sepNavSelRange = "{626758, 0}";
+			sepNavVisRange = "{553439, 143}";
+			sepNavWindowFrame = "{{496, 57}, {895, 821}}";
+		};
+	};
+	8B02375E1D42B1C400E1E8C8 /* Source Control */ = {
+		isa = PBXSourceControlManager;
+		fallbackIsa = XCSourceControlManager;
+		isSCMEnabled = 0;
+		scmConfiguration = {
+			repositoryNamesForRoots = {
+				"" = "";
+			};
+		};
+	};
+	8B02375F1D42B1C400E1E8C8 /* Code sense */ = {
+		isa = PBXCodeSenseManager;
+		indexTemplatePath = "";
+	};
+	8B063A4B2380C14D00606DBC /* PBXTextBookmark */ = {
+		isa = PBXTextBookmark;
+		fRef = 24D8286F09A914000093AEF8 /* PocketVerbsProc.cpp */;
+		name = "PocketVerbsProc.cpp: 18359";
+		rLen = 0;
+		rLoc = 626758;
+		rType = 0;
+		vrLen = 143;
+		vrLoc = 553435;
+	};
+	8B063A4C2380C14D00606DBC /* PBXTextBookmark */ = {
+		isa = PBXTextBookmark;
+		fRef = 24D8286F09A914000093AEF8 /* PocketVerbsProc.cpp */;
+		name = "PocketVerbsProc.cpp: 18359";
+		rLen = 0;
+		rLoc = 626758;
+		rType = 0;
+		vrLen = 143;
+		vrLoc = 553439;
+	};
+	8D01CCC60486CAD60068D4B7 /* PocketVerbs */ = {
+		activeExec = 0;
+	};
+}
diff --git a/plugins/MacVST/PocketVerbs/PocketVerbs.xcodeproj/christopherjohnson.perspectivev3 b/plugins/MacVST/PocketVerbs/PocketVerbs.xcodeproj/christopherjohnson.perspectivev3
new file mode 100755
index 0000000..3c65e1f
--- /dev/null
+++ b/plugins/MacVST/PocketVerbs/PocketVerbs.xcodeproj/christopherjohnson.perspectivev3
@@ -0,0 +1,1528 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>ActivePerspectiveName</key>
+	<string>Project</string>
+	<key>AllowedModules</key>
+	<array>
+		<dict>
+			<key>BundleLoadPath</key>
+			<string></string>
+			<key>MaxInstances</key>
+			<string>n</string>
+			<key>Module</key>
+			<string>PBXSmartGroupTreeModule</string>
+			<key>Name</key>
+			<string>Groups and Files Outline View</string>
+		</dict>
+		<dict>
+			<key>BundleLoadPath</key>
+			<string></string>
+			<key>MaxInstances</key>
+			<string>n</string>
+			<key>Module</key>
+			<string>PBXNavigatorGroup</string>
+			<key>Name</key>
+			<string>Editor</string>
+		</dict>
+		<dict>
+			<key>BundleLoadPath</key>
+			<string></string>
+			<key>MaxInstances</key>
+			<string>n</string>
+			<key>Module</key>
+			<string>XCTaskListModule</string>
+			<key>Name</key>
+			<string>Task List</string>
+		</dict>
+		<dict>
+			<key>BundleLoadPath</key>
+			<string></string>
+			<key>MaxInstances</key>
+			<string>n</string>
+			<key>Module</key>
+			<string>XCDetailModule</string>
+			<key>Name</key>
+			<string>File and Smart Group Detail Viewer</string>
+		</dict>
+		<dict>
+			<key>BundleLoadPath</key>
+			<string></string>
+			<key>MaxInstances</key>
+			<string>1</string>
+			<key>Module</key>
+			<string>PBXBuildResultsModule</string>
+			<key>Name</key>
+			<string>Detailed Build Results Viewer</string>
+		</dict>
+		<dict>
+			<key>BundleLoadPath</key>
+			<string></string>
+			<key>MaxInstances</key>
+			<string>1</string>
+			<key>Module</key>
+			<string>PBXProjectFindModule</string>
+			<key>Name</key>
+			<string>Project Batch Find Tool</string>
+		</dict>
+		<dict>
+			<key>BundleLoadPath</key>
+			<string></string>
+			<key>MaxInstances</key>
+			<string>n</string>
+			<key>Module</key>
+			<string>XCProjectFormatConflictsModule</string>
+			<key>Name</key>
+			<string>Project Format Conflicts List</string>
+		</dict>
+		<dict>
+			<key>BundleLoadPath</key>
+			<string></string>
+			<key>MaxInstances</key>
+			<string>n</string>
+			<key>Module</key>
+			<string>PBXBookmarksModule</string>
+			<key>Name</key>
+			<string>Bookmarks Tool</string>
+		</dict>
+		<dict>
+			<key>BundleLoadPath</key>
+			<string></string>
+			<key>MaxInstances</key>
+			<string>n</string>
+			<key>Module</key>
+			<string>PBXClassBrowserModule</string>
+			<key>Name</key>
+			<string>Class Browser</string>
+		</dict>
+		<dict>
+			<key>BundleLoadPath</key>
+			<string></string>
+			<key>MaxInstances</key>
+			<string>n</string>
+			<key>Module</key>
+			<string>PBXCVSModule</string>
+			<key>Name</key>
+			<string>Source Code Control Tool</string>
+		</dict>
+		<dict>
+			<key>BundleLoadPath</key>
+			<string></string>
+			<key>MaxInstances</key>
+			<string>n</string>
+			<key>Module</key>
+			<string>PBXDebugBreakpointsModule</string>
+			<key>Name</key>
+			<string>Debug Breakpoints Tool</string>
+		</dict>
+		<dict>
+			<key>BundleLoadPath</key>
+			<string></string>
+			<key>MaxInstances</key>
+			<string>n</string>
+			<key>Module</key>
+			<string>XCDockableInspector</string>
+			<key>Name</key>
+			<string>Inspector</string>
+		</dict>
+		<dict>
+			<key>BundleLoadPath</key>
+			<string></string>
+			<key>MaxInstances</key>
+			<string>n</string>
+			<key>Module</key>
+			<string>PBXOpenQuicklyModule</string>
+			<key>Name</key>
+			<string>Open Quickly Tool</string>
+		</dict>
+		<dict>
+			<key>BundleLoadPath</key>
+			<string></string>
+			<key>MaxInstances</key>
+			<string>1</string>
+			<key>Module</key>
+			<string>PBXDebugSessionModule</string>
+			<key>Name</key>
+			<string>Debugger</string>
+		</dict>
+		<dict>
+			<key>BundleLoadPath</key>
+			<string></string>
+			<key>MaxInstances</key>
+			<string>1</string>
+			<key>Module</key>
+			<string>PBXDebugCLIModule</string>
+			<key>Name</key>
+			<string>Debug Console</string>
+		</dict>
+		<dict>
+			<key>BundleLoadPath</key>
+			<string></string>
+			<key>MaxInstances</key>
+			<string>n</string>
+			<key>Module</key>
+			<string>XCSnapshotModule</string>
+			<key>Name</key>
+			<string>Snapshots Tool</string>
+		</dict>
+	</array>
+	<key>BundlePath</key>
+	<string>/Developer/Library/PrivateFrameworks/DevToolsInterface.framework/Resources</string>
+	<key>Description</key>
+	<string>AIODescriptionKey</string>
+	<key>DockingSystemVisible</key>
+	<false/>
+	<key>Extension</key>
+	<string>perspectivev3</string>
+	<key>FavBarConfig</key>
+	<dict>
+		<key>PBXProjectModuleGUID</key>
+		<string>8B02375D1D42B1C400E1E8C8</string>
+		<key>XCBarModuleItemNames</key>
+		<dict/>
+		<key>XCBarModuleItems</key>
+		<array/>
+	</dict>
+	<key>FirstTimeWindowDisplayed</key>
+	<false/>
+	<key>Identifier</key>
+	<string>com.apple.perspectives.project.defaultV3</string>
+	<key>MajorVersion</key>
+	<integer>34</integer>
+	<key>MinorVersion</key>
+	<integer>0</integer>
+	<key>Name</key>
+	<string>All-In-One</string>
+	<key>Notifications</key>
+	<array>
+		<dict>
+			<key>XCObserverAutoDisconnectKey</key>
+			<true/>
+			<key>XCObserverDefintionKey</key>
+			<dict>
+				<key>PBXStatusErrorsKey</key>
+				<integer>0</integer>
+			</dict>
+			<key>XCObserverFactoryKey</key>
+			<string>XCPerspectivesSpecificationIdentifier</string>
+			<key>XCObserverGUIDKey</key>
+			<string>XCObserverProjectIdentifier</string>
+			<key>XCObserverNotificationKey</key>
+			<string>PBXStatusBuildStateMessageNotification</string>
+			<key>XCObserverTargetKey</key>
+			<string>XCMainBuildResultsModuleGUID</string>
+			<key>XCObserverTriggerKey</key>
+			<string>awakenModuleWithObserver:</string>
+			<key>XCObserverValidationKey</key>
+			<dict>
+				<key>PBXStatusErrorsKey</key>
+				<integer>2</integer>
+			</dict>
+		</dict>
+	</array>
+	<key>OpenEditors</key>
+	<array/>
+	<key>PerspectiveWidths</key>
+	<array>
+		<integer>810</integer>
+		<integer>810</integer>
+	</array>
+	<key>Perspectives</key>
+	<array>
+		<dict>
+			<key>ChosenToolbarItems</key>
+			<array>
+				<string>XCToolbarPerspectiveControl</string>
+				<string>NSToolbarSeparatorItem</string>
+				<string>active-combo-popup</string>
+				<string>action</string>
+				<string>NSToolbarFlexibleSpaceItem</string>
+				<string>debugger-enable-breakpoints</string>
+				<string>build-and-go</string>
+				<string>com.apple.ide.PBXToolbarStopButton</string>
+				<string>get-info</string>
+				<string>NSToolbarFlexibleSpaceItem</string>
+				<string>com.apple.pbx.toolbar.searchfield</string>
+			</array>
+			<key>ControllerClassBaseName</key>
+			<string></string>
+			<key>IconName</key>
+			<string>WindowOfProject</string>
+			<key>Identifier</key>
+			<string>perspective.project</string>
+			<key>IsVertical</key>
+			<false/>
+			<key>Layout</key>
+			<array>
+				<dict>
+					<key>ContentConfiguration</key>
+					<dict>
+						<key>PBXBottomSmartGroupGIDs</key>
+						<array>
+							<string>1C37FBAC04509CD000000102</string>
+							<string>1C37FAAC04509CD000000102</string>
+							<string>1C37FABC05509CD000000102</string>
+							<string>1C37FABC05539CD112110102</string>
+							<string>E2644B35053B69B200211256</string>
+							<string>1C37FABC04509CD000100104</string>
+							<string>1CC0EA4004350EF90044410B</string>
+							<string>1CC0EA4004350EF90041110B</string>
+							<string>1C77FABC04509CD000000102</string>
+						</array>
+						<key>PBXProjectModuleGUID</key>
+						<string>1CA23ED40692098700951B8B</string>
+						<key>PBXProjectModuleLabel</key>
+						<string>Files</string>
+						<key>PBXProjectStructureProvided</key>
+						<string>yes</string>
+						<key>PBXSmartGroupTreeModuleColumnData</key>
+						<dict>
+							<key>PBXSmartGroupTreeModuleColumnWidthsKey</key>
+							<array>
+								<real>185</real>
+							</array>
+							<key>PBXSmartGroupTreeModuleColumnsKey_v4</key>
+							<array>
+								<string>MainColumn</string>
+							</array>
+						</dict>
+						<key>PBXSmartGroupTreeModuleOutlineStateKey_v7</key>
+						<dict>
+							<key>PBXSmartGroupTreeModuleOutlineStateExpansionKey</key>
+							<array>
+								<string>089C166AFE841209C02AAC07</string>
+								<string>08FB77ADFE841716C02AAC07</string>
+								<string>1C37FBAC04509CD000000102</string>
+							</array>
+							<key>PBXSmartGroupTreeModuleOutlineStateSelectionKey</key>
+							<array>
+								<array>
+									<integer>6</integer>
+									<integer>4</integer>
+									<integer>0</integer>
+								</array>
+							</array>
+							<key>PBXSmartGroupTreeModuleOutlineStateVisibleRectKey</key>
+							<string>{{0, 0}, {185, 428}}</string>
+						</dict>
+						<key>PBXTopSmartGroupGIDs</key>
+						<array/>
+						<key>XCIncludePerspectivesSwitch</key>
+						<false/>
+					</dict>
+					<key>GeometryConfiguration</key>
+					<dict>
+						<key>Frame</key>
+						<string>{{0, 0}, {202, 446}}</string>
+						<key>GroupTreeTableConfiguration</key>
+						<array>
+							<string>MainColumn</string>
+							<real>185</real>
+						</array>
+						<key>RubberWindowFrame</key>
+						<string>31 381 810 487 0 0 1440 878 </string>
+					</dict>
+					<key>Module</key>
+					<string>PBXSmartGroupTreeModule</string>
+					<key>Proportion</key>
+					<string>202pt</string>
+				</dict>
+				<dict>
+					<key>Dock</key>
+					<array>
+						<dict>
+							<key>ContentConfiguration</key>
+							<dict>
+								<key>PBXProjectModuleGUID</key>
+								<string>8B0237581D42B1C400E1E8C8</string>
+								<key>PBXProjectModuleLabel</key>
+								<string>PocketVerbsProc.cpp</string>
+								<key>PBXSplitModuleInNavigatorKey</key>
+								<dict>
+									<key>Split0</key>
+									<dict>
+										<key>PBXProjectModuleGUID</key>
+										<string>8B0237591D42B1C400E1E8C8</string>
+										<key>PBXProjectModuleLabel</key>
+										<string>PocketVerbsProc.cpp</string>
+										<key>_historyCapacity</key>
+										<integer>0</integer>
+										<key>bookmark</key>
+										<string>8B063A4C2380C14D00606DBC</string>
+										<key>history</key>
+										<array>
+											<string>8B063A4B2380C14D00606DBC</string>
+										</array>
+									</dict>
+									<key>SplitCount</key>
+									<string>1</string>
+								</dict>
+								<key>StatusBarVisibility</key>
+								<true/>
+								<key>XCSharingToken</key>
+								<string>com.apple.Xcode.CommonNavigatorGroupSharingToken</string>
+							</dict>
+							<key>GeometryConfiguration</key>
+							<dict>
+								<key>Frame</key>
+								<string>{{0, 0}, {603, 117}}</string>
+								<key>RubberWindowFrame</key>
+								<string>31 381 810 487 0 0 1440 878 </string>
+							</dict>
+							<key>Module</key>
+							<string>PBXNavigatorGroup</string>
+							<key>Proportion</key>
+							<string>117pt</string>
+						</dict>
+						<dict>
+							<key>Proportion</key>
+							<string>324pt</string>
+							<key>Tabs</key>
+							<array>
+								<dict>
+									<key>ContentConfiguration</key>
+									<dict>
+										<key>PBXProjectModuleGUID</key>
+										<string>1CA23EDF0692099D00951B8B</string>
+										<key>PBXProjectModuleLabel</key>
+										<string>Detail</string>
+									</dict>
+									<key>GeometryConfiguration</key>
+									<dict>
+										<key>Frame</key>
+										<string>{{10, 27}, {603, 297}}</string>
+									</dict>
+									<key>Module</key>
+									<string>XCDetailModule</string>
+								</dict>
+								<dict>
+									<key>ContentConfiguration</key>
+									<dict>
+										<key>PBXProjectModuleGUID</key>
+										<string>1CA23EE00692099D00951B8B</string>
+										<key>PBXProjectModuleLabel</key>
+										<string>Project Find</string>
+									</dict>
+									<key>GeometryConfiguration</key>
+									<dict>
+										<key>Frame</key>
+										<string>{{10, 31}, {603, 297}}</string>
+									</dict>
+									<key>Module</key>
+									<string>PBXProjectFindModule</string>
+								</dict>
+								<dict>
+									<key>ContentConfiguration</key>
+									<dict>
+										<key>PBXCVSModuleFilterTypeKey</key>
+										<integer>1032</integer>
+										<key>PBXProjectModuleGUID</key>
+										<string>1CA23EE10692099D00951B8B</string>
+										<key>PBXProjectModuleLabel</key>
+										<string>SCM Results</string>
+									</dict>
+									<key>GeometryConfiguration</key>
+									<dict>
+										<key>Frame</key>
+										<string>{{10, 31}, {603, 297}}</string>
+									</dict>
+									<key>Module</key>
+									<string>PBXCVSModule</string>
+								</dict>
+								<dict>
+									<key>ContentConfiguration</key>
+									<dict>
+										<key>PBXProjectModuleGUID</key>
+										<string>XCMainBuildResultsModuleGUID</string>
+										<key>PBXProjectModuleLabel</key>
+										<string>Build Results</string>
+										<key>XCBuildResultsTrigger_Collapse</key>
+										<integer>1023</integer>
+										<key>XCBuildResultsTrigger_Open</key>
+										<integer>1012</integer>
+									</dict>
+									<key>GeometryConfiguration</key>
+									<dict>
+										<key>Frame</key>
+										<string>{{10, 27}, {603, 297}}</string>
+										<key>RubberWindowFrame</key>
+										<string>31 381 810 487 0 0 1440 878 </string>
+									</dict>
+									<key>Module</key>
+									<string>PBXBuildResultsModule</string>
+								</dict>
+							</array>
+						</dict>
+					</array>
+					<key>Proportion</key>
+					<string>603pt</string>
+				</dict>
+			</array>
+			<key>Name</key>
+			<string>Project</string>
+			<key>ServiceClasses</key>
+			<array>
+				<string>XCModuleDock</string>
+				<string>PBXSmartGroupTreeModule</string>
+				<string>XCModuleDock</string>
+				<string>PBXNavigatorGroup</string>
+				<string>XCDockableTabModule</string>
+				<string>XCDetailModule</string>
+				<string>PBXProjectFindModule</string>
+				<string>PBXCVSModule</string>
+				<string>PBXBuildResultsModule</string>
+			</array>
+			<key>TableOfContents</key>
+			<array>
+				<string>8B063A4D2380C14D00606DBC</string>
+				<string>1CA23ED40692098700951B8B</string>
+				<string>8B063A4E2380C14D00606DBC</string>
+				<string>8B0237581D42B1C400E1E8C8</string>
+				<string>8B063A4F2380C14D00606DBC</string>
+				<string>1CA23EDF0692099D00951B8B</string>
+				<string>1CA23EE00692099D00951B8B</string>
+				<string>1CA23EE10692099D00951B8B</string>
+				<string>XCMainBuildResultsModuleGUID</string>
+			</array>
+			<key>ToolbarConfigUserDefaultsMinorVersion</key>
+			<string>2</string>
+			<key>ToolbarConfiguration</key>
+			<string>xcode.toolbar.config.defaultV3</string>
+		</dict>
+		<dict>
+			<key>ChosenToolbarItems</key>
+			<array>
+				<string>XCToolbarPerspectiveControl</string>
+				<string>NSToolbarSeparatorItem</string>
+				<string>active-combo-popup</string>
+				<string>NSToolbarFlexibleSpaceItem</string>
+				<string>debugger-enable-breakpoints</string>
+				<string>build-and-go</string>
+				<string>com.apple.ide.PBXToolbarStopButton</string>
+				<string>debugger-restart-executable</string>
+				<string>debugger-pause</string>
+				<string>debugger-step-over</string>
+				<string>debugger-step-into</string>
+				<string>debugger-step-out</string>
+				<string>NSToolbarFlexibleSpaceItem</string>
+				<string>servicesModulebreakpoints</string>
+				<string>debugger-show-console-window</string>
+			</array>
+			<key>ControllerClassBaseName</key>
+			<string>PBXDebugSessionModule</string>
+			<key>IconName</key>
+			<string>DebugTabIcon</string>
+			<key>Identifier</key>
+			<string>perspective.debug</string>
+			<key>IsVertical</key>
+			<true/>
+			<key>Layout</key>
+			<array>
+				<dict>
+					<key>ContentConfiguration</key>
+					<dict>
+						<key>PBXProjectModuleGUID</key>
+						<string>1CCC7628064C1048000F2A68</string>
+						<key>PBXProjectModuleLabel</key>
+						<string>Debugger Console</string>
+					</dict>
+					<key>GeometryConfiguration</key>
+					<dict>
+						<key>Frame</key>
+						<string>{{0, 0}, {424, 270}}</string>
+					</dict>
+					<key>Module</key>
+					<string>PBXDebugCLIModule</string>
+					<key>Proportion</key>
+					<string>270pt</string>
+				</dict>
+				<dict>
+					<key>ContentConfiguration</key>
+					<dict>
+						<key>Debugger</key>
+						<dict>
+							<key>HorizontalSplitView</key>
+							<dict>
+								<key>_collapsingFrameDimension</key>
+								<real>0.0</real>
+								<key>_indexOfCollapsedView</key>
+								<integer>0</integer>
+								<key>_percentageOfCollapsedView</key>
+								<real>0.0</real>
+								<key>isCollapsed</key>
+								<string>yes</string>
+								<key>sizes</key>
+								<array>
+									<string>{{0, 0}, {395, 213}}</string>
+									<string>{{395, 0}, {415, 213}}</string>
+								</array>
+							</dict>
+							<key>VerticalSplitView</key>
+							<dict>
+								<key>_collapsingFrameDimension</key>
+								<real>0.0</real>
+								<key>_indexOfCollapsedView</key>
+								<integer>0</integer>
+								<key>_percentageOfCollapsedView</key>
+								<real>0.0</real>
+								<key>isCollapsed</key>
+								<string>yes</string>
+								<key>sizes</key>
+								<array>
+									<string>{{0, 0}, {810, 213}}</string>
+									<string>{{0, 213}, {810, 225}}</string>
+								</array>
+							</dict>
+						</dict>
+						<key>LauncherConfigVersion</key>
+						<string>8</string>
+						<key>PBXProjectModuleGUID</key>
+						<string>1CCC7629064C1048000F2A68</string>
+						<key>PBXProjectModuleLabel</key>
+						<string>Debug</string>
+					</dict>
+					<key>GeometryConfiguration</key>
+					<dict>
+						<key>DebugConsoleVisible</key>
+						<string>None</string>
+						<key>DebugConsoleWindowFrame</key>
+						<string>{{200, 200}, {500, 300}}</string>
+						<key>DebugSTDIOWindowFrame</key>
+						<string>{{200, 200}, {500, 300}}</string>
+						<key>Frame</key>
+						<string>{{0, 7}, {810, 438}}</string>
+						<key>PBXDebugSessionStackFrameViewKey</key>
+						<dict>
+							<key>DebugVariablesTableConfiguration</key>
+							<array>
+								<string>Name</string>
+								<real>120</real>
+								<string>Value</string>
+								<real>85</real>
+								<string>Summary</string>
+								<real>185</real>
+							</array>
+							<key>Frame</key>
+							<string>{{395, 0}, {415, 213}}</string>
+						</dict>
+					</dict>
+					<key>Module</key>
+					<string>PBXDebugSessionModule</string>
+					<key>Proportion</key>
+					<string>438pt</string>
+				</dict>
+			</array>
+			<key>Name</key>
+			<string>Debug</string>
+			<key>ServiceClasses</key>
+			<array>
+				<string>XCModuleDock</string>
+				<string>PBXDebugCLIModule</string>
+				<string>PBXDebugSessionModule</string>
+				<string>PBXDebugProcessAndThreadModule</string>
+				<string>PBXDebugProcessViewModule</string>
+				<string>PBXDebugThreadViewModule</string>
+				<string>PBXDebugStackFrameViewModule</string>
+				<string>PBXNavigatorGroup</string>
+			</array>
+			<key>TableOfContents</key>
+			<array>
+				<string>8B063A272380BEA500606DBC</string>
+				<string>1CCC7628064C1048000F2A68</string>
+				<string>1CCC7629064C1048000F2A68</string>
+				<string>8B063A282380BEA500606DBC</string>
+				<string>8B063A292380BEA500606DBC</string>
+				<string>8B063A2A2380BEA500606DBC</string>
+				<string>8B063A2B2380BEA500606DBC</string>
+				<string>8B063A2C2380BEA500606DBC</string>
+			</array>
+			<key>ToolbarConfigUserDefaultsMinorVersion</key>
+			<string>2</string>
+			<key>ToolbarConfiguration</key>
+			<string>xcode.toolbar.config.debugV3</string>
+		</dict>
+	</array>
+	<key>PerspectivesBarVisible</key>
+	<true/>
+	<key>ShelfIsVisible</key>
+	<false/>
+	<key>SourceDescription</key>
+	<string>file at '/Developer/Library/PrivateFrameworks/DevToolsInterface.framework/Resources/XCPerspectivesSpecification.xcperspec'</string>
+	<key>StatusbarIsVisible</key>
+	<true/>
+	<key>TimeStamp</key>
+	<real>595640653.28914702</real>
+	<key>ToolbarConfigUserDefaultsMinorVersion</key>
+	<string>2</string>
+	<key>ToolbarDisplayMode</key>
+	<integer>1</integer>
+	<key>ToolbarIsVisible</key>
+	<true/>
+	<key>ToolbarSizeMode</key>
+	<integer>2</integer>
+	<key>Type</key>
+	<string>Perspectives</string>
+	<key>UpdateMessage</key>
+	<string></string>
+	<key>WindowJustification</key>
+	<integer>5</integer>
+	<key>WindowOrderList</key>
+	<array>
+		<string>/Users/christopherjohnson/Desktop/Plugins/MacVST/PocketVerbs/PocketVerbs.xcodeproj</string>
+	</array>
+	<key>WindowString</key>
+	<string>31 381 810 487 0 0 1440 878 </string>
+	<key>WindowToolsV3</key>
+	<array>
+		<dict>
+			<key>Identifier</key>
+			<string>windowTool.debugger</string>
+			<key>Layout</key>
+			<array>
+				<dict>
+					<key>Dock</key>
+					<array>
+						<dict>
+							<key>ContentConfiguration</key>
+							<dict>
+								<key>Debugger</key>
+								<dict>
+									<key>HorizontalSplitView</key>
+									<dict>
+										<key>_collapsingFrameDimension</key>
+										<real>0.0</real>
+										<key>_indexOfCollapsedView</key>
+										<integer>0</integer>
+										<key>_percentageOfCollapsedView</key>
+										<real>0.0</real>
+										<key>isCollapsed</key>
+										<string>yes</string>
+										<key>sizes</key>
+										<array>
+											<string>{{0, 0}, {317, 164}}</string>
+											<string>{{317, 0}, {377, 164}}</string>
+										</array>
+									</dict>
+									<key>VerticalSplitView</key>
+									<dict>
+										<key>_collapsingFrameDimension</key>
+										<real>0.0</real>
+										<key>_indexOfCollapsedView</key>
+										<integer>0</integer>
+										<key>_percentageOfCollapsedView</key>
+										<real>0.0</real>
+										<key>isCollapsed</key>
+										<string>yes</string>
+										<key>sizes</key>
+										<array>
+											<string>{{0, 0}, {694, 164}}</string>
+											<string>{{0, 164}, {694, 216}}</string>
+										</array>
+									</dict>
+								</dict>
+								<key>LauncherConfigVersion</key>
+								<string>8</string>
+								<key>PBXProjectModuleGUID</key>
+								<string>1C162984064C10D400B95A72</string>
+								<key>PBXProjectModuleLabel</key>
+								<string>Debug - GLUTExamples (Underwater)</string>
+							</dict>
+							<key>GeometryConfiguration</key>
+							<dict>
+								<key>DebugConsoleDrawerSize</key>
+								<string>{100, 120}</string>
+								<key>DebugConsoleVisible</key>
+								<string>None</string>
+								<key>DebugConsoleWindowFrame</key>
+								<string>{{200, 200}, {500, 300}}</string>
+								<key>DebugSTDIOWindowFrame</key>
+								<string>{{200, 200}, {500, 300}}</string>
+								<key>Frame</key>
+								<string>{{0, 0}, {694, 380}}</string>
+								<key>RubberWindowFrame</key>
+								<string>321 238 694 422 0 0 1440 878 </string>
+							</dict>
+							<key>Module</key>
+							<string>PBXDebugSessionModule</string>
+							<key>Proportion</key>
+							<string>100%</string>
+						</dict>
+					</array>
+					<key>Proportion</key>
+					<string>100%</string>
+				</dict>
+			</array>
+			<key>Name</key>
+			<string>Debugger</string>
+			<key>ServiceClasses</key>
+			<array>
+				<string>PBXDebugSessionModule</string>
+			</array>
+			<key>StatusbarIsVisible</key>
+			<integer>1</integer>
+			<key>TableOfContents</key>
+			<array>
+				<string>1CD10A99069EF8BA00B06720</string>
+				<string>1C0AD2AB069F1E9B00FABCE6</string>
+				<string>1C162984064C10D400B95A72</string>
+				<string>1C0AD2AC069F1E9B00FABCE6</string>
+			</array>
+			<key>ToolbarConfiguration</key>
+			<string>xcode.toolbar.config.debugV3</string>
+			<key>WindowString</key>
+			<string>321 238 694 422 0 0 1440 878 </string>
+			<key>WindowToolGUID</key>
+			<string>1CD10A99069EF8BA00B06720</string>
+			<key>WindowToolIsVisible</key>
+			<integer>0</integer>
+		</dict>
+		<dict>
+			<key>Identifier</key>
+			<string>windowTool.build</string>
+			<key>Layout</key>
+			<array>
+				<dict>
+					<key>Dock</key>
+					<array>
+						<dict>
+							<key>ContentConfiguration</key>
+							<dict>
+								<key>PBXProjectModuleGUID</key>
+								<string>1CD0528F0623707200166675</string>
+								<key>PBXProjectModuleLabel</key>
+								<string>&lt;No Editor&gt;</string>
+								<key>PBXSplitModuleInNavigatorKey</key>
+								<dict>
+									<key>Split0</key>
+									<dict>
+										<key>PBXProjectModuleGUID</key>
+										<string>1CD052900623707200166675</string>
+									</dict>
+									<key>SplitCount</key>
+									<string>1</string>
+								</dict>
+								<key>StatusBarVisibility</key>
+								<integer>1</integer>
+							</dict>
+							<key>GeometryConfiguration</key>
+							<dict>
+								<key>Frame</key>
+								<string>{{0, 0}, {500, 215}}</string>
+								<key>RubberWindowFrame</key>
+								<string>192 257 500 500 0 0 1280 1002 </string>
+							</dict>
+							<key>Module</key>
+							<string>PBXNavigatorGroup</string>
+							<key>Proportion</key>
+							<string>218pt</string>
+						</dict>
+						<dict>
+							<key>BecomeActive</key>
+							<integer>1</integer>
+							<key>ContentConfiguration</key>
+							<dict>
+								<key>PBXProjectModuleGUID</key>
+								<string>XCMainBuildResultsModuleGUID</string>
+								<key>PBXProjectModuleLabel</key>
+								<string>Build Results</string>
+							</dict>
+							<key>GeometryConfiguration</key>
+							<dict>
+								<key>Frame</key>
+								<string>{{0, 222}, {500, 236}}</string>
+								<key>RubberWindowFrame</key>
+								<string>192 257 500 500 0 0 1280 1002 </string>
+							</dict>
+							<key>Module</key>
+							<string>PBXBuildResultsModule</string>
+							<key>Proportion</key>
+							<string>236pt</string>
+						</dict>
+					</array>
+					<key>Proportion</key>
+					<string>458pt</string>
+				</dict>
+			</array>
+			<key>Name</key>
+			<string>Build Results</string>
+			<key>ServiceClasses</key>
+			<array>
+				<string>PBXBuildResultsModule</string>
+			</array>
+			<key>StatusbarIsVisible</key>
+			<integer>1</integer>
+			<key>TableOfContents</key>
+			<array>
+				<string>1C78EAA5065D492600B07095</string>
+				<string>1C78EAA6065D492600B07095</string>
+				<string>1CD0528F0623707200166675</string>
+				<string>XCMainBuildResultsModuleGUID</string>
+			</array>
+			<key>ToolbarConfiguration</key>
+			<string>xcode.toolbar.config.buildV3</string>
+			<key>WindowString</key>
+			<string>192 257 500 500 0 0 1280 1002 </string>
+		</dict>
+		<dict>
+			<key>Identifier</key>
+			<string>windowTool.find</string>
+			<key>Layout</key>
+			<array>
+				<dict>
+					<key>Dock</key>
+					<array>
+						<dict>
+							<key>Dock</key>
+							<array>
+								<dict>
+									<key>ContentConfiguration</key>
+									<dict>
+										<key>PBXProjectModuleGUID</key>
+										<string>1CDD528C0622207200134675</string>
+										<key>PBXProjectModuleLabel</key>
+										<string>&lt;No Editor&gt;</string>
+										<key>PBXSplitModuleInNavigatorKey</key>
+										<dict>
+											<key>Split0</key>
+											<dict>
+												<key>PBXProjectModuleGUID</key>
+												<string>1CD0528D0623707200166675</string>
+											</dict>
+											<key>SplitCount</key>
+											<string>1</string>
+										</dict>
+										<key>StatusBarVisibility</key>
+										<integer>1</integer>
+									</dict>
+									<key>GeometryConfiguration</key>
+									<dict>
+										<key>Frame</key>
+										<string>{{0, 0}, {781, 167}}</string>
+										<key>RubberWindowFrame</key>
+										<string>62 385 781 470 0 0 1440 878 </string>
+									</dict>
+									<key>Module</key>
+									<string>PBXNavigatorGroup</string>
+									<key>Proportion</key>
+									<string>781pt</string>
+								</dict>
+							</array>
+							<key>Proportion</key>
+							<string>50%</string>
+						</dict>
+						<dict>
+							<key>BecomeActive</key>
+							<integer>1</integer>
+							<key>ContentConfiguration</key>
+							<dict>
+								<key>PBXProjectModuleGUID</key>
+								<string>1CD0528E0623707200166675</string>
+								<key>PBXProjectModuleLabel</key>
+								<string>Project Find</string>
+							</dict>
+							<key>GeometryConfiguration</key>
+							<dict>
+								<key>Frame</key>
+								<string>{{8, 0}, {773, 254}}</string>
+								<key>RubberWindowFrame</key>
+								<string>62 385 781 470 0 0 1440 878 </string>
+							</dict>
+							<key>Module</key>
+							<string>PBXProjectFindModule</string>
+							<key>Proportion</key>
+							<string>50%</string>
+						</dict>
+					</array>
+					<key>Proportion</key>
+					<string>428pt</string>
+				</dict>
+			</array>
+			<key>Name</key>
+			<string>Project Find</string>
+			<key>ServiceClasses</key>
+			<array>
+				<string>PBXProjectFindModule</string>
+			</array>
+			<key>StatusbarIsVisible</key>
+			<integer>1</integer>
+			<key>TableOfContents</key>
+			<array>
+				<string>1C530D57069F1CE1000CFCEE</string>
+				<string>1C530D58069F1CE1000CFCEE</string>
+				<string>1C530D59069F1CE1000CFCEE</string>
+				<string>1CDD528C0622207200134675</string>
+				<string>1C530D5A069F1CE1000CFCEE</string>
+				<string>1CE0B1FE06471DED0097A5F4</string>
+				<string>1CD0528E0623707200166675</string>
+			</array>
+			<key>WindowString</key>
+			<string>62 385 781 470 0 0 1440 878 </string>
+			<key>WindowToolGUID</key>
+			<string>1C530D57069F1CE1000CFCEE</string>
+			<key>WindowToolIsVisible</key>
+			<integer>0</integer>
+		</dict>
+		<dict>
+			<key>Identifier</key>
+			<string>windowTool.snapshots</string>
+			<key>Layout</key>
+			<array>
+				<dict>
+					<key>Dock</key>
+					<array>
+						<dict>
+							<key>Module</key>
+							<string>XCSnapshotModule</string>
+							<key>Proportion</key>
+							<string>100%</string>
+						</dict>
+					</array>
+					<key>Proportion</key>
+					<string>100%</string>
+				</dict>
+			</array>
+			<key>Name</key>
+			<string>Snapshots</string>
+			<key>ServiceClasses</key>
+			<array>
+				<string>XCSnapshotModule</string>
+			</array>
+			<key>StatusbarIsVisible</key>
+			<string>Yes</string>
+			<key>ToolbarConfiguration</key>
+			<string>xcode.toolbar.config.snapshots</string>
+			<key>WindowString</key>
+			<string>315 824 300 550 0 0 1440 878 </string>
+			<key>WindowToolIsVisible</key>
+			<string>Yes</string>
+		</dict>
+		<dict>
+			<key>Identifier</key>
+			<string>windowTool.debuggerConsole</string>
+			<key>Layout</key>
+			<array>
+				<dict>
+					<key>Dock</key>
+					<array>
+						<dict>
+							<key>BecomeActive</key>
+							<integer>1</integer>
+							<key>ContentConfiguration</key>
+							<dict>
+								<key>PBXProjectModuleGUID</key>
+								<string>1C78EAAC065D492600B07095</string>
+								<key>PBXProjectModuleLabel</key>
+								<string>Debugger Console</string>
+							</dict>
+							<key>GeometryConfiguration</key>
+							<dict>
+								<key>Frame</key>
+								<string>{{0, 0}, {700, 358}}</string>
+								<key>RubberWindowFrame</key>
+								<string>149 87 700 400 0 0 1440 878 </string>
+							</dict>
+							<key>Module</key>
+							<string>PBXDebugCLIModule</string>
+							<key>Proportion</key>
+							<string>358pt</string>
+						</dict>
+					</array>
+					<key>Proportion</key>
+					<string>358pt</string>
+				</dict>
+			</array>
+			<key>Name</key>
+			<string>Debugger Console</string>
+			<key>ServiceClasses</key>
+			<array>
+				<string>PBXDebugCLIModule</string>
+			</array>
+			<key>StatusbarIsVisible</key>
+			<integer>1</integer>
+			<key>TableOfContents</key>
+			<array>
+				<string>1C530D5B069F1CE1000CFCEE</string>
+				<string>1C530D5C069F1CE1000CFCEE</string>
+				<string>1C78EAAC065D492600B07095</string>
+			</array>
+			<key>ToolbarConfiguration</key>
+			<string>xcode.toolbar.config.consoleV3</string>
+			<key>WindowString</key>
+			<string>149 87 440 400 0 0 1440 878 </string>
+			<key>WindowToolGUID</key>
+			<string>1C530D5B069F1CE1000CFCEE</string>
+			<key>WindowToolIsVisible</key>
+			<integer>0</integer>
+		</dict>
+		<dict>
+			<key>Identifier</key>
+			<string>windowTool.scm</string>
+			<key>Layout</key>
+			<array>
+				<dict>
+					<key>Dock</key>
+					<array>
+						<dict>
+							<key>ContentConfiguration</key>
+							<dict>
+								<key>PBXProjectModuleGUID</key>
+								<string>1C78EAB2065D492600B07095</string>
+								<key>PBXProjectModuleLabel</key>
+								<string>&lt;No Editor&gt;</string>
+								<key>PBXSplitModuleInNavigatorKey</key>
+								<dict>
+									<key>Split0</key>
+									<dict>
+										<key>PBXProjectModuleGUID</key>
+										<string>1C78EAB3065D492600B07095</string>
+									</dict>
+									<key>SplitCount</key>
+									<string>1</string>
+								</dict>
+								<key>StatusBarVisibility</key>
+								<integer>1</integer>
+							</dict>
+							<key>GeometryConfiguration</key>
+							<dict>
+								<key>Frame</key>
+								<string>{{0, 0}, {452, 0}}</string>
+								<key>RubberWindowFrame</key>
+								<string>743 379 452 308 0 0 1280 1002 </string>
+							</dict>
+							<key>Module</key>
+							<string>PBXNavigatorGroup</string>
+							<key>Proportion</key>
+							<string>0pt</string>
+						</dict>
+						<dict>
+							<key>BecomeActive</key>
+							<integer>1</integer>
+							<key>ContentConfiguration</key>
+							<dict>
+								<key>PBXProjectModuleGUID</key>
+								<string>1CD052920623707200166675</string>
+								<key>PBXProjectModuleLabel</key>
+								<string>SCM</string>
+							</dict>
+							<key>GeometryConfiguration</key>
+							<dict>
+								<key>ConsoleFrame</key>
+								<string>{{0, 259}, {452, 0}}</string>
+								<key>Frame</key>
+								<string>{{0, 7}, {452, 259}}</string>
+								<key>RubberWindowFrame</key>
+								<string>743 379 452 308 0 0 1280 1002 </string>
+								<key>TableConfiguration</key>
+								<array>
+									<string>Status</string>
+									<real>30</real>
+									<string>FileName</string>
+									<real>199</real>
+									<string>Path</string>
+									<real>197.09500122070312</real>
+								</array>
+								<key>TableFrame</key>
+								<string>{{0, 0}, {452, 250}}</string>
+							</dict>
+							<key>Module</key>
+							<string>PBXCVSModule</string>
+							<key>Proportion</key>
+							<string>262pt</string>
+						</dict>
+					</array>
+					<key>Proportion</key>
+					<string>266pt</string>
+				</dict>
+			</array>
+			<key>Name</key>
+			<string>SCM</string>
+			<key>ServiceClasses</key>
+			<array>
+				<string>PBXCVSModule</string>
+			</array>
+			<key>StatusbarIsVisible</key>
+			<integer>1</integer>
+			<key>TableOfContents</key>
+			<array>
+				<string>1C78EAB4065D492600B07095</string>
+				<string>1C78EAB5065D492600B07095</string>
+				<string>1C78EAB2065D492600B07095</string>
+				<string>1CD052920623707200166675</string>
+			</array>
+			<key>ToolbarConfiguration</key>
+			<string>xcode.toolbar.config.scmV3</string>
+			<key>WindowString</key>
+			<string>743 379 452 308 0 0 1280 1002 </string>
+		</dict>
+		<dict>
+			<key>Identifier</key>
+			<string>windowTool.breakpoints</string>
+			<key>IsVertical</key>
+			<integer>0</integer>
+			<key>Layout</key>
+			<array>
+				<dict>
+					<key>Dock</key>
+					<array>
+						<dict>
+							<key>BecomeActive</key>
+							<integer>1</integer>
+							<key>ContentConfiguration</key>
+							<dict>
+								<key>PBXBottomSmartGroupGIDs</key>
+								<array>
+									<string>1C77FABC04509CD000000102</string>
+								</array>
+								<key>PBXProjectModuleGUID</key>
+								<string>1CE0B1FE06471DED0097A5F4</string>
+								<key>PBXProjectModuleLabel</key>
+								<string>Files</string>
+								<key>PBXProjectStructureProvided</key>
+								<string>no</string>
+								<key>PBXSmartGroupTreeModuleColumnData</key>
+								<dict>
+									<key>PBXSmartGroupTreeModuleColumnWidthsKey</key>
+									<array>
+										<real>168</real>
+									</array>
+									<key>PBXSmartGroupTreeModuleColumnsKey_v4</key>
+									<array>
+										<string>MainColumn</string>
+									</array>
+								</dict>
+								<key>PBXSmartGroupTreeModuleOutlineStateKey_v7</key>
+								<dict>
+									<key>PBXSmartGroupTreeModuleOutlineStateExpansionKey</key>
+									<array>
+										<string>1C77FABC04509CD000000102</string>
+									</array>
+									<key>PBXSmartGroupTreeModuleOutlineStateSelectionKey</key>
+									<array>
+										<array>
+											<integer>0</integer>
+										</array>
+									</array>
+									<key>PBXSmartGroupTreeModuleOutlineStateVisibleRectKey</key>
+									<string>{{0, 0}, {168, 350}}</string>
+								</dict>
+								<key>PBXTopSmartGroupGIDs</key>
+								<array/>
+								<key>XCIncludePerspectivesSwitch</key>
+								<integer>0</integer>
+							</dict>
+							<key>GeometryConfiguration</key>
+							<dict>
+								<key>Frame</key>
+								<string>{{0, 0}, {185, 368}}</string>
+								<key>GroupTreeTableConfiguration</key>
+								<array>
+									<string>MainColumn</string>
+									<real>168</real>
+								</array>
+								<key>RubberWindowFrame</key>
+								<string>315 424 744 409 0 0 1440 878 </string>
+							</dict>
+							<key>Module</key>
+							<string>PBXSmartGroupTreeModule</string>
+							<key>Proportion</key>
+							<string>185pt</string>
+						</dict>
+						<dict>
+							<key>ContentConfiguration</key>
+							<dict>
+								<key>PBXProjectModuleGUID</key>
+								<string>1CA1AED706398EBD00589147</string>
+								<key>PBXProjectModuleLabel</key>
+								<string>Detail</string>
+							</dict>
+							<key>GeometryConfiguration</key>
+							<dict>
+								<key>Frame</key>
+								<string>{{190, 0}, {554, 368}}</string>
+								<key>RubberWindowFrame</key>
+								<string>315 424 744 409 0 0 1440 878 </string>
+							</dict>
+							<key>Module</key>
+							<string>XCDetailModule</string>
+							<key>Proportion</key>
+							<string>554pt</string>
+						</dict>
+					</array>
+					<key>Proportion</key>
+					<string>368pt</string>
+				</dict>
+			</array>
+			<key>MajorVersion</key>
+			<integer>3</integer>
+			<key>MinorVersion</key>
+			<integer>0</integer>
+			<key>Name</key>
+			<string>Breakpoints</string>
+			<key>ServiceClasses</key>
+			<array>
+				<string>PBXSmartGroupTreeModule</string>
+				<string>XCDetailModule</string>
+			</array>
+			<key>StatusbarIsVisible</key>
+			<integer>1</integer>
+			<key>TableOfContents</key>
+			<array>
+				<string>1CDDB66807F98D9800BB5817</string>
+				<string>1CDDB66907F98D9800BB5817</string>
+				<string>1CE0B1FE06471DED0097A5F4</string>
+				<string>1CA1AED706398EBD00589147</string>
+			</array>
+			<key>ToolbarConfiguration</key>
+			<string>xcode.toolbar.config.breakpointsV3</string>
+			<key>WindowString</key>
+			<string>315 424 744 409 0 0 1440 878 </string>
+			<key>WindowToolGUID</key>
+			<string>1CDDB66807F98D9800BB5817</string>
+			<key>WindowToolIsVisible</key>
+			<integer>1</integer>
+		</dict>
+		<dict>
+			<key>Identifier</key>
+			<string>windowTool.debugAnimator</string>
+			<key>Layout</key>
+			<array>
+				<dict>
+					<key>Dock</key>
+					<array>
+						<dict>
+							<key>Module</key>
+							<string>PBXNavigatorGroup</string>
+							<key>Proportion</key>
+							<string>100%</string>
+						</dict>
+					</array>
+					<key>Proportion</key>
+					<string>100%</string>
+				</dict>
+			</array>
+			<key>Name</key>
+			<string>Debug Visualizer</string>
+			<key>ServiceClasses</key>
+			<array>
+				<string>PBXNavigatorGroup</string>
+			</array>
+			<key>StatusbarIsVisible</key>
+			<integer>1</integer>
+			<key>ToolbarConfiguration</key>
+			<string>xcode.toolbar.config.debugAnimatorV3</string>
+			<key>WindowString</key>
+			<string>100 100 700 500 0 0 1280 1002 </string>
+		</dict>
+		<dict>
+			<key>Identifier</key>
+			<string>windowTool.bookmarks</string>
+			<key>Layout</key>
+			<array>
+				<dict>
+					<key>Dock</key>
+					<array>
+						<dict>
+							<key>Module</key>
+							<string>PBXBookmarksModule</string>
+							<key>Proportion</key>
+							<string>166pt</string>
+						</dict>
+					</array>
+					<key>Proportion</key>
+					<string>166pt</string>
+				</dict>
+			</array>
+			<key>Name</key>
+			<string>Bookmarks</string>
+			<key>ServiceClasses</key>
+			<array>
+				<string>PBXBookmarksModule</string>
+			</array>
+			<key>StatusbarIsVisible</key>
+			<integer>0</integer>
+			<key>WindowString</key>
+			<string>538 42 401 187 0 0 1280 1002 </string>
+		</dict>
+		<dict>
+			<key>FirstTimeWindowDisplayed</key>
+			<false/>
+			<key>Identifier</key>
+			<string>windowTool.projectFormatConflicts</string>
+			<key>IsVertical</key>
+			<true/>
+			<key>Layout</key>
+			<array>
+				<dict>
+					<key>Dock</key>
+					<array>
+						<dict>
+							<key>BecomeActive</key>
+							<true/>
+							<key>ContentConfiguration</key>
+							<dict>
+								<key>PBXProjectModuleGUID</key>
+								<string>8BCAE52E1D49920D0047D4BD</string>
+							</dict>
+							<key>GeometryConfiguration</key>
+							<dict>
+								<key>Frame</key>
+								<string>{{0, 0}, {472, 302}}</string>
+								<key>RubberWindowFrame</key>
+								<string>569 378 472 322 0 0 1440 878 </string>
+							</dict>
+							<key>Module</key>
+							<string>XCProjectFormatConflictsModule</string>
+							<key>Proportion</key>
+							<string>302pt</string>
+						</dict>
+					</array>
+					<key>Proportion</key>
+					<string>302pt</string>
+				</dict>
+			</array>
+			<key>Name</key>
+			<string>Project Format Conflicts</string>
+			<key>ServiceClasses</key>
+			<array>
+				<string>XCProjectFormatConflictsModule</string>
+			</array>
+			<key>StatusbarIsVisible</key>
+			<false/>
+			<key>TableOfContents</key>
+			<array>
+				<string>8BCAE52F1D49920D0047D4BD</string>
+				<string>8BCAE5301D49920D0047D4BD</string>
+				<string>8BCAE52E1D49920D0047D4BD</string>
+			</array>
+			<key>WindowContentMinSize</key>
+			<string>450 300</string>
+			<key>WindowString</key>
+			<string>569 378 472 322 0 0 1440 878 </string>
+			<key>WindowToolGUID</key>
+			<string>8BCAE52F1D49920D0047D4BD</string>
+			<key>WindowToolIsVisible</key>
+			<false/>
+		</dict>
+		<dict>
+			<key>Identifier</key>
+			<string>windowTool.classBrowser</string>
+			<key>Layout</key>
+			<array>
+				<dict>
+					<key>Dock</key>
+					<array>
+						<dict>
+							<key>BecomeActive</key>
+							<integer>1</integer>
+							<key>ContentConfiguration</key>
+							<dict>
+								<key>OptionsSetName</key>
+								<string>Hierarchy, all classes</string>
+								<key>PBXProjectModuleGUID</key>
+								<string>1CA6456E063B45B4001379D8</string>
+								<key>PBXProjectModuleLabel</key>
+								<string>Class Browser - NSObject</string>
+							</dict>
+							<key>GeometryConfiguration</key>
+							<dict>
+								<key>ClassesFrame</key>
+								<string>{{0, 0}, {369, 96}}</string>
+								<key>ClassesTreeTableConfiguration</key>
+								<array>
+									<string>PBXClassNameColumnIdentifier</string>
+									<real>208</real>
+									<string>PBXClassBookColumnIdentifier</string>
+									<real>22</real>
+								</array>
+								<key>Frame</key>
+								<string>{{0, 0}, {616, 353}}</string>
+								<key>MembersFrame</key>
+								<string>{{0, 105}, {369, 395}}</string>
+								<key>MembersTreeTableConfiguration</key>
+								<array>
+									<string>PBXMemberTypeIconColumnIdentifier</string>
+									<real>22</real>
+									<string>PBXMemberNameColumnIdentifier</string>
+									<real>216</real>
+									<string>PBXMemberTypeColumnIdentifier</string>
+									<real>94</real>
+									<string>PBXMemberBookColumnIdentifier</string>
+									<real>22</real>
+								</array>
+								<key>PBXModuleWindowStatusBarHidden2</key>
+								<integer>1</integer>
+								<key>RubberWindowFrame</key>
+								<string>597 125 616 374 0 0 1280 1002 </string>
+							</dict>
+							<key>Module</key>
+							<string>PBXClassBrowserModule</string>
+							<key>Proportion</key>
+							<string>354pt</string>
+						</dict>
+					</array>
+					<key>Proportion</key>
+					<string>354pt</string>
+				</dict>
+			</array>
+			<key>Name</key>
+			<string>Class Browser</string>
+			<key>ServiceClasses</key>
+			<array>
+				<string>PBXClassBrowserModule</string>
+			</array>
+			<key>StatusbarIsVisible</key>
+			<integer>0</integer>
+			<key>TableOfContents</key>
+			<array>
+				<string>1C78EABA065D492600B07095</string>
+				<string>1C78EABB065D492600B07095</string>
+				<string>1CA6456E063B45B4001379D8</string>
+			</array>
+			<key>ToolbarConfiguration</key>
+			<string>xcode.toolbar.config.classbrowser</string>
+			<key>WindowString</key>
+			<string>597 125 616 374 0 0 1280 1002 </string>
+		</dict>
+		<dict>
+			<key>Identifier</key>
+			<string>windowTool.refactoring</string>
+			<key>IncludeInToolsMenu</key>
+			<integer>0</integer>
+			<key>Layout</key>
+			<array>
+				<dict>
+					<key>Dock</key>
+					<array>
+						<dict>
+							<key>BecomeActive</key>
+							<integer>1</integer>
+							<key>GeometryConfiguration</key>
+							<dict>
+								<key>Frame</key>
+								<string>{0, 0}, {500, 335}</string>
+								<key>RubberWindowFrame</key>
+								<string>{0, 0}, {500, 335}</string>
+							</dict>
+							<key>Module</key>
+							<string>XCRefactoringModule</string>
+							<key>Proportion</key>
+							<string>100%</string>
+						</dict>
+					</array>
+					<key>Proportion</key>
+					<string>100%</string>
+				</dict>
+			</array>
+			<key>Name</key>
+			<string>Refactoring</string>
+			<key>ServiceClasses</key>
+			<array>
+				<string>XCRefactoringModule</string>
+			</array>
+			<key>WindowString</key>
+			<string>200 200 500 356 0 0 1920 1200 </string>
+		</dict>
+	</array>
+</dict>
+</plist>
diff --git a/plugins/MacVST/PocketVerbs/PocketVerbs.xcodeproj/project.pbxproj b/plugins/MacVST/PocketVerbs/PocketVerbs.xcodeproj/project.pbxproj
new file mode 100755
index 0000000..b989f10
--- /dev/null
+++ b/plugins/MacVST/PocketVerbs/PocketVerbs.xcodeproj/project.pbxproj
@@ -0,0 +1,2201 @@
+// !$*UTF8*$!
+{
+	archiveVersion = 1;
+	classes = {
+	};
+	objectVersion = 42;
+	objects = {
+
+/* Begin PBXBuildFile section */
+		2407DEB9089929BA00EB68BF /* PocketVerbs.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 2407DEB6089929BA00EB68BF /* PocketVerbs.cpp */; };
+		245463B90991757100464AD3 /* PocketVerbs.h in Headers */ = {isa = PBXBuildFile; fileRef = 245463B80991757100464AD3 /* PocketVerbs.h */; };
+		24A202190F90D1DE003BB5A7 /* aeffect.h in Headers */ = {isa = PBXBuildFile; fileRef = 24A2FF910F90D1DD003BB5A7 /* aeffect.h */; };
+		24A2021A0F90D1DE003BB5A7 /* aeffectx.h in Headers */ = {isa = PBXBuildFile; fileRef = 24A2FF920F90D1DD003BB5A7 /* aeffectx.h */; };
+		24A2021B0F90D1DE003BB5A7 /* vstfxstore.h in Headers */ = {isa = PBXBuildFile; fileRef = 24A2FF930F90D1DD003BB5A7 /* vstfxstore.h */; };
+		24A2021D0F90D1DE003BB5A7 /* adelay.h in Headers */ = {isa = PBXBuildFile; fileRef = 24A2FF990F90D1DD003BB5A7 /* adelay.h */; };
+		24A202240F90D1DE003BB5A7 /* sdeditor.h in Headers */ = {isa = PBXBuildFile; fileRef = 24A2FFA20F90D1DD003BB5A7 /* sdeditor.h */; };
+		24A202260F90D1DE003BB5A7 /* surrounddelay.h in Headers */ = {isa = PBXBuildFile; fileRef = 24A2FFA40F90D1DD003BB5A7 /* surrounddelay.h */; };
+		24A2022A0F90D1DE003BB5A7 /* again.h in Headers */ = {isa = PBXBuildFile; fileRef = 24A2FFAB0F90D1DD003BB5A7 /* again.h */; };
+		24A202330F90D1DE003BB5A7 /* gmnames.h in Headers */ = {isa = PBXBuildFile; fileRef = 24A2FFBF0F90D1DD003BB5A7 /* gmnames.h */; };
+		24A202350F90D1DE003BB5A7 /* vstxsynth.h in Headers */ = {isa = PBXBuildFile; fileRef = 24A2FFC10F90D1DD003BB5A7 /* vstxsynth.h */; };
+		24A202460F90D1DE003BB5A7 /* aeffeditor.h in Headers */ = {isa = PBXBuildFile; fileRef = 24A2FFD80F90D1DD003BB5A7 /* aeffeditor.h */; };
+		24A202480F90D1DE003BB5A7 /* audioeffect.h in Headers */ = {isa = PBXBuildFile; fileRef = 24A2FFDA0F90D1DD003BB5A7 /* audioeffect.h */; };
+		24A2024A0F90D1DE003BB5A7 /* audioeffectx.h in Headers */ = {isa = PBXBuildFile; fileRef = 24A2FFDC0F90D1DD003BB5A7 /* audioeffectx.h */; };
+		24A2024D0F90D1DE003BB5A7 /* cw_vst_prefix.pch++ in Headers */ = {isa = PBXBuildFile; fileRef = 24A2FFE20F90D1DD003BB5A7 /* cw_vst_prefix.pch++ */; };
+		24A202510F90D1DE003BB5A7 /* xcode_au_prefix.h in Headers */ = {isa = PBXBuildFile; fileRef = 24A2FFEC0F90D1DD003BB5A7 /* xcode_au_prefix.h */; };
+		24A202520F90D1DE003BB5A7 /* xcode_vst_prefix.h in Headers */ = {isa = PBXBuildFile; fileRef = 24A2FFED0F90D1DD003BB5A7 /* xcode_vst_prefix.h */; };
+		24A202680F90D1DE003BB5A7 /* controlsgui.h in Headers */ = {isa = PBXBuildFile; fileRef = 24A200050F90D1DD003BB5A7 /* controlsgui.h */; };
+		24A2026A0F90D1DE003BB5A7 /* pdrawtesteditor.h in Headers */ = {isa = PBXBuildFile; fileRef = 24A200070F90D1DD003BB5A7 /* pdrawtesteditor.h */; };
+		24A2026C0F90D1DE003BB5A7 /* pdrawtesteffect.h in Headers */ = {isa = PBXBuildFile; fileRef = 24A200090F90D1DD003BB5A7 /* pdrawtesteffect.h */; };
+		24A2026F0F90D1DE003BB5A7 /* pdrawtestview.h in Headers */ = {isa = PBXBuildFile; fileRef = 24A2000C0F90D1DD003BB5A7 /* pdrawtestview.h */; };
+		24A202710F90D1DE003BB5A7 /* pprimitivesviews.h in Headers */ = {isa = PBXBuildFile; fileRef = 24A2000E0F90D1DD003BB5A7 /* pprimitivesviews.h */; };
+		24A202780F90D1DE003BB5A7 /* aeffguieditor.h in Headers */ = {isa = PBXBuildFile; fileRef = 24A200180F90D1DD003BB5A7 /* aeffguieditor.h */; };
+		24A2027A0F90D1DE003BB5A7 /* cfileselector.h in Headers */ = {isa = PBXBuildFile; fileRef = 24A2001A0F90D1DD003BB5A7 /* cfileselector.h */; };
+		24A2027D0F90D1DE003BB5A7 /* cscrollview.h in Headers */ = {isa = PBXBuildFile; fileRef = 24A2001D0F90D1DD003BB5A7 /* cscrollview.h */; };
+		24A2027F0F90D1DE003BB5A7 /* ctabview.h in Headers */ = {isa = PBXBuildFile; fileRef = 24A2001F0F90D1DD003BB5A7 /* ctabview.h */; };
+		24A203A50F90D1DE003BB5A7 /* plugguieditor.h in Headers */ = {isa = PBXBuildFile; fileRef = 24A201470F90D1DE003BB5A7 /* plugguieditor.h */; };
+		24A203A70F90D1DE003BB5A7 /* vstcontrols.h in Headers */ = {isa = PBXBuildFile; fileRef = 24A201490F90D1DE003BB5A7 /* vstcontrols.h */; };
+		24A203A90F90D1DE003BB5A7 /* vstgui.h in Headers */ = {isa = PBXBuildFile; fileRef = 24A2014B0F90D1DE003BB5A7 /* vstgui.h */; };
+		24A203AA0F90D1DE003BB5A7 /* vstkeycode.h in Headers */ = {isa = PBXBuildFile; fileRef = 24A2014C0F90D1DE003BB5A7 /* vstkeycode.h */; };
+		24A203AB0F90D1DE003BB5A7 /* vstplugscarbon.h in Headers */ = {isa = PBXBuildFile; fileRef = 24A2014D0F90D1DE003BB5A7 /* vstplugscarbon.h */; };
+		24A203AC0F90D1DE003BB5A7 /* vstplugsmac.h in Headers */ = {isa = PBXBuildFile; fileRef = 24A2014E0F90D1DE003BB5A7 /* vstplugsmac.h */; };
+		24A203AD0F90D1DE003BB5A7 /* vstplugsmacho.h in Headers */ = {isa = PBXBuildFile; fileRef = 24A2014F0F90D1DE003BB5A7 /* vstplugsmacho.h */; };
+		24A203AE0F90D1DE003BB5A7 /* vstplugsquartz.h in Headers */ = {isa = PBXBuildFile; fileRef = 24A201500F90D1DE003BB5A7 /* vstplugsquartz.h */; };
+		24A203CB0F90D251003BB5A7 /* audioeffect.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 24A2FFD90F90D1DD003BB5A7 /* audioeffect.cpp */; };
+		24A203CC0F90D251003BB5A7 /* audioeffectx.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 24A2FFDB0F90D1DD003BB5A7 /* audioeffectx.cpp */; };
+		24A203CD0F90D251003BB5A7 /* vstplugmain.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 24A2FFDD0F90D1DD003BB5A7 /* vstplugmain.cpp */; };
+		24CFB70407E7A0220081BD57 /* PkgInfo in Resources */ = {isa = PBXBuildFile; fileRef = 24CFB70307E7A0220081BD57 /* PkgInfo */; };
+		24D8287009A914000093AEF8 /* PocketVerbsProc.cpp in Sources */ = {isa = PBXBuildFile; fileRef = 24D8286F09A914000093AEF8 /* PocketVerbsProc.cpp */; };
+		24D8287F09A9164A0093AEF8 /* xcode_vst_prefix.h in Headers */ = {isa = PBXBuildFile; fileRef = 24D8287E09A9164A0093AEF8 /* xcode_vst_prefix.h */; };
+/* End PBXBuildFile section */
+
+/* Begin PBXContainerItemProxy section */
+		24A203D60F90D272003BB5A7 /* PBXContainerItemProxy */ = {
+			isa = PBXContainerItemProxy;
+			containerPortal = 24A2FFB00F90D1DD003BB5A7 /* vst 2.4 examples.xcodeproj */;
+			proxyType = 2;
+			remoteGlobalIDString = 8D01CCD20486CAD60068D4B7;
+			remoteInfo = again;
+		};
+		24A203D80F90D272003BB5A7 /* PBXContainerItemProxy */ = {
+			isa = PBXContainerItemProxy;
+			containerPortal = 24A2FFB00F90D1DD003BB5A7 /* vst 2.4 examples.xcodeproj */;
+			proxyType = 2;
+			remoteGlobalIDString = F4476974093DAE42008998C4;
+			remoteInfo = adelay;
+		};
+		24A203DA0F90D272003BB5A7 /* PBXContainerItemProxy */ = {
+			isa = PBXContainerItemProxy;
+			containerPortal = 24A2FFB00F90D1DD003BB5A7 /* vst 2.4 examples.xcodeproj */;
+			proxyType = 2;
+			remoteGlobalIDString = F4FF52220929FBF500DDED7A;
+			remoteInfo = vstxsynth;
+		};
+		24A203DC0F90D272003BB5A7 /* PBXContainerItemProxy */ = {
+			isa = PBXContainerItemProxy;
+			containerPortal = 24A2FFB00F90D1DD003BB5A7 /* vst 2.4 examples.xcodeproj */;
+			proxyType = 2;
+			remoteGlobalIDString = F4476A10093DCAF9008998C4;
+			remoteInfo = surrounddelay;
+		};
+		24A203DE0F90D272003BB5A7 /* PBXContainerItemProxy */ = {
+			isa = PBXContainerItemProxy;
+			containerPortal = 24A2FFB00F90D1DD003BB5A7 /* vst 2.4 examples.xcodeproj */;
+			proxyType = 2;
+			remoteGlobalIDString = F4FF52F3092A312800DDED7A;
+			remoteInfo = minihost;
+		};
+		24A203E40F90D272003BB5A7 /* PBXContainerItemProxy */ = {
+			isa = PBXContainerItemProxy;
+			containerPortal = 24A2FFE50F90D1DD003BB5A7 /* drawtest.xcode */;
+			proxyType = 2;
+			remoteGlobalIDString = 8D01CCD20486CAD60068D4B7;
+			remoteInfo = AudioUnit;
+		};
+		24A203E60F90D272003BB5A7 /* PBXContainerItemProxy */ = {
+			isa = PBXContainerItemProxy;
+			containerPortal = 24A2FFE50F90D1DD003BB5A7 /* drawtest.xcode */;
+			proxyType = 2;
+			remoteGlobalIDString = F4C9F1D407B2320800010DAD;
+			remoteInfo = VST;
+		};
+		24A203EC0F90D272003BB5A7 /* PBXContainerItemProxy */ = {
+			isa = PBXContainerItemProxy;
+			containerPortal = 24A2FFE80F90D1DD003BB5A7 /* drawtest.xcodeproj */;
+			proxyType = 2;
+			remoteGlobalIDString = 8D01CCD20486CAD60068D4B7;
+			remoteInfo = AudioUnit;
+		};
+		24A203EE0F90D272003BB5A7 /* PBXContainerItemProxy */ = {
+			isa = PBXContainerItemProxy;
+			containerPortal = 24A2FFE80F90D1DD003BB5A7 /* drawtest.xcodeproj */;
+			proxyType = 2;
+			remoteGlobalIDString = F4C9F1D407B2320800010DAD;
+			remoteInfo = VST;
+		};
+/* End PBXContainerItemProxy section */
+
+/* Begin PBXFileReference section */
+		08EA7FFBFE8413EDC02AAC07 /* Carbon.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = Carbon.framework; path = /System/Library/Frameworks/Carbon.framework; sourceTree = "<absolute>"; };
+		2407DE920899296600EB68BF /* PocketVerbs.vst */ = {isa = PBXFileReference; explicitFileType = wrapper.cfbundle; includeInIndex = 0; path = PocketVerbs.vst; sourceTree = BUILT_PRODUCTS_DIR; };
+		2407DEB6089929BA00EB68BF /* PocketVerbs.cpp */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.cpp.cpp; name = PocketVerbs.cpp; path = source/PocketVerbs.cpp; sourceTree = "<group>"; };
+		2434720A098313350063BBF1 /* QuickTime.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = QuickTime.framework; path = /System/Library/Frameworks/QuickTime.framework; sourceTree = "<absolute>"; };
+		245463B80991757100464AD3 /* PocketVerbs.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; name = PocketVerbs.h; path = source/PocketVerbs.h; sourceTree = "<group>"; };
+		24A200000F90D1DD003BB5A7 /* bmp10014.bmp */ = {isa = PBXFileReference; lastKnownFileType = image.bmp; path = bmp10014.bmp; sourceTree = "<group>"; };
+		24A200010F90D1DD003BB5A7 /* bmp10015.bmp */ = {isa = PBXFileReference; lastKnownFileType = image.bmp; path = bmp10015.bmp; sourceTree = "<group>"; };
+		24A200020F90D1DD003BB5A7 /* bmp10016.bmp */ = {isa = PBXFileReference; lastKnownFileType = image.bmp; path = bmp10016.bmp; sourceTree = "<group>"; };
+		24A200040F90D1DD003BB5A7 /* controlsgui.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = controlsgui.cpp; sourceTree = "<group>"; };
+		24A200050F90D1DD003BB5A7 /* controlsgui.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = controlsgui.h; sourceTree = "<group>"; };
+		24A200060F90D1DD003BB5A7 /* pdrawtesteditor.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = pdrawtesteditor.cpp; sourceTree = "<group>"; };
+		24A200070F90D1DD003BB5A7 /* pdrawtesteditor.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = pdrawtesteditor.h; sourceTree = "<group>"; };
+		24A200080F90D1DD003BB5A7 /* pdrawtesteffect.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = pdrawtesteffect.cpp; sourceTree = "<group>"; };
+		24A200090F90D1DD003BB5A7 /* pdrawtesteffect.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = pdrawtesteffect.h; sourceTree = "<group>"; };
+		24A2000A0F90D1DD003BB5A7 /* pdrawtestmain.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = pdrawtestmain.cpp; sourceTree = "<group>"; };
+		24A2000B0F90D1DD003BB5A7 /* pdrawtestview.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = pdrawtestview.cpp; sourceTree = "<group>"; };
+		24A2000C0F90D1DD003BB5A7 /* pdrawtestview.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = pdrawtestview.h; sourceTree = "<group>"; };
+		24A2000D0F90D1DD003BB5A7 /* pprimitivesviews.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = pprimitivesviews.cpp; sourceTree = "<group>"; };
+		24A2000E0F90D1DD003BB5A7 /* pprimitivesviews.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = pprimitivesviews.h; sourceTree = "<group>"; };
+		24A200100F90D1DD003BB5A7 /* drawtest.def */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = drawtest.def; sourceTree = "<group>"; };
+		24A200110F90D1DD003BB5A7 /* drawtest.rc */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = drawtest.rc; sourceTree = "<group>"; };
+		24A200120F90D1DD003BB5A7 /* drawtest.vcproj */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xml; path = drawtest.vcproj; sourceTree = "<group>"; };
+		24A200140F90D1DD003BB5A7 /* drawtest.dsp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = drawtest.dsp; sourceTree = "<group>"; };
+		24A200150F90D1DD003BB5A7 /* drawtest.dsw */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = drawtest.dsw; sourceTree = "<group>"; };
+		24A200170F90D1DD003BB5A7 /* aeffguieditor.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = aeffguieditor.cpp; sourceTree = "<group>"; };
+		24A200180F90D1DD003BB5A7 /* aeffguieditor.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = aeffguieditor.h; sourceTree = "<group>"; };
+		24A200190F90D1DD003BB5A7 /* cfileselector.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = cfileselector.cpp; sourceTree = "<group>"; };
+		24A2001A0F90D1DD003BB5A7 /* cfileselector.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = cfileselector.h; sourceTree = "<group>"; };
+		24A2001B0F90D1DD003BB5A7 /* Changelog */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = Changelog; sourceTree = "<group>"; };
+		24A2001C0F90D1DD003BB5A7 /* cscrollview.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = cscrollview.cpp; sourceTree = "<group>"; };
+		24A2001D0F90D1DD003BB5A7 /* cscrollview.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = cscrollview.h; sourceTree = "<group>"; };
+		24A2001E0F90D1DD003BB5A7 /* ctabview.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = ctabview.cpp; sourceTree = "<group>"; };
+		24A2001F0F90D1DD003BB5A7 /* ctabview.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = ctabview.h; sourceTree = "<group>"; };
+		24A200220F90D1DD003BB5A7 /* aeffguieditor_8cpp.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = aeffguieditor_8cpp.html; sourceTree = "<group>"; };
+		24A200230F90D1DD003BB5A7 /* aeffguieditor_8h.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = aeffguieditor_8h.html; sourceTree = "<group>"; };
+		24A200240F90D1DD003BB5A7 /* annotated.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = annotated.html; sourceTree = "<group>"; };
+		24A200250F90D1DD003BB5A7 /* cfileselector_8cpp.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = cfileselector_8cpp.html; sourceTree = "<group>"; };
+		24A200260F90D1DD003BB5A7 /* cfileselector_8h.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = cfileselector_8h.html; sourceTree = "<group>"; };
+		24A200270F90D1DD003BB5A7 /* class_a_eff_g_u_i_editor-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = "class_a_eff_g_u_i_editor-members.html"; sourceTree = "<group>"; };
+		24A200280F90D1DD003BB5A7 /* class_a_eff_g_u_i_editor.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = class_a_eff_g_u_i_editor.html; sourceTree = "<group>"; };
+		24A200290F90D1DD003BB5A7 /* class_c_anim_knob-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = "class_c_anim_knob-members.html"; sourceTree = "<group>"; };
+		24A2002A0F90D1DD003BB5A7 /* class_c_anim_knob.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = class_c_anim_knob.html; sourceTree = "<group>"; };
+		24A2002B0F90D1DD003BB5A7 /* class_c_anim_knob.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = class_c_anim_knob.png; sourceTree = "<group>"; };
+		24A2002C0F90D1DD003BB5A7 /* class_c_attribute_list_entry-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = "class_c_attribute_list_entry-members.html"; sourceTree = "<group>"; };
+		24A2002D0F90D1DD003BB5A7 /* class_c_attribute_list_entry.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = class_c_attribute_list_entry.html; sourceTree = "<group>"; };
+		24A2002E0F90D1DD003BB5A7 /* class_c_auto_animation-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = "class_c_auto_animation-members.html"; sourceTree = "<group>"; };
+		24A2002F0F90D1DD003BB5A7 /* class_c_auto_animation.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = class_c_auto_animation.html; sourceTree = "<group>"; };
+		24A200300F90D1DD003BB5A7 /* class_c_auto_animation.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = class_c_auto_animation.png; sourceTree = "<group>"; };
+		24A200310F90D1DD003BB5A7 /* class_c_bitmap-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = "class_c_bitmap-members.html"; sourceTree = "<group>"; };
+		24A200320F90D1DD003BB5A7 /* class_c_bitmap.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = class_c_bitmap.html; sourceTree = "<group>"; };
+		24A200330F90D1DD003BB5A7 /* class_c_bitmap.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = class_c_bitmap.png; sourceTree = "<group>"; };
+		24A200340F90D1DD003BB5A7 /* class_c_c_view-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = "class_c_c_view-members.html"; sourceTree = "<group>"; };
+		24A200350F90D1DD003BB5A7 /* class_c_c_view.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = class_c_c_view.html; sourceTree = "<group>"; };
+		24A200360F90D1DD003BB5A7 /* class_c_control-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = "class_c_control-members.html"; sourceTree = "<group>"; };
+		24A200370F90D1DD003BB5A7 /* class_c_control.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = class_c_control.html; sourceTree = "<group>"; };
+		24A200380F90D1DD003BB5A7 /* class_c_control.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = class_c_control.png; sourceTree = "<group>"; };
+		24A200390F90D1DD003BB5A7 /* class_c_control_listener-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = "class_c_control_listener-members.html"; sourceTree = "<group>"; };
+		24A2003A0F90D1DD003BB5A7 /* class_c_control_listener.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = class_c_control_listener.html; sourceTree = "<group>"; };
+		24A2003B0F90D1DD003BB5A7 /* class_c_control_listener.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = class_c_control_listener.png; sourceTree = "<group>"; };
+		24A2003C0F90D1DD003BB5A7 /* class_c_drag_container-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = "class_c_drag_container-members.html"; sourceTree = "<group>"; };
+		24A2003D0F90D1DD003BB5A7 /* class_c_drag_container.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = class_c_drag_container.html; sourceTree = "<group>"; };
+		24A2003E0F90D1DD003BB5A7 /* class_c_drag_container.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = class_c_drag_container.png; sourceTree = "<group>"; };
+		24A2003F0F90D1DD003BB5A7 /* class_c_draw_context-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = "class_c_draw_context-members.html"; sourceTree = "<group>"; };
+		24A200400F90D1DD003BB5A7 /* class_c_draw_context.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = class_c_draw_context.html; sourceTree = "<group>"; };
+		24A200410F90D1DD003BB5A7 /* class_c_draw_context.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = class_c_draw_context.png; sourceTree = "<group>"; };
+		24A200420F90D1DD003BB5A7 /* class_c_file_selector-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = "class_c_file_selector-members.html"; sourceTree = "<group>"; };
+		24A200430F90D1DD003BB5A7 /* class_c_file_selector.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = class_c_file_selector.html; sourceTree = "<group>"; };
+		24A200440F90D1DD003BB5A7 /* class_c_frame-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = "class_c_frame-members.html"; sourceTree = "<group>"; };
+		24A200450F90D1DD003BB5A7 /* class_c_frame.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = class_c_frame.html; sourceTree = "<group>"; };
+		24A200460F90D1DD003BB5A7 /* class_c_frame.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = class_c_frame.png; sourceTree = "<group>"; };
+		24A200470F90D1DD003BB5A7 /* class_c_horizontal_slider-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = "class_c_horizontal_slider-members.html"; sourceTree = "<group>"; };
+		24A200480F90D1DD003BB5A7 /* class_c_horizontal_slider.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = class_c_horizontal_slider.html; sourceTree = "<group>"; };
+		24A200490F90D1DD003BB5A7 /* class_c_horizontal_slider.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = class_c_horizontal_slider.png; sourceTree = "<group>"; };
+		24A2004A0F90D1DD003BB5A7 /* class_c_horizontal_switch-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = "class_c_horizontal_switch-members.html"; sourceTree = "<group>"; };
+		24A2004B0F90D1DD003BB5A7 /* class_c_horizontal_switch.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = class_c_horizontal_switch.html; sourceTree = "<group>"; };
+		24A2004C0F90D1DD003BB5A7 /* class_c_horizontal_switch.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = class_c_horizontal_switch.png; sourceTree = "<group>"; };
+		24A2004D0F90D1DD003BB5A7 /* class_c_kick_button-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = "class_c_kick_button-members.html"; sourceTree = "<group>"; };
+		24A2004E0F90D1DD003BB5A7 /* class_c_kick_button.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = class_c_kick_button.html; sourceTree = "<group>"; };
+		24A2004F0F90D1DD003BB5A7 /* class_c_kick_button.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = class_c_kick_button.png; sourceTree = "<group>"; };
+		24A200500F90D1DD003BB5A7 /* class_c_knob-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = "class_c_knob-members.html"; sourceTree = "<group>"; };
+		24A200510F90D1DD003BB5A7 /* class_c_knob.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = class_c_knob.html; sourceTree = "<group>"; };
+		24A200520F90D1DD003BB5A7 /* class_c_knob.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = class_c_knob.png; sourceTree = "<group>"; };
+		24A200530F90D1DD003BB5A7 /* class_c_movie_bitmap-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = "class_c_movie_bitmap-members.html"; sourceTree = "<group>"; };
+		24A200540F90D1DD003BB5A7 /* class_c_movie_bitmap.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = class_c_movie_bitmap.html; sourceTree = "<group>"; };
+		24A200550F90D1DD003BB5A7 /* class_c_movie_bitmap.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = class_c_movie_bitmap.png; sourceTree = "<group>"; };
+		24A200560F90D1DD003BB5A7 /* class_c_movie_button-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = "class_c_movie_button-members.html"; sourceTree = "<group>"; };
+		24A200570F90D1DD003BB5A7 /* class_c_movie_button.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = class_c_movie_button.html; sourceTree = "<group>"; };
+		24A200580F90D1DD003BB5A7 /* class_c_movie_button.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = class_c_movie_button.png; sourceTree = "<group>"; };
+		24A200590F90D1DD003BB5A7 /* class_c_offscreen_context-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = "class_c_offscreen_context-members.html"; sourceTree = "<group>"; };
+		24A2005A0F90D1DD003BB5A7 /* class_c_offscreen_context.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = class_c_offscreen_context.html; sourceTree = "<group>"; };
+		24A2005B0F90D1DD003BB5A7 /* class_c_offscreen_context.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = class_c_offscreen_context.png; sourceTree = "<group>"; };
+		24A2005C0F90D1DD003BB5A7 /* class_c_on_off_button-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = "class_c_on_off_button-members.html"; sourceTree = "<group>"; };
+		24A2005D0F90D1DD003BB5A7 /* class_c_on_off_button.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = class_c_on_off_button.html; sourceTree = "<group>"; };
+		24A2005E0F90D1DD003BB5A7 /* class_c_on_off_button.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = class_c_on_off_button.png; sourceTree = "<group>"; };
+		24A2005F0F90D1DD003BB5A7 /* class_c_option_menu-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = "class_c_option_menu-members.html"; sourceTree = "<group>"; };
+		24A200600F90D1DD003BB5A7 /* class_c_option_menu.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = class_c_option_menu.html; sourceTree = "<group>"; };
+		24A200610F90D1DD003BB5A7 /* class_c_option_menu.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = class_c_option_menu.png; sourceTree = "<group>"; };
+		24A200620F90D1DD003BB5A7 /* class_c_option_menu_scheme-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = "class_c_option_menu_scheme-members.html"; sourceTree = "<group>"; };
+		24A200630F90D1DD003BB5A7 /* class_c_option_menu_scheme.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = class_c_option_menu_scheme.html; sourceTree = "<group>"; };
+		24A200640F90D1DD003BB5A7 /* class_c_option_menu_scheme.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = class_c_option_menu_scheme.png; sourceTree = "<group>"; };
+		24A200650F90D1DD003BB5A7 /* class_c_param_display-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = "class_c_param_display-members.html"; sourceTree = "<group>"; };
+		24A200660F90D1DD003BB5A7 /* class_c_param_display.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = class_c_param_display.html; sourceTree = "<group>"; };
+		24A200670F90D1DD003BB5A7 /* class_c_param_display.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = class_c_param_display.png; sourceTree = "<group>"; };
+		24A200680F90D1DD003BB5A7 /* class_c_reference_counter-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = "class_c_reference_counter-members.html"; sourceTree = "<group>"; };
+		24A200690F90D1DD003BB5A7 /* class_c_reference_counter.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = class_c_reference_counter.html; sourceTree = "<group>"; };
+		24A2006A0F90D1DD003BB5A7 /* class_c_reference_counter.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = class_c_reference_counter.png; sourceTree = "<group>"; };
+		24A2006B0F90D1DD003BB5A7 /* class_c_rocker_switch-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = "class_c_rocker_switch-members.html"; sourceTree = "<group>"; };
+		24A2006C0F90D1DD003BB5A7 /* class_c_rocker_switch.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = class_c_rocker_switch.html; sourceTree = "<group>"; };
+		24A2006D0F90D1DD003BB5A7 /* class_c_rocker_switch.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = class_c_rocker_switch.png; sourceTree = "<group>"; };
+		24A2006E0F90D1DD003BB5A7 /* class_c_scroll_container-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = "class_c_scroll_container-members.html"; sourceTree = "<group>"; };
+		24A2006F0F90D1DD003BB5A7 /* class_c_scroll_container.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = class_c_scroll_container.html; sourceTree = "<group>"; };
+		24A200700F90D1DD003BB5A7 /* class_c_scroll_container.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = class_c_scroll_container.png; sourceTree = "<group>"; };
+		24A200710F90D1DD003BB5A7 /* class_c_scroll_view-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = "class_c_scroll_view-members.html"; sourceTree = "<group>"; };
+		24A200720F90D1DD003BB5A7 /* class_c_scroll_view.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = class_c_scroll_view.html; sourceTree = "<group>"; };
+		24A200730F90D1DD003BB5A7 /* class_c_scroll_view.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = class_c_scroll_view.png; sourceTree = "<group>"; };
+		24A200740F90D1DD003BB5A7 /* class_c_scrollbar-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = "class_c_scrollbar-members.html"; sourceTree = "<group>"; };
+		24A200750F90D1DD003BB5A7 /* class_c_scrollbar.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = class_c_scrollbar.html; sourceTree = "<group>"; };
+		24A200760F90D1DD003BB5A7 /* class_c_scrollbar.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = class_c_scrollbar.png; sourceTree = "<group>"; };
+		24A200770F90D1DD003BB5A7 /* class_c_slider-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = "class_c_slider-members.html"; sourceTree = "<group>"; };
+		24A200780F90D1DD003BB5A7 /* class_c_slider.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = class_c_slider.html; sourceTree = "<group>"; };
+		24A200790F90D1DD003BB5A7 /* class_c_slider.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = class_c_slider.png; sourceTree = "<group>"; };
+		24A2007A0F90D1DD003BB5A7 /* class_c_special_digit-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = "class_c_special_digit-members.html"; sourceTree = "<group>"; };
+		24A2007B0F90D1DD003BB5A7 /* class_c_special_digit.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = class_c_special_digit.html; sourceTree = "<group>"; };
+		24A2007C0F90D1DD003BB5A7 /* class_c_special_digit.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = class_c_special_digit.png; sourceTree = "<group>"; };
+		24A2007D0F90D1DD003BB5A7 /* class_c_splash_screen-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = "class_c_splash_screen-members.html"; sourceTree = "<group>"; };
+		24A2007E0F90D1DD003BB5A7 /* class_c_splash_screen.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = class_c_splash_screen.html; sourceTree = "<group>"; };
+		24A2007F0F90D1DD003BB5A7 /* class_c_splash_screen.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = class_c_splash_screen.png; sourceTree = "<group>"; };
+		24A200800F90D1DD003BB5A7 /* class_c_splash_screen_view-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = "class_c_splash_screen_view-members.html"; sourceTree = "<group>"; };
+		24A200810F90D1DD003BB5A7 /* class_c_splash_screen_view.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = class_c_splash_screen_view.html; sourceTree = "<group>"; };
+		24A200820F90D1DD003BB5A7 /* class_c_splash_screen_view.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = class_c_splash_screen_view.png; sourceTree = "<group>"; };
+		24A200830F90D1DD003BB5A7 /* class_c_tab_button-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = "class_c_tab_button-members.html"; sourceTree = "<group>"; };
+		24A200840F90D1DD003BB5A7 /* class_c_tab_button.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = class_c_tab_button.html; sourceTree = "<group>"; };
+		24A200850F90D1DD003BB5A7 /* class_c_tab_button.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = class_c_tab_button.png; sourceTree = "<group>"; };
+		24A200860F90D1DD003BB5A7 /* class_c_tab_child_view-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = "class_c_tab_child_view-members.html"; sourceTree = "<group>"; };
+		24A200870F90D1DD003BB5A7 /* class_c_tab_child_view.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = class_c_tab_child_view.html; sourceTree = "<group>"; };
+		24A200880F90D1DD003BB5A7 /* class_c_tab_child_view.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = class_c_tab_child_view.png; sourceTree = "<group>"; };
+		24A200890F90D1DD003BB5A7 /* class_c_tab_view-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = "class_c_tab_view-members.html"; sourceTree = "<group>"; };
+		24A2008A0F90D1DD003BB5A7 /* class_c_tab_view.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = class_c_tab_view.html; sourceTree = "<group>"; };
+		24A2008B0F90D1DD003BB5A7 /* class_c_tab_view.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = class_c_tab_view.png; sourceTree = "<group>"; };
+		24A2008C0F90D1DD003BB5A7 /* class_c_text_edit-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = "class_c_text_edit-members.html"; sourceTree = "<group>"; };
+		24A2008D0F90D1DD003BB5A7 /* class_c_text_edit.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = class_c_text_edit.html; sourceTree = "<group>"; };
+		24A2008E0F90D1DD003BB5A7 /* class_c_text_edit.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = class_c_text_edit.png; sourceTree = "<group>"; };
+		24A2008F0F90D1DD003BB5A7 /* class_c_text_label-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = "class_c_text_label-members.html"; sourceTree = "<group>"; };
+		24A200900F90D1DD003BB5A7 /* class_c_text_label.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = class_c_text_label.html; sourceTree = "<group>"; };
+		24A200910F90D1DD003BB5A7 /* class_c_text_label.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = class_c_text_label.png; sourceTree = "<group>"; };
+		24A200920F90D1DD003BB5A7 /* class_c_vertical_slider-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = "class_c_vertical_slider-members.html"; sourceTree = "<group>"; };
+		24A200930F90D1DD003BB5A7 /* class_c_vertical_slider.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = class_c_vertical_slider.html; sourceTree = "<group>"; };
+		24A200940F90D1DD003BB5A7 /* class_c_vertical_slider.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = class_c_vertical_slider.png; sourceTree = "<group>"; };
+		24A200950F90D1DD003BB5A7 /* class_c_vertical_switch-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = "class_c_vertical_switch-members.html"; sourceTree = "<group>"; };
+		24A200960F90D1DD003BB5A7 /* class_c_vertical_switch.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = class_c_vertical_switch.html; sourceTree = "<group>"; };
+		24A200970F90D1DD003BB5A7 /* class_c_vertical_switch.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = class_c_vertical_switch.png; sourceTree = "<group>"; };
+		24A200980F90D1DD003BB5A7 /* class_c_view-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = "class_c_view-members.html"; sourceTree = "<group>"; };
+		24A200990F90D1DD003BB5A7 /* class_c_view.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = class_c_view.html; sourceTree = "<group>"; };
+		24A2009A0F90D1DD003BB5A7 /* class_c_view.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = class_c_view.png; sourceTree = "<group>"; };
+		24A2009B0F90D1DD003BB5A7 /* class_c_view_container-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = "class_c_view_container-members.html"; sourceTree = "<group>"; };
+		24A2009C0F90D1DD003BB5A7 /* class_c_view_container.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = class_c_view_container.html; sourceTree = "<group>"; };
+		24A2009D0F90D1DD003BB5A7 /* class_c_view_container.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = class_c_view_container.png; sourceTree = "<group>"; };
+		24A2009E0F90D1DD003BB5A7 /* class_c_vu_meter-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = "class_c_vu_meter-members.html"; sourceTree = "<group>"; };
+		24A2009F0F90D1DD003BB5A7 /* class_c_vu_meter.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = class_c_vu_meter.html; sourceTree = "<group>"; };
+		24A200A00F90D1DD003BB5A7 /* class_c_vu_meter.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = class_c_vu_meter.png; sourceTree = "<group>"; };
+		24A200A10F90D1DD003BB5A7 /* class_i_scrollbar_drawer-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = "class_i_scrollbar_drawer-members.html"; sourceTree = "<group>"; };
+		24A200A20F90D1DD003BB5A7 /* class_i_scrollbar_drawer.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = class_i_scrollbar_drawer.html; sourceTree = "<group>"; };
+		24A200A30F90D1DD003BB5A7 /* class_plugin_g_u_i_editor-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = "class_plugin_g_u_i_editor-members.html"; sourceTree = "<group>"; };
+		24A200A40F90D1DD003BB5A7 /* class_plugin_g_u_i_editor.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = class_plugin_g_u_i_editor.html; sourceTree = "<group>"; };
+		24A200A50F90D1DD003BB5A7 /* cscrollview_8cpp.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = cscrollview_8cpp.html; sourceTree = "<group>"; };
+		24A200A60F90D1DD003BB5A7 /* cscrollview_8h.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = cscrollview_8h.html; sourceTree = "<group>"; };
+		24A200A70F90D1DD003BB5A7 /* ctabview_8cpp.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = ctabview_8cpp.html; sourceTree = "<group>"; };
+		24A200A80F90D1DD003BB5A7 /* ctabview_8h.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = ctabview_8h.html; sourceTree = "<group>"; };
+		24A200A90F90D1DD003BB5A7 /* deprecated.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = deprecated.html; sourceTree = "<group>"; };
+		24A200AA0F90D1DD003BB5A7 /* doc_8h.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = doc_8h.html; sourceTree = "<group>"; };
+		24A200AB0F90D1DD003BB5A7 /* doxygen.css */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.css; path = doxygen.css; sourceTree = "<group>"; };
+		24A200AC0F90D1DD003BB5A7 /* doxygen.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = doxygen.png; sourceTree = "<group>"; };
+		24A200AD0F90D1DD003BB5A7 /* files.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = files.html; sourceTree = "<group>"; };
+		24A200AE0F90D1DD003BB5A7 /* ftv2blank.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = ftv2blank.png; sourceTree = "<group>"; };
+		24A200AF0F90D1DD003BB5A7 /* ftv2doc.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = ftv2doc.png; sourceTree = "<group>"; };
+		24A200B00F90D1DD003BB5A7 /* ftv2folderclosed.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = ftv2folderclosed.png; sourceTree = "<group>"; };
+		24A200B10F90D1DE003BB5A7 /* ftv2folderopen.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = ftv2folderopen.png; sourceTree = "<group>"; };
+		24A200B20F90D1DE003BB5A7 /* ftv2lastnode.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = ftv2lastnode.png; sourceTree = "<group>"; };
+		24A200B30F90D1DE003BB5A7 /* ftv2link.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = ftv2link.png; sourceTree = "<group>"; };
+		24A200B40F90D1DE003BB5A7 /* ftv2mlastnode.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = ftv2mlastnode.png; sourceTree = "<group>"; };
+		24A200B50F90D1DE003BB5A7 /* ftv2mnode.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = ftv2mnode.png; sourceTree = "<group>"; };
+		24A200B60F90D1DE003BB5A7 /* ftv2node.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = ftv2node.png; sourceTree = "<group>"; };
+		24A200B70F90D1DE003BB5A7 /* ftv2plastnode.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = ftv2plastnode.png; sourceTree = "<group>"; };
+		24A200B80F90D1DE003BB5A7 /* ftv2pnode.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = ftv2pnode.png; sourceTree = "<group>"; };
+		24A200B90F90D1DE003BB5A7 /* ftv2vertline.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = ftv2vertline.png; sourceTree = "<group>"; };
+		24A200BA0F90D1DE003BB5A7 /* functions.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions.html; sourceTree = "<group>"; };
+		24A200BB0F90D1DE003BB5A7 /* functions_0x62.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_0x62.html; sourceTree = "<group>"; };
+		24A200BC0F90D1DE003BB5A7 /* functions_0x63.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_0x63.html; sourceTree = "<group>"; };
+		24A200BD0F90D1DE003BB5A7 /* functions_0x64.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_0x64.html; sourceTree = "<group>"; };
+		24A200BE0F90D1DE003BB5A7 /* functions_0x65.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_0x65.html; sourceTree = "<group>"; };
+		24A200BF0F90D1DE003BB5A7 /* functions_0x66.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_0x66.html; sourceTree = "<group>"; };
+		24A200C00F90D1DE003BB5A7 /* functions_0x67.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_0x67.html; sourceTree = "<group>"; };
+		24A200C10F90D1DE003BB5A7 /* functions_0x68.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_0x68.html; sourceTree = "<group>"; };
+		24A200C20F90D1DE003BB5A7 /* functions_0x69.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_0x69.html; sourceTree = "<group>"; };
+		24A200C30F90D1DE003BB5A7 /* functions_0x6b.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_0x6b.html; sourceTree = "<group>"; };
+		24A200C40F90D1DE003BB5A7 /* functions_0x6c.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_0x6c.html; sourceTree = "<group>"; };
+		24A200C50F90D1DE003BB5A7 /* functions_0x6d.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_0x6d.html; sourceTree = "<group>"; };
+		24A200C60F90D1DE003BB5A7 /* functions_0x6e.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_0x6e.html; sourceTree = "<group>"; };
+		24A200C70F90D1DE003BB5A7 /* functions_0x6f.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_0x6f.html; sourceTree = "<group>"; };
+		24A200C80F90D1DE003BB5A7 /* functions_0x70.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_0x70.html; sourceTree = "<group>"; };
+		24A200C90F90D1DE003BB5A7 /* functions_0x72.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_0x72.html; sourceTree = "<group>"; };
+		24A200CA0F90D1DE003BB5A7 /* functions_0x73.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_0x73.html; sourceTree = "<group>"; };
+		24A200CB0F90D1DE003BB5A7 /* functions_0x74.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_0x74.html; sourceTree = "<group>"; };
+		24A200CC0F90D1DE003BB5A7 /* functions_0x75.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_0x75.html; sourceTree = "<group>"; };
+		24A200CD0F90D1DE003BB5A7 /* functions_0x76.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_0x76.html; sourceTree = "<group>"; };
+		24A200CE0F90D1DE003BB5A7 /* functions_0x77.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_0x77.html; sourceTree = "<group>"; };
+		24A200CF0F90D1DE003BB5A7 /* functions_0x78.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_0x78.html; sourceTree = "<group>"; };
+		24A200D00F90D1DE003BB5A7 /* functions_0x79.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_0x79.html; sourceTree = "<group>"; };
+		24A200D10F90D1DE003BB5A7 /* functions_0x7a.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_0x7a.html; sourceTree = "<group>"; };
+		24A200D20F90D1DE003BB5A7 /* functions_0x7e.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_0x7e.html; sourceTree = "<group>"; };
+		24A200D30F90D1DE003BB5A7 /* functions_eval.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_eval.html; sourceTree = "<group>"; };
+		24A200D40F90D1DE003BB5A7 /* functions_func.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_func.html; sourceTree = "<group>"; };
+		24A200D50F90D1DE003BB5A7 /* functions_func_0x62.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_func_0x62.html; sourceTree = "<group>"; };
+		24A200D60F90D1DE003BB5A7 /* functions_func_0x63.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_func_0x63.html; sourceTree = "<group>"; };
+		24A200D70F90D1DE003BB5A7 /* functions_func_0x64.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_func_0x64.html; sourceTree = "<group>"; };
+		24A200D80F90D1DE003BB5A7 /* functions_func_0x65.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_func_0x65.html; sourceTree = "<group>"; };
+		24A200D90F90D1DE003BB5A7 /* functions_func_0x66.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_func_0x66.html; sourceTree = "<group>"; };
+		24A200DA0F90D1DE003BB5A7 /* functions_func_0x67.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_func_0x67.html; sourceTree = "<group>"; };
+		24A200DB0F90D1DE003BB5A7 /* functions_func_0x68.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_func_0x68.html; sourceTree = "<group>"; };
+		24A200DC0F90D1DE003BB5A7 /* functions_func_0x69.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_func_0x69.html; sourceTree = "<group>"; };
+		24A200DD0F90D1DE003BB5A7 /* functions_func_0x6c.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_func_0x6c.html; sourceTree = "<group>"; };
+		24A200DE0F90D1DE003BB5A7 /* functions_func_0x6d.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_func_0x6d.html; sourceTree = "<group>"; };
+		24A200DF0F90D1DE003BB5A7 /* functions_func_0x6e.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_func_0x6e.html; sourceTree = "<group>"; };
+		24A200E00F90D1DE003BB5A7 /* functions_func_0x6f.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_func_0x6f.html; sourceTree = "<group>"; };
+		24A200E10F90D1DE003BB5A7 /* functions_func_0x70.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_func_0x70.html; sourceTree = "<group>"; };
+		24A200E20F90D1DE003BB5A7 /* functions_func_0x72.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_func_0x72.html; sourceTree = "<group>"; };
+		24A200E30F90D1DE003BB5A7 /* functions_func_0x73.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_func_0x73.html; sourceTree = "<group>"; };
+		24A200E40F90D1DE003BB5A7 /* functions_func_0x74.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_func_0x74.html; sourceTree = "<group>"; };
+		24A200E50F90D1DE003BB5A7 /* functions_func_0x75.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_func_0x75.html; sourceTree = "<group>"; };
+		24A200E60F90D1DE003BB5A7 /* functions_func_0x76.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_func_0x76.html; sourceTree = "<group>"; };
+		24A200E70F90D1DE003BB5A7 /* functions_func_0x77.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_func_0x77.html; sourceTree = "<group>"; };
+		24A200E80F90D1DE003BB5A7 /* functions_func_0x7e.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_func_0x7e.html; sourceTree = "<group>"; };
+		24A200E90F90D1DE003BB5A7 /* functions_rela.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_rela.html; sourceTree = "<group>"; };
+		24A200EA0F90D1DE003BB5A7 /* functions_vars.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_vars.html; sourceTree = "<group>"; };
+		24A200EB0F90D1DE003BB5A7 /* functions_vars_0x62.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_vars_0x62.html; sourceTree = "<group>"; };
+		24A200EC0F90D1DE003BB5A7 /* functions_vars_0x63.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_vars_0x63.html; sourceTree = "<group>"; };
+		24A200ED0F90D1DE003BB5A7 /* functions_vars_0x64.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_vars_0x64.html; sourceTree = "<group>"; };
+		24A200EE0F90D1DE003BB5A7 /* functions_vars_0x65.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_vars_0x65.html; sourceTree = "<group>"; };
+		24A200EF0F90D1DE003BB5A7 /* functions_vars_0x66.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_vars_0x66.html; sourceTree = "<group>"; };
+		24A200F00F90D1DE003BB5A7 /* functions_vars_0x67.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_vars_0x67.html; sourceTree = "<group>"; };
+		24A200F10F90D1DE003BB5A7 /* functions_vars_0x68.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_vars_0x68.html; sourceTree = "<group>"; };
+		24A200F20F90D1DE003BB5A7 /* functions_vars_0x69.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_vars_0x69.html; sourceTree = "<group>"; };
+		24A200F30F90D1DE003BB5A7 /* functions_vars_0x6b.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_vars_0x6b.html; sourceTree = "<group>"; };
+		24A200F40F90D1DE003BB5A7 /* functions_vars_0x6c.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_vars_0x6c.html; sourceTree = "<group>"; };
+		24A200F50F90D1DE003BB5A7 /* functions_vars_0x6d.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_vars_0x6d.html; sourceTree = "<group>"; };
+		24A200F60F90D1DE003BB5A7 /* functions_vars_0x6e.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_vars_0x6e.html; sourceTree = "<group>"; };
+		24A200F70F90D1DE003BB5A7 /* functions_vars_0x6f.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_vars_0x6f.html; sourceTree = "<group>"; };
+		24A200F80F90D1DE003BB5A7 /* functions_vars_0x70.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_vars_0x70.html; sourceTree = "<group>"; };
+		24A200F90F90D1DE003BB5A7 /* functions_vars_0x72.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_vars_0x72.html; sourceTree = "<group>"; };
+		24A200FA0F90D1DE003BB5A7 /* functions_vars_0x73.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_vars_0x73.html; sourceTree = "<group>"; };
+		24A200FB0F90D1DE003BB5A7 /* functions_vars_0x74.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_vars_0x74.html; sourceTree = "<group>"; };
+		24A200FC0F90D1DE003BB5A7 /* functions_vars_0x75.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_vars_0x75.html; sourceTree = "<group>"; };
+		24A200FD0F90D1DE003BB5A7 /* functions_vars_0x76.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_vars_0x76.html; sourceTree = "<group>"; };
+		24A200FE0F90D1DE003BB5A7 /* functions_vars_0x77.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_vars_0x77.html; sourceTree = "<group>"; };
+		24A200FF0F90D1DE003BB5A7 /* functions_vars_0x78.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_vars_0x78.html; sourceTree = "<group>"; };
+		24A201000F90D1DE003BB5A7 /* functions_vars_0x79.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_vars_0x79.html; sourceTree = "<group>"; };
+		24A201010F90D1DE003BB5A7 /* functions_vars_0x7a.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = functions_vars_0x7a.html; sourceTree = "<group>"; };
+		24A201020F90D1DE003BB5A7 /* globals.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = globals.html; sourceTree = "<group>"; };
+		24A201030F90D1DE003BB5A7 /* globals_0x61.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = globals_0x61.html; sourceTree = "<group>"; };
+		24A201040F90D1DE003BB5A7 /* globals_0x62.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = globals_0x62.html; sourceTree = "<group>"; };
+		24A201050F90D1DE003BB5A7 /* globals_0x63.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = globals_0x63.html; sourceTree = "<group>"; };
+		24A201060F90D1DE003BB5A7 /* globals_0x65.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = globals_0x65.html; sourceTree = "<group>"; };
+		24A201070F90D1DE003BB5A7 /* globals_0x66.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = globals_0x66.html; sourceTree = "<group>"; };
+		24A201080F90D1DE003BB5A7 /* globals_0x67.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = globals_0x67.html; sourceTree = "<group>"; };
+		24A201090F90D1DE003BB5A7 /* globals_0x6b.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = globals_0x6b.html; sourceTree = "<group>"; };
+		24A2010A0F90D1DE003BB5A7 /* globals_0x6d.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = globals_0x6d.html; sourceTree = "<group>"; };
+		24A2010B0F90D1DE003BB5A7 /* globals_0x6e.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = globals_0x6e.html; sourceTree = "<group>"; };
+		24A2010C0F90D1DE003BB5A7 /* globals_0x6f.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = globals_0x6f.html; sourceTree = "<group>"; };
+		24A2010D0F90D1DE003BB5A7 /* globals_0x71.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = globals_0x71.html; sourceTree = "<group>"; };
+		24A2010E0F90D1DE003BB5A7 /* globals_0x72.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = globals_0x72.html; sourceTree = "<group>"; };
+		24A2010F0F90D1DE003BB5A7 /* globals_0x73.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = globals_0x73.html; sourceTree = "<group>"; };
+		24A201100F90D1DE003BB5A7 /* globals_0x74.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = globals_0x74.html; sourceTree = "<group>"; };
+		24A201110F90D1DE003BB5A7 /* globals_0x75.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = globals_0x75.html; sourceTree = "<group>"; };
+		24A201120F90D1DE003BB5A7 /* globals_0x76.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = globals_0x76.html; sourceTree = "<group>"; };
+		24A201130F90D1DE003BB5A7 /* globals_0x77.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = globals_0x77.html; sourceTree = "<group>"; };
+		24A201140F90D1DE003BB5A7 /* globals_defs.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = globals_defs.html; sourceTree = "<group>"; };
+		24A201150F90D1DE003BB5A7 /* globals_enum.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = globals_enum.html; sourceTree = "<group>"; };
+		24A201160F90D1DE003BB5A7 /* globals_eval.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = globals_eval.html; sourceTree = "<group>"; };
+		24A201170F90D1DE003BB5A7 /* globals_type.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = globals_type.html; sourceTree = "<group>"; };
+		24A201180F90D1DE003BB5A7 /* globals_vars.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = globals_vars.html; sourceTree = "<group>"; };
+		24A201190F90D1DE003BB5A7 /* hierarchy.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = hierarchy.html; sourceTree = "<group>"; };
+		24A2011A0F90D1DE003BB5A7 /* index.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = index.html; sourceTree = "<group>"; };
+		24A2011B0F90D1DE003BB5A7 /* intro.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = intro.html; sourceTree = "<group>"; };
+		24A2011C0F90D1DE003BB5A7 /* license.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = license.html; sourceTree = "<group>"; };
+		24A2011D0F90D1DE003BB5A7 /* maceditor.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = maceditor.html; sourceTree = "<group>"; };
+		24A2011E0F90D1DE003BB5A7 /* main.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = main.html; sourceTree = "<group>"; };
+		24A2011F0F90D1DE003BB5A7 /* others.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = others.html; sourceTree = "<group>"; };
+		24A201200F90D1DE003BB5A7 /* pages.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = pages.html; sourceTree = "<group>"; };
+		24A201210F90D1DE003BB5A7 /* plugguieditor_8cpp.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = plugguieditor_8cpp.html; sourceTree = "<group>"; };
+		24A201220F90D1DE003BB5A7 /* plugguieditor_8h.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = plugguieditor_8h.html; sourceTree = "<group>"; };
+		24A201230F90D1DE003BB5A7 /* sequences.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = sequences.html; sourceTree = "<group>"; };
+		24A201240F90D1DE003BB5A7 /* struct_c_color-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = "struct_c_color-members.html"; sourceTree = "<group>"; };
+		24A201250F90D1DE003BB5A7 /* struct_c_color.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = struct_c_color.html; sourceTree = "<group>"; };
+		24A201260F90D1DE003BB5A7 /* struct_c_point-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = "struct_c_point-members.html"; sourceTree = "<group>"; };
+		24A201270F90D1DE003BB5A7 /* struct_c_point.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = struct_c_point.html; sourceTree = "<group>"; };
+		24A201280F90D1DE003BB5A7 /* struct_c_rect-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = "struct_c_rect-members.html"; sourceTree = "<group>"; };
+		24A201290F90D1DE003BB5A7 /* struct_c_rect.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = struct_c_rect.html; sourceTree = "<group>"; };
+		24A2012A0F90D1DE003BB5A7 /* struct_e_rect-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = "struct_e_rect-members.html"; sourceTree = "<group>"; };
+		24A2012B0F90D1DE003BB5A7 /* struct_e_rect.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = struct_e_rect.html; sourceTree = "<group>"; };
+		24A2012C0F90D1DE003BB5A7 /* struct_vst_file_select-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = "struct_vst_file_select-members.html"; sourceTree = "<group>"; };
+		24A2012D0F90D1DE003BB5A7 /* struct_vst_file_select.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = struct_vst_file_select.html; sourceTree = "<group>"; };
+		24A2012E0F90D1DE003BB5A7 /* struct_vst_file_type-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = "struct_vst_file_type-members.html"; sourceTree = "<group>"; };
+		24A2012F0F90D1DE003BB5A7 /* struct_vst_file_type.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = struct_vst_file_type.html; sourceTree = "<group>"; };
+		24A201300F90D1DE003BB5A7 /* struct_vst_key_code-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = "struct_vst_key_code-members.html"; sourceTree = "<group>"; };
+		24A201310F90D1DE003BB5A7 /* struct_vst_key_code.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = struct_vst_key_code.html; sourceTree = "<group>"; };
+		24A201320F90D1DE003BB5A7 /* tab_b.gif */ = {isa = PBXFileReference; lastKnownFileType = image.gif; path = tab_b.gif; sourceTree = "<group>"; };
+		24A201330F90D1DE003BB5A7 /* tab_l.gif */ = {isa = PBXFileReference; lastKnownFileType = image.gif; path = tab_l.gif; sourceTree = "<group>"; };
+		24A201340F90D1DE003BB5A7 /* tab_r.gif */ = {isa = PBXFileReference; lastKnownFileType = image.gif; path = tab_r.gif; sourceTree = "<group>"; };
+		24A201350F90D1DE003BB5A7 /* tabs.css */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.css; path = tabs.css; sourceTree = "<group>"; };
+		24A201360F90D1DE003BB5A7 /* thanks.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = thanks.html; sourceTree = "<group>"; };
+		24A201370F90D1DE003BB5A7 /* tree.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = tree.html; sourceTree = "<group>"; };
+		24A201380F90D1DE003BB5A7 /* vstcontrols_8cpp.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = vstcontrols_8cpp.html; sourceTree = "<group>"; };
+		24A201390F90D1DE003BB5A7 /* vstcontrols_8h.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = vstcontrols_8h.html; sourceTree = "<group>"; };
+		24A2013A0F90D1DE003BB5A7 /* vstgui_8cpp.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = vstgui_8cpp.html; sourceTree = "<group>"; };
+		24A2013B0F90D1DE003BB5A7 /* vstgui_8h.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = vstgui_8h.html; sourceTree = "<group>"; };
+		24A2013C0F90D1DE003BB5A7 /* vstkeycode_8h.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = vstkeycode_8h.html; sourceTree = "<group>"; };
+		24A2013D0F90D1DE003BB5A7 /* vstoffline.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = vstoffline.html; sourceTree = "<group>"; };
+		24A2013E0F90D1DE003BB5A7 /* vstparamstruct.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = vstparamstruct.html; sourceTree = "<group>"; };
+		24A2013F0F90D1DE003BB5A7 /* vstplugscarbon_8h.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = vstplugscarbon_8h.html; sourceTree = "<group>"; };
+		24A201400F90D1DE003BB5A7 /* vstplugsmac_8h.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = vstplugsmac_8h.html; sourceTree = "<group>"; };
+		24A201410F90D1DE003BB5A7 /* vstplugsmacho_8h.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = vstplugsmacho_8h.html; sourceTree = "<group>"; };
+		24A201420F90D1DE003BB5A7 /* vstplugsquartz_8h.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = vstplugsquartz_8h.html; sourceTree = "<group>"; };
+		24A201430F90D1DE003BB5A7 /* whatsnew.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = whatsnew.html; sourceTree = "<group>"; };
+		24A201440F90D1DE003BB5A7 /* index.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html.documentation; path = index.html; sourceTree = "<group>"; };
+		24A201450F90D1DE003BB5A7 /* Migrating from 2.3.rtf */ = {isa = PBXFileReference; lastKnownFileType = text.rtf; path = "Migrating from 2.3.rtf"; sourceTree = "<group>"; };
+		24A201460F90D1DE003BB5A7 /* plugguieditor.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = plugguieditor.cpp; sourceTree = "<group>"; };
+		24A201470F90D1DE003BB5A7 /* plugguieditor.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = plugguieditor.h; sourceTree = "<group>"; };
+		24A201480F90D1DE003BB5A7 /* vstcontrols.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = vstcontrols.cpp; sourceTree = "<group>"; };
+		24A201490F90D1DE003BB5A7 /* vstcontrols.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = vstcontrols.h; sourceTree = "<group>"; };
+		24A2014A0F90D1DE003BB5A7 /* vstgui.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = vstgui.cpp; sourceTree = "<group>"; };
+		24A2014B0F90D1DE003BB5A7 /* vstgui.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = vstgui.h; sourceTree = "<group>"; };
+		24A2014C0F90D1DE003BB5A7 /* vstkeycode.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = vstkeycode.h; sourceTree = "<group>"; };
+		24A2014D0F90D1DE003BB5A7 /* vstplugscarbon.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = vstplugscarbon.h; sourceTree = "<group>"; };
+		24A2014E0F90D1DE003BB5A7 /* vstplugsmac.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = vstplugsmac.h; sourceTree = "<group>"; };
+		24A2014F0F90D1DE003BB5A7 /* vstplugsmacho.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = vstplugsmacho.h; sourceTree = "<group>"; };
+		24A201500F90D1DE003BB5A7 /* vstplugsquartz.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = vstplugsquartz.h; sourceTree = "<group>"; };
+		24A2FEBD0F90D1DC003BB5A7 /* Thumbs.db */ = {isa = PBXFileReference; lastKnownFileType = file; path = Thumbs.db; sourceTree = "<group>"; };
+		24A2FEBE0F90D1DC003BB5A7 /* VST_Logo_Usage_Guideline.pdf */ = {isa = PBXFileReference; lastKnownFileType = image.pdf; path = VST_Logo_Usage_Guideline.pdf; sourceTree = "<group>"; };
+		24A2FEBF0F90D1DC003BB5A7 /* VSTLogoAlpha.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = VSTLogoAlpha.png; sourceTree = "<group>"; };
+		24A2FEC00F90D1DC003BB5A7 /* VSTLogoBlack.jpg */ = {isa = PBXFileReference; lastKnownFileType = image.jpeg; path = VSTLogoBlack.jpg; sourceTree = "<group>"; };
+		24A2FEC10F90D1DC003BB5A7 /* VSTLogoWhite.jpg */ = {isa = PBXFileReference; lastKnownFileType = image.jpeg; path = VSTLogoWhite.jpg; sourceTree = "<group>"; };
+		24A2FEC60F90D1DC003BB5A7 /* Info.plist */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.plist.xml; path = Info.plist; sourceTree = "<group>"; };
+		24A2FEC80F90D1DC003BB5A7 /* VSTMonitor */ = {isa = PBXFileReference; lastKnownFileType = "compiled.mach-o.bundle"; path = VSTMonitor; sourceTree = "<group>"; };
+		24A2FEC90F90D1DC003BB5A7 /* PkgInfo */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = PkgInfo; sourceTree = "<group>"; };
+		24A2FECB0F90D1DC003BB5A7 /* bmp50000.bmp */ = {isa = PBXFileReference; lastKnownFileType = image.bmp; path = bmp50000.bmp; sourceTree = "<group>"; };
+		24A2FECC0F90D1DC003BB5A7 /* bmp50001.bmp */ = {isa = PBXFileReference; lastKnownFileType = image.bmp; path = bmp50001.bmp; sourceTree = "<group>"; };
+		24A2FECD0F90D1DC003BB5A7 /* bmp50002.bmp */ = {isa = PBXFileReference; lastKnownFileType = image.bmp; path = bmp50002.bmp; sourceTree = "<group>"; };
+		24A2FECE0F90D1DC003BB5A7 /* bmp50003.bmp */ = {isa = PBXFileReference; lastKnownFileType = image.bmp; path = bmp50003.bmp; sourceTree = "<group>"; };
+		24A2FECF0F90D1DC003BB5A7 /* bmp50004.bmp */ = {isa = PBXFileReference; lastKnownFileType = image.bmp; path = bmp50004.bmp; sourceTree = "<group>"; };
+		24A2FED00F90D1DC003BB5A7 /* bmp50005.bmp */ = {isa = PBXFileReference; lastKnownFileType = image.bmp; path = bmp50005.bmp; sourceTree = "<group>"; };
+		24A2FED10F90D1DC003BB5A7 /* bmp50006.bmp */ = {isa = PBXFileReference; lastKnownFileType = image.bmp; path = bmp50006.bmp; sourceTree = "<group>"; };
+		24A2FED20F90D1DC003BB5A7 /* bmp50007.bmp */ = {isa = PBXFileReference; lastKnownFileType = image.bmp; path = bmp50007.bmp; sourceTree = "<group>"; };
+		24A2FED30F90D1DC003BB5A7 /* bmp50008.bmp */ = {isa = PBXFileReference; lastKnownFileType = image.bmp; path = bmp50008.bmp; sourceTree = "<group>"; };
+		24A2FED40F90D1DC003BB5A7 /* VSTParamTool.app */ = {isa = PBXFileReference; lastKnownFileType = wrapper.application; path = VSTParamTool.app; sourceTree = "<group>"; };
+		24A2FED60F90D1DC003BB5A7 /* vstmonitor.dll */ = {isa = PBXFileReference; lastKnownFileType = file; path = vstmonitor.dll; sourceTree = "<group>"; };
+		24A2FED70F90D1DC003BB5A7 /* vstparamtool.exe */ = {isa = PBXFileReference; lastKnownFileType = file; path = vstparamtool.exe; sourceTree = "<group>"; };
+		24A2FEDA0F90D1DC003BB5A7 /* folder.gif */ = {isa = PBXFileReference; lastKnownFileType = image.gif; path = folder.gif; sourceTree = "<group>"; };
+		24A2FEDB0F90D1DC003BB5A7 /* mac.gif */ = {isa = PBXFileReference; lastKnownFileType = image.gif; path = mac.gif; sourceTree = "<group>"; };
+		24A2FEDC0F90D1DC003BB5A7 /* vstpluglogo_small.jpg */ = {isa = PBXFileReference; lastKnownFileType = image.jpeg; path = vstpluglogo_small.jpg; sourceTree = "<group>"; };
+		24A2FEDD0F90D1DC003BB5A7 /* win.gif */ = {isa = PBXFileReference; lastKnownFileType = image.gif; path = win.gif; sourceTree = "<group>"; };
+		24A2FEDF0F90D1DC003BB5A7 /* aeffect_8h.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = aeffect_8h.html; sourceTree = "<group>"; };
+		24A2FEE00F90D1DC003BB5A7 /* aeffectx_8h.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = aeffectx_8h.html; sourceTree = "<group>"; };
+		24A2FEE10F90D1DC003BB5A7 /* aeffeditor_8h.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = aeffeditor_8h.html; sourceTree = "<group>"; };
+		24A2FEE20F90D1DC003BB5A7 /* annotated.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = annotated.html; sourceTree = "<group>"; };
+		24A2FEE30F90D1DC003BB5A7 /* audioeffect_8cpp.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = audioeffect_8cpp.html; sourceTree = "<group>"; };
+		24A2FEE40F90D1DC003BB5A7 /* audioeffect_8h.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = audioeffect_8h.html; sourceTree = "<group>"; };
+		24A2FEE50F90D1DC003BB5A7 /* audioeffectx_8cpp.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = audioeffectx_8cpp.html; sourceTree = "<group>"; };
+		24A2FEE60F90D1DC003BB5A7 /* audioeffectx_8h.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = audioeffectx_8h.html; sourceTree = "<group>"; };
+		24A2FEE70F90D1DC003BB5A7 /* Blocksizechange.gif */ = {isa = PBXFileReference; lastKnownFileType = image.gif; path = Blocksizechange.gif; sourceTree = "<group>"; };
+		24A2FEE80F90D1DC003BB5A7 /* class_a_eff_editor-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = "class_a_eff_editor-members.html"; sourceTree = "<group>"; };
+		24A2FEE90F90D1DC003BB5A7 /* class_a_eff_editor.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = class_a_eff_editor.html; sourceTree = "<group>"; };
+		24A2FEEA0F90D1DC003BB5A7 /* class_audio_effect-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = "class_audio_effect-members.html"; sourceTree = "<group>"; };
+		24A2FEEB0F90D1DC003BB5A7 /* class_audio_effect.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = class_audio_effect.html; sourceTree = "<group>"; };
+		24A2FEEC0F90D1DC003BB5A7 /* class_audio_effect.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = class_audio_effect.png; sourceTree = "<group>"; };
+		24A2FEED0F90D1DC003BB5A7 /* class_audio_effect_x-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = "class_audio_effect_x-members.html"; sourceTree = "<group>"; };
+		24A2FEEE0F90D1DC003BB5A7 /* class_audio_effect_x.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = class_audio_effect_x.html; sourceTree = "<group>"; };
+		24A2FEEF0F90D1DC003BB5A7 /* class_audio_effect_x.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = class_audio_effect_x.png; sourceTree = "<group>"; };
+		24A2FEF00F90D1DC003BB5A7 /* ControlChanged.gif */ = {isa = PBXFileReference; lastKnownFileType = image.gif; path = ControlChanged.gif; sourceTree = "<group>"; };
+		24A2FEF10F90D1DC003BB5A7 /* deprecated.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = deprecated.html; sourceTree = "<group>"; };
+		24A2FEF20F90D1DC003BB5A7 /* dir_2d3252dd12c84c66c1d25b26bb45a1f5.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = dir_2d3252dd12c84c66c1d25b26bb45a1f5.html; sourceTree = "<group>"; };
+		24A2FEF30F90D1DC003BB5A7 /* dir_77c628dfee72e555f82d5ef53b733f38.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = dir_77c628dfee72e555f82d5ef53b733f38.html; sourceTree = "<group>"; };
+		24A2FEF40F90D1DC003BB5A7 /* dir_f81105d3b854bea570aaf3bae5cb64c1.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = dir_f81105d3b854bea570aaf3bae5cb64c1.html; sourceTree = "<group>"; };
+		24A2FEF50F90D1DC003BB5A7 /* dir_fa0454ab79b4262333bf837ea3d765e9.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = dir_fa0454ab79b4262333bf837ea3d765e9.html; sourceTree = "<group>"; };
+		24A2FEF60F90D1DC003BB5A7 /* dirs.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = dirs.html; sourceTree = "<group>"; };
+		24A2FEF70F90D1DC003BB5A7 /* doc_8h.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = doc_8h.html; sourceTree = "<group>"; };
+		24A2FEF80F90D1DC003BB5A7 /* doxygen.css */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.css; path = doxygen.css; sourceTree = "<group>"; };
+		24A2FEF90F90D1DC003BB5A7 /* doxygen.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = doxygen.png; sourceTree = "<group>"; };
+		24A2FEFA0F90D1DC003BB5A7 /* files.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = files.html; sourceTree = "<group>"; };
+		24A2FEFB0F90D1DC003BB5A7 /* ftv2blank.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = ftv2blank.png; sourceTree = "<group>"; };
+		24A2FEFC0F90D1DC003BB5A7 /* ftv2doc.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = ftv2doc.png; sourceTree = "<group>"; };
+		24A2FEFD0F90D1DC003BB5A7 /* ftv2folderclosed.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = ftv2folderclosed.png; sourceTree = "<group>"; };
+		24A2FEFE0F90D1DC003BB5A7 /* ftv2folderopen.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = ftv2folderopen.png; sourceTree = "<group>"; };
+		24A2FEFF0F90D1DC003BB5A7 /* ftv2lastnode.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = ftv2lastnode.png; sourceTree = "<group>"; };
+		24A2FF000F90D1DC003BB5A7 /* ftv2link.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = ftv2link.png; sourceTree = "<group>"; };
+		24A2FF010F90D1DC003BB5A7 /* ftv2mlastnode.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = ftv2mlastnode.png; sourceTree = "<group>"; };
+		24A2FF020F90D1DC003BB5A7 /* ftv2mnode.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = ftv2mnode.png; sourceTree = "<group>"; };
+		24A2FF030F90D1DC003BB5A7 /* ftv2node.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = ftv2node.png; sourceTree = "<group>"; };
+		24A2FF040F90D1DC003BB5A7 /* ftv2plastnode.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = ftv2plastnode.png; sourceTree = "<group>"; };
+		24A2FF050F90D1DC003BB5A7 /* ftv2pnode.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = ftv2pnode.png; sourceTree = "<group>"; };
+		24A2FF060F90D1DC003BB5A7 /* ftv2vertline.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = ftv2vertline.png; sourceTree = "<group>"; };
+		24A2FF070F90D1DC003BB5A7 /* functions.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = functions.html; sourceTree = "<group>"; };
+		24A2FF080F90D1DC003BB5A7 /* functions_0x62.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = functions_0x62.html; sourceTree = "<group>"; };
+		24A2FF090F90D1DC003BB5A7 /* functions_0x63.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = functions_0x63.html; sourceTree = "<group>"; };
+		24A2FF0A0F90D1DC003BB5A7 /* functions_0x64.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = functions_0x64.html; sourceTree = "<group>"; };
+		24A2FF0B0F90D1DC003BB5A7 /* functions_0x65.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = functions_0x65.html; sourceTree = "<group>"; };
+		24A2FF0C0F90D1DC003BB5A7 /* functions_0x66.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = functions_0x66.html; sourceTree = "<group>"; };
+		24A2FF0D0F90D1DC003BB5A7 /* functions_0x67.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = functions_0x67.html; sourceTree = "<group>"; };
+		24A2FF0E0F90D1DC003BB5A7 /* functions_0x68.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = functions_0x68.html; sourceTree = "<group>"; };
+		24A2FF0F0F90D1DC003BB5A7 /* functions_0x69.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = functions_0x69.html; sourceTree = "<group>"; };
+		24A2FF100F90D1DC003BB5A7 /* functions_0x6b.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = functions_0x6b.html; sourceTree = "<group>"; };
+		24A2FF110F90D1DC003BB5A7 /* functions_0x6c.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = functions_0x6c.html; sourceTree = "<group>"; };
+		24A2FF120F90D1DC003BB5A7 /* functions_0x6d.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = functions_0x6d.html; sourceTree = "<group>"; };
+		24A2FF130F90D1DC003BB5A7 /* functions_0x6e.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = functions_0x6e.html; sourceTree = "<group>"; };
+		24A2FF140F90D1DC003BB5A7 /* functions_0x6f.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = functions_0x6f.html; sourceTree = "<group>"; };
+		24A2FF150F90D1DC003BB5A7 /* functions_0x70.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = functions_0x70.html; sourceTree = "<group>"; };
+		24A2FF160F90D1DC003BB5A7 /* functions_0x72.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = functions_0x72.html; sourceTree = "<group>"; };
+		24A2FF170F90D1DC003BB5A7 /* functions_0x73.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = functions_0x73.html; sourceTree = "<group>"; };
+		24A2FF180F90D1DC003BB5A7 /* functions_0x74.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = functions_0x74.html; sourceTree = "<group>"; };
+		24A2FF190F90D1DC003BB5A7 /* functions_0x75.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = functions_0x75.html; sourceTree = "<group>"; };
+		24A2FF1A0F90D1DC003BB5A7 /* functions_0x76.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = functions_0x76.html; sourceTree = "<group>"; };
+		24A2FF1B0F90D1DC003BB5A7 /* functions_0x77.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = functions_0x77.html; sourceTree = "<group>"; };
+		24A2FF1C0F90D1DC003BB5A7 /* functions_0x78.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = functions_0x78.html; sourceTree = "<group>"; };
+		24A2FF1D0F90D1DC003BB5A7 /* functions_0x79.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = functions_0x79.html; sourceTree = "<group>"; };
+		24A2FF1E0F90D1DC003BB5A7 /* functions_0x7e.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = functions_0x7e.html; sourceTree = "<group>"; };
+		24A2FF1F0F90D1DC003BB5A7 /* functions_func.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = functions_func.html; sourceTree = "<group>"; };
+		24A2FF200F90D1DC003BB5A7 /* functions_vars.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = functions_vars.html; sourceTree = "<group>"; };
+		24A2FF210F90D1DC003BB5A7 /* globals.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = globals.html; sourceTree = "<group>"; };
+		24A2FF220F90D1DC003BB5A7 /* globals_0x62.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = globals_0x62.html; sourceTree = "<group>"; };
+		24A2FF230F90D1DC003BB5A7 /* globals_0x63.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = globals_0x63.html; sourceTree = "<group>"; };
+		24A2FF240F90D1DC003BB5A7 /* globals_0x64.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = globals_0x64.html; sourceTree = "<group>"; };
+		24A2FF250F90D1DC003BB5A7 /* globals_0x65.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = globals_0x65.html; sourceTree = "<group>"; };
+		24A2FF260F90D1DC003BB5A7 /* globals_0x66.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = globals_0x66.html; sourceTree = "<group>"; };
+		24A2FF270F90D1DC003BB5A7 /* globals_0x6b.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = globals_0x6b.html; sourceTree = "<group>"; };
+		24A2FF280F90D1DC003BB5A7 /* globals_0x6d.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = globals_0x6d.html; sourceTree = "<group>"; };
+		24A2FF290F90D1DC003BB5A7 /* globals_0x74.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = globals_0x74.html; sourceTree = "<group>"; };
+		24A2FF2A0F90D1DC003BB5A7 /* globals_0x76.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = globals_0x76.html; sourceTree = "<group>"; };
+		24A2FF2B0F90D1DC003BB5A7 /* globals_defs.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = globals_defs.html; sourceTree = "<group>"; };
+		24A2FF2C0F90D1DC003BB5A7 /* globals_enum.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = globals_enum.html; sourceTree = "<group>"; };
+		24A2FF2D0F90D1DC003BB5A7 /* globals_eval.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = globals_eval.html; sourceTree = "<group>"; };
+		24A2FF2E0F90D1DC003BB5A7 /* globals_eval_0x65.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = globals_eval_0x65.html; sourceTree = "<group>"; };
+		24A2FF2F0F90D1DC003BB5A7 /* globals_eval_0x6b.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = globals_eval_0x6b.html; sourceTree = "<group>"; };
+		24A2FF300F90D1DC003BB5A7 /* globals_eval_0x6d.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = globals_eval_0x6d.html; sourceTree = "<group>"; };
+		24A2FF310F90D1DC003BB5A7 /* globals_eval_0x76.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = globals_eval_0x76.html; sourceTree = "<group>"; };
+		24A2FF320F90D1DC003BB5A7 /* globals_func.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = globals_func.html; sourceTree = "<group>"; };
+		24A2FF330F90D1DC003BB5A7 /* globals_type.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = globals_type.html; sourceTree = "<group>"; };
+		24A2FF340F90D1DC003BB5A7 /* globals_vars.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = globals_vars.html; sourceTree = "<group>"; };
+		24A2FF350F90D1DC003BB5A7 /* hierarchy.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = hierarchy.html; sourceTree = "<group>"; };
+		24A2FF360F90D1DC003BB5A7 /* history.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = history.html; sourceTree = "<group>"; };
+		24A2FF370F90D1DC003BB5A7 /* index.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = index.html; sourceTree = "<group>"; };
+		24A2FF380F90D1DC003BB5A7 /* Initialisation.gif */ = {isa = PBXFileReference; lastKnownFileType = image.gif; path = Initialisation.gif; sourceTree = "<group>"; };
+		24A2FF390F90D1DC003BB5A7 /* intro.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = intro.html; sourceTree = "<group>"; };
+		24A2FF3A0F90D1DC003BB5A7 /* IOchange.gif */ = {isa = PBXFileReference; lastKnownFileType = image.gif; path = IOchange.gif; sourceTree = "<group>"; };
+		24A2FF3B0F90D1DC003BB5A7 /* license.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = license.html; sourceTree = "<group>"; };
+		24A2FF3C0F90D1DC003BB5A7 /* maceditor.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = maceditor.html; sourceTree = "<group>"; };
+		24A2FF3D0F90D1DC003BB5A7 /* main.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = main.html; sourceTree = "<group>"; };
+		24A2FF3E0F90D1DC003BB5A7 /* namespace_host_can_dos.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = namespace_host_can_dos.html; sourceTree = "<group>"; };
+		24A2FF3F0F90D1DC003BB5A7 /* namespace_plug_can_dos.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = namespace_plug_can_dos.html; sourceTree = "<group>"; };
+		24A2FF400F90D1DC003BB5A7 /* namespacemembers.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = namespacemembers.html; sourceTree = "<group>"; };
+		24A2FF410F90D1DC003BB5A7 /* namespacemembers_vars.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = namespacemembers_vars.html; sourceTree = "<group>"; };
+		24A2FF420F90D1DC003BB5A7 /* namespaces.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = namespaces.html; sourceTree = "<group>"; };
+		24A2FF430F90D1DC003BB5A7 /* Offlineprocessing.gif */ = {isa = PBXFileReference; lastKnownFileType = image.gif; path = Offlineprocessing.gif; sourceTree = "<group>"; };
+		24A2FF440F90D1DC003BB5A7 /* others.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = others.html; sourceTree = "<group>"; };
+		24A2FF450F90D1DC003BB5A7 /* pages.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = pages.html; sourceTree = "<group>"; };
+		24A2FF460F90D1DC003BB5A7 /* Sampleratechange.gif */ = {isa = PBXFileReference; lastKnownFileType = image.gif; path = Sampleratechange.gif; sourceTree = "<group>"; };
+		24A2FF470F90D1DC003BB5A7 /* sequences.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = sequences.html; sourceTree = "<group>"; };
+		24A2FF480F90D1DC003BB5A7 /* SpeakerarrangementnegotiationforVSTfx.gif */ = {isa = PBXFileReference; lastKnownFileType = image.gif; path = SpeakerarrangementnegotiationforVSTfx.gif; sourceTree = "<group>"; };
+		24A2FF490F90D1DC003BB5A7 /* struct_a_effect-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = "struct_a_effect-members.html"; sourceTree = "<group>"; };
+		24A2FF4A0F90D1DC003BB5A7 /* struct_a_effect.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = struct_a_effect.html; sourceTree = "<group>"; };
+		24A2FF4B0F90D1DC003BB5A7 /* struct_e_rect-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = "struct_e_rect-members.html"; sourceTree = "<group>"; };
+		24A2FF4C0F90D1DC003BB5A7 /* struct_e_rect.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = struct_e_rect.html; sourceTree = "<group>"; };
+		24A2FF4D0F90D1DC003BB5A7 /* struct_midi_key_name-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = "struct_midi_key_name-members.html"; sourceTree = "<group>"; };
+		24A2FF4E0F90D1DC003BB5A7 /* struct_midi_key_name.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = struct_midi_key_name.html; sourceTree = "<group>"; };
+		24A2FF4F0F90D1DC003BB5A7 /* struct_midi_program_category-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = "struct_midi_program_category-members.html"; sourceTree = "<group>"; };
+		24A2FF500F90D1DC003BB5A7 /* struct_midi_program_category.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = struct_midi_program_category.html; sourceTree = "<group>"; };
+		24A2FF510F90D1DC003BB5A7 /* struct_midi_program_name-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = "struct_midi_program_name-members.html"; sourceTree = "<group>"; };
+		24A2FF520F90D1DC003BB5A7 /* struct_midi_program_name.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = struct_midi_program_name.html; sourceTree = "<group>"; };
+		24A2FF530F90D1DC003BB5A7 /* struct_vst_audio_file-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = "struct_vst_audio_file-members.html"; sourceTree = "<group>"; };
+		24A2FF540F90D1DC003BB5A7 /* struct_vst_audio_file.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = struct_vst_audio_file.html; sourceTree = "<group>"; };
+		24A2FF550F90D1DC003BB5A7 /* struct_vst_audio_file_marker-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = "struct_vst_audio_file_marker-members.html"; sourceTree = "<group>"; };
+		24A2FF560F90D1DC003BB5A7 /* struct_vst_audio_file_marker.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = struct_vst_audio_file_marker.html; sourceTree = "<group>"; };
+		24A2FF570F90D1DC003BB5A7 /* struct_vst_event-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = "struct_vst_event-members.html"; sourceTree = "<group>"; };
+		24A2FF580F90D1DC003BB5A7 /* struct_vst_event.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = struct_vst_event.html; sourceTree = "<group>"; };
+		24A2FF590F90D1DD003BB5A7 /* struct_vst_events-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = "struct_vst_events-members.html"; sourceTree = "<group>"; };
+		24A2FF5A0F90D1DD003BB5A7 /* struct_vst_events.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = struct_vst_events.html; sourceTree = "<group>"; };
+		24A2FF5B0F90D1DD003BB5A7 /* struct_vst_file_select-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = "struct_vst_file_select-members.html"; sourceTree = "<group>"; };
+		24A2FF5C0F90D1DD003BB5A7 /* struct_vst_file_select.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = struct_vst_file_select.html; sourceTree = "<group>"; };
+		24A2FF5D0F90D1DD003BB5A7 /* struct_vst_file_type-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = "struct_vst_file_type-members.html"; sourceTree = "<group>"; };
+		24A2FF5E0F90D1DD003BB5A7 /* struct_vst_file_type.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = struct_vst_file_type.html; sourceTree = "<group>"; };
+		24A2FF5F0F90D1DD003BB5A7 /* struct_vst_key_code-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = "struct_vst_key_code-members.html"; sourceTree = "<group>"; };
+		24A2FF600F90D1DD003BB5A7 /* struct_vst_key_code.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = struct_vst_key_code.html; sourceTree = "<group>"; };
+		24A2FF610F90D1DD003BB5A7 /* struct_vst_midi_event-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = "struct_vst_midi_event-members.html"; sourceTree = "<group>"; };
+		24A2FF620F90D1DD003BB5A7 /* struct_vst_midi_event.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = struct_vst_midi_event.html; sourceTree = "<group>"; };
+		24A2FF630F90D1DD003BB5A7 /* struct_vst_midi_sysex_event-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = "struct_vst_midi_sysex_event-members.html"; sourceTree = "<group>"; };
+		24A2FF640F90D1DD003BB5A7 /* struct_vst_midi_sysex_event.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = struct_vst_midi_sysex_event.html; sourceTree = "<group>"; };
+		24A2FF650F90D1DD003BB5A7 /* struct_vst_offline_task-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = "struct_vst_offline_task-members.html"; sourceTree = "<group>"; };
+		24A2FF660F90D1DD003BB5A7 /* struct_vst_offline_task.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = struct_vst_offline_task.html; sourceTree = "<group>"; };
+		24A2FF670F90D1DD003BB5A7 /* struct_vst_parameter_properties-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = "struct_vst_parameter_properties-members.html"; sourceTree = "<group>"; };
+		24A2FF680F90D1DD003BB5A7 /* struct_vst_parameter_properties.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = struct_vst_parameter_properties.html; sourceTree = "<group>"; };
+		24A2FF690F90D1DD003BB5A7 /* struct_vst_patch_chunk_info-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = "struct_vst_patch_chunk_info-members.html"; sourceTree = "<group>"; };
+		24A2FF6A0F90D1DD003BB5A7 /* struct_vst_patch_chunk_info.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = struct_vst_patch_chunk_info.html; sourceTree = "<group>"; };
+		24A2FF6B0F90D1DD003BB5A7 /* struct_vst_pin_properties-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = "struct_vst_pin_properties-members.html"; sourceTree = "<group>"; };
+		24A2FF6C0F90D1DD003BB5A7 /* struct_vst_pin_properties.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = struct_vst_pin_properties.html; sourceTree = "<group>"; };
+		24A2FF6D0F90D1DD003BB5A7 /* struct_vst_speaker_arrangement-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = "struct_vst_speaker_arrangement-members.html"; sourceTree = "<group>"; };
+		24A2FF6E0F90D1DD003BB5A7 /* struct_vst_speaker_arrangement.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = struct_vst_speaker_arrangement.html; sourceTree = "<group>"; };
+		24A2FF6F0F90D1DD003BB5A7 /* struct_vst_speaker_properties-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = "struct_vst_speaker_properties-members.html"; sourceTree = "<group>"; };
+		24A2FF700F90D1DD003BB5A7 /* struct_vst_speaker_properties.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = struct_vst_speaker_properties.html; sourceTree = "<group>"; };
+		24A2FF710F90D1DD003BB5A7 /* struct_vst_time_info-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = "struct_vst_time_info-members.html"; sourceTree = "<group>"; };
+		24A2FF720F90D1DD003BB5A7 /* struct_vst_time_info.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = struct_vst_time_info.html; sourceTree = "<group>"; };
+		24A2FF730F90D1DD003BB5A7 /* struct_vst_variable_io-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = "struct_vst_variable_io-members.html"; sourceTree = "<group>"; };
+		24A2FF740F90D1DD003BB5A7 /* struct_vst_variable_io.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = struct_vst_variable_io.html; sourceTree = "<group>"; };
+		24A2FF750F90D1DD003BB5A7 /* struct_vst_window-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = "struct_vst_window-members.html"; sourceTree = "<group>"; };
+		24A2FF760F90D1DD003BB5A7 /* struct_vst_window.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = struct_vst_window.html; sourceTree = "<group>"; };
+		24A2FF770F90D1DD003BB5A7 /* structfx_bank-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = "structfx_bank-members.html"; sourceTree = "<group>"; };
+		24A2FF780F90D1DD003BB5A7 /* structfx_bank.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = structfx_bank.html; sourceTree = "<group>"; };
+		24A2FF790F90D1DD003BB5A7 /* structfx_program-members.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = "structfx_program-members.html"; sourceTree = "<group>"; };
+		24A2FF7A0F90D1DD003BB5A7 /* structfx_program.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = structfx_program.html; sourceTree = "<group>"; };
+		24A2FF7B0F90D1DD003BB5A7 /* tab_b.gif */ = {isa = PBXFileReference; lastKnownFileType = image.gif; path = tab_b.gif; sourceTree = "<group>"; };
+		24A2FF7C0F90D1DD003BB5A7 /* tab_l.gif */ = {isa = PBXFileReference; lastKnownFileType = image.gif; path = tab_l.gif; sourceTree = "<group>"; };
+		24A2FF7D0F90D1DD003BB5A7 /* tab_r.gif */ = {isa = PBXFileReference; lastKnownFileType = image.gif; path = tab_r.gif; sourceTree = "<group>"; };
+		24A2FF7E0F90D1DD003BB5A7 /* tabs.css */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.css; path = tabs.css; sourceTree = "<group>"; };
+		24A2FF7F0F90D1DD003BB5A7 /* Termination.gif */ = {isa = PBXFileReference; lastKnownFileType = image.gif; path = Termination.gif; sourceTree = "<group>"; };
+		24A2FF800F90D1DD003BB5A7 /* thanks.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = thanks.html; sourceTree = "<group>"; };
+		24A2FF810F90D1DD003BB5A7 /* tree.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = tree.html; sourceTree = "<group>"; };
+		24A2FF820F90D1DD003BB5A7 /* TurnOff.gif */ = {isa = PBXFileReference; lastKnownFileType = image.gif; path = TurnOff.gif; sourceTree = "<group>"; };
+		24A2FF830F90D1DD003BB5A7 /* TurnOn.gif */ = {isa = PBXFileReference; lastKnownFileType = image.gif; path = TurnOn.gif; sourceTree = "<group>"; };
+		24A2FF840F90D1DD003BB5A7 /* vstfxstore_8h.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = vstfxstore_8h.html; sourceTree = "<group>"; };
+		24A2FF850F90D1DD003BB5A7 /* vstoffline.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = vstoffline.html; sourceTree = "<group>"; };
+		24A2FF860F90D1DD003BB5A7 /* vstparamstruct.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = vstparamstruct.html; sourceTree = "<group>"; };
+		24A2FF870F90D1DD003BB5A7 /* vstpluglogo.jpg */ = {isa = PBXFileReference; lastKnownFileType = image.jpeg; path = vstpluglogo.jpg; sourceTree = "<group>"; };
+		24A2FF880F90D1DD003BB5A7 /* vstplugmain_8cpp.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = vstplugmain_8cpp.html; sourceTree = "<group>"; };
+		24A2FF890F90D1DD003BB5A7 /* whatsnew.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = whatsnew.html; sourceTree = "<group>"; };
+		24A2FF8A0F90D1DD003BB5A7 /* sdk.menu.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = sdk.menu.html; sourceTree = "<group>"; };
+		24A2FF8B0F90D1DD003BB5A7 /* sdk.overview.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = sdk.overview.html; sourceTree = "<group>"; };
+		24A2FF8C0F90D1DD003BB5A7 /* sdkdoc.css */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.css; path = sdkdoc.css; sourceTree = "<group>"; };
+		24A2FF8D0F90D1DD003BB5A7 /* VST Licensing Agreement.rtf */ = {isa = PBXFileReference; lastKnownFileType = text.rtf; path = "VST Licensing Agreement.rtf"; sourceTree = "<group>"; };
+		24A2FF8E0F90D1DD003BB5A7 /* index.html */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.html; path = index.html; sourceTree = "<group>"; };
+		24A2FF910F90D1DD003BB5A7 /* aeffect.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = aeffect.h; sourceTree = "<group>"; };
+		24A2FF920F90D1DD003BB5A7 /* aeffectx.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = aeffectx.h; sourceTree = "<group>"; };
+		24A2FF930F90D1DD003BB5A7 /* vstfxstore.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = vstfxstore.h; sourceTree = "<group>"; };
+		24A2FF980F90D1DD003BB5A7 /* adelay.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = adelay.cpp; sourceTree = "<group>"; };
+		24A2FF990F90D1DD003BB5A7 /* adelay.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = adelay.h; sourceTree = "<group>"; };
+		24A2FF9A0F90D1DD003BB5A7 /* adelaymain.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = adelaymain.cpp; sourceTree = "<group>"; };
+		24A2FF9D0F90D1DD003BB5A7 /* bmp00128.bmp */ = {isa = PBXFileReference; lastKnownFileType = image.bmp; path = bmp00128.bmp; sourceTree = "<group>"; };
+		24A2FF9E0F90D1DD003BB5A7 /* bmp00129.bmp */ = {isa = PBXFileReference; lastKnownFileType = image.bmp; path = bmp00129.bmp; sourceTree = "<group>"; };
+		24A2FF9F0F90D1DD003BB5A7 /* bmp00130.bmp */ = {isa = PBXFileReference; lastKnownFileType = image.bmp; path = bmp00130.bmp; sourceTree = "<group>"; };
+		24A2FFA00F90D1DD003BB5A7 /* surrounddelay.rc */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = surrounddelay.rc; sourceTree = "<group>"; };
+		24A2FFA10F90D1DD003BB5A7 /* sdeditor.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = sdeditor.cpp; sourceTree = "<group>"; };
+		24A2FFA20F90D1DD003BB5A7 /* sdeditor.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = sdeditor.h; sourceTree = "<group>"; };
+		24A2FFA30F90D1DD003BB5A7 /* surrounddelay.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = surrounddelay.cpp; sourceTree = "<group>"; };
+		24A2FFA40F90D1DD003BB5A7 /* surrounddelay.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = surrounddelay.h; sourceTree = "<group>"; };
+		24A2FFA60F90D1DD003BB5A7 /* adelay.vcproj */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xml; path = adelay.vcproj; sourceTree = "<group>"; };
+		24A2FFA70F90D1DD003BB5A7 /* surrounddelay.vcproj */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xml; path = surrounddelay.vcproj; sourceTree = "<group>"; };
+		24A2FFAA0F90D1DD003BB5A7 /* again.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = again.cpp; sourceTree = "<group>"; };
+		24A2FFAB0F90D1DD003BB5A7 /* again.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = again.h; sourceTree = "<group>"; };
+		24A2FFAD0F90D1DD003BB5A7 /* again.vcproj */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xml; path = again.vcproj; sourceTree = "<group>"; };
+		24A2FFAF0F90D1DD003BB5A7 /* minihost-Info.plist */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.plist.xml; path = "minihost-Info.plist"; sourceTree = "<group>"; };
+		24A2FFB00F90D1DD003BB5A7 /* vst 2.4 examples.xcodeproj */ = {isa = PBXFileReference; lastKnownFileType = "wrapper.pb-project"; path = "vst 2.4 examples.xcodeproj"; sourceTree = "<group>"; };
+		24A2FFB30F90D1DD003BB5A7 /* vst2.4Info.plist */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.plist.xml; path = vst2.4Info.plist; sourceTree = "<group>"; };
+		24A2FFB60F90D1DD003BB5A7 /* minieditor.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = minieditor.cpp; sourceTree = "<group>"; };
+		24A2FFB70F90D1DD003BB5A7 /* minihost.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = minihost.cpp; sourceTree = "<group>"; };
+		24A2FFB90F90D1DD003BB5A7 /* minihost.vcproj */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xml; path = minihost.vcproj; sourceTree = "<group>"; };
+		24A2FFBC0F90D1DD003BB5A7 /* vstxsynth.rc */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = vstxsynth.rc; sourceTree = "<group>"; };
+		24A2FFBD0F90D1DD003BB5A7 /* vstxsynth.vstxml */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = vstxsynth.vstxml; sourceTree = "<group>"; };
+		24A2FFBF0F90D1DD003BB5A7 /* gmnames.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = gmnames.h; sourceTree = "<group>"; };
+		24A2FFC00F90D1DD003BB5A7 /* vstxsynth.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = vstxsynth.cpp; sourceTree = "<group>"; };
+		24A2FFC10F90D1DD003BB5A7 /* vstxsynth.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = vstxsynth.h; sourceTree = "<group>"; };
+		24A2FFC20F90D1DD003BB5A7 /* vstxsynthproc.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = vstxsynthproc.cpp; sourceTree = "<group>"; };
+		24A2FFC40F90D1DD003BB5A7 /* vstxsynth.vcproj */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xml; path = vstxsynth.vcproj; sourceTree = "<group>"; };
+		24A2FFC60F90D1DD003BB5A7 /* samples.sln */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = samples.sln; sourceTree = "<group>"; };
+		24A2FFC70F90D1DD003BB5A7 /* vstplug.def */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = vstplug.def; sourceTree = "<group>"; };
+		24A2FFC90F90D1DD003BB5A7 /* adelay.vcproj */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xml; path = adelay.vcproj; sourceTree = "<group>"; };
+		24A2FFCA0F90D1DD003BB5A7 /* again.vcproj */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xml; path = again.vcproj; sourceTree = "<group>"; };
+		24A2FFCB0F90D1DD003BB5A7 /* minihost.vcproj */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xml; path = minihost.vcproj; sourceTree = "<group>"; };
+		24A2FFCC0F90D1DD003BB5A7 /* samples.sln */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = samples.sln; sourceTree = "<group>"; };
+		24A2FFCD0F90D1DD003BB5A7 /* surrounddelay.vcproj */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xml; path = surrounddelay.vcproj; sourceTree = "<group>"; };
+		24A2FFCE0F90D1DD003BB5A7 /* vstxsynth.vcproj */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xml; path = vstxsynth.vcproj; sourceTree = "<group>"; };
+		24A2FFD00F90D1DD003BB5A7 /* adelay.dsp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = adelay.dsp; sourceTree = "<group>"; };
+		24A2FFD10F90D1DD003BB5A7 /* again.dsp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = again.dsp; sourceTree = "<group>"; };
+		24A2FFD20F90D1DD003BB5A7 /* minihost.dsp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = minihost.dsp; sourceTree = "<group>"; };
+		24A2FFD30F90D1DD003BB5A7 /* samples.dsw */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = samples.dsw; sourceTree = "<group>"; };
+		24A2FFD40F90D1DD003BB5A7 /* surrounddelay.dsp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = surrounddelay.dsp; sourceTree = "<group>"; };
+		24A2FFD50F90D1DD003BB5A7 /* vstxsynth.dsp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = vstxsynth.dsp; sourceTree = "<group>"; };
+		24A2FFD80F90D1DD003BB5A7 /* aeffeditor.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = aeffeditor.h; sourceTree = "<group>"; };
+		24A2FFD90F90D1DD003BB5A7 /* audioeffect.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = audioeffect.cpp; sourceTree = "<group>"; };
+		24A2FFDA0F90D1DD003BB5A7 /* audioeffect.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = audioeffect.h; sourceTree = "<group>"; };
+		24A2FFDB0F90D1DD003BB5A7 /* audioeffectx.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = audioeffectx.cpp; sourceTree = "<group>"; };
+		24A2FFDC0F90D1DD003BB5A7 /* audioeffectx.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = audioeffectx.h; sourceTree = "<group>"; };
+		24A2FFDD0F90D1DD003BB5A7 /* vstplugmain.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = vstplugmain.cpp; sourceTree = "<group>"; };
+		24A2FFE10F90D1DD003BB5A7 /* audiounit.exp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.exports; path = audiounit.exp; sourceTree = "<group>"; };
+		24A2FFE20F90D1DD003BB5A7 /* cw_vst_prefix.pch++ */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.h; path = "cw_vst_prefix.pch++"; sourceTree = "<group>"; };
+		24A2FFE30F90D1DD003BB5A7 /* drawtest.cw9prj */ = {isa = PBXFileReference; lastKnownFileType = file; path = drawtest.cw9prj; sourceTree = "<group>"; };
+		24A2FFE40F90D1DD003BB5A7 /* drawtest.plc */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; path = drawtest.plc; sourceTree = "<group>"; };
+		24A2FFE50F90D1DD003BB5A7 /* drawtest.xcode */ = {isa = PBXFileReference; lastKnownFileType = "wrapper.pb-project"; path = drawtest.xcode; sourceTree = "<group>"; };
+		24A2FFE80F90D1DD003BB5A7 /* drawtest.xcodeproj */ = {isa = PBXFileReference; lastKnownFileType = "wrapper.pb-project"; path = drawtest.xcodeproj; sourceTree = "<group>"; };
+		24A2FFEB0F90D1DD003BB5A7 /* Info.plist */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.plist.xml; path = Info.plist; sourceTree = "<group>"; };
+		24A2FFEC0F90D1DD003BB5A7 /* xcode_au_prefix.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = xcode_au_prefix.h; sourceTree = "<group>"; };
+		24A2FFED0F90D1DD003BB5A7 /* xcode_vst_prefix.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = xcode_vst_prefix.h; sourceTree = "<group>"; };
+		24A2FFEF0F90D1DD003BB5A7 /* audiounit.r */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.rez; path = audiounit.r; sourceTree = "<group>"; };
+		24A2FFF00F90D1DD003BB5A7 /* bmp00001.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = bmp00001.png; sourceTree = "<group>"; };
+		24A2FFF10F90D1DD003BB5A7 /* bmp00100.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = bmp00100.png; sourceTree = "<group>"; };
+		24A2FFF20F90D1DD003BB5A7 /* bmp01000.png */ = {isa = PBXFileReference; lastKnownFileType = image.png; path = bmp01000.png; sourceTree = "<group>"; };
+		24A2FFF30F90D1DD003BB5A7 /* bmp10001.bmp */ = {isa = PBXFileReference; lastKnownFileType = image.bmp; path = bmp10001.bmp; sourceTree = "<group>"; };
+		24A2FFF40F90D1DD003BB5A7 /* bmp10002.bmp */ = {isa = PBXFileReference; lastKnownFileType = image.bmp; path = bmp10002.bmp; sourceTree = "<group>"; };
+		24A2FFF50F90D1DD003BB5A7 /* bmp10003.bmp */ = {isa = PBXFileReference; lastKnownFileType = image.bmp; path = bmp10003.bmp; sourceTree = "<group>"; };
+		24A2FFF60F90D1DD003BB5A7 /* bmp10004.bmp */ = {isa = PBXFileReference; lastKnownFileType = image.bmp; path = bmp10004.bmp; sourceTree = "<group>"; };
+		24A2FFF70F90D1DD003BB5A7 /* bmp10005.bmp */ = {isa = PBXFileReference; lastKnownFileType = image.bmp; path = bmp10005.bmp; sourceTree = "<group>"; };
+		24A2FFF80F90D1DD003BB5A7 /* bmp10006.bmp */ = {isa = PBXFileReference; lastKnownFileType = image.bmp; path = bmp10006.bmp; sourceTree = "<group>"; };
+		24A2FFF90F90D1DD003BB5A7 /* bmp10007.bmp */ = {isa = PBXFileReference; lastKnownFileType = image.bmp; path = bmp10007.bmp; sourceTree = "<group>"; };
+		24A2FFFA0F90D1DD003BB5A7 /* bmp10008.bmp */ = {isa = PBXFileReference; lastKnownFileType = image.bmp; path = bmp10008.bmp; sourceTree = "<group>"; };
+		24A2FFFB0F90D1DD003BB5A7 /* bmp10009.bmp */ = {isa = PBXFileReference; lastKnownFileType = image.bmp; path = bmp10009.bmp; sourceTree = "<group>"; };
+		24A2FFFC0F90D1DD003BB5A7 /* bmp10010.bmp */ = {isa = PBXFileReference; lastKnownFileType = image.bmp; path = bmp10010.bmp; sourceTree = "<group>"; };
+		24A2FFFD0F90D1DD003BB5A7 /* bmp10011.bmp */ = {isa = PBXFileReference; lastKnownFileType = image.bmp; path = bmp10011.bmp; sourceTree = "<group>"; };
+		24A2FFFE0F90D1DD003BB5A7 /* bmp10012.bmp */ = {isa = PBXFileReference; lastKnownFileType = image.bmp; path = bmp10012.bmp; sourceTree = "<group>"; };
+		24A2FFFF0F90D1DD003BB5A7 /* bmp10013.bmp */ = {isa = PBXFileReference; lastKnownFileType = image.bmp; path = bmp10013.bmp; sourceTree = "<group>"; };
+		24CFB70307E7A0220081BD57 /* PkgInfo */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text; name = PkgInfo; path = mac/PkgInfo; sourceTree = "<group>"; };
+		24D8286F09A914000093AEF8 /* PocketVerbsProc.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = PocketVerbsProc.cpp; path = source/PocketVerbsProc.cpp; sourceTree = "<group>"; };
+		24D8287E09A9164A0093AEF8 /* xcode_vst_prefix.h */ = {isa = PBXFileReference; fileEncoding = 30; lastKnownFileType = sourcecode.c.h; name = xcode_vst_prefix.h; path = mac/xcode_vst_prefix.h; sourceTree = SOURCE_ROOT; };
+		8D01CCD10486CAD60068D4B7 /* Info.plist */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.plist.xml; name = Info.plist; path = mac/Info.plist; sourceTree = "<group>"; };
+/* End PBXFileReference section */
+
+/* Begin PBXGroup section */
+		089C166AFE841209C02AAC07 /* FM-Chopper */ = {
+			isa = PBXGroup;
+			children = (
+				089C1671FE841209C02AAC07 /* External Frameworks and Libraries */,
+				19C28FB4FE9D528D11CA2CBB /* Products */,
+				089C167CFE841241C02AAC07 /* Resources */,
+				08FB77ADFE841716C02AAC07 /* Source */,
+				24A2FEBB0F90D1DB003BB5A7 /* vstsdk2.4 */,
+			);
+			name = "FM-Chopper";
+			sourceTree = "<group>";
+		};
+		089C1671FE841209C02AAC07 /* External Frameworks and Libraries */ = {
+			isa = PBXGroup;
+			children = (
+				2434720A098313350063BBF1 /* QuickTime.framework */,
+				08EA7FFBFE8413EDC02AAC07 /* Carbon.framework */,
+			);
+			name = "External Frameworks and Libraries";
+			sourceTree = "<group>";
+		};
+		089C167CFE841241C02AAC07 /* Resources */ = {
+			isa = PBXGroup;
+			children = (
+				24D8287E09A9164A0093AEF8 /* xcode_vst_prefix.h */,
+				24CFB70307E7A0220081BD57 /* PkgInfo */,
+				8D01CCD10486CAD60068D4B7 /* Info.plist */,
+			);
+			name = Resources;
+			sourceTree = "<group>";
+		};
+		08FB77ADFE841716C02AAC07 /* Source */ = {
+			isa = PBXGroup;
+			children = (
+				2407DEB6089929BA00EB68BF /* PocketVerbs.cpp */,
+				24D8286F09A914000093AEF8 /* PocketVerbsProc.cpp */,
+				245463B80991757100464AD3 /* PocketVerbs.h */,
+			);
+			name = Source;
+			sourceTree = "<group>";
+		};
+		19C28FB4FE9D528D11CA2CBB /* Products */ = {
+			isa = PBXGroup;
+			children = (
+				2407DE920899296600EB68BF /* PocketVerbs.vst */,
+			);
+			name = Products;
+			sourceTree = "<group>";
+		};
+		24A200030F90D1DD003BB5A7 /* source */ = {
+			isa = PBXGroup;
+			children = (
+				24A200040F90D1DD003BB5A7 /* controlsgui.cpp */,
+				24A200050F90D1DD003BB5A7 /* controlsgui.h */,
+				24A200060F90D1DD003BB5A7 /* pdrawtesteditor.cpp */,
+				24A200070F90D1DD003BB5A7 /* pdrawtesteditor.h */,
+				24A200080F90D1DD003BB5A7 /* pdrawtesteffect.cpp */,
+				24A200090F90D1DD003BB5A7 /* pdrawtesteffect.h */,
+				24A2000A0F90D1DD003BB5A7 /* pdrawtestmain.cpp */,
+				24A2000B0F90D1DD003BB5A7 /* pdrawtestview.cpp */,
+				24A2000C0F90D1DD003BB5A7 /* pdrawtestview.h */,
+				24A2000D0F90D1DD003BB5A7 /* pprimitivesviews.cpp */,
+				24A2000E0F90D1DD003BB5A7 /* pprimitivesviews.h */,
+			);
+			name = source;
+			path = /vstsdk2.4/vstgui.sf/drawtest/source;
+			sourceTree = "<absolute>";
+		};
+		24A2000F0F90D1DD003BB5A7 /* win */ = {
+			isa = PBXGroup;
+			children = (
+				24A200100F90D1DD003BB5A7 /* drawtest.def */,
+				24A200110F90D1DD003BB5A7 /* drawtest.rc */,
+				24A200120F90D1DD003BB5A7 /* drawtest.vcproj */,
+			);
+			name = win;
+			path = /vstsdk2.4/vstgui.sf/drawtest/win;
+			sourceTree = "<absolute>";
+		};
+		24A200130F90D1DD003BB5A7 /* win.vc6 */ = {
+			isa = PBXGroup;
+			children = (
+				24A200140F90D1DD003BB5A7 /* drawtest.dsp */,
+				24A200150F90D1DD003BB5A7 /* drawtest.dsw */,
+			);
+			name = win.vc6;
+			path = /vstsdk2.4/vstgui.sf/drawtest/win.vc6;
+			sourceTree = "<absolute>";
+		};
+		24A200160F90D1DD003BB5A7 /* vstgui */ = {
+			isa = PBXGroup;
+			children = (
+				24A200170F90D1DD003BB5A7 /* aeffguieditor.cpp */,
+				24A200180F90D1DD003BB5A7 /* aeffguieditor.h */,
+				24A200190F90D1DD003BB5A7 /* cfileselector.cpp */,
+				24A2001A0F90D1DD003BB5A7 /* cfileselector.h */,
+				24A2001B0F90D1DD003BB5A7 /* Changelog */,
+				24A2001C0F90D1DD003BB5A7 /* cscrollview.cpp */,
+				24A2001D0F90D1DD003BB5A7 /* cscrollview.h */,
+				24A2001E0F90D1DD003BB5A7 /* ctabview.cpp */,
+				24A2001F0F90D1DD003BB5A7 /* ctabview.h */,
+				24A200200F90D1DD003BB5A7 /* Documentation */,
+				24A201460F90D1DE003BB5A7 /* plugguieditor.cpp */,
+				24A201470F90D1DE003BB5A7 /* plugguieditor.h */,
+				24A201480F90D1DE003BB5A7 /* vstcontrols.cpp */,
+				24A201490F90D1DE003BB5A7 /* vstcontrols.h */,
+				24A2014A0F90D1DE003BB5A7 /* vstgui.cpp */,
+				24A2014B0F90D1DE003BB5A7 /* vstgui.h */,
+				24A2014C0F90D1DE003BB5A7 /* vstkeycode.h */,
+				24A2014D0F90D1DE003BB5A7 /* vstplugscarbon.h */,
+				24A2014E0F90D1DE003BB5A7 /* vstplugsmac.h */,
+				24A2014F0F90D1DE003BB5A7 /* vstplugsmacho.h */,
+				24A201500F90D1DE003BB5A7 /* vstplugsquartz.h */,
+			);
+			name = vstgui;
+			path = /vstsdk2.4/vstgui.sf/vstgui;
+			sourceTree = "<absolute>";
+		};
+		24A200200F90D1DD003BB5A7 /* Documentation */ = {
+			isa = PBXGroup;
+			children = (
+				24A200210F90D1DD003BB5A7 /* html */,
+				24A201440F90D1DE003BB5A7 /* index.html */,
+				24A201450F90D1DE003BB5A7 /* Migrating from 2.3.rtf */,
+			);
+			name = Documentation;
+			path = /vstsdk2.4/vstgui.sf/vstgui/Documentation;
+			sourceTree = "<absolute>";
+		};
+		24A200210F90D1DD003BB5A7 /* html */ = {
+			isa = PBXGroup;
+			children = (
+				24A200220F90D1DD003BB5A7 /* aeffguieditor_8cpp.html */,
+				24A200230F90D1DD003BB5A7 /* aeffguieditor_8h.html */,
+				24A200240F90D1DD003BB5A7 /* annotated.html */,
+				24A200250F90D1DD003BB5A7 /* cfileselector_8cpp.html */,
+				24A200260F90D1DD003BB5A7 /* cfileselector_8h.html */,
+				24A200270F90D1DD003BB5A7 /* class_a_eff_g_u_i_editor-members.html */,
+				24A200280F90D1DD003BB5A7 /* class_a_eff_g_u_i_editor.html */,
+				24A200290F90D1DD003BB5A7 /* class_c_anim_knob-members.html */,
+				24A2002A0F90D1DD003BB5A7 /* class_c_anim_knob.html */,
+				24A2002B0F90D1DD003BB5A7 /* class_c_anim_knob.png */,
+				24A2002C0F90D1DD003BB5A7 /* class_c_attribute_list_entry-members.html */,
+				24A2002D0F90D1DD003BB5A7 /* class_c_attribute_list_entry.html */,
+				24A2002E0F90D1DD003BB5A7 /* class_c_auto_animation-members.html */,
+				24A2002F0F90D1DD003BB5A7 /* class_c_auto_animation.html */,
+				24A200300F90D1DD003BB5A7 /* class_c_auto_animation.png */,
+				24A200310F90D1DD003BB5A7 /* class_c_bitmap-members.html */,
+				24A200320F90D1DD003BB5A7 /* class_c_bitmap.html */,
+				24A200330F90D1DD003BB5A7 /* class_c_bitmap.png */,
+				24A200340F90D1DD003BB5A7 /* class_c_c_view-members.html */,
+				24A200350F90D1DD003BB5A7 /* class_c_c_view.html */,
+				24A200360F90D1DD003BB5A7 /* class_c_control-members.html */,
+				24A200370F90D1DD003BB5A7 /* class_c_control.html */,
+				24A200380F90D1DD003BB5A7 /* class_c_control.png */,
+				24A200390F90D1DD003BB5A7 /* class_c_control_listener-members.html */,
+				24A2003A0F90D1DD003BB5A7 /* class_c_control_listener.html */,
+				24A2003B0F90D1DD003BB5A7 /* class_c_control_listener.png */,
+				24A2003C0F90D1DD003BB5A7 /* class_c_drag_container-members.html */,
+				24A2003D0F90D1DD003BB5A7 /* class_c_drag_container.html */,
+				24A2003E0F90D1DD003BB5A7 /* class_c_drag_container.png */,
+				24A2003F0F90D1DD003BB5A7 /* class_c_draw_context-members.html */,
+				24A200400F90D1DD003BB5A7 /* class_c_draw_context.html */,
+				24A200410F90D1DD003BB5A7 /* class_c_draw_context.png */,
+				24A200420F90D1DD003BB5A7 /* class_c_file_selector-members.html */,
+				24A200430F90D1DD003BB5A7 /* class_c_file_selector.html */,
+				24A200440F90D1DD003BB5A7 /* class_c_frame-members.html */,
+				24A200450F90D1DD003BB5A7 /* class_c_frame.html */,
+				24A200460F90D1DD003BB5A7 /* class_c_frame.png */,
+				24A200470F90D1DD003BB5A7 /* class_c_horizontal_slider-members.html */,
+				24A200480F90D1DD003BB5A7 /* class_c_horizontal_slider.html */,
+				24A200490F90D1DD003BB5A7 /* class_c_horizontal_slider.png */,
+				24A2004A0F90D1DD003BB5A7 /* class_c_horizontal_switch-members.html */,
+				24A2004B0F90D1DD003BB5A7 /* class_c_horizontal_switch.html */,
+				24A2004C0F90D1DD003BB5A7 /* class_c_horizontal_switch.png */,
+				24A2004D0F90D1DD003BB5A7 /* class_c_kick_button-members.html */,
+				24A2004E0F90D1DD003BB5A7 /* class_c_kick_button.html */,
+				24A2004F0F90D1DD003BB5A7 /* class_c_kick_button.png */,
+				24A200500F90D1DD003BB5A7 /* class_c_knob-members.html */,
+				24A200510F90D1DD003BB5A7 /* class_c_knob.html */,
+				24A200520F90D1DD003BB5A7 /* class_c_knob.png */,
+				24A200530F90D1DD003BB5A7 /* class_c_movie_bitmap-members.html */,
+				24A200540F90D1DD003BB5A7 /* class_c_movie_bitmap.html */,
+				24A200550F90D1DD003BB5A7 /* class_c_movie_bitmap.png */,
+				24A200560F90D1DD003BB5A7 /* class_c_movie_button-members.html */,
+				24A200570F90D1DD003BB5A7 /* class_c_movie_button.html */,
+				24A200580F90D1DD003BB5A7 /* class_c_movie_button.png */,
+				24A200590F90D1DD003BB5A7 /* class_c_offscreen_context-members.html */,
+				24A2005A0F90D1DD003BB5A7 /* class_c_offscreen_context.html */,
+				24A2005B0F90D1DD003BB5A7 /* class_c_offscreen_context.png */,
+				24A2005C0F90D1DD003BB5A7 /* class_c_on_off_button-members.html */,
+				24A2005D0F90D1DD003BB5A7 /* class_c_on_off_button.html */,
+				24A2005E0F90D1DD003BB5A7 /* class_c_on_off_button.png */,
+				24A2005F0F90D1DD003BB5A7 /* class_c_option_menu-members.html */,
+				24A200600F90D1DD003BB5A7 /* class_c_option_menu.html */,
+				24A200610F90D1DD003BB5A7 /* class_c_option_menu.png */,
+				24A200620F90D1DD003BB5A7 /* class_c_option_menu_scheme-members.html */,
+				24A200630F90D1DD003BB5A7 /* class_c_option_menu_scheme.html */,
+				24A200640F90D1DD003BB5A7 /* class_c_option_menu_scheme.png */,
+				24A200650F90D1DD003BB5A7 /* class_c_param_display-members.html */,
+				24A200660F90D1DD003BB5A7 /* class_c_param_display.html */,
+				24A200670F90D1DD003BB5A7 /* class_c_param_display.png */,
+				24A200680F90D1DD003BB5A7 /* class_c_reference_counter-members.html */,
+				24A200690F90D1DD003BB5A7 /* class_c_reference_counter.html */,
+				24A2006A0F90D1DD003BB5A7 /* class_c_reference_counter.png */,
+				24A2006B0F90D1DD003BB5A7 /* class_c_rocker_switch-members.html */,
+				24A2006C0F90D1DD003BB5A7 /* class_c_rocker_switch.html */,
+				24A2006D0F90D1DD003BB5A7 /* class_c_rocker_switch.png */,
+				24A2006E0F90D1DD003BB5A7 /* class_c_scroll_container-members.html */,
+				24A2006F0F90D1DD003BB5A7 /* class_c_scroll_container.html */,
+				24A200700F90D1DD003BB5A7 /* class_c_scroll_container.png */,
+				24A200710F90D1DD003BB5A7 /* class_c_scroll_view-members.html */,
+				24A200720F90D1DD003BB5A7 /* class_c_scroll_view.html */,
+				24A200730F90D1DD003BB5A7 /* class_c_scroll_view.png */,
+				24A200740F90D1DD003BB5A7 /* class_c_scrollbar-members.html */,
+				24A200750F90D1DD003BB5A7 /* class_c_scrollbar.html */,
+				24A200760F90D1DD003BB5A7 /* class_c_scrollbar.png */,
+				24A200770F90D1DD003BB5A7 /* class_c_slider-members.html */,
+				24A200780F90D1DD003BB5A7 /* class_c_slider.html */,
+				24A200790F90D1DD003BB5A7 /* class_c_slider.png */,
+				24A2007A0F90D1DD003BB5A7 /* class_c_special_digit-members.html */,
+				24A2007B0F90D1DD003BB5A7 /* class_c_special_digit.html */,
+				24A2007C0F90D1DD003BB5A7 /* class_c_special_digit.png */,
+				24A2007D0F90D1DD003BB5A7 /* class_c_splash_screen-members.html */,
+				24A2007E0F90D1DD003BB5A7 /* class_c_splash_screen.html */,
+				24A2007F0F90D1DD003BB5A7 /* class_c_splash_screen.png */,
+				24A200800F90D1DD003BB5A7 /* class_c_splash_screen_view-members.html */,
+				24A200810F90D1DD003BB5A7 /* class_c_splash_screen_view.html */,
+				24A200820F90D1DD003BB5A7 /* class_c_splash_screen_view.png */,
+				24A200830F90D1DD003BB5A7 /* class_c_tab_button-members.html */,
+				24A200840F90D1DD003BB5A7 /* class_c_tab_button.html */,
+				24A200850F90D1DD003BB5A7 /* class_c_tab_button.png */,
+				24A200860F90D1DD003BB5A7 /* class_c_tab_child_view-members.html */,
+				24A200870F90D1DD003BB5A7 /* class_c_tab_child_view.html */,
+				24A200880F90D1DD003BB5A7 /* class_c_tab_child_view.png */,
+				24A200890F90D1DD003BB5A7 /* class_c_tab_view-members.html */,
+				24A2008A0F90D1DD003BB5A7 /* class_c_tab_view.html */,
+				24A2008B0F90D1DD003BB5A7 /* class_c_tab_view.png */,
+				24A2008C0F90D1DD003BB5A7 /* class_c_text_edit-members.html */,
+				24A2008D0F90D1DD003BB5A7 /* class_c_text_edit.html */,
+				24A2008E0F90D1DD003BB5A7 /* class_c_text_edit.png */,
+				24A2008F0F90D1DD003BB5A7 /* class_c_text_label-members.html */,
+				24A200900F90D1DD003BB5A7 /* class_c_text_label.html */,
+				24A200910F90D1DD003BB5A7 /* class_c_text_label.png */,
+				24A200920F90D1DD003BB5A7 /* class_c_vertical_slider-members.html */,
+				24A200930F90D1DD003BB5A7 /* class_c_vertical_slider.html */,
+				24A200940F90D1DD003BB5A7 /* class_c_vertical_slider.png */,
+				24A200950F90D1DD003BB5A7 /* class_c_vertical_switch-members.html */,
+				24A200960F90D1DD003BB5A7 /* class_c_vertical_switch.html */,
+				24A200970F90D1DD003BB5A7 /* class_c_vertical_switch.png */,
+				24A200980F90D1DD003BB5A7 /* class_c_view-members.html */,
+				24A200990F90D1DD003BB5A7 /* class_c_view.html */,
+				24A2009A0F90D1DD003BB5A7 /* class_c_view.png */,
+				24A2009B0F90D1DD003BB5A7 /* class_c_view_container-members.html */,
+				24A2009C0F90D1DD003BB5A7 /* class_c_view_container.html */,
+				24A2009D0F90D1DD003BB5A7 /* class_c_view_container.png */,
+				24A2009E0F90D1DD003BB5A7 /* class_c_vu_meter-members.html */,
+				24A2009F0F90D1DD003BB5A7 /* class_c_vu_meter.html */,
+				24A200A00F90D1DD003BB5A7 /* class_c_vu_meter.png */,
+				24A200A10F90D1DD003BB5A7 /* class_i_scrollbar_drawer-members.html */,
+				24A200A20F90D1DD003BB5A7 /* class_i_scrollbar_drawer.html */,
+				24A200A30F90D1DD003BB5A7 /* class_plugin_g_u_i_editor-members.html */,
+				24A200A40F90D1DD003BB5A7 /* class_plugin_g_u_i_editor.html */,
+				24A200A50F90D1DD003BB5A7 /* cscrollview_8cpp.html */,
+				24A200A60F90D1DD003BB5A7 /* cscrollview_8h.html */,
+				24A200A70F90D1DD003BB5A7 /* ctabview_8cpp.html */,
+				24A200A80F90D1DD003BB5A7 /* ctabview_8h.html */,
+				24A200A90F90D1DD003BB5A7 /* deprecated.html */,
+				24A200AA0F90D1DD003BB5A7 /* doc_8h.html */,
+				24A200AB0F90D1DD003BB5A7 /* doxygen.css */,
+				24A200AC0F90D1DD003BB5A7 /* doxygen.png */,
+				24A200AD0F90D1DD003BB5A7 /* files.html */,
+				24A200AE0F90D1DD003BB5A7 /* ftv2blank.png */,
+				24A200AF0F90D1DD003BB5A7 /* ftv2doc.png */,
+				24A200B00F90D1DD003BB5A7 /* ftv2folderclosed.png */,
+				24A200B10F90D1DE003BB5A7 /* ftv2folderopen.png */,
+				24A200B20F90D1DE003BB5A7 /* ftv2lastnode.png */,
+				24A200B30F90D1DE003BB5A7 /* ftv2link.png */,
+				24A200B40F90D1DE003BB5A7 /* ftv2mlastnode.png */,
+				24A200B50F90D1DE003BB5A7 /* ftv2mnode.png */,
+				24A200B60F90D1DE003BB5A7 /* ftv2node.png */,
+				24A200B70F90D1DE003BB5A7 /* ftv2plastnode.png */,
+				24A200B80F90D1DE003BB5A7 /* ftv2pnode.png */,
+				24A200B90F90D1DE003BB5A7 /* ftv2vertline.png */,
+				24A200BA0F90D1DE003BB5A7 /* functions.html */,
+				24A200BB0F90D1DE003BB5A7 /* functions_0x62.html */,
+				24A200BC0F90D1DE003BB5A7 /* functions_0x63.html */,
+				24A200BD0F90D1DE003BB5A7 /* functions_0x64.html */,
+				24A200BE0F90D1DE003BB5A7 /* functions_0x65.html */,
+				24A200BF0F90D1DE003BB5A7 /* functions_0x66.html */,
+				24A200C00F90D1DE003BB5A7 /* functions_0x67.html */,
+				24A200C10F90D1DE003BB5A7 /* functions_0x68.html */,
+				24A200C20F90D1DE003BB5A7 /* functions_0x69.html */,
+				24A200C30F90D1DE003BB5A7 /* functions_0x6b.html */,
+				24A200C40F90D1DE003BB5A7 /* functions_0x6c.html */,
+				24A200C50F90D1DE003BB5A7 /* functions_0x6d.html */,
+				24A200C60F90D1DE003BB5A7 /* functions_0x6e.html */,
+				24A200C70F90D1DE003BB5A7 /* functions_0x6f.html */,
+				24A200C80F90D1DE003BB5A7 /* functions_0x70.html */,
+				24A200C90F90D1DE003BB5A7 /* functions_0x72.html */,
+				24A200CA0F90D1DE003BB5A7 /* functions_0x73.html */,
+				24A200CB0F90D1DE003BB5A7 /* functions_0x74.html */,
+				24A200CC0F90D1DE003BB5A7 /* functions_0x75.html */,
+				24A200CD0F90D1DE003BB5A7 /* functions_0x76.html */,
+				24A200CE0F90D1DE003BB5A7 /* functions_0x77.html */,
+				24A200CF0F90D1DE003BB5A7 /* functions_0x78.html */,
+				24A200D00F90D1DE003BB5A7 /* functions_0x79.html */,
+				24A200D10F90D1DE003BB5A7 /* functions_0x7a.html */,
+				24A200D20F90D1DE003BB5A7 /* functions_0x7e.html */,
+				24A200D30F90D1DE003BB5A7 /* functions_eval.html */,
+				24A200D40F90D1DE003BB5A7 /* functions_func.html */,
+				24A200D50F90D1DE003BB5A7 /* functions_func_0x62.html */,
+				24A200D60F90D1DE003BB5A7 /* functions_func_0x63.html */,
+				24A200D70F90D1DE003BB5A7 /* functions_func_0x64.html */,
+				24A200D80F90D1DE003BB5A7 /* functions_func_0x65.html */,
+				24A200D90F90D1DE003BB5A7 /* functions_func_0x66.html */,
+				24A200DA0F90D1DE003BB5A7 /* functions_func_0x67.html */,
+				24A200DB0F90D1DE003BB5A7 /* functions_func_0x68.html */,
+				24A200DC0F90D1DE003BB5A7 /* functions_func_0x69.html */,
+				24A200DD0F90D1DE003BB5A7 /* functions_func_0x6c.html */,
+				24A200DE0F90D1DE003BB5A7 /* functions_func_0x6d.html */,
+				24A200DF0F90D1DE003BB5A7 /* functions_func_0x6e.html */,
+				24A200E00F90D1DE003BB5A7 /* functions_func_0x6f.html */,
+				24A200E10F90D1DE003BB5A7 /* functions_func_0x70.html */,
+				24A200E20F90D1DE003BB5A7 /* functions_func_0x72.html */,
+				24A200E30F90D1DE003BB5A7 /* functions_func_0x73.html */,
+				24A200E40F90D1DE003BB5A7 /* functions_func_0x74.html */,
+				24A200E50F90D1DE003BB5A7 /* functions_func_0x75.html */,
+				24A200E60F90D1DE003BB5A7 /* functions_func_0x76.html */,
+				24A200E70F90D1DE003BB5A7 /* functions_func_0x77.html */,
+				24A200E80F90D1DE003BB5A7 /* functions_func_0x7e.html */,
+				24A200E90F90D1DE003BB5A7 /* functions_rela.html */,
+				24A200EA0F90D1DE003BB5A7 /* functions_vars.html */,
+				24A200EB0F90D1DE003BB5A7 /* functions_vars_0x62.html */,
+				24A200EC0F90D1DE003BB5A7 /* functions_vars_0x63.html */,
+				24A200ED0F90D1DE003BB5A7 /* functions_vars_0x64.html */,
+				24A200EE0F90D1DE003BB5A7 /* functions_vars_0x65.html */,
+				24A200EF0F90D1DE003BB5A7 /* functions_vars_0x66.html */,
+				24A200F00F90D1DE003BB5A7 /* functions_vars_0x67.html */,
+				24A200F10F90D1DE003BB5A7 /* functions_vars_0x68.html */,
+				24A200F20F90D1DE003BB5A7 /* functions_vars_0x69.html */,
+				24A200F30F90D1DE003BB5A7 /* functions_vars_0x6b.html */,
+				24A200F40F90D1DE003BB5A7 /* functions_vars_0x6c.html */,
+				24A200F50F90D1DE003BB5A7 /* functions_vars_0x6d.html */,
+				24A200F60F90D1DE003BB5A7 /* functions_vars_0x6e.html */,
+				24A200F70F90D1DE003BB5A7 /* functions_vars_0x6f.html */,
+				24A200F80F90D1DE003BB5A7 /* functions_vars_0x70.html */,
+				24A200F90F90D1DE003BB5A7 /* functions_vars_0x72.html */,
+				24A200FA0F90D1DE003BB5A7 /* functions_vars_0x73.html */,
+				24A200FB0F90D1DE003BB5A7 /* functions_vars_0x74.html */,
+				24A200FC0F90D1DE003BB5A7 /* functions_vars_0x75.html */,
+				24A200FD0F90D1DE003BB5A7 /* functions_vars_0x76.html */,
+				24A200FE0F90D1DE003BB5A7 /* functions_vars_0x77.html */,
+				24A200FF0F90D1DE003BB5A7 /* functions_vars_0x78.html */,
+				24A201000F90D1DE003BB5A7 /* functions_vars_0x79.html */,
+				24A201010F90D1DE003BB5A7 /* functions_vars_0x7a.html */,
+				24A201020F90D1DE003BB5A7 /* globals.html */,
+				24A201030F90D1DE003BB5A7 /* globals_0x61.html */,
+				24A201040F90D1DE003BB5A7 /* globals_0x62.html */,
+				24A201050F90D1DE003BB5A7 /* globals_0x63.html */,
+				24A201060F90D1DE003BB5A7 /* globals_0x65.html */,
+				24A201070F90D1DE003BB5A7 /* globals_0x66.html */,
+				24A201080F90D1DE003BB5A7 /* globals_0x67.html */,
+				24A201090F90D1DE003BB5A7 /* globals_0x6b.html */,
+				24A2010A0F90D1DE003BB5A7 /* globals_0x6d.html */,
+				24A2010B0F90D1DE003BB5A7 /* globals_0x6e.html */,
+				24A2010C0F90D1DE003BB5A7 /* globals_0x6f.html */,
+				24A2010D0F90D1DE003BB5A7 /* globals_0x71.html */,
+				24A2010E0F90D1DE003BB5A7 /* globals_0x72.html */,
+				24A2010F0F90D1DE003BB5A7 /* globals_0x73.html */,
+				24A201100F90D1DE003BB5A7 /* globals_0x74.html */,
+				24A201110F90D1DE003BB5A7 /* globals_0x75.html */,
+				24A201120F90D1DE003BB5A7 /* globals_0x76.html */,
+				24A201130F90D1DE003BB5A7 /* globals_0x77.html */,
+				24A201140F90D1DE003BB5A7 /* globals_defs.html */,
+				24A201150F90D1DE003BB5A7 /* globals_enum.html */,
+				24A201160F90D1DE003BB5A7 /* globals_eval.html */,
+				24A201170F90D1DE003BB5A7 /* globals_type.html */,
+				24A201180F90D1DE003BB5A7 /* globals_vars.html */,
+				24A201190F90D1DE003BB5A7 /* hierarchy.html */,
+				24A2011A0F90D1DE003BB5A7 /* index.html */,
+				24A2011B0F90D1DE003BB5A7 /* intro.html */,
+				24A2011C0F90D1DE003BB5A7 /* license.html */,
+				24A2011D0F90D1DE003BB5A7 /* maceditor.html */,
+				24A2011E0F90D1DE003BB5A7 /* main.html */,
+				24A2011F0F90D1DE003BB5A7 /* others.html */,
+				24A201200F90D1DE003BB5A7 /* pages.html */,
+				24A201210F90D1DE003BB5A7 /* plugguieditor_8cpp.html */,
+				24A201220F90D1DE003BB5A7 /* plugguieditor_8h.html */,
+				24A201230F90D1DE003BB5A7 /* sequences.html */,
+				24A201240F90D1DE003BB5A7 /* struct_c_color-members.html */,
+				24A201250F90D1DE003BB5A7 /* struct_c_color.html */,
+				24A201260F90D1DE003BB5A7 /* struct_c_point-members.html */,
+				24A201270F90D1DE003BB5A7 /* struct_c_point.html */,
+				24A201280F90D1DE003BB5A7 /* struct_c_rect-members.html */,
+				24A201290F90D1DE003BB5A7 /* struct_c_rect.html */,
+				24A2012A0F90D1DE003BB5A7 /* struct_e_rect-members.html */,
+				24A2012B0F90D1DE003BB5A7 /* struct_e_rect.html */,
+				24A2012C0F90D1DE003BB5A7 /* struct_vst_file_select-members.html */,
+				24A2012D0F90D1DE003BB5A7 /* struct_vst_file_select.html */,
+				24A2012E0F90D1DE003BB5A7 /* struct_vst_file_type-members.html */,
+				24A2012F0F90D1DE003BB5A7 /* struct_vst_file_type.html */,
+				24A201300F90D1DE003BB5A7 /* struct_vst_key_code-members.html */,
+				24A201310F90D1DE003BB5A7 /* struct_vst_key_code.html */,
+				24A201320F90D1DE003BB5A7 /* tab_b.gif */,
+				24A201330F90D1DE003BB5A7 /* tab_l.gif */,
+				24A201340F90D1DE003BB5A7 /* tab_r.gif */,
+				24A201350F90D1DE003BB5A7 /* tabs.css */,
+				24A201360F90D1DE003BB5A7 /* thanks.html */,
+				24A201370F90D1DE003BB5A7 /* tree.html */,
+				24A201380F90D1DE003BB5A7 /* vstcontrols_8cpp.html */,
+				24A201390F90D1DE003BB5A7 /* vstcontrols_8h.html */,
+				24A2013A0F90D1DE003BB5A7 /* vstgui_8cpp.html */,
+				24A2013B0F90D1DE003BB5A7 /* vstgui_8h.html */,
+				24A2013C0F90D1DE003BB5A7 /* vstkeycode_8h.html */,
+				24A2013D0F90D1DE003BB5A7 /* vstoffline.html */,
+				24A2013E0F90D1DE003BB5A7 /* vstparamstruct.html */,
+				24A2013F0F90D1DE003BB5A7 /* vstplugscarbon_8h.html */,
+				24A201400F90D1DE003BB5A7 /* vstplugsmac_8h.html */,
+				24A201410F90D1DE003BB5A7 /* vstplugsmacho_8h.html */,
+				24A201420F90D1DE003BB5A7 /* vstplugsquartz_8h.html */,
+				24A201430F90D1DE003BB5A7 /* whatsnew.html */,
+			);
+			name = html;
+			path = /vstsdk2.4/vstgui.sf/vstgui/Documentation/html;
+			sourceTree = "<absolute>";
+		};
+		24A203CE0F90D272003BB5A7 /* Products */ = {
+			isa = PBXGroup;
+			children = (
+				24A203D70F90D272003BB5A7 /* again.vst */,
+				24A203D90F90D272003BB5A7 /* adelay.vst */,
+				24A203DB0F90D272003BB5A7 /* vstxsynth.vst */,
+				24A203DD0F90D272003BB5A7 /* surrounddelay.vst */,
+				24A203DF0F90D272003BB5A7 /* minihost.app */,
+			);
+			name = Products;
+			sourceTree = "<group>";
+		};
+		24A203E00F90D272003BB5A7 /* Products */ = {
+			isa = PBXGroup;
+			children = (
+				24A203E50F90D272003BB5A7 /* drawtest.component */,
+				24A203E70F90D272003BB5A7 /* drawtest.vst */,
+			);
+			name = Products;
+			sourceTree = "<group>";
+		};
+		24A203E80F90D272003BB5A7 /* Products */ = {
+			isa = PBXGroup;
+			children = (
+				24A203ED0F90D272003BB5A7 /* drawtest.component */,
+				24A203EF0F90D272003BB5A7 /* drawtest.vst */,
+			);
+			name = Products;
+			sourceTree = "<group>";
+		};
+		24A2FEBB0F90D1DB003BB5A7 /* vstsdk2.4 */ = {
+			isa = PBXGroup;
+			children = (
+				24A2FEBC0F90D1DC003BB5A7 /* artwork */,
+				24A2FEC20F90D1DC003BB5A7 /* bin */,
+				24A2FED80F90D1DC003BB5A7 /* doc */,
+				24A2FF8E0F90D1DD003BB5A7 /* index.html */,
+				24A2FF8F0F90D1DD003BB5A7 /* pluginterfaces */,
+				24A2FF940F90D1DD003BB5A7 /* public.sdk */,
+				24A2FFDE0F90D1DD003BB5A7 /* vstgui.sf */,
+			);
+			name = vstsdk2.4;
+			path = /vstsdk2.4;
+			sourceTree = "<absolute>";
+		};
+		24A2FEBC0F90D1DC003BB5A7 /* artwork */ = {
+			isa = PBXGroup;
+			children = (
+				24A2FEBD0F90D1DC003BB5A7 /* Thumbs.db */,
+				24A2FEBE0F90D1DC003BB5A7 /* VST_Logo_Usage_Guideline.pdf */,
+				24A2FEBF0F90D1DC003BB5A7 /* VSTLogoAlpha.png */,
+				24A2FEC00F90D1DC003BB5A7 /* VSTLogoBlack.jpg */,
+				24A2FEC10F90D1DC003BB5A7 /* VSTLogoWhite.jpg */,
+			);
+			name = artwork;
+			path = /vstsdk2.4/artwork;
+			sourceTree = "<absolute>";
+		};
+		24A2FEC20F90D1DC003BB5A7 /* bin */ = {
+			isa = PBXGroup;
+			children = (
+				24A2FEC30F90D1DC003BB5A7 /* mac */,
+				24A2FED50F90D1DC003BB5A7 /* win */,
+			);
+			name = bin;
+			path = /vstsdk2.4/bin;
+			sourceTree = "<absolute>";
+		};
+		24A2FEC30F90D1DC003BB5A7 /* mac */ = {
+			isa = PBXGroup;
+			children = (
+				24A2FEC40F90D1DC003BB5A7 /* VSTMonitor.vst */,
+				24A2FED40F90D1DC003BB5A7 /* VSTParamTool.app */,
+			);
+			name = mac;
+			path = /vstsdk2.4/bin/mac;
+			sourceTree = "<absolute>";
+		};
+		24A2FEC40F90D1DC003BB5A7 /* VSTMonitor.vst */ = {
+			isa = PBXGroup;
+			children = (
+				24A2FEC50F90D1DC003BB5A7 /* Contents */,
+			);
+			name = VSTMonitor.vst;
+			path = /vstsdk2.4/bin/mac/VSTMonitor.vst;
+			sourceTree = "<absolute>";
+		};
+		24A2FEC50F90D1DC003BB5A7 /* Contents */ = {
+			isa = PBXGroup;
+			children = (
+				24A2FEC60F90D1DC003BB5A7 /* Info.plist */,
+				24A2FEC70F90D1DC003BB5A7 /* MacOS */,
+				24A2FEC90F90D1DC003BB5A7 /* PkgInfo */,
+				24A2FECA0F90D1DC003BB5A7 /* Resources */,
+			);
+			name = Contents;
+			path = /vstsdk2.4/bin/mac/VSTMonitor.vst/Contents;
+			sourceTree = "<absolute>";
+		};
+		24A2FEC70F90D1DC003BB5A7 /* MacOS */ = {
+			isa = PBXGroup;
+			children = (
+				24A2FEC80F90D1DC003BB5A7 /* VSTMonitor */,
+			);
+			name = MacOS;
+			path = /vstsdk2.4/bin/mac/VSTMonitor.vst/Contents/MacOS;
+			sourceTree = "<absolute>";
+		};
+		24A2FECA0F90D1DC003BB5A7 /* Resources */ = {
+			isa = PBXGroup;
+			children = (
+				24A2FECB0F90D1DC003BB5A7 /* bmp50000.bmp */,
+				24A2FECC0F90D1DC003BB5A7 /* bmp50001.bmp */,
+				24A2FECD0F90D1DC003BB5A7 /* bmp50002.bmp */,
+				24A2FECE0F90D1DC003BB5A7 /* bmp50003.bmp */,
+				24A2FECF0F90D1DC003BB5A7 /* bmp50004.bmp */,
+				24A2FED00F90D1DC003BB5A7 /* bmp50005.bmp */,
+				24A2FED10F90D1DC003BB5A7 /* bmp50006.bmp */,
+				24A2FED20F90D1DC003BB5A7 /* bmp50007.bmp */,
+				24A2FED30F90D1DC003BB5A7 /* bmp50008.bmp */,
+			);
+			name = Resources;
+			path = /vstsdk2.4/bin/mac/VSTMonitor.vst/Contents/Resources;
+			sourceTree = "<absolute>";
+		};
+		24A2FED50F90D1DC003BB5A7 /* win */ = {
+			isa = PBXGroup;
+			children = (
+				24A2FED60F90D1DC003BB5A7 /* vstmonitor.dll */,
+				24A2FED70F90D1DC003BB5A7 /* vstparamtool.exe */,
+			);
+			name = win;
+			path = /vstsdk2.4/bin/win;
+			sourceTree = "<absolute>";
+		};
+		24A2FED80F90D1DC003BB5A7 /* doc */ = {
+			isa = PBXGroup;
+			children = (
+				24A2FED90F90D1DC003BB5A7 /* gfx */,
+				24A2FEDE0F90D1DC003BB5A7 /* html */,
+				24A2FF8A0F90D1DD003BB5A7 /* sdk.menu.html */,
+				24A2FF8B0F90D1DD003BB5A7 /* sdk.overview.html */,
+				24A2FF8C0F90D1DD003BB5A7 /* sdkdoc.css */,
+				24A2FF8D0F90D1DD003BB5A7 /* VST Licensing Agreement.rtf */,
+			);
+			name = doc;
+			path = /vstsdk2.4/doc;
+			sourceTree = "<absolute>";
+		};
+		24A2FED90F90D1DC003BB5A7 /* gfx */ = {
+			isa = PBXGroup;
+			children = (
+				24A2FEDA0F90D1DC003BB5A7 /* folder.gif */,
+				24A2FEDB0F90D1DC003BB5A7 /* mac.gif */,
+				24A2FEDC0F90D1DC003BB5A7 /* vstpluglogo_small.jpg */,
+				24A2FEDD0F90D1DC003BB5A7 /* win.gif */,
+			);
+			name = gfx;
+			path = /vstsdk2.4/doc/gfx;
+			sourceTree = "<absolute>";
+		};
+		24A2FEDE0F90D1DC003BB5A7 /* html */ = {
+			isa = PBXGroup;
+			children = (
+				24A2FEDF0F90D1DC003BB5A7 /* aeffect_8h.html */,
+				24A2FEE00F90D1DC003BB5A7 /* aeffectx_8h.html */,
+				24A2FEE10F90D1DC003BB5A7 /* aeffeditor_8h.html */,
+				24A2FEE20F90D1DC003BB5A7 /* annotated.html */,
+				24A2FEE30F90D1DC003BB5A7 /* audioeffect_8cpp.html */,
+				24A2FEE40F90D1DC003BB5A7 /* audioeffect_8h.html */,
+				24A2FEE50F90D1DC003BB5A7 /* audioeffectx_8cpp.html */,
+				24A2FEE60F90D1DC003BB5A7 /* audioeffectx_8h.html */,
+				24A2FEE70F90D1DC003BB5A7 /* Blocksizechange.gif */,
+				24A2FEE80F90D1DC003BB5A7 /* class_a_eff_editor-members.html */,
+				24A2FEE90F90D1DC003BB5A7 /* class_a_eff_editor.html */,
+				24A2FEEA0F90D1DC003BB5A7 /* class_audio_effect-members.html */,
+				24A2FEEB0F90D1DC003BB5A7 /* class_audio_effect.html */,
+				24A2FEEC0F90D1DC003BB5A7 /* class_audio_effect.png */,
+				24A2FEED0F90D1DC003BB5A7 /* class_audio_effect_x-members.html */,
+				24A2FEEE0F90D1DC003BB5A7 /* class_audio_effect_x.html */,
+				24A2FEEF0F90D1DC003BB5A7 /* class_audio_effect_x.png */,
+				24A2FEF00F90D1DC003BB5A7 /* ControlChanged.gif */,
+				24A2FEF10F90D1DC003BB5A7 /* deprecated.html */,
+				24A2FEF20F90D1DC003BB5A7 /* dir_2d3252dd12c84c66c1d25b26bb45a1f5.html */,
+				24A2FEF30F90D1DC003BB5A7 /* dir_77c628dfee72e555f82d5ef53b733f38.html */,
+				24A2FEF40F90D1DC003BB5A7 /* dir_f81105d3b854bea570aaf3bae5cb64c1.html */,
+				24A2FEF50F90D1DC003BB5A7 /* dir_fa0454ab79b4262333bf837ea3d765e9.html */,
+				24A2FEF60F90D1DC003BB5A7 /* dirs.html */,
+				24A2FEF70F90D1DC003BB5A7 /* doc_8h.html */,
+				24A2FEF80F90D1DC003BB5A7 /* doxygen.css */,
+				24A2FEF90F90D1DC003BB5A7 /* doxygen.png */,
+				24A2FEFA0F90D1DC003BB5A7 /* files.html */,
+				24A2FEFB0F90D1DC003BB5A7 /* ftv2blank.png */,
+				24A2FEFC0F90D1DC003BB5A7 /* ftv2doc.png */,
+				24A2FEFD0F90D1DC003BB5A7 /* ftv2folderclosed.png */,
+				24A2FEFE0F90D1DC003BB5A7 /* ftv2folderopen.png */,
+				24A2FEFF0F90D1DC003BB5A7 /* ftv2lastnode.png */,
+				24A2FF000F90D1DC003BB5A7 /* ftv2link.png */,
+				24A2FF010F90D1DC003BB5A7 /* ftv2mlastnode.png */,
+				24A2FF020F90D1DC003BB5A7 /* ftv2mnode.png */,
+				24A2FF030F90D1DC003BB5A7 /* ftv2node.png */,
+				24A2FF040F90D1DC003BB5A7 /* ftv2plastnode.png */,
+				24A2FF050F90D1DC003BB5A7 /* ftv2pnode.png */,
+				24A2FF060F90D1DC003BB5A7 /* ftv2vertline.png */,
+				24A2FF070F90D1DC003BB5A7 /* functions.html */,
+				24A2FF080F90D1DC003BB5A7 /* functions_0x62.html */,
+				24A2FF090F90D1DC003BB5A7 /* functions_0x63.html */,
+				24A2FF0A0F90D1DC003BB5A7 /* functions_0x64.html */,
+				24A2FF0B0F90D1DC003BB5A7 /* functions_0x65.html */,
+				24A2FF0C0F90D1DC003BB5A7 /* functions_0x66.html */,
+				24A2FF0D0F90D1DC003BB5A7 /* functions_0x67.html */,
+				24A2FF0E0F90D1DC003BB5A7 /* functions_0x68.html */,
+				24A2FF0F0F90D1DC003BB5A7 /* functions_0x69.html */,
+				24A2FF100F90D1DC003BB5A7 /* functions_0x6b.html */,
+				24A2FF110F90D1DC003BB5A7 /* functions_0x6c.html */,
+				24A2FF120F90D1DC003BB5A7 /* functions_0x6d.html */,
+				24A2FF130F90D1DC003BB5A7 /* functions_0x6e.html */,
+				24A2FF140F90D1DC003BB5A7 /* functions_0x6f.html */,
+				24A2FF150F90D1DC003BB5A7 /* functions_0x70.html */,
+				24A2FF160F90D1DC003BB5A7 /* functions_0x72.html */,
+				24A2FF170F90D1DC003BB5A7 /* functions_0x73.html */,
+				24A2FF180F90D1DC003BB5A7 /* functions_0x74.html */,
+				24A2FF190F90D1DC003BB5A7 /* functions_0x75.html */,
+				24A2FF1A0F90D1DC003BB5A7 /* functions_0x76.html */,
+				24A2FF1B0F90D1DC003BB5A7 /* functions_0x77.html */,
+				24A2FF1C0F90D1DC003BB5A7 /* functions_0x78.html */,
+				24A2FF1D0F90D1DC003BB5A7 /* functions_0x79.html */,
+				24A2FF1E0F90D1DC003BB5A7 /* functions_0x7e.html */,
+				24A2FF1F0F90D1DC003BB5A7 /* functions_func.html */,
+				24A2FF200F90D1DC003BB5A7 /* functions_vars.html */,
+				24A2FF210F90D1DC003BB5A7 /* globals.html */,
+				24A2FF220F90D1DC003BB5A7 /* globals_0x62.html */,
+				24A2FF230F90D1DC003BB5A7 /* globals_0x63.html */,
+				24A2FF240F90D1DC003BB5A7 /* globals_0x64.html */,
+				24A2FF250F90D1DC003BB5A7 /* globals_0x65.html */,
+				24A2FF260F90D1DC003BB5A7 /* globals_0x66.html */,
+				24A2FF270F90D1DC003BB5A7 /* globals_0x6b.html */,
+				24A2FF280F90D1DC003BB5A7 /* globals_0x6d.html */,
+				24A2FF290F90D1DC003BB5A7 /* globals_0x74.html */,
+				24A2FF2A0F90D1DC003BB5A7 /* globals_0x76.html */,
+				24A2FF2B0F90D1DC003BB5A7 /* globals_defs.html */,
+				24A2FF2C0F90D1DC003BB5A7 /* globals_enum.html */,
+				24A2FF2D0F90D1DC003BB5A7 /* globals_eval.html */,
+				24A2FF2E0F90D1DC003BB5A7 /* globals_eval_0x65.html */,
+				24A2FF2F0F90D1DC003BB5A7 /* globals_eval_0x6b.html */,
+				24A2FF300F90D1DC003BB5A7 /* globals_eval_0x6d.html */,
+				24A2FF310F90D1DC003BB5A7 /* globals_eval_0x76.html */,
+				24A2FF320F90D1DC003BB5A7 /* globals_func.html */,
+				24A2FF330F90D1DC003BB5A7 /* globals_type.html */,
+				24A2FF340F90D1DC003BB5A7 /* globals_vars.html */,
+				24A2FF350F90D1DC003BB5A7 /* hierarchy.html */,
+				24A2FF360F90D1DC003BB5A7 /* history.html */,
+				24A2FF370F90D1DC003BB5A7 /* index.html */,
+				24A2FF380F90D1DC003BB5A7 /* Initialisation.gif */,
+				24A2FF390F90D1DC003BB5A7 /* intro.html */,
+				24A2FF3A0F90D1DC003BB5A7 /* IOchange.gif */,
+				24A2FF3B0F90D1DC003BB5A7 /* license.html */,
+				24A2FF3C0F90D1DC003BB5A7 /* maceditor.html */,
+				24A2FF3D0F90D1DC003BB5A7 /* main.html */,
+				24A2FF3E0F90D1DC003BB5A7 /* namespace_host_can_dos.html */,
+				24A2FF3F0F90D1DC003BB5A7 /* namespace_plug_can_dos.html */,
+				24A2FF400F90D1DC003BB5A7 /* namespacemembers.html */,
+				24A2FF410F90D1DC003BB5A7 /* namespacemembers_vars.html */,
+				24A2FF420F90D1DC003BB5A7 /* namespaces.html */,
+				24A2FF430F90D1DC003BB5A7 /* Offlineprocessing.gif */,
+				24A2FF440F90D1DC003BB5A7 /* others.html */,
+				24A2FF450F90D1DC003BB5A7 /* pages.html */,
+				24A2FF460F90D1DC003BB5A7 /* Sampleratechange.gif */,
+				24A2FF470F90D1DC003BB5A7 /* sequences.html */,
+				24A2FF480F90D1DC003BB5A7 /* SpeakerarrangementnegotiationforVSTfx.gif */,
+				24A2FF490F90D1DC003BB5A7 /* struct_a_effect-members.html */,
+				24A2FF4A0F90D1DC003BB5A7 /* struct_a_effect.html */,
+				24A2FF4B0F90D1DC003BB5A7 /* struct_e_rect-members.html */,
+				24A2FF4C0F90D1DC003BB5A7 /* struct_e_rect.html */,
+				24A2FF4D0F90D1DC003BB5A7 /* struct_midi_key_name-members.html */,
+				24A2FF4E0F90D1DC003BB5A7 /* struct_midi_key_name.html */,
+				24A2FF4F0F90D1DC003BB5A7 /* struct_midi_program_category-members.html */,
+				24A2FF500F90D1DC003BB5A7 /* struct_midi_program_category.html */,
+				24A2FF510F90D1DC003BB5A7 /* struct_midi_program_name-members.html */,
+				24A2FF520F90D1DC003BB5A7 /* struct_midi_program_name.html */,
+				24A2FF530F90D1DC003BB5A7 /* struct_vst_audio_file-members.html */,
+				24A2FF540F90D1DC003BB5A7 /* struct_vst_audio_file.html */,
+				24A2FF550F90D1DC003BB5A7 /* struct_vst_audio_file_marker-members.html */,
+				24A2FF560F90D1DC003BB5A7 /* struct_vst_audio_file_marker.html */,
+				24A2FF570F90D1DC003BB5A7 /* struct_vst_event-members.html */,
+				24A2FF580F90D1DC003BB5A7 /* struct_vst_event.html */,
+				24A2FF590F90D1DD003BB5A7 /* struct_vst_events-members.html */,
+				24A2FF5A0F90D1DD003BB5A7 /* struct_vst_events.html */,
+				24A2FF5B0F90D1DD003BB5A7 /* struct_vst_file_select-members.html */,
+				24A2FF5C0F90D1DD003BB5A7 /* struct_vst_file_select.html */,
+				24A2FF5D0F90D1DD003BB5A7 /* struct_vst_file_type-members.html */,
+				24A2FF5E0F90D1DD003BB5A7 /* struct_vst_file_type.html */,
+				24A2FF5F0F90D1DD003BB5A7 /* struct_vst_key_code-members.html */,
+				24A2FF600F90D1DD003BB5A7 /* struct_vst_key_code.html */,
+				24A2FF610F90D1DD003BB5A7 /* struct_vst_midi_event-members.html */,
+				24A2FF620F90D1DD003BB5A7 /* struct_vst_midi_event.html */,
+				24A2FF630F90D1DD003BB5A7 /* struct_vst_midi_sysex_event-members.html */,
+				24A2FF640F90D1DD003BB5A7 /* struct_vst_midi_sysex_event.html */,
+				24A2FF650F90D1DD003BB5A7 /* struct_vst_offline_task-members.html */,
+				24A2FF660F90D1DD003BB5A7 /* struct_vst_offline_task.html */,
+				24A2FF670F90D1DD003BB5A7 /* struct_vst_parameter_properties-members.html */,
+				24A2FF680F90D1DD003BB5A7 /* struct_vst_parameter_properties.html */,
+				24A2FF690F90D1DD003BB5A7 /* struct_vst_patch_chunk_info-members.html */,
+				24A2FF6A0F90D1DD003BB5A7 /* struct_vst_patch_chunk_info.html */,
+				24A2FF6B0F90D1DD003BB5A7 /* struct_vst_pin_properties-members.html */,
+				24A2FF6C0F90D1DD003BB5A7 /* struct_vst_pin_properties.html */,
+				24A2FF6D0F90D1DD003BB5A7 /* struct_vst_speaker_arrangement-members.html */,
+				24A2FF6E0F90D1DD003BB5A7 /* struct_vst_speaker_arrangement.html */,
+				24A2FF6F0F90D1DD003BB5A7 /* struct_vst_speaker_properties-members.html */,
+				24A2FF700F90D1DD003BB5A7 /* struct_vst_speaker_properties.html */,
+				24A2FF710F90D1DD003BB5A7 /* struct_vst_time_info-members.html */,
+				24A2FF720F90D1DD003BB5A7 /* struct_vst_time_info.html */,
+				24A2FF730F90D1DD003BB5A7 /* struct_vst_variable_io-members.html */,
+				24A2FF740F90D1DD003BB5A7 /* struct_vst_variable_io.html */,
+				24A2FF750F90D1DD003BB5A7 /* struct_vst_window-members.html */,
+				24A2FF760F90D1DD003BB5A7 /* struct_vst_window.html */,
+				24A2FF770F90D1DD003BB5A7 /* structfx_bank-members.html */,
+				24A2FF780F90D1DD003BB5A7 /* structfx_bank.html */,
+				24A2FF790F90D1DD003BB5A7 /* structfx_program-members.html */,
+				24A2FF7A0F90D1DD003BB5A7 /* structfx_program.html */,
+				24A2FF7B0F90D1DD003BB5A7 /* tab_b.gif */,
+				24A2FF7C0F90D1DD003BB5A7 /* tab_l.gif */,
+				24A2FF7D0F90D1DD003BB5A7 /* tab_r.gif */,
+				24A2FF7E0F90D1DD003BB5A7 /* tabs.css */,
+				24A2FF7F0F90D1DD003BB5A7 /* Termination.gif */,
+				24A2FF800F90D1DD003BB5A7 /* thanks.html */,
+				24A2FF810F90D1DD003BB5A7 /* tree.html */,
+				24A2FF820F90D1DD003BB5A7 /* TurnOff.gif */,
+				24A2FF830F90D1DD003BB5A7 /* TurnOn.gif */,
+				24A2FF840F90D1DD003BB5A7 /* vstfxstore_8h.html */,
+				24A2FF850F90D1DD003BB5A7 /* vstoffline.html */,
+				24A2FF860F90D1DD003BB5A7 /* vstparamstruct.html */,
+				24A2FF870F90D1DD003BB5A7 /* vstpluglogo.jpg */,
+				24A2FF880F90D1DD003BB5A7 /* vstplugmain_8cpp.html */,
+				24A2FF890F90D1DD003BB5A7 /* whatsnew.html */,
+			);
+			name = html;
+			path = /vstsdk2.4/doc/html;
+			sourceTree = "<absolute>";
+		};
+		24A2FF8F0F90D1DD003BB5A7 /* pluginterfaces */ = {
+			isa = PBXGroup;
+			children = (
+				24A2FF900F90D1DD003BB5A7 /* vst2.x */,
+			);
+			name = pluginterfaces;
+			path = /vstsdk2.4/pluginterfaces;
+			sourceTree = "<absolute>";
+		};
+		24A2FF900F90D1DD003BB5A7 /* vst2.x */ = {
+			isa = PBXGroup;
+			children = (
+				24A2FF910F90D1DD003BB5A7 /* aeffect.h */,
+				24A2FF920F90D1DD003BB5A7 /* aeffectx.h */,
+				24A2FF930F90D1DD003BB5A7 /* vstfxstore.h */,
+			);
+			name = vst2.x;
+			path = /vstsdk2.4/pluginterfaces/vst2.x;
+			sourceTree = "<absolute>";
+		};
+		24A2FF940F90D1DD003BB5A7 /* public.sdk */ = {
+			isa = PBXGroup;
+			children = (
+				24A2FF950F90D1DD003BB5A7 /* samples */,
+				24A2FFD60F90D1DD003BB5A7 /* source */,
+			);
+			name = public.sdk;
+			path = /vstsdk2.4/public.sdk;
+			sourceTree = "<absolute>";
+		};
+		24A2FF950F90D1DD003BB5A7 /* samples */ = {
+			isa = PBXGroup;
+			children = (
+				24A2FF960F90D1DD003BB5A7 /* vst2.x */,
+			);
+			name = samples;
+			path = /vstsdk2.4/public.sdk/samples;
+			sourceTree = "<absolute>";
+		};
+		24A2FF960F90D1DD003BB5A7 /* vst2.x */ = {
+			isa = PBXGroup;
+			children = (
+				24A2FF970F90D1DD003BB5A7 /* adelay */,
+				24A2FFA80F90D1DD003BB5A7 /* again */,
+				24A2FFAE0F90D1DD003BB5A7 /* mac */,
+				24A2FFB40F90D1DD003BB5A7 /* minihost */,
+				24A2FFBA0F90D1DD003BB5A7 /* vstxsynth */,
+				24A2FFC50F90D1DD003BB5A7 /* win */,
+				24A2FFC80F90D1DD003BB5A7 /* win.vc2003 */,
+				24A2FFCF0F90D1DD003BB5A7 /* win.vc6 */,
+			);
+			name = vst2.x;
+			path = /vstsdk2.4/public.sdk/samples/vst2.x;
+			sourceTree = "<absolute>";
+		};
+		24A2FF970F90D1DD003BB5A7 /* adelay */ = {
+			isa = PBXGroup;
+			children = (
+				24A2FF980F90D1DD003BB5A7 /* adelay.cpp */,
+				24A2FF990F90D1DD003BB5A7 /* adelay.h */,
+				24A2FF9A0F90D1DD003BB5A7 /* adelaymain.cpp */,
+				24A2FF9B0F90D1DD003BB5A7 /* editor */,
+				24A2FFA30F90D1DD003BB5A7 /* surrounddelay.cpp */,
+				24A2FFA40F90D1DD003BB5A7 /* surrounddelay.h */,
+				24A2FFA50F90D1DD003BB5A7 /* win */,
+			);
+			name = adelay;
+			path = /vstsdk2.4/public.sdk/samples/vst2.x/adelay;
+			sourceTree = "<absolute>";
+		};
+		24A2FF9B0F90D1DD003BB5A7 /* editor */ = {
+			isa = PBXGroup;
+			children = (
+				24A2FF9C0F90D1DD003BB5A7 /* resources */,
+				24A2FFA10F90D1DD003BB5A7 /* sdeditor.cpp */,
+				24A2FFA20F90D1DD003BB5A7 /* sdeditor.h */,
+			);
+			name = editor;
+			path = /vstsdk2.4/public.sdk/samples/vst2.x/adelay/editor;
+			sourceTree = "<absolute>";
+		};
+		24A2FF9C0F90D1DD003BB5A7 /* resources */ = {
+			isa = PBXGroup;
+			children = (
+				24A2FF9D0F90D1DD003BB5A7 /* bmp00128.bmp */,
+				24A2FF9E0F90D1DD003BB5A7 /* bmp00129.bmp */,
+				24A2FF9F0F90D1DD003BB5A7 /* bmp00130.bmp */,
+				24A2FFA00F90D1DD003BB5A7 /* surrounddelay.rc */,
+			);
+			name = resources;
+			path = /vstsdk2.4/public.sdk/samples/vst2.x/adelay/editor/resources;
+			sourceTree = "<absolute>";
+		};
+		24A2FFA50F90D1DD003BB5A7 /* win */ = {
+			isa = PBXGroup;
+			children = (
+				24A2FFA60F90D1DD003BB5A7 /* adelay.vcproj */,
+				24A2FFA70F90D1DD003BB5A7 /* surrounddelay.vcproj */,
+			);
+			name = win;
+			path = /vstsdk2.4/public.sdk/samples/vst2.x/adelay/win;
+			sourceTree = "<absolute>";
+		};
+		24A2FFA80F90D1DD003BB5A7 /* again */ = {
+			isa = PBXGroup;
+			children = (
+				24A2FFA90F90D1DD003BB5A7 /* source */,
+				24A2FFAC0F90D1DD003BB5A7 /* win */,
+			);
+			name = again;
+			path = /vstsdk2.4/public.sdk/samples/vst2.x/again;
+			sourceTree = "<absolute>";
+		};
+		24A2FFA90F90D1DD003BB5A7 /* source */ = {
+			isa = PBXGroup;
+			children = (
+				24A2FFAA0F90D1DD003BB5A7 /* again.cpp */,
+				24A2FFAB0F90D1DD003BB5A7 /* again.h */,
+			);
+			name = source;
+			path = /vstsdk2.4/public.sdk/samples/vst2.x/again/source;
+			sourceTree = "<absolute>";
+		};
+		24A2FFAC0F90D1DD003BB5A7 /* win */ = {
+			isa = PBXGroup;
+			children = (
+				24A2FFAD0F90D1DD003BB5A7 /* again.vcproj */,
+			);
+			name = win;
+			path = /vstsdk2.4/public.sdk/samples/vst2.x/again/win;
+			sourceTree = "<absolute>";
+		};
+		24A2FFAE0F90D1DD003BB5A7 /* mac */ = {
+			isa = PBXGroup;
+			children = (
+				24A2FFAF0F90D1DD003BB5A7 /* minihost-Info.plist */,
+				24A2FFB00F90D1DD003BB5A7 /* vst 2.4 examples.xcodeproj */,
+				24A2FFB30F90D1DD003BB5A7 /* vst2.4Info.plist */,
+			);
+			name = mac;
+			path = /vstsdk2.4/public.sdk/samples/vst2.x/mac;
+			sourceTree = "<absolute>";
+		};
+		24A2FFB40F90D1DD003BB5A7 /* minihost */ = {
+			isa = PBXGroup;
+			children = (
+				24A2FFB50F90D1DD003BB5A7 /* source */,
+				24A2FFB80F90D1DD003BB5A7 /* win */,
+			);
+			name = minihost;
+			path = /vstsdk2.4/public.sdk/samples/vst2.x/minihost;
+			sourceTree = "<absolute>";
+		};
+		24A2FFB50F90D1DD003BB5A7 /* source */ = {
+			isa = PBXGroup;
+			children = (
+				24A2FFB60F90D1DD003BB5A7 /* minieditor.cpp */,
+				24A2FFB70F90D1DD003BB5A7 /* minihost.cpp */,
+			);
+			name = source;
+			path = /vstsdk2.4/public.sdk/samples/vst2.x/minihost/source;
+			sourceTree = "<absolute>";
+		};
+		24A2FFB80F90D1DD003BB5A7 /* win */ = {
+			isa = PBXGroup;
+			children = (
+				24A2FFB90F90D1DD003BB5A7 /* minihost.vcproj */,
+			);
+			name = win;
+			path = /vstsdk2.4/public.sdk/samples/vst2.x/minihost/win;
+			sourceTree = "<absolute>";
+		};
+		24A2FFBA0F90D1DD003BB5A7 /* vstxsynth */ = {
+			isa = PBXGroup;
+			children = (
+				24A2FFBB0F90D1DD003BB5A7 /* resource */,
+				24A2FFBE0F90D1DD003BB5A7 /* source */,
+				24A2FFC30F90D1DD003BB5A7 /* win */,
+			);
+			name = vstxsynth;
+			path = /vstsdk2.4/public.sdk/samples/vst2.x/vstxsynth;
+			sourceTree = "<absolute>";
+		};
+		24A2FFBB0F90D1DD003BB5A7 /* resource */ = {
+			isa = PBXGroup;
+			children = (
+				24A2FFBC0F90D1DD003BB5A7 /* vstxsynth.rc */,
+				24A2FFBD0F90D1DD003BB5A7 /* vstxsynth.vstxml */,
+			);
+			name = resource;
+			path = /vstsdk2.4/public.sdk/samples/vst2.x/vstxsynth/resource;
+			sourceTree = "<absolute>";
+		};
+		24A2FFBE0F90D1DD003BB5A7 /* source */ = {
+			isa = PBXGroup;
+			children = (
+				24A2FFBF0F90D1DD003BB5A7 /* gmnames.h */,
+				24A2FFC00F90D1DD003BB5A7 /* vstxsynth.cpp */,
+				24A2FFC10F90D1DD003BB5A7 /* vstxsynth.h */,
+				24A2FFC20F90D1DD003BB5A7 /* vstxsynthproc.cpp */,
+			);
+			name = source;
+			path = /vstsdk2.4/public.sdk/samples/vst2.x/vstxsynth/source;
+			sourceTree = "<absolute>";
+		};
+		24A2FFC30F90D1DD003BB5A7 /* win */ = {
+			isa = PBXGroup;
+			children = (
+				24A2FFC40F90D1DD003BB5A7 /* vstxsynth.vcproj */,
+			);
+			name = win;
+			path = /vstsdk2.4/public.sdk/samples/vst2.x/vstxsynth/win;
+			sourceTree = "<absolute>";
+		};
+		24A2FFC50F90D1DD003BB5A7 /* win */ = {
+			isa = PBXGroup;
+			children = (
+				24A2FFC60F90D1DD003BB5A7 /* samples.sln */,
+				24A2FFC70F90D1DD003BB5A7 /* vstplug.def */,
+			);
+			name = win;
+			path = /vstsdk2.4/public.sdk/samples/vst2.x/win;
+			sourceTree = "<absolute>";
+		};
+		24A2FFC80F90D1DD003BB5A7 /* win.vc2003 */ = {
+			isa = PBXGroup;
+			children = (
+				24A2FFC90F90D1DD003BB5A7 /* adelay.vcproj */,
+				24A2FFCA0F90D1DD003BB5A7 /* again.vcproj */,
+				24A2FFCB0F90D1DD003BB5A7 /* minihost.vcproj */,
+				24A2FFCC0F90D1DD003BB5A7 /* samples.sln */,
+				24A2FFCD0F90D1DD003BB5A7 /* surrounddelay.vcproj */,
+				24A2FFCE0F90D1DD003BB5A7 /* vstxsynth.vcproj */,
+			);
+			name = win.vc2003;
+			path = /vstsdk2.4/public.sdk/samples/vst2.x/win.vc2003;
+			sourceTree = "<absolute>";
+		};
+		24A2FFCF0F90D1DD003BB5A7 /* win.vc6 */ = {
+			isa = PBXGroup;
+			children = (
+				24A2FFD00F90D1DD003BB5A7 /* adelay.dsp */,
+				24A2FFD10F90D1DD003BB5A7 /* again.dsp */,
+				24A2FFD20F90D1DD003BB5A7 /* minihost.dsp */,
+				24A2FFD30F90D1DD003BB5A7 /* samples.dsw */,
+				24A2FFD40F90D1DD003BB5A7 /* surrounddelay.dsp */,
+				24A2FFD50F90D1DD003BB5A7 /* vstxsynth.dsp */,
+			);
+			name = win.vc6;
+			path = /vstsdk2.4/public.sdk/samples/vst2.x/win.vc6;
+			sourceTree = "<absolute>";
+		};
+		24A2FFD60F90D1DD003BB5A7 /* source */ = {
+			isa = PBXGroup;
+			children = (
+				24A2FFD70F90D1DD003BB5A7 /* vst2.x */,
+			);
+			name = source;
+			path = /vstsdk2.4/public.sdk/source;
+			sourceTree = "<absolute>";
+		};
+		24A2FFD70F90D1DD003BB5A7 /* vst2.x */ = {
+			isa = PBXGroup;
+			children = (
+				24A2FFD80F90D1DD003BB5A7 /* aeffeditor.h */,
+				24A2FFD90F90D1DD003BB5A7 /* audioeffect.cpp */,
+				24A2FFDA0F90D1DD003BB5A7 /* audioeffect.h */,
+				24A2FFDB0F90D1DD003BB5A7 /* audioeffectx.cpp */,
+				24A2FFDC0F90D1DD003BB5A7 /* audioeffectx.h */,
+				24A2FFDD0F90D1DD003BB5A7 /* vstplugmain.cpp */,
+			);
+			name = vst2.x;
+			path = /vstsdk2.4/public.sdk/source/vst2.x;
+			sourceTree = "<absolute>";
+		};
+		24A2FFDE0F90D1DD003BB5A7 /* vstgui.sf */ = {
+			isa = PBXGroup;
+			children = (
+				24A2FFDF0F90D1DD003BB5A7 /* drawtest */,
+				24A200160F90D1DD003BB5A7 /* vstgui */,
+			);
+			name = vstgui.sf;
+			path = /vstsdk2.4/vstgui.sf;
+			sourceTree = "<absolute>";
+		};
+		24A2FFDF0F90D1DD003BB5A7 /* drawtest */ = {
+			isa = PBXGroup;
+			children = (
+				24A2FFE00F90D1DD003BB5A7 /* mac */,
+				24A2FFEE0F90D1DD003BB5A7 /* resources */,
+				24A200030F90D1DD003BB5A7 /* source */,
+				24A2000F0F90D1DD003BB5A7 /* win */,
+				24A200130F90D1DD003BB5A7 /* win.vc6 */,
+			);
+			name = drawtest;
+			path = /vstsdk2.4/vstgui.sf/drawtest;
+			sourceTree = "<absolute>";
+		};
+		24A2FFE00F90D1DD003BB5A7 /* mac */ = {
+			isa = PBXGroup;
+			children = (
+				24A2FFE10F90D1DD003BB5A7 /* audiounit.exp */,
+				24A2FFE20F90D1DD003BB5A7 /* cw_vst_prefix.pch++ */,
+				24A2FFE30F90D1DD003BB5A7 /* drawtest.cw9prj */,
+				24A2FFE40F90D1DD003BB5A7 /* drawtest.plc */,
+				24A2FFE50F90D1DD003BB5A7 /* drawtest.xcode */,
+				24A2FFE80F90D1DD003BB5A7 /* drawtest.xcodeproj */,
+				24A2FFEB0F90D1DD003BB5A7 /* Info.plist */,
+				24A2FFEC0F90D1DD003BB5A7 /* xcode_au_prefix.h */,
+				24A2FFED0F90D1DD003BB5A7 /* xcode_vst_prefix.h */,
+			);
+			name = mac;
+			path = /vstsdk2.4/vstgui.sf/drawtest/mac;
+			sourceTree = "<absolute>";
+		};
+		24A2FFEE0F90D1DD003BB5A7 /* resources */ = {
+			isa = PBXGroup;
+			children = (
+				24A2FFEF0F90D1DD003BB5A7 /* audiounit.r */,
+				24A2FFF00F90D1DD003BB5A7 /* bmp00001.png */,
+				24A2FFF10F90D1DD003BB5A7 /* bmp00100.png */,
+				24A2FFF20F90D1DD003BB5A7 /* bmp01000.png */,
+				24A2FFF30F90D1DD003BB5A7 /* bmp10001.bmp */,
+				24A2FFF40F90D1DD003BB5A7 /* bmp10002.bmp */,
+				24A2FFF50F90D1DD003BB5A7 /* bmp10003.bmp */,
+				24A2FFF60F90D1DD003BB5A7 /* bmp10004.bmp */,
+				24A2FFF70F90D1DD003BB5A7 /* bmp10005.bmp */,
+				24A2FFF80F90D1DD003BB5A7 /* bmp10006.bmp */,
+				24A2FFF90F90D1DD003BB5A7 /* bmp10007.bmp */,
+				24A2FFFA0F90D1DD003BB5A7 /* bmp10008.bmp */,
+				24A2FFFB0F90D1DD003BB5A7 /* bmp10009.bmp */,
+				24A2FFFC0F90D1DD003BB5A7 /* bmp10010.bmp */,
+				24A2FFFD0F90D1DD003BB5A7 /* bmp10011.bmp */,
+				24A2FFFE0F90D1DD003BB5A7 /* bmp10012.bmp */,
+				24A2FFFF0F90D1DD003BB5A7 /* bmp10013.bmp */,
+				24A200000F90D1DD003BB5A7 /* bmp10014.bmp */,
+				24A200010F90D1DD003BB5A7 /* bmp10015.bmp */,
+				24A200020F90D1DD003BB5A7 /* bmp10016.bmp */,
+			);
+			name = resources;
+			path = /vstsdk2.4/vstgui.sf/drawtest/resources;
+			sourceTree = "<absolute>";
+		};
+/* End PBXGroup section */
+
+/* Begin PBXHeadersBuildPhase section */
+		8D01CCC70486CAD60068D4B7 /* Headers */ = {
+			isa = PBXHeadersBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				245463B90991757100464AD3 /* PocketVerbs.h in Headers */,
+				24D8287F09A9164A0093AEF8 /* xcode_vst_prefix.h in Headers */,
+				24A202190F90D1DE003BB5A7 /* aeffect.h in Headers */,
+				24A2021A0F90D1DE003BB5A7 /* aeffectx.h in Headers */,
+				24A2021B0F90D1DE003BB5A7 /* vstfxstore.h in Headers */,
+				24A2021D0F90D1DE003BB5A7 /* adelay.h in Headers */,
+				24A202240F90D1DE003BB5A7 /* sdeditor.h in Headers */,
+				24A202260F90D1DE003BB5A7 /* surrounddelay.h in Headers */,
+				24A2022A0F90D1DE003BB5A7 /* again.h in Headers */,
+				24A202330F90D1DE003BB5A7 /* gmnames.h in Headers */,
+				24A202350F90D1DE003BB5A7 /* vstxsynth.h in Headers */,
+				24A202460F90D1DE003BB5A7 /* aeffeditor.h in Headers */,
+				24A202480F90D1DE003BB5A7 /* audioeffect.h in Headers */,
+				24A2024A0F90D1DE003BB5A7 /* audioeffectx.h in Headers */,
+				24A2024D0F90D1DE003BB5A7 /* cw_vst_prefix.pch++ in Headers */,
+				24A202510F90D1DE003BB5A7 /* xcode_au_prefix.h in Headers */,
+				24A202520F90D1DE003BB5A7 /* xcode_vst_prefix.h in Headers */,
+				24A202680F90D1DE003BB5A7 /* controlsgui.h in Headers */,
+				24A2026A0F90D1DE003BB5A7 /* pdrawtesteditor.h in Headers */,
+				24A2026C0F90D1DE003BB5A7 /* pdrawtesteffect.h in Headers */,
+				24A2026F0F90D1DE003BB5A7 /* pdrawtestview.h in Headers */,
+				24A202710F90D1DE003BB5A7 /* pprimitivesviews.h in Headers */,
+				24A202780F90D1DE003BB5A7 /* aeffguieditor.h in Headers */,
+				24A2027A0F90D1DE003BB5A7 /* cfileselector.h in Headers */,
+				24A2027D0F90D1DE003BB5A7 /* cscrollview.h in Headers */,
+				24A2027F0F90D1DE003BB5A7 /* ctabview.h in Headers */,
+				24A203A50F90D1DE003BB5A7 /* plugguieditor.h in Headers */,
+				24A203A70F90D1DE003BB5A7 /* vstcontrols.h in Headers */,
+				24A203A90F90D1DE003BB5A7 /* vstgui.h in Headers */,
+				24A203AA0F90D1DE003BB5A7 /* vstkeycode.h in Headers */,
+				24A203AB0F90D1DE003BB5A7 /* vstplugscarbon.h in Headers */,
+				24A203AC0F90D1DE003BB5A7 /* vstplugsmac.h in Headers */,
+				24A203AD0F90D1DE003BB5A7 /* vstplugsmacho.h in Headers */,
+				24A203AE0F90D1DE003BB5A7 /* vstplugsquartz.h in Headers */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXHeadersBuildPhase section */
+
+/* Begin PBXNativeTarget section */
+		8D01CCC60486CAD60068D4B7 /* PocketVerbs */ = {
+			isa = PBXNativeTarget;
+			buildConfigurationList = 24BEAAED08919AE700E695F9 /* Build configuration list for PBXNativeTarget "PocketVerbs" */;
+			buildPhases = (
+				8D01CCC70486CAD60068D4B7 /* Headers */,
+				8D01CCC90486CAD60068D4B7 /* Resources */,
+				8D01CCCB0486CAD60068D4B7 /* Sources */,
+				8D01CCCF0486CAD60068D4B7 /* Rez */,
+				24CFB70807E7A07C0081BD57 /* Copy PkgInfo */,
+			);
+			buildRules = (
+			);
+			dependencies = (
+			);
+			name = PocketVerbs;
+			productInstallPath = "$(HOME)/Library/Bundles";
+			productName = "FM-Chopper";
+			productReference = 2407DE920899296600EB68BF /* PocketVerbs.vst */;
+			productType = "com.apple.product-type.bundle";
+		};
+/* End PBXNativeTarget section */
+
+/* Begin PBXProject section */
+		089C1669FE841209C02AAC07 /* Project object */ = {
+			isa = PBXProject;
+			buildConfigurationList = 24BEAAF108919AE700E695F9 /* Build configuration list for PBXProject "PocketVerbs" */;
+			compatibilityVersion = "Xcode 2.4";
+			developmentRegion = English;
+			hasScannedForEncodings = 1;
+			knownRegions = (
+				English,
+				Japanese,
+				French,
+				German,
+			);
+			mainGroup = 089C166AFE841209C02AAC07 /* FM-Chopper */;
+			projectDirPath = "";
+			projectReferences = (
+				{
+					ProductGroup = 24A203E00F90D272003BB5A7 /* Products */;
+					ProjectRef = 24A2FFE50F90D1DD003BB5A7 /* drawtest.xcode */;
+				},
+				{
+					ProductGroup = 24A203E80F90D272003BB5A7 /* Products */;
+					ProjectRef = 24A2FFE80F90D1DD003BB5A7 /* drawtest.xcodeproj */;
+				},
+				{
+					ProductGroup = 24A203CE0F90D272003BB5A7 /* Products */;
+					ProjectRef = 24A2FFB00F90D1DD003BB5A7 /* vst 2.4 examples.xcodeproj */;
+				},
+			);
+			projectRoot = "";
+			targets = (
+				8D01CCC60486CAD60068D4B7 /* PocketVerbs */,
+			);
+		};
+/* End PBXProject section */
+
+/* Begin PBXReferenceProxy section */
+		24A203D70F90D272003BB5A7 /* again.vst */ = {
+			isa = PBXReferenceProxy;
+			fileType = wrapper.cfbundle;
+			path = again.vst;
+			remoteRef = 24A203D60F90D272003BB5A7 /* PBXContainerItemProxy */;
+			sourceTree = BUILT_PRODUCTS_DIR;
+		};
+		24A203D90F90D272003BB5A7 /* adelay.vst */ = {
+			isa = PBXReferenceProxy;
+			fileType = wrapper.cfbundle;
+			path = adelay.vst;
+			remoteRef = 24A203D80F90D272003BB5A7 /* PBXContainerItemProxy */;
+			sourceTree = BUILT_PRODUCTS_DIR;
+		};
+		24A203DB0F90D272003BB5A7 /* vstxsynth.vst */ = {
+			isa = PBXReferenceProxy;
+			fileType = wrapper.cfbundle;
+			path = vstxsynth.vst;
+			remoteRef = 24A203DA0F90D272003BB5A7 /* PBXContainerItemProxy */;
+			sourceTree = BUILT_PRODUCTS_DIR;
+		};
+		24A203DD0F90D272003BB5A7 /* surrounddelay.vst */ = {
+			isa = PBXReferenceProxy;
+			fileType = wrapper.cfbundle;
+			path = surrounddelay.vst;
+			remoteRef = 24A203DC0F90D272003BB5A7 /* PBXContainerItemProxy */;
+			sourceTree = BUILT_PRODUCTS_DIR;
+		};
+		24A203DF0F90D272003BB5A7 /* minihost.app */ = {
+			isa = PBXReferenceProxy;
+			fileType = wrapper.application;
+			path = minihost.app;
+			remoteRef = 24A203DE0F90D272003BB5A7 /* PBXContainerItemProxy */;
+			sourceTree = BUILT_PRODUCTS_DIR;
+		};
+		24A203E50F90D272003BB5A7 /* drawtest.component */ = {
+			isa = PBXReferenceProxy;
+			fileType = wrapper.cfbundle;
+			path = drawtest.component;
+			remoteRef = 24A203E40F90D272003BB5A7 /* PBXContainerItemProxy */;
+			sourceTree = BUILT_PRODUCTS_DIR;
+		};
+		24A203E70F90D272003BB5A7 /* drawtest.vst */ = {
+			isa = PBXReferenceProxy;
+			fileType = wrapper.cfbundle;
+			path = drawtest.vst;
+			remoteRef = 24A203E60F90D272003BB5A7 /* PBXContainerItemProxy */;
+			sourceTree = BUILT_PRODUCTS_DIR;
+		};
+		24A203ED0F90D272003BB5A7 /* drawtest.component */ = {
+			isa = PBXReferenceProxy;
+			fileType = wrapper.cfbundle;
+			path = drawtest.component;
+			remoteRef = 24A203EC0F90D272003BB5A7 /* PBXContainerItemProxy */;
+			sourceTree = BUILT_PRODUCTS_DIR;
+		};
+		24A203EF0F90D272003BB5A7 /* drawtest.vst */ = {
+			isa = PBXReferenceProxy;
+			fileType = wrapper.cfbundle;
+			path = drawtest.vst;
+			remoteRef = 24A203EE0F90D272003BB5A7 /* PBXContainerItemProxy */;
+			sourceTree = BUILT_PRODUCTS_DIR;
+		};
+/* End PBXReferenceProxy section */
+
+/* Begin PBXResourcesBuildPhase section */
+		8D01CCC90486CAD60068D4B7 /* Resources */ = {
+			isa = PBXResourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				24CFB70407E7A0220081BD57 /* PkgInfo in Resources */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXResourcesBuildPhase section */
+
+/* Begin PBXRezBuildPhase section */
+		8D01CCCF0486CAD60068D4B7 /* Rez */ = {
+			isa = PBXRezBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXRezBuildPhase section */
+
+/* Begin PBXShellScriptBuildPhase section */
+		24CFB70807E7A07C0081BD57 /* Copy PkgInfo */ = {
+			isa = PBXShellScriptBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+			);
+			inputPaths = (
+			);
+			name = "Copy PkgInfo";
+			outputPaths = (
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+			shellPath = /bin/bash;
+			shellScript = "cp mac/PkgInfo \"$BUILT_PRODUCTS_DIR/$PRODUCT_NAME.vst/Contents/\"";
+		};
+/* End PBXShellScriptBuildPhase section */
+
+/* Begin PBXSourcesBuildPhase section */
+		8D01CCCB0486CAD60068D4B7 /* Sources */ = {
+			isa = PBXSourcesBuildPhase;
+			buildActionMask = 2147483647;
+			files = (
+				2407DEB9089929BA00EB68BF /* PocketVerbs.cpp in Sources */,
+				24D8287009A914000093AEF8 /* PocketVerbsProc.cpp in Sources */,
+				24A203CB0F90D251003BB5A7 /* audioeffect.cpp in Sources */,
+				24A203CC0F90D251003BB5A7 /* audioeffectx.cpp in Sources */,
+				24A203CD0F90D251003BB5A7 /* vstplugmain.cpp in Sources */,
+			);
+			runOnlyForDeploymentPostprocessing = 0;
+		};
+/* End PBXSourcesBuildPhase section */
+
+/* Begin XCBuildConfiguration section */
+		24BEAAEE08919AE700E695F9 /* Debug */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				COPY_PHASE_STRIP = NO;
+				FRAMEWORK_SEARCH_PATHS = "";
+				GCC_DYNAMIC_NO_PIC = NO;
+				GCC_ENABLE_FIX_AND_CONTINUE = YES;
+				GCC_ENABLE_TRIGRAPHS = NO;
+				GCC_GENERATE_DEBUGGING_SYMBOLS = YES;
+				GCC_PRECOMPILE_PREFIX_HEADER = YES;
+				GCC_PREFIX_HEADER = "";
+				GCC_WARN_ABOUT_MISSING_PROTOTYPES = NO;
+				GCC_WARN_FOUR_CHARACTER_CONSTANTS = NO;
+				GCC_WARN_UNKNOWN_PRAGMAS = NO;
+				HEADER_SEARCH_PATHS = "/vstsdk2.4/**";
+				INFOPLIST_FILE = ./mac/Info.plist;
+				LIBRARY_SEARCH_PATHS = "";
+				OTHER_CFLAGS = "";
+				OTHER_LDFLAGS = "";
+				OTHER_REZFLAGS = "";
+				PRODUCT_NAME = Gain;
+				SECTORDER_FLAGS = "";
+				WARNING_CFLAGS = (
+					"-Wmost",
+					"-Wno-four-char-constants",
+					"-Wno-unknown-pragmas",
+				);
+				WRAPPER_EXTENSION = vst;
+			};
+			name = Debug;
+		};
+		24BEAAEF08919AE700E695F9 /* Release */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ARCHS = (
+					ppc,
+					i386,
+					x86_64,
+				);
+				COPY_PHASE_STRIP = YES;
+				DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym";
+				FRAMEWORK_SEARCH_PATHS = "";
+				GCC_C_LANGUAGE_STANDARD = c99;
+				GCC_ENABLE_FIX_AND_CONTINUE = NO;
+				GCC_ENABLE_TRIGRAPHS = NO;
+				GCC_GENERATE_DEBUGGING_SYMBOLS = NO;
+				GCC_MODEL_TUNING = G4;
+				GCC_OPTIMIZATION_LEVEL = s;
+				GCC_PRECOMPILE_PREFIX_HEADER = YES;
+				GCC_PREFIX_HEADER = "";
+				GCC_WARN_ABOUT_MISSING_PROTOTYPES = NO;
+				GCC_WARN_FOUR_CHARACTER_CONSTANTS = NO;
+				GCC_WARN_UNKNOWN_PRAGMAS = NO;
+				HEADER_SEARCH_PATHS = "/vstsdk2.4/**";
+				INFOPLIST_FILE = ./mac/Info.plist;
+				LIBRARY_SEARCH_PATHS = "";
+				MACOSX_DEPLOYMENT_TARGET = 10.4;
+				OTHER_CFLAGS = "";
+				OTHER_LDFLAGS = "";
+				OTHER_REZFLAGS = "";
+				PRODUCT_NAME = PocketVerbs;
+				SDKROOT = /Developer/SDKs/MacOSX10.5.sdk;
+				SECTORDER_FLAGS = "";
+				SKIP_INSTALL = NO;
+				STRIP_INSTALLED_PRODUCT = YES;
+				STRIP_STYLE = all;
+				WARNING_CFLAGS = (
+					"-Wmost",
+					"-Wno-four-char-constants",
+					"-Wno-unknown-pragmas",
+				);
+				WRAPPER_EXTENSION = vst;
+			};
+			name = Release;
+		};
+		24BEAAF208919AE700E695F9 /* Debug */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ARCHS = "$(NATIVE_ARCH)";
+				GCC_MODEL_TUNING = G5;
+				GCC_OPTIMIZATION_LEVEL = 0;
+				GCC_PREPROCESSOR_DEFINITIONS = "DEBUG=1";
+				INFOPLIST_FILE = "";
+				INFOPLIST_PREPROCESS = NO;
+			};
+			name = Debug;
+		};
+		24BEAAF308919AE700E695F9 /* Release */ = {
+			isa = XCBuildConfiguration;
+			buildSettings = {
+				ARCHS = "$(ARCHS_STANDARD_32_64_BIT_PRE_XCODE_3_1)";
+				ARCHS_STANDARD_32_64_BIT_PRE_XCODE_3_1 = "x86_64 i386 ppc";
+				DEBUG_INFORMATION_FORMAT = "dwarf-with-dsym";
+				GCC_C_LANGUAGE_STANDARD = c99;
+				GCC_MODEL_TUNING = G4;
+				GCC_OPTIMIZATION_LEVEL = s;
+				INFOPLIST_FILE = "";
+				INFOPLIST_PREPROCESS = NO;
+				SDKROOT = "$(DEVELOPER_SDK_DIR)/MacOSX10.6.sdk";
+			};
+			name = Release;
+		};
+/* End XCBuildConfiguration section */
+
+/* Begin XCConfigurationList section */
+		24BEAAED08919AE700E695F9 /* Build configuration list for PBXNativeTarget "PocketVerbs" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				24BEAAEE08919AE700E695F9 /* Debug */,
+				24BEAAEF08919AE700E695F9 /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Debug;
+		};
+		24BEAAF108919AE700E695F9 /* Build configuration list for PBXProject "PocketVerbs" */ = {
+			isa = XCConfigurationList;
+			buildConfigurations = (
+				24BEAAF208919AE700E695F9 /* Debug */,
+				24BEAAF308919AE700E695F9 /* Release */,
+			);
+			defaultConfigurationIsVisible = 0;
+			defaultConfigurationName = Debug;
+		};
+/* End XCConfigurationList section */
+	};
+	rootObject = 089C1669FE841209C02AAC07 /* Project object */;
+}
diff --git a/plugins/MacVST/PocketVerbs/PocketVerbs.xcodeproj/project.xcworkspace/contents.xcworkspacedata b/plugins/MacVST/PocketVerbs/PocketVerbs.xcodeproj/project.xcworkspace/contents.xcworkspacedata
new file mode 100755
index 0000000..a80c038
--- /dev/null
+++ b/plugins/MacVST/PocketVerbs/PocketVerbs.xcodeproj/project.xcworkspace/contents.xcworkspacedata
@@ -0,0 +1,7 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Workspace
+   version = "1.0">
+   <FileRef
+      location = "self:Sample.xcodeproj">
+   </FileRef>
+</Workspace>
diff --git a/plugins/MacVST/PocketVerbs/PocketVerbs.xcodeproj/project.xcworkspace/xcuserdata/christopherjohnson.xcuserdatad/UserInterfaceState.xcuserstate b/plugins/MacVST/PocketVerbs/PocketVerbs.xcodeproj/project.xcworkspace/xcuserdata/christopherjohnson.xcuserdatad/UserInterfaceState.xcuserstate
new file mode 100755
index 0000000..5c38f94
--- /dev/null
+++ b/plugins/MacVST/PocketVerbs/PocketVerbs.xcodeproj/project.xcworkspace/xcuserdata/christopherjohnson.xcuserdatad/UserInterfaceState.xcuserstate
diff --git a/plugins/MacVST/PocketVerbs/PocketVerbs.xcodeproj/project.xcworkspace/xcuserdata/spiadmin.xcuserdatad/UserInterfaceState.xcuserstate b/plugins/MacVST/PocketVerbs/PocketVerbs.xcodeproj/project.xcworkspace/xcuserdata/spiadmin.xcuserdatad/UserInterfaceState.xcuserstate
new file mode 100755
index 0000000..314de0f
--- /dev/null
+++ b/plugins/MacVST/PocketVerbs/PocketVerbs.xcodeproj/project.xcworkspace/xcuserdata/spiadmin.xcuserdatad/UserInterfaceState.xcuserstate
diff --git a/plugins/MacVST/PocketVerbs/PocketVerbs.xcodeproj/spiadmin.mode1v3 b/plugins/MacVST/PocketVerbs/PocketVerbs.xcodeproj/spiadmin.mode1v3
new file mode 100755
index 0000000..c572326
--- /dev/null
+++ b/plugins/MacVST/PocketVerbs/PocketVerbs.xcodeproj/spiadmin.mode1v3
@@ -0,0 +1,1372 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>ActivePerspectiveName</key>
+	<string>Project</string>
+	<key>AllowedModules</key>
+	<array>
+		<dict>
+			<key>BundleLoadPath</key>
+			<string></string>
+			<key>MaxInstances</key>
+			<string>n</string>
+			<key>Module</key>
+			<string>PBXSmartGroupTreeModule</string>
+			<key>Name</key>
+			<string>Groups and Files Outline View</string>
+		</dict>
+		<dict>
+			<key>BundleLoadPath</key>
+			<string></string>
+			<key>MaxInstances</key>
+			<string>n</string>
+			<key>Module</key>
+			<string>PBXNavigatorGroup</string>
+			<key>Name</key>
+			<string>Editor</string>
+		</dict>
+		<dict>
+			<key>BundleLoadPath</key>
+			<string></string>
+			<key>MaxInstances</key>
+			<string>n</string>
+			<key>Module</key>
+			<string>XCTaskListModule</string>
+			<key>Name</key>
+			<string>Task List</string>
+		</dict>
+		<dict>
+			<key>BundleLoadPath</key>
+			<string></string>
+			<key>MaxInstances</key>
+			<string>n</string>
+			<key>Module</key>
+			<string>XCDetailModule</string>
+			<key>Name</key>
+			<string>File and Smart Group Detail Viewer</string>
+		</dict>
+		<dict>
+			<key>BundleLoadPath</key>
+			<string></string>
+			<key>MaxInstances</key>
+			<string>1</string>
+			<key>Module</key>
+			<string>PBXBuildResultsModule</string>
+			<key>Name</key>
+			<string>Detailed Build Results Viewer</string>
+		</dict>
+		<dict>
+			<key>BundleLoadPath</key>
+			<string></string>
+			<key>MaxInstances</key>
+			<string>1</string>
+			<key>Module</key>
+			<string>PBXProjectFindModule</string>
+			<key>Name</key>
+			<string>Project Batch Find Tool</string>
+		</dict>
+		<dict>
+			<key>BundleLoadPath</key>
+			<string></string>
+			<key>MaxInstances</key>
+			<string>n</string>
+			<key>Module</key>
+			<string>XCProjectFormatConflictsModule</string>
+			<key>Name</key>
+			<string>Project Format Conflicts List</string>
+		</dict>
+		<dict>
+			<key>BundleLoadPath</key>
+			<string></string>
+			<key>MaxInstances</key>
+			<string>n</string>
+			<key>Module</key>
+			<string>PBXBookmarksModule</string>
+			<key>Name</key>
+			<string>Bookmarks Tool</string>
+		</dict>
+		<dict>
+			<key>BundleLoadPath</key>
+			<string></string>
+			<key>MaxInstances</key>
+			<string>n</string>
+			<key>Module</key>
+			<string>PBXClassBrowserModule</string>
+			<key>Name</key>
+			<string>Class Browser</string>
+		</dict>
+		<dict>
+			<key>BundleLoadPath</key>
+			<string></string>
+			<key>MaxInstances</key>
+			<string>n</string>
+			<key>Module</key>
+			<string>PBXCVSModule</string>
+			<key>Name</key>
+			<string>Source Code Control Tool</string>
+		</dict>
+		<dict>
+			<key>BundleLoadPath</key>
+			<string></string>
+			<key>MaxInstances</key>
+			<string>n</string>
+			<key>Module</key>
+			<string>PBXDebugBreakpointsModule</string>
+			<key>Name</key>
+			<string>Debug Breakpoints Tool</string>
+		</dict>
+		<dict>
+			<key>BundleLoadPath</key>
+			<string></string>
+			<key>MaxInstances</key>
+			<string>n</string>
+			<key>Module</key>
+			<string>XCDockableInspector</string>
+			<key>Name</key>
+			<string>Inspector</string>
+		</dict>
+		<dict>
+			<key>BundleLoadPath</key>
+			<string></string>
+			<key>MaxInstances</key>
+			<string>n</string>
+			<key>Module</key>
+			<string>PBXOpenQuicklyModule</string>
+			<key>Name</key>
+			<string>Open Quickly Tool</string>
+		</dict>
+		<dict>
+			<key>BundleLoadPath</key>
+			<string></string>
+			<key>MaxInstances</key>
+			<string>1</string>
+			<key>Module</key>
+			<string>PBXDebugSessionModule</string>
+			<key>Name</key>
+			<string>Debugger</string>
+		</dict>
+		<dict>
+			<key>BundleLoadPath</key>
+			<string></string>
+			<key>MaxInstances</key>
+			<string>1</string>
+			<key>Module</key>
+			<string>PBXDebugCLIModule</string>
+			<key>Name</key>
+			<string>Debug Console</string>
+		</dict>
+		<dict>
+			<key>BundleLoadPath</key>
+			<string></string>
+			<key>MaxInstances</key>
+			<string>n</string>
+			<key>Module</key>
+			<string>XCSnapshotModule</string>
+			<key>Name</key>
+			<string>Snapshots Tool</string>
+		</dict>
+	</array>
+	<key>BundlePath</key>
+	<string>/Xcode3/Library/PrivateFrameworks/DevToolsInterface.framework/Resources</string>
+	<key>Description</key>
+	<string>DefaultDescriptionKey</string>
+	<key>DockingSystemVisible</key>
+	<false/>
+	<key>Extension</key>
+	<string>mode1v3</string>
+	<key>FavBarConfig</key>
+	<dict>
+		<key>PBXProjectModuleGUID</key>
+		<string>91857D9F148EF61800AAA11B</string>
+		<key>XCBarModuleItemNames</key>
+		<dict/>
+		<key>XCBarModuleItems</key>
+		<array/>
+	</dict>
+	<key>FirstTimeWindowDisplayed</key>
+	<false/>
+	<key>Identifier</key>
+	<string>com.apple.perspectives.project.mode1v3</string>
+	<key>MajorVersion</key>
+	<integer>33</integer>
+	<key>MinorVersion</key>
+	<integer>0</integer>
+	<key>Name</key>
+	<string>Default</string>
+	<key>Notifications</key>
+	<array/>
+	<key>OpenEditors</key>
+	<array/>
+	<key>PerspectiveWidths</key>
+	<array>
+		<integer>-1</integer>
+		<integer>-1</integer>
+	</array>
+	<key>Perspectives</key>
+	<array>
+		<dict>
+			<key>ChosenToolbarItems</key>
+			<array>
+				<string>active-combo-popup</string>
+				<string>action</string>
+				<string>NSToolbarFlexibleSpaceItem</string>
+				<string>debugger-enable-breakpoints</string>
+				<string>build-and-go</string>
+				<string>com.apple.ide.PBXToolbarStopButton</string>
+				<string>get-info</string>
+				<string>NSToolbarFlexibleSpaceItem</string>
+				<string>com.apple.pbx.toolbar.searchfield</string>
+			</array>
+			<key>ControllerClassBaseName</key>
+			<string></string>
+			<key>IconName</key>
+			<string>WindowOfProjectWithEditor</string>
+			<key>Identifier</key>
+			<string>perspective.project</string>
+			<key>IsVertical</key>
+			<false/>
+			<key>Layout</key>
+			<array>
+				<dict>
+					<key>ContentConfiguration</key>
+					<dict>
+						<key>PBXBottomSmartGroupGIDs</key>
+						<array>
+							<string>1C37FBAC04509CD000000102</string>
+							<string>1C37FAAC04509CD000000102</string>
+							<string>1C37FABC05509CD000000102</string>
+							<string>1C37FABC05539CD112110102</string>
+							<string>E2644B35053B69B200211256</string>
+							<string>1C37FABC04509CD000100104</string>
+							<string>1CC0EA4004350EF90044410B</string>
+							<string>1CC0EA4004350EF90041110B</string>
+						</array>
+						<key>PBXProjectModuleGUID</key>
+						<string>1CE0B1FE06471DED0097A5F4</string>
+						<key>PBXProjectModuleLabel</key>
+						<string>Files</string>
+						<key>PBXProjectStructureProvided</key>
+						<string>yes</string>
+						<key>PBXSmartGroupTreeModuleColumnData</key>
+						<dict>
+							<key>PBXSmartGroupTreeModuleColumnWidthsKey</key>
+							<array>
+								<real>186</real>
+							</array>
+							<key>PBXSmartGroupTreeModuleColumnsKey_v4</key>
+							<array>
+								<string>MainColumn</string>
+							</array>
+						</dict>
+						<key>PBXSmartGroupTreeModuleOutlineStateKey_v7</key>
+						<dict>
+							<key>PBXSmartGroupTreeModuleOutlineStateExpansionKey</key>
+							<array>
+								<string>089C166AFE841209C02AAC07</string>
+								<string>089C1671FE841209C02AAC07</string>
+								<string>19C28FB4FE9D528D11CA2CBB</string>
+								<string>089C167CFE841241C02AAC07</string>
+								<string>08FB77ADFE841716C02AAC07</string>
+								<string>1C37FBAC04509CD000000102</string>
+								<string>1C37FABC05509CD000000102</string>
+							</array>
+							<key>PBXSmartGroupTreeModuleOutlineStateSelectionKey</key>
+							<array>
+								<array>
+									<integer>11</integer>
+									<integer>10</integer>
+									<integer>0</integer>
+								</array>
+							</array>
+							<key>PBXSmartGroupTreeModuleOutlineStateVisibleRectKey</key>
+							<string>{{0, 0}, {186, 693}}</string>
+						</dict>
+						<key>PBXTopSmartGroupGIDs</key>
+						<array/>
+						<key>XCIncludePerspectivesSwitch</key>
+						<true/>
+						<key>XCSharingToken</key>
+						<string>com.apple.Xcode.GFSharingToken</string>
+					</dict>
+					<key>GeometryConfiguration</key>
+					<dict>
+						<key>Frame</key>
+						<string>{{0, 0}, {203, 711}}</string>
+						<key>GroupTreeTableConfiguration</key>
+						<array>
+							<string>MainColumn</string>
+							<real>186</real>
+						</array>
+						<key>RubberWindowFrame</key>
+						<string>286 197 1261 752 0 0 1680 1028 </string>
+					</dict>
+					<key>Module</key>
+					<string>PBXSmartGroupTreeModule</string>
+					<key>Proportion</key>
+					<string>203pt</string>
+				</dict>
+				<dict>
+					<key>Dock</key>
+					<array>
+						<dict>
+							<key>BecomeActive</key>
+							<true/>
+							<key>ContentConfiguration</key>
+							<dict>
+								<key>PBXProjectModuleGUID</key>
+								<string>1CE0B20306471E060097A5F4</string>
+								<key>PBXProjectModuleLabel</key>
+								<string>Gain.cpp</string>
+								<key>PBXSplitModuleInNavigatorKey</key>
+								<dict>
+									<key>Split0</key>
+									<dict>
+										<key>PBXProjectModuleGUID</key>
+										<string>1CE0B20406471E060097A5F4</string>
+										<key>PBXProjectModuleLabel</key>
+										<string>Gain.cpp</string>
+										<key>_historyCapacity</key>
+										<integer>0</integer>
+										<key>bookmark</key>
+										<string>911C2A9D1491A5F600A430AF</string>
+										<key>history</key>
+										<array>
+											<string>915DCCBB1491A5B8008574E6</string>
+										</array>
+									</dict>
+									<key>SplitCount</key>
+									<string>1</string>
+								</dict>
+								<key>StatusBarVisibility</key>
+								<true/>
+							</dict>
+							<key>GeometryConfiguration</key>
+							<dict>
+								<key>Frame</key>
+								<string>{{0, 0}, {1053, 508}}</string>
+								<key>RubberWindowFrame</key>
+								<string>286 197 1261 752 0 0 1680 1028 </string>
+							</dict>
+							<key>Module</key>
+							<string>PBXNavigatorGroup</string>
+							<key>Proportion</key>
+							<string>508pt</string>
+						</dict>
+						<dict>
+							<key>ContentConfiguration</key>
+							<dict>
+								<key>PBXProjectModuleGUID</key>
+								<string>1CE0B20506471E060097A5F4</string>
+								<key>PBXProjectModuleLabel</key>
+								<string>Detail</string>
+							</dict>
+							<key>GeometryConfiguration</key>
+							<dict>
+								<key>Frame</key>
+								<string>{{0, 513}, {1053, 198}}</string>
+								<key>RubberWindowFrame</key>
+								<string>286 197 1261 752 0 0 1680 1028 </string>
+							</dict>
+							<key>Module</key>
+							<string>XCDetailModule</string>
+							<key>Proportion</key>
+							<string>198pt</string>
+						</dict>
+					</array>
+					<key>Proportion</key>
+					<string>1053pt</string>
+				</dict>
+			</array>
+			<key>Name</key>
+			<string>Project</string>
+			<key>ServiceClasses</key>
+			<array>
+				<string>XCModuleDock</string>
+				<string>PBXSmartGroupTreeModule</string>
+				<string>XCModuleDock</string>
+				<string>PBXNavigatorGroup</string>
+				<string>XCDetailModule</string>
+			</array>
+			<key>TableOfContents</key>
+			<array>
+				<string>911C2A901491A5F600A430AF</string>
+				<string>1CE0B1FE06471DED0097A5F4</string>
+				<string>911C2A911491A5F600A430AF</string>
+				<string>1CE0B20306471E060097A5F4</string>
+				<string>1CE0B20506471E060097A5F4</string>
+			</array>
+			<key>ToolbarConfigUserDefaultsMinorVersion</key>
+			<string>2</string>
+			<key>ToolbarConfiguration</key>
+			<string>xcode.toolbar.config.defaultV3</string>
+		</dict>
+		<dict>
+			<key>ControllerClassBaseName</key>
+			<string></string>
+			<key>IconName</key>
+			<string>WindowOfProject</string>
+			<key>Identifier</key>
+			<string>perspective.morph</string>
+			<key>IsVertical</key>
+			<integer>0</integer>
+			<key>Layout</key>
+			<array>
+				<dict>
+					<key>BecomeActive</key>
+					<integer>1</integer>
+					<key>ContentConfiguration</key>
+					<dict>
+						<key>PBXBottomSmartGroupGIDs</key>
+						<array>
+							<string>1C37FBAC04509CD000000102</string>
+							<string>1C37FAAC04509CD000000102</string>
+							<string>1C08E77C0454961000C914BD</string>
+							<string>1C37FABC05509CD000000102</string>
+							<string>1C37FABC05539CD112110102</string>
+							<string>E2644B35053B69B200211256</string>
+							<string>1C37FABC04509CD000100104</string>
+							<string>1CC0EA4004350EF90044410B</string>
+							<string>1CC0EA4004350EF90041110B</string>
+						</array>
+						<key>PBXProjectModuleGUID</key>
+						<string>11E0B1FE06471DED0097A5F4</string>
+						<key>PBXProjectModuleLabel</key>
+						<string>Files</string>
+						<key>PBXProjectStructureProvided</key>
+						<string>yes</string>
+						<key>PBXSmartGroupTreeModuleColumnData</key>
+						<dict>
+							<key>PBXSmartGroupTreeModuleColumnWidthsKey</key>
+							<array>
+								<real>186</real>
+							</array>
+							<key>PBXSmartGroupTreeModuleColumnsKey_v4</key>
+							<array>
+								<string>MainColumn</string>
+							</array>
+						</dict>
+						<key>PBXSmartGroupTreeModuleOutlineStateKey_v7</key>
+						<dict>
+							<key>PBXSmartGroupTreeModuleOutlineStateExpansionKey</key>
+							<array>
+								<string>29B97314FDCFA39411CA2CEA</string>
+								<string>1C37FABC05509CD000000102</string>
+							</array>
+							<key>PBXSmartGroupTreeModuleOutlineStateSelectionKey</key>
+							<array>
+								<array>
+									<integer>0</integer>
+								</array>
+							</array>
+							<key>PBXSmartGroupTreeModuleOutlineStateVisibleRectKey</key>
+							<string>{{0, 0}, {186, 337}}</string>
+						</dict>
+						<key>PBXTopSmartGroupGIDs</key>
+						<array/>
+						<key>XCIncludePerspectivesSwitch</key>
+						<integer>1</integer>
+						<key>XCSharingToken</key>
+						<string>com.apple.Xcode.GFSharingToken</string>
+					</dict>
+					<key>GeometryConfiguration</key>
+					<dict>
+						<key>Frame</key>
+						<string>{{0, 0}, {203, 355}}</string>
+						<key>GroupTreeTableConfiguration</key>
+						<array>
+							<string>MainColumn</string>
+							<real>186</real>
+						</array>
+						<key>RubberWindowFrame</key>
+						<string>373 269 690 397 0 0 1440 878 </string>
+					</dict>
+					<key>Module</key>
+					<string>PBXSmartGroupTreeModule</string>
+					<key>Proportion</key>
+					<string>100%</string>
+				</dict>
+			</array>
+			<key>Name</key>
+			<string>Morph</string>
+			<key>PreferredWidth</key>
+			<integer>300</integer>
+			<key>ServiceClasses</key>
+			<array>
+				<string>XCModuleDock</string>
+				<string>PBXSmartGroupTreeModule</string>
+			</array>
+			<key>TableOfContents</key>
+			<array>
+				<string>11E0B1FE06471DED0097A5F4</string>
+			</array>
+			<key>ToolbarConfiguration</key>
+			<string>xcode.toolbar.config.default.shortV3</string>
+		</dict>
+	</array>
+	<key>PerspectivesBarVisible</key>
+	<false/>
+	<key>ShelfIsVisible</key>
+	<false/>
+	<key>SourceDescription</key>
+	<string>file at '/Xcode3/Library/PrivateFrameworks/DevToolsInterface.framework/Resources/XCPerspectivesSpecificationMode1.xcperspec'</string>
+	<key>StatusbarIsVisible</key>
+	<true/>
+	<key>TimeStamp</key>
+	<real>0.0</real>
+	<key>ToolbarConfigUserDefaultsMinorVersion</key>
+	<string>2</string>
+	<key>ToolbarDisplayMode</key>
+	<integer>1</integer>
+	<key>ToolbarIsVisible</key>
+	<true/>
+	<key>ToolbarSizeMode</key>
+	<integer>1</integer>
+	<key>Type</key>
+	<string>Perspectives</string>
+	<key>UpdateMessage</key>
+	<string>The Default Workspace in this version of Xcode now includes support to hide and show the detail view (what has been referred to as the "Metro-Morph" feature).  You must discard your current Default Workspace settings and update to the latest Default Workspace in order to gain this feature.  Do you wish to update to the latest Workspace defaults for project '%@'?</string>
+	<key>WindowJustification</key>
+	<integer>5</integer>
+	<key>WindowOrderList</key>
+	<array>
+		<string>91857DA0148EF61800AAA11B</string>
+		<string>/Users/spiadmin/Documents/Gain/Gain.xcodeproj</string>
+	</array>
+	<key>WindowString</key>
+	<string>286 197 1261 752 0 0 1680 1028 </string>
+	<key>WindowToolsV3</key>
+	<array>
+		<dict>
+			<key>FirstTimeWindowDisplayed</key>
+			<false/>
+			<key>Identifier</key>
+			<string>windowTool.build</string>
+			<key>IsVertical</key>
+			<true/>
+			<key>Layout</key>
+			<array>
+				<dict>
+					<key>Dock</key>
+					<array>
+						<dict>
+							<key>ContentConfiguration</key>
+							<dict>
+								<key>PBXProjectModuleGUID</key>
+								<string>1CD0528F0623707200166675</string>
+								<key>PBXProjectModuleLabel</key>
+								<string></string>
+								<key>StatusBarVisibility</key>
+								<true/>
+							</dict>
+							<key>GeometryConfiguration</key>
+							<dict>
+								<key>Frame</key>
+								<string>{{0, 0}, {743, 413}}</string>
+								<key>RubberWindowFrame</key>
+								<string>112 208 743 695 0 0 1680 1028 </string>
+							</dict>
+							<key>Module</key>
+							<string>PBXNavigatorGroup</string>
+							<key>Proportion</key>
+							<string>413pt</string>
+						</dict>
+						<dict>
+							<key>ContentConfiguration</key>
+							<dict>
+								<key>PBXProjectModuleGUID</key>
+								<string>XCMainBuildResultsModuleGUID</string>
+								<key>PBXProjectModuleLabel</key>
+								<string>Build Results</string>
+								<key>XCBuildResultsTrigger_Collapse</key>
+								<integer>1021</integer>
+								<key>XCBuildResultsTrigger_Open</key>
+								<integer>1011</integer>
+							</dict>
+							<key>GeometryConfiguration</key>
+							<dict>
+								<key>Frame</key>
+								<string>{{0, 418}, {743, 236}}</string>
+								<key>RubberWindowFrame</key>
+								<string>112 208 743 695 0 0 1680 1028 </string>
+							</dict>
+							<key>Module</key>
+							<string>PBXBuildResultsModule</string>
+							<key>Proportion</key>
+							<string>236pt</string>
+						</dict>
+					</array>
+					<key>Proportion</key>
+					<string>654pt</string>
+				</dict>
+			</array>
+			<key>Name</key>
+			<string>Build Results</string>
+			<key>ServiceClasses</key>
+			<array>
+				<string>PBXBuildResultsModule</string>
+			</array>
+			<key>StatusbarIsVisible</key>
+			<true/>
+			<key>TableOfContents</key>
+			<array>
+				<string>91857DA0148EF61800AAA11B</string>
+				<string>911C2A921491A5F600A430AF</string>
+				<string>1CD0528F0623707200166675</string>
+				<string>XCMainBuildResultsModuleGUID</string>
+			</array>
+			<key>ToolbarConfiguration</key>
+			<string>xcode.toolbar.config.buildV3</string>
+			<key>WindowContentMinSize</key>
+			<string>486 300</string>
+			<key>WindowString</key>
+			<string>112 208 743 695 0 0 1680 1028 </string>
+			<key>WindowToolGUID</key>
+			<string>91857DA0148EF61800AAA11B</string>
+			<key>WindowToolIsVisible</key>
+			<false/>
+		</dict>
+		<dict>
+			<key>Identifier</key>
+			<string>windowTool.debugger</string>
+			<key>Layout</key>
+			<array>
+				<dict>
+					<key>Dock</key>
+					<array>
+						<dict>
+							<key>ContentConfiguration</key>
+							<dict>
+								<key>Debugger</key>
+								<dict>
+									<key>HorizontalSplitView</key>
+									<dict>
+										<key>_collapsingFrameDimension</key>
+										<real>0.0</real>
+										<key>_indexOfCollapsedView</key>
+										<integer>0</integer>
+										<key>_percentageOfCollapsedView</key>
+										<real>0.0</real>
+										<key>isCollapsed</key>
+										<string>yes</string>
+										<key>sizes</key>
+										<array>
+											<string>{{0, 0}, {317, 164}}</string>
+											<string>{{317, 0}, {377, 164}}</string>
+										</array>
+									</dict>
+									<key>VerticalSplitView</key>
+									<dict>
+										<key>_collapsingFrameDimension</key>
+										<real>0.0</real>
+										<key>_indexOfCollapsedView</key>
+										<integer>0</integer>
+										<key>_percentageOfCollapsedView</key>
+										<real>0.0</real>
+										<key>isCollapsed</key>
+										<string>yes</string>
+										<key>sizes</key>
+										<array>
+											<string>{{0, 0}, {694, 164}}</string>
+											<string>{{0, 164}, {694, 216}}</string>
+										</array>
+									</dict>
+								</dict>
+								<key>LauncherConfigVersion</key>
+								<string>8</string>
+								<key>PBXProjectModuleGUID</key>
+								<string>1C162984064C10D400B95A72</string>
+								<key>PBXProjectModuleLabel</key>
+								<string>Debug - GLUTExamples (Underwater)</string>
+							</dict>
+							<key>GeometryConfiguration</key>
+							<dict>
+								<key>DebugConsoleDrawerSize</key>
+								<string>{100, 120}</string>
+								<key>DebugConsoleVisible</key>
+								<string>None</string>
+								<key>DebugConsoleWindowFrame</key>
+								<string>{{200, 200}, {500, 300}}</string>
+								<key>DebugSTDIOWindowFrame</key>
+								<string>{{200, 200}, {500, 300}}</string>
+								<key>Frame</key>
+								<string>{{0, 0}, {694, 380}}</string>
+								<key>RubberWindowFrame</key>
+								<string>321 238 694 422 0 0 1440 878 </string>
+							</dict>
+							<key>Module</key>
+							<string>PBXDebugSessionModule</string>
+							<key>Proportion</key>
+							<string>100%</string>
+						</dict>
+					</array>
+					<key>Proportion</key>
+					<string>100%</string>
+				</dict>
+			</array>
+			<key>Name</key>
+			<string>Debugger</string>
+			<key>ServiceClasses</key>
+			<array>
+				<string>PBXDebugSessionModule</string>
+			</array>
+			<key>StatusbarIsVisible</key>
+			<integer>1</integer>
+			<key>TableOfContents</key>
+			<array>
+				<string>1CD10A99069EF8BA00B06720</string>
+				<string>1C0AD2AB069F1E9B00FABCE6</string>
+				<string>1C162984064C10D400B95A72</string>
+				<string>1C0AD2AC069F1E9B00FABCE6</string>
+			</array>
+			<key>ToolbarConfiguration</key>
+			<string>xcode.toolbar.config.debugV3</string>
+			<key>WindowString</key>
+			<string>321 238 694 422 0 0 1440 878 </string>
+			<key>WindowToolGUID</key>
+			<string>1CD10A99069EF8BA00B06720</string>
+			<key>WindowToolIsVisible</key>
+			<integer>0</integer>
+		</dict>
+		<dict>
+			<key>Identifier</key>
+			<string>windowTool.find</string>
+			<key>Layout</key>
+			<array>
+				<dict>
+					<key>Dock</key>
+					<array>
+						<dict>
+							<key>Dock</key>
+							<array>
+								<dict>
+									<key>ContentConfiguration</key>
+									<dict>
+										<key>PBXProjectModuleGUID</key>
+										<string>1CDD528C0622207200134675</string>
+										<key>PBXProjectModuleLabel</key>
+										<string>&lt;No Editor&gt;</string>
+										<key>PBXSplitModuleInNavigatorKey</key>
+										<dict>
+											<key>Split0</key>
+											<dict>
+												<key>PBXProjectModuleGUID</key>
+												<string>1CD0528D0623707200166675</string>
+											</dict>
+											<key>SplitCount</key>
+											<string>1</string>
+										</dict>
+										<key>StatusBarVisibility</key>
+										<integer>1</integer>
+									</dict>
+									<key>GeometryConfiguration</key>
+									<dict>
+										<key>Frame</key>
+										<string>{{0, 0}, {781, 167}}</string>
+										<key>RubberWindowFrame</key>
+										<string>62 385 781 470 0 0 1440 878 </string>
+									</dict>
+									<key>Module</key>
+									<string>PBXNavigatorGroup</string>
+									<key>Proportion</key>
+									<string>781pt</string>
+								</dict>
+							</array>
+							<key>Proportion</key>
+							<string>50%</string>
+						</dict>
+						<dict>
+							<key>BecomeActive</key>
+							<integer>1</integer>
+							<key>ContentConfiguration</key>
+							<dict>
+								<key>PBXProjectModuleGUID</key>
+								<string>1CD0528E0623707200166675</string>
+								<key>PBXProjectModuleLabel</key>
+								<string>Project Find</string>
+							</dict>
+							<key>GeometryConfiguration</key>
+							<dict>
+								<key>Frame</key>
+								<string>{{8, 0}, {773, 254}}</string>
+								<key>RubberWindowFrame</key>
+								<string>62 385 781 470 0 0 1440 878 </string>
+							</dict>
+							<key>Module</key>
+							<string>PBXProjectFindModule</string>
+							<key>Proportion</key>
+							<string>50%</string>
+						</dict>
+					</array>
+					<key>Proportion</key>
+					<string>428pt</string>
+				</dict>
+			</array>
+			<key>Name</key>
+			<string>Project Find</string>
+			<key>ServiceClasses</key>
+			<array>
+				<string>PBXProjectFindModule</string>
+			</array>
+			<key>StatusbarIsVisible</key>
+			<integer>1</integer>
+			<key>TableOfContents</key>
+			<array>
+				<string>1C530D57069F1CE1000CFCEE</string>
+				<string>1C530D58069F1CE1000CFCEE</string>
+				<string>1C530D59069F1CE1000CFCEE</string>
+				<string>1CDD528C0622207200134675</string>
+				<string>1C530D5A069F1CE1000CFCEE</string>
+				<string>1CE0B1FE06471DED0097A5F4</string>
+				<string>1CD0528E0623707200166675</string>
+			</array>
+			<key>WindowString</key>
+			<string>62 385 781 470 0 0 1440 878 </string>
+			<key>WindowToolGUID</key>
+			<string>1C530D57069F1CE1000CFCEE</string>
+			<key>WindowToolIsVisible</key>
+			<integer>0</integer>
+		</dict>
+		<dict>
+			<key>Identifier</key>
+			<string>MENUSEPARATOR</string>
+		</dict>
+		<dict>
+			<key>Identifier</key>
+			<string>windowTool.debuggerConsole</string>
+			<key>Layout</key>
+			<array>
+				<dict>
+					<key>Dock</key>
+					<array>
+						<dict>
+							<key>BecomeActive</key>
+							<integer>1</integer>
+							<key>ContentConfiguration</key>
+							<dict>
+								<key>PBXProjectModuleGUID</key>
+								<string>1C78EAAC065D492600B07095</string>
+								<key>PBXProjectModuleLabel</key>
+								<string>Debugger Console</string>
+							</dict>
+							<key>GeometryConfiguration</key>
+							<dict>
+								<key>Frame</key>
+								<string>{{0, 0}, {650, 250}}</string>
+								<key>RubberWindowFrame</key>
+								<string>516 632 650 250 0 0 1680 1027 </string>
+							</dict>
+							<key>Module</key>
+							<string>PBXDebugCLIModule</string>
+							<key>Proportion</key>
+							<string>209pt</string>
+						</dict>
+					</array>
+					<key>Proportion</key>
+					<string>209pt</string>
+				</dict>
+			</array>
+			<key>Name</key>
+			<string>Debugger Console</string>
+			<key>ServiceClasses</key>
+			<array>
+				<string>PBXDebugCLIModule</string>
+			</array>
+			<key>StatusbarIsVisible</key>
+			<integer>1</integer>
+			<key>TableOfContents</key>
+			<array>
+				<string>1C78EAAD065D492600B07095</string>
+				<string>1C78EAAE065D492600B07095</string>
+				<string>1C78EAAC065D492600B07095</string>
+			</array>
+			<key>ToolbarConfiguration</key>
+			<string>xcode.toolbar.config.consoleV3</string>
+			<key>WindowString</key>
+			<string>650 41 650 250 0 0 1280 1002 </string>
+			<key>WindowToolGUID</key>
+			<string>1C78EAAD065D492600B07095</string>
+			<key>WindowToolIsVisible</key>
+			<integer>0</integer>
+		</dict>
+		<dict>
+			<key>Identifier</key>
+			<string>windowTool.snapshots</string>
+			<key>Layout</key>
+			<array>
+				<dict>
+					<key>Dock</key>
+					<array>
+						<dict>
+							<key>Module</key>
+							<string>XCSnapshotModule</string>
+							<key>Proportion</key>
+							<string>100%</string>
+						</dict>
+					</array>
+					<key>Proportion</key>
+					<string>100%</string>
+				</dict>
+			</array>
+			<key>Name</key>
+			<string>Snapshots</string>
+			<key>ServiceClasses</key>
+			<array>
+				<string>XCSnapshotModule</string>
+			</array>
+			<key>StatusbarIsVisible</key>
+			<string>Yes</string>
+			<key>ToolbarConfiguration</key>
+			<string>xcode.toolbar.config.snapshots</string>
+			<key>WindowString</key>
+			<string>315 824 300 550 0 0 1440 878 </string>
+			<key>WindowToolIsVisible</key>
+			<string>Yes</string>
+		</dict>
+		<dict>
+			<key>Identifier</key>
+			<string>windowTool.scm</string>
+			<key>Layout</key>
+			<array>
+				<dict>
+					<key>Dock</key>
+					<array>
+						<dict>
+							<key>ContentConfiguration</key>
+							<dict>
+								<key>PBXProjectModuleGUID</key>
+								<string>1C78EAB2065D492600B07095</string>
+								<key>PBXProjectModuleLabel</key>
+								<string>&lt;No Editor&gt;</string>
+								<key>PBXSplitModuleInNavigatorKey</key>
+								<dict>
+									<key>Split0</key>
+									<dict>
+										<key>PBXProjectModuleGUID</key>
+										<string>1C78EAB3065D492600B07095</string>
+									</dict>
+									<key>SplitCount</key>
+									<string>1</string>
+								</dict>
+								<key>StatusBarVisibility</key>
+								<integer>1</integer>
+							</dict>
+							<key>GeometryConfiguration</key>
+							<dict>
+								<key>Frame</key>
+								<string>{{0, 0}, {452, 0}}</string>
+								<key>RubberWindowFrame</key>
+								<string>743 379 452 308 0 0 1280 1002 </string>
+							</dict>
+							<key>Module</key>
+							<string>PBXNavigatorGroup</string>
+							<key>Proportion</key>
+							<string>0pt</string>
+						</dict>
+						<dict>
+							<key>BecomeActive</key>
+							<integer>1</integer>
+							<key>ContentConfiguration</key>
+							<dict>
+								<key>PBXProjectModuleGUID</key>
+								<string>1CD052920623707200166675</string>
+								<key>PBXProjectModuleLabel</key>
+								<string>SCM</string>
+							</dict>
+							<key>GeometryConfiguration</key>
+							<dict>
+								<key>ConsoleFrame</key>
+								<string>{{0, 259}, {452, 0}}</string>
+								<key>Frame</key>
+								<string>{{0, 7}, {452, 259}}</string>
+								<key>RubberWindowFrame</key>
+								<string>743 379 452 308 0 0 1280 1002 </string>
+								<key>TableConfiguration</key>
+								<array>
+									<string>Status</string>
+									<real>30</real>
+									<string>FileName</string>
+									<real>199</real>
+									<string>Path</string>
+									<real>197.0950012207031</real>
+								</array>
+								<key>TableFrame</key>
+								<string>{{0, 0}, {452, 250}}</string>
+							</dict>
+							<key>Module</key>
+							<string>PBXCVSModule</string>
+							<key>Proportion</key>
+							<string>262pt</string>
+						</dict>
+					</array>
+					<key>Proportion</key>
+					<string>266pt</string>
+				</dict>
+			</array>
+			<key>Name</key>
+			<string>SCM</string>
+			<key>ServiceClasses</key>
+			<array>
+				<string>PBXCVSModule</string>
+			</array>
+			<key>StatusbarIsVisible</key>
+			<integer>1</integer>
+			<key>TableOfContents</key>
+			<array>
+				<string>1C78EAB4065D492600B07095</string>
+				<string>1C78EAB5065D492600B07095</string>
+				<string>1C78EAB2065D492600B07095</string>
+				<string>1CD052920623707200166675</string>
+			</array>
+			<key>ToolbarConfiguration</key>
+			<string>xcode.toolbar.config.scm</string>
+			<key>WindowString</key>
+			<string>743 379 452 308 0 0 1280 1002 </string>
+		</dict>
+		<dict>
+			<key>Identifier</key>
+			<string>windowTool.breakpoints</string>
+			<key>IsVertical</key>
+			<integer>0</integer>
+			<key>Layout</key>
+			<array>
+				<dict>
+					<key>Dock</key>
+					<array>
+						<dict>
+							<key>BecomeActive</key>
+							<integer>1</integer>
+							<key>ContentConfiguration</key>
+							<dict>
+								<key>PBXBottomSmartGroupGIDs</key>
+								<array>
+									<string>1C77FABC04509CD000000102</string>
+								</array>
+								<key>PBXProjectModuleGUID</key>
+								<string>1CE0B1FE06471DED0097A5F4</string>
+								<key>PBXProjectModuleLabel</key>
+								<string>Files</string>
+								<key>PBXProjectStructureProvided</key>
+								<string>no</string>
+								<key>PBXSmartGroupTreeModuleColumnData</key>
+								<dict>
+									<key>PBXSmartGroupTreeModuleColumnWidthsKey</key>
+									<array>
+										<real>168</real>
+									</array>
+									<key>PBXSmartGroupTreeModuleColumnsKey_v4</key>
+									<array>
+										<string>MainColumn</string>
+									</array>
+								</dict>
+								<key>PBXSmartGroupTreeModuleOutlineStateKey_v7</key>
+								<dict>
+									<key>PBXSmartGroupTreeModuleOutlineStateExpansionKey</key>
+									<array>
+										<string>1C77FABC04509CD000000102</string>
+									</array>
+									<key>PBXSmartGroupTreeModuleOutlineStateSelectionKey</key>
+									<array>
+										<array>
+											<integer>0</integer>
+										</array>
+									</array>
+									<key>PBXSmartGroupTreeModuleOutlineStateVisibleRectKey</key>
+									<string>{{0, 0}, {168, 350}}</string>
+								</dict>
+								<key>PBXTopSmartGroupGIDs</key>
+								<array/>
+								<key>XCIncludePerspectivesSwitch</key>
+								<integer>0</integer>
+							</dict>
+							<key>GeometryConfiguration</key>
+							<dict>
+								<key>Frame</key>
+								<string>{{0, 0}, {185, 368}}</string>
+								<key>GroupTreeTableConfiguration</key>
+								<array>
+									<string>MainColumn</string>
+									<real>168</real>
+								</array>
+								<key>RubberWindowFrame</key>
+								<string>315 424 744 409 0 0 1440 878 </string>
+							</dict>
+							<key>Module</key>
+							<string>PBXSmartGroupTreeModule</string>
+							<key>Proportion</key>
+							<string>185pt</string>
+						</dict>
+						<dict>
+							<key>ContentConfiguration</key>
+							<dict>
+								<key>PBXProjectModuleGUID</key>
+								<string>1CA1AED706398EBD00589147</string>
+								<key>PBXProjectModuleLabel</key>
+								<string>Detail</string>
+							</dict>
+							<key>GeometryConfiguration</key>
+							<dict>
+								<key>Frame</key>
+								<string>{{190, 0}, {554, 368}}</string>
+								<key>RubberWindowFrame</key>
+								<string>315 424 744 409 0 0 1440 878 </string>
+							</dict>
+							<key>Module</key>
+							<string>XCDetailModule</string>
+							<key>Proportion</key>
+							<string>554pt</string>
+						</dict>
+					</array>
+					<key>Proportion</key>
+					<string>368pt</string>
+				</dict>
+			</array>
+			<key>MajorVersion</key>
+			<integer>3</integer>
+			<key>MinorVersion</key>
+			<integer>0</integer>
+			<key>Name</key>
+			<string>Breakpoints</string>
+			<key>ServiceClasses</key>
+			<array>
+				<string>PBXSmartGroupTreeModule</string>
+				<string>XCDetailModule</string>
+			</array>
+			<key>StatusbarIsVisible</key>
+			<integer>1</integer>
+			<key>TableOfContents</key>
+			<array>
+				<string>1CDDB66807F98D9800BB5817</string>
+				<string>1CDDB66907F98D9800BB5817</string>
+				<string>1CE0B1FE06471DED0097A5F4</string>
+				<string>1CA1AED706398EBD00589147</string>
+			</array>
+			<key>ToolbarConfiguration</key>
+			<string>xcode.toolbar.config.breakpointsV3</string>
+			<key>WindowString</key>
+			<string>315 424 744 409 0 0 1440 878 </string>
+			<key>WindowToolGUID</key>
+			<string>1CDDB66807F98D9800BB5817</string>
+			<key>WindowToolIsVisible</key>
+			<integer>1</integer>
+		</dict>
+		<dict>
+			<key>Identifier</key>
+			<string>windowTool.debugAnimator</string>
+			<key>Layout</key>
+			<array>
+				<dict>
+					<key>Dock</key>
+					<array>
+						<dict>
+							<key>Module</key>
+							<string>PBXNavigatorGroup</string>
+							<key>Proportion</key>
+							<string>100%</string>
+						</dict>
+					</array>
+					<key>Proportion</key>
+					<string>100%</string>
+				</dict>
+			</array>
+			<key>Name</key>
+			<string>Debug Visualizer</string>
+			<key>ServiceClasses</key>
+			<array>
+				<string>PBXNavigatorGroup</string>
+			</array>
+			<key>StatusbarIsVisible</key>
+			<integer>1</integer>
+			<key>ToolbarConfiguration</key>
+			<string>xcode.toolbar.config.debugAnimatorV3</string>
+			<key>WindowString</key>
+			<string>100 100 700 500 0 0 1280 1002 </string>
+		</dict>
+		<dict>
+			<key>Identifier</key>
+			<string>windowTool.bookmarks</string>
+			<key>Layout</key>
+			<array>
+				<dict>
+					<key>Dock</key>
+					<array>
+						<dict>
+							<key>Module</key>
+							<string>PBXBookmarksModule</string>
+							<key>Proportion</key>
+							<string>100%</string>
+						</dict>
+					</array>
+					<key>Proportion</key>
+					<string>100%</string>
+				</dict>
+			</array>
+			<key>Name</key>
+			<string>Bookmarks</string>
+			<key>ServiceClasses</key>
+			<array>
+				<string>PBXBookmarksModule</string>
+			</array>
+			<key>StatusbarIsVisible</key>
+			<integer>0</integer>
+			<key>WindowString</key>
+			<string>538 42 401 187 0 0 1280 1002 </string>
+		</dict>
+		<dict>
+			<key>Identifier</key>
+			<string>windowTool.projectFormatConflicts</string>
+			<key>Layout</key>
+			<array>
+				<dict>
+					<key>Dock</key>
+					<array>
+						<dict>
+							<key>Module</key>
+							<string>XCProjectFormatConflictsModule</string>
+							<key>Proportion</key>
+							<string>100%</string>
+						</dict>
+					</array>
+					<key>Proportion</key>
+					<string>100%</string>
+				</dict>
+			</array>
+			<key>Name</key>
+			<string>Project Format Conflicts</string>
+			<key>ServiceClasses</key>
+			<array>
+				<string>XCProjectFormatConflictsModule</string>
+			</array>
+			<key>StatusbarIsVisible</key>
+			<integer>0</integer>
+			<key>WindowContentMinSize</key>
+			<string>450 300</string>
+			<key>WindowString</key>
+			<string>50 850 472 307 0 0 1440 877</string>
+		</dict>
+		<dict>
+			<key>Identifier</key>
+			<string>windowTool.classBrowser</string>
+			<key>Layout</key>
+			<array>
+				<dict>
+					<key>Dock</key>
+					<array>
+						<dict>
+							<key>BecomeActive</key>
+							<integer>1</integer>
+							<key>ContentConfiguration</key>
+							<dict>
+								<key>OptionsSetName</key>
+								<string>Hierarchy, all classes</string>
+								<key>PBXProjectModuleGUID</key>
+								<string>1CA6456E063B45B4001379D8</string>
+								<key>PBXProjectModuleLabel</key>
+								<string>Class Browser - NSObject</string>
+							</dict>
+							<key>GeometryConfiguration</key>
+							<dict>
+								<key>ClassesFrame</key>
+								<string>{{0, 0}, {374, 96}}</string>
+								<key>ClassesTreeTableConfiguration</key>
+								<array>
+									<string>PBXClassNameColumnIdentifier</string>
+									<real>208</real>
+									<string>PBXClassBookColumnIdentifier</string>
+									<real>22</real>
+								</array>
+								<key>Frame</key>
+								<string>{{0, 0}, {630, 331}}</string>
+								<key>MembersFrame</key>
+								<string>{{0, 105}, {374, 395}}</string>
+								<key>MembersTreeTableConfiguration</key>
+								<array>
+									<string>PBXMemberTypeIconColumnIdentifier</string>
+									<real>22</real>
+									<string>PBXMemberNameColumnIdentifier</string>
+									<real>216</real>
+									<string>PBXMemberTypeColumnIdentifier</string>
+									<real>97</real>
+									<string>PBXMemberBookColumnIdentifier</string>
+									<real>22</real>
+								</array>
+								<key>PBXModuleWindowStatusBarHidden2</key>
+								<integer>1</integer>
+								<key>RubberWindowFrame</key>
+								<string>385 179 630 352 0 0 1440 878 </string>
+							</dict>
+							<key>Module</key>
+							<string>PBXClassBrowserModule</string>
+							<key>Proportion</key>
+							<string>332pt</string>
+						</dict>
+					</array>
+					<key>Proportion</key>
+					<string>332pt</string>
+				</dict>
+			</array>
+			<key>Name</key>
+			<string>Class Browser</string>
+			<key>ServiceClasses</key>
+			<array>
+				<string>PBXClassBrowserModule</string>
+			</array>
+			<key>StatusbarIsVisible</key>
+			<integer>0</integer>
+			<key>TableOfContents</key>
+			<array>
+				<string>1C0AD2AF069F1E9B00FABCE6</string>
+				<string>1C0AD2B0069F1E9B00FABCE6</string>
+				<string>1CA6456E063B45B4001379D8</string>
+			</array>
+			<key>ToolbarConfiguration</key>
+			<string>xcode.toolbar.config.classbrowser</string>
+			<key>WindowString</key>
+			<string>385 179 630 352 0 0 1440 878 </string>
+			<key>WindowToolGUID</key>
+			<string>1C0AD2AF069F1E9B00FABCE6</string>
+			<key>WindowToolIsVisible</key>
+			<integer>0</integer>
+		</dict>
+		<dict>
+			<key>Identifier</key>
+			<string>windowTool.refactoring</string>
+			<key>IncludeInToolsMenu</key>
+			<integer>0</integer>
+			<key>Layout</key>
+			<array>
+				<dict>
+					<key>Dock</key>
+					<array>
+						<dict>
+							<key>BecomeActive</key>
+							<integer>1</integer>
+							<key>GeometryConfiguration</key>
+							<dict>
+								<key>Frame</key>
+								<string>{0, 0}, {500, 335}</string>
+								<key>RubberWindowFrame</key>
+								<string>{0, 0}, {500, 335}</string>
+							</dict>
+							<key>Module</key>
+							<string>XCRefactoringModule</string>
+							<key>Proportion</key>
+							<string>100%</string>
+						</dict>
+					</array>
+					<key>Proportion</key>
+					<string>100%</string>
+				</dict>
+			</array>
+			<key>Name</key>
+			<string>Refactoring</string>
+			<key>ServiceClasses</key>
+			<array>
+				<string>XCRefactoringModule</string>
+			</array>
+			<key>WindowString</key>
+			<string>200 200 500 356 0 0 1920 1200 </string>
+		</dict>
+	</array>
+</dict>
+</plist>
diff --git a/plugins/MacVST/PocketVerbs/PocketVerbs.xcodeproj/spiadmin.pbxuser b/plugins/MacVST/PocketVerbs/PocketVerbs.xcodeproj/spiadmin.pbxuser
new file mode 100755
index 0000000..df94780
--- /dev/null
+++ b/plugins/MacVST/PocketVerbs/PocketVerbs.xcodeproj/spiadmin.pbxuser
@@ -0,0 +1,143 @@
+// !$*UTF8*$!
+{
+	089C1669FE841209C02AAC07 /* Project object */ = {
+		activeBuildConfigurationName = Release;
+		activeTarget = 8D01CCC60486CAD60068D4B7 /* Gain */;
+		codeSenseManager = 91857D95148EF55400AAA11B /* Code sense */;
+		perUserDictionary = {
+			PBXConfiguration.PBXFileTableDataSource3.PBXFileTableDataSource = {
+				PBXFileTableDataSourceColumnSortingDirectionKey = "-1";
+				PBXFileTableDataSourceColumnSortingKey = PBXFileDataSource_Filename_ColumnID;
+				PBXFileTableDataSourceColumnWidthsKey = (
+					20,
+					829,
+					20,
+					48,
+					43,
+					43,
+					20,
+				);
+				PBXFileTableDataSourceColumnsKey = (
+					PBXFileDataSource_FiletypeID,
+					PBXFileDataSource_Filename_ColumnID,
+					PBXFileDataSource_Built_ColumnID,
+					PBXFileDataSource_ObjectSize_ColumnID,
+					PBXFileDataSource_Errors_ColumnID,
+					PBXFileDataSource_Warnings_ColumnID,
+					PBXFileDataSource_Target_ColumnID,
+				);
+			};
+			PBXConfiguration.PBXTargetDataSource.PBXTargetDataSource = {
+				PBXFileTableDataSourceColumnSortingDirectionKey = "-1";
+				PBXFileTableDataSourceColumnSortingKey = PBXFileDataSource_Filename_ColumnID;
+				PBXFileTableDataSourceColumnWidthsKey = (
+					20,
+					789,
+					60,
+					20,
+					48,
+					43,
+					43,
+				);
+				PBXFileTableDataSourceColumnsKey = (
+					PBXFileDataSource_FiletypeID,
+					PBXFileDataSource_Filename_ColumnID,
+					PBXTargetDataSource_PrimaryAttribute,
+					PBXFileDataSource_Built_ColumnID,
+					PBXFileDataSource_ObjectSize_ColumnID,
+					PBXFileDataSource_Errors_ColumnID,
+					PBXFileDataSource_Warnings_ColumnID,
+				);
+			};
+			PBXPerProjectTemplateStateSaveDate = 345089498;
+			PBXWorkspaceStateSaveDate = 345089498;
+		};
+		perUserProjectItems = {
+			911C2A9D1491A5F600A430AF /* PBXTextBookmark */ = 911C2A9D1491A5F600A430AF /* PBXTextBookmark */;
+			915DCCBB1491A5B8008574E6 /* PBXTextBookmark */ = 915DCCBB1491A5B8008574E6 /* PBXTextBookmark */;
+		};
+		sourceControlManager = 91857D94148EF55400AAA11B /* Source Control */;
+		userBuildSettings = {
+		};
+	};
+	2407DEB6089929BA00EB68BF /* Gain.cpp */ = {
+		uiCtxt = {
+			sepNavIntBoundsRect = "{{0, 0}, {992, 1768}}";
+			sepNavSelRange = "{247, 0}";
+			sepNavVisRange = "{0, 1657}";
+		};
+	};
+	245463B80991757100464AD3 /* Gain.h */ = {
+		uiCtxt = {
+			sepNavIntBoundsRect = "{{0, 0}, {992, 975}}";
+			sepNavSelRange = "{1552, 0}";
+			sepNavVisRange = "{796, 1857}";
+			sepNavWindowFrame = "{{15, 465}, {750, 558}}";
+		};
+	};
+	24A2FF9A0F90D1DD003BB5A7 /* adelaymain.cpp */ = {
+		uiCtxt = {
+			sepNavIntBoundsRect = "{{0, 0}, {992, 488}}";
+			sepNavSelRange = "{0, 0}";
+			sepNavVisRange = "{0, 798}";
+		};
+	};
+	24A2FFDB0F90D1DD003BB5A7 /* audioeffectx.cpp */ = {
+		uiCtxt = {
+			sepNavIntBoundsRect = "{{0, 0}, {859, 19825}}";
+			sepNavSelRange = "{10641, 0}";
+			sepNavVisRange = "{10076, 1095}";
+		};
+	};
+	24D8286F09A914000093AEF8 /* GainProc.cpp */ = {
+		uiCtxt = {
+			sepNavIntBoundsRect = "{{0, 0}, {992, 482}}";
+			sepNavSelRange = "{239, 0}";
+			sepNavVisRange = "{0, 950}";
+		};
+	};
+	24D8287E09A9164A0093AEF8 /* xcode_vst_prefix.h */ = {
+		uiCtxt = {
+			sepNavIntBoundsRect = "{{0, 0}, {992, 493}}";
+			sepNavSelRange = "{249, 0}";
+			sepNavVisRange = "{0, 249}";
+		};
+	};
+	8D01CCC60486CAD60068D4B7 /* Gain */ = {
+		activeExec = 0;
+	};
+	911C2A9D1491A5F600A430AF /* PBXTextBookmark */ = {
+		isa = PBXTextBookmark;
+		fRef = 2407DEB6089929BA00EB68BF /* Gain.cpp */;
+		name = "Gain.cpp: 10";
+		rLen = 0;
+		rLoc = 247;
+		rType = 0;
+		vrLen = 1657;
+		vrLoc = 0;
+	};
+	915DCCBB1491A5B8008574E6 /* PBXTextBookmark */ = {
+		isa = PBXTextBookmark;
+		fRef = 2407DEB6089929BA00EB68BF /* Gain.cpp */;
+		name = "Gain.cpp: 10";
+		rLen = 0;
+		rLoc = 247;
+		rType = 0;
+		vrLen = 1625;
+		vrLoc = 0;
+	};
+	91857D94148EF55400AAA11B /* Source Control */ = {
+		isa = PBXSourceControlManager;
+		fallbackIsa = XCSourceControlManager;
+		isSCMEnabled = 0;
+		scmConfiguration = {
+			repositoryNamesForRoots = {
+				"" = "";
+			};
+		};
+	};
+	91857D95148EF55400AAA11B /* Code sense */ = {
+		isa = PBXCodeSenseManager;
+		indexTemplatePath = "";
+	};
+}
diff --git a/plugins/MacVST/PocketVerbs/PocketVerbs.xcodeproj/xcuserdata/christopherjohnson.xcuserdatad/xcschemes/Gain.xcscheme b/plugins/MacVST/PocketVerbs/PocketVerbs.xcodeproj/xcuserdata/christopherjohnson.xcuserdatad/xcschemes/Gain.xcscheme
new file mode 100755
index 0000000..8ee693f
--- /dev/null
+++ b/plugins/MacVST/PocketVerbs/PocketVerbs.xcodeproj/xcuserdata/christopherjohnson.xcuserdatad/xcschemes/Gain.xcscheme
@@ -0,0 +1,80 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Scheme
+   LastUpgradeVersion = "0720"
+   version = "1.3">
+   <BuildAction
+      parallelizeBuildables = "YES"
+      buildImplicitDependencies = "YES">
+      <BuildActionEntries>
+         <BuildActionEntry
+            buildForTesting = "YES"
+            buildForRunning = "YES"
+            buildForProfiling = "YES"
+            buildForArchiving = "YES"
+            buildForAnalyzing = "YES">
+            <BuildableReference
+               BuildableIdentifier = "primary"
+               BlueprintIdentifier = "8D01CCC60486CAD60068D4B7"
+               BuildableName = "Gain.vst"
+               BlueprintName = "Gain"
+               ReferencedContainer = "container:Gain.xcodeproj">
+            </BuildableReference>
+         </BuildActionEntry>
+      </BuildActionEntries>
+   </BuildAction>
+   <TestAction
+      buildConfiguration = "Debug"
+      selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
+      selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
+      shouldUseLaunchSchemeArgsEnv = "YES">
+      <Testables>
+      </Testables>
+      <AdditionalOptions>
+      </AdditionalOptions>
+   </TestAction>
+   <LaunchAction
+      buildConfiguration = "Debug"
+      selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.LLDB"
+      selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.LLDB"
+      launchStyle = "0"
+      useCustomWorkingDirectory = "NO"
+      ignoresPersistentStateOnLaunch = "NO"
+      debugDocumentVersioning = "YES"
+      debugServiceExtension = "internal"
+      allowLocationSimulation = "YES">
+      <MacroExpansion>
+         <BuildableReference
+            BuildableIdentifier = "primary"
+            BlueprintIdentifier = "8D01CCC60486CAD60068D4B7"
+            BuildableName = "Gain.vst"
+            BlueprintName = "Gain"
+            ReferencedContainer = "container:Gain.xcodeproj">
+         </BuildableReference>
+      </MacroExpansion>
+      <AdditionalOptions>
+      </AdditionalOptions>
+   </LaunchAction>
+   <ProfileAction
+      buildConfiguration = "Release"
+      shouldUseLaunchSchemeArgsEnv = "YES"
+      savedToolIdentifier = ""
+      useCustomWorkingDirectory = "NO"
+      debugDocumentVersioning = "YES">
+      <MacroExpansion>
+         <BuildableReference
+            BuildableIdentifier = "primary"
+            BlueprintIdentifier = "8D01CCC60486CAD60068D4B7"
+            BuildableName = "Gain.vst"
+            BlueprintName = "Gain"
+            ReferencedContainer = "container:Gain.xcodeproj">
+         </BuildableReference>
+      </MacroExpansion>
+   </ProfileAction>
+   <AnalyzeAction
+      buildConfiguration = "Debug">
+   </AnalyzeAction>
+   <ArchiveAction
+      buildConfiguration = "Release"
+      revealArchiveInOrganizer = "YES">
+   </ArchiveAction>
+</Scheme>
diff --git a/plugins/MacVST/PocketVerbs/PocketVerbs.xcodeproj/xcuserdata/christopherjohnson.xcuserdatad/xcschemes/xcschememanagement.plist b/plugins/MacVST/PocketVerbs/PocketVerbs.xcodeproj/xcuserdata/christopherjohnson.xcuserdatad/xcschemes/xcschememanagement.plist
new file mode 100755
index 0000000..5bccbcb
--- /dev/null
+++ b/plugins/MacVST/PocketVerbs/PocketVerbs.xcodeproj/xcuserdata/christopherjohnson.xcuserdatad/xcschemes/xcschememanagement.plist
@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>SchemeUserState</key>
+	<dict>
+		<key>Gain.xcscheme</key>
+		<dict>
+			<key>orderHint</key>
+			<integer>8</integer>
+		</dict>
+	</dict>
+	<key>SuppressBuildableAutocreation</key>
+	<dict>
+		<key>8D01CCC60486CAD60068D4B7</key>
+		<dict>
+			<key>primary</key>
+			<true/>
+		</dict>
+	</dict>
+</dict>
+</plist>
diff --git a/plugins/MacVST/PocketVerbs/PocketVerbs.xcodeproj/xcuserdata/spiadmin.xcuserdatad/xcschemes/xcschememanagement.plist b/plugins/MacVST/PocketVerbs/PocketVerbs.xcodeproj/xcuserdata/spiadmin.xcuserdatad/xcschemes/xcschememanagement.plist
new file mode 100755
index 0000000..a7bdd62
--- /dev/null
+++ b/plugins/MacVST/PocketVerbs/PocketVerbs.xcodeproj/xcuserdata/spiadmin.xcuserdatad/xcschemes/xcschememanagement.plist
@@ -0,0 +1,22 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>SchemeUserState</key>
+	<dict>
+		<key>«PROJECTNAME».xcscheme</key>
+		<dict>
+			<key>orderHint</key>
+			<integer>0</integer>
+		</dict>
+	</dict>
+	<key>SuppressBuildableAutocreation</key>
+	<dict>
+		<key>8D01CCC60486CAD60068D4B7</key>
+		<dict>
+			<key>primary</key>
+			<true/>
+		</dict>
+	</dict>
+</dict>
+</plist>
diff --git a/plugins/MacVST/PocketVerbs/PocketVerbs.xcodeproj/xcuserdata/spiadmin.xcuserdatad/xcschemes/«PROJECTNAME».xcscheme b/plugins/MacVST/PocketVerbs/PocketVerbs.xcodeproj/xcuserdata/spiadmin.xcuserdatad/xcschemes/«PROJECTNAME».xcscheme
new file mode 100755
index 0000000..0df2de4
--- /dev/null
+++ b/plugins/MacVST/PocketVerbs/PocketVerbs.xcodeproj/xcuserdata/spiadmin.xcuserdatad/xcschemes/«PROJECTNAME».xcscheme
@@ -0,0 +1,57 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<Scheme
+   version = "1.3">
+   <BuildAction
+      parallelizeBuildables = "YES"
+      buildImplicitDependencies = "YES">
+      <BuildActionEntries>
+         <BuildActionEntry
+            buildForTesting = "YES"
+            buildForRunning = "YES"
+            buildForProfiling = "YES"
+            buildForArchiving = "YES"
+            buildForAnalyzing = "YES">
+            <BuildableReference
+               BuildableIdentifier = "primary"
+               BlueprintIdentifier = "8D01CCC60486CAD60068D4B7"
+               BuildableName = "&#171;PROJECTNAME&#187;.vst"
+               BlueprintName = "&#171;PROJECTNAME&#187;"
+               ReferencedContainer = "container:Sample.xcodeproj">
+            </BuildableReference>
+         </BuildActionEntry>
+      </BuildActionEntries>
+   </BuildAction>
+   <TestAction
+      selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.GDB"
+      selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.GDB"
+      shouldUseLaunchSchemeArgsEnv = "YES"
+      buildConfiguration = "Debug">
+      <Testables>
+      </Testables>
+   </TestAction>
+   <LaunchAction
+      selectedDebuggerIdentifier = "Xcode.DebuggerFoundation.Debugger.GDB"
+      selectedLauncherIdentifier = "Xcode.DebuggerFoundation.Launcher.GDB"
+      launchStyle = "0"
+      useCustomWorkingDirectory = "NO"
+      buildConfiguration = "Debug"
+      debugDocumentVersioning = "YES"
+      allowLocationSimulation = "YES">
+      <AdditionalOptions>
+      </AdditionalOptions>
+   </LaunchAction>
+   <ProfileAction
+      shouldUseLaunchSchemeArgsEnv = "YES"
+      savedToolIdentifier = ""
+      useCustomWorkingDirectory = "NO"
+      buildConfiguration = "Release"
+      debugDocumentVersioning = "YES">
+   </ProfileAction>
+   <AnalyzeAction
+      buildConfiguration = "Debug">
+   </AnalyzeAction>
+   <ArchiveAction
+      buildConfiguration = "Release"
+      revealArchiveInOrganizer = "YES">
+   </ArchiveAction>
+</Scheme>
diff --git a/plugins/MacVST/PocketVerbs/mac/Info.plist b/plugins/MacVST/PocketVerbs/mac/Info.plist
new file mode 100755
index 0000000..697416c
--- /dev/null
+++ b/plugins/MacVST/PocketVerbs/mac/Info.plist
@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+	<key>CFBundleDevelopmentRegion</key>
+	<string>English</string>
+	<key>CFBundleExecutable</key>
+	<string>PocketVerbs</string>
+	<key>CFBundleIconFile</key>
+	<string></string>
+	<key>CFBundleIdentifier</key>
+	<string>com.airwindows.PocketVerbs</string>
+	<key>CFBundleInfoDictionaryVersion</key>
+	<string>6.0</string>
+	<key>CFBundlePackageType</key>
+	<string>BNDL</string>
+	<key>CFBundleSignature</key>
+	<string>Dthr</string>
+	<key>CFBundleVersion</key>
+	<string>1.0</string>
+	<key>CSResourcesFileMapped</key>
+	<true/>
+</dict>
+</plist>
diff --git a/plugins/MacVST/PocketVerbs/mac/PkgInfo b/plugins/MacVST/PocketVerbs/mac/PkgInfo
new file mode 100755
index 0000000..19a9cf6
--- /dev/null
+++ b/plugins/MacVST/PocketVerbs/mac/PkgInfo
@@ -0,0 +1 @@
+BNDL????
\ No newline at end of file
diff --git a/plugins/MacVST/PocketVerbs/mac/xcode_vst_prefix.h b/plugins/MacVST/PocketVerbs/mac/xcode_vst_prefix.h
new file mode 100755
index 0000000..eaf4c0b
--- /dev/null
+++ b/plugins/MacVST/PocketVerbs/mac/xcode_vst_prefix.h
@@ -0,0 +1,17 @@
+#define MAC 1
+#define MACX 1
+
+#define USE_NAMESPACE 0
+
+#define TARGET_API_MAC_CARBON 1
+#define USENAVSERVICES 1
+
+#define __CF_USE_FRAMEWORK_INCLUDES__
+
+#if __MWERKS__
+#define __NOEXTENSIONS__
+#endif
+
+#define QUARTZ 1
+
+#include <AvailabilityMacros.h>
\ No newline at end of file
diff --git a/plugins/MacVST/PocketVerbs/source/PocketVerbs.cpp b/plugins/MacVST/PocketVerbs/source/PocketVerbs.cpp
new file mode 100755
index 0000000..4426e4b
--- /dev/null
+++ b/plugins/MacVST/PocketVerbs/source/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/MacVST/PocketVerbs/source/PocketVerbs.h b/plugins/MacVST/PocketVerbs/source/PocketVerbs.h
new file mode 100755
index 0000000..7feaf8e
--- /dev/null
+++ b/plugins/MacVST/PocketVerbs/source/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/MacVST/PocketVerbs/source/PocketVerbsProc.cpp b/plugins/MacVST/PocketVerbs/source/PocketVerbsProc.cpp
new file mode 100755
index 0000000..4ea8f51
--- /dev/null
+++ b/plugins/MacVST/PocketVerbs/source/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/.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