/*
*	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;
	}
}