new JIntLiteral(N+x-1 + x-1),
new JIntLiteral(N+x-1),
    private void makeReplacement(SIRFilter self) {	/* if we don't have a linear form for this stream, we are done. */	if(!this.linearityInformation.hasLinearRepresentation(self)) {	    return;	}	LinearFilterRepresentation linearRep = this.linearityInformation.getLinearRepresentation(self);	/* if there is not an FIR filter, we are done. */	if (!linearRep.isFIR()) {	    return;	}			/* now is when we get to the fun part, we have a linear representation	 * that computes an FIR (ef pop 1, push 1, peek N) and we want to replace it with an FFT.	 * Note that we can equate N with the block size of the input that we are looking at.	 */	int x = linearRep.getPeekCount();	int N = calculateN(this.targetNumberOfOutputs,x);	int filterSize = N+2*(x-1);	LinearPrinter.println(" creating frequency filter. (N=" + N +			      ",x=" + x + ",size=" + filterSize + ")");		/* make fields to hold the real and imaginary parts of the weights. */	String realWeightName = "freq_weights_r";	String imagWeightName = "freq_weights_i";	JVariableDefinition realWeightField    = makeWeightField(realWeightName);	JVariableDefinition imagWeightField    = makeWeightField(imagWeightName);	/* make fields to hold the real and imaginary partial results between executions */	String partialFieldName = "freq_partial";	JVariableDefinition partialField   = makeWeightField(partialFieldName);		/* wrap them up, along with any fields that the filter already has. */	JFieldDeclaration[] newFields = makeFieldDeclarations(self.getFields(),realWeightField, imagWeightField, partialField);		/* make a new init function */	JMethodDeclaration freqInit = makeNewInit(linearRep, realWeightField, imagWeightField, partialField,						  filterSize, x);	/* make the init work function */	JMethodDeclaration freqInitWork = makeNewWork(INITWORK, realWeightField, imagWeightField, partialField,						      filterSize, x, N);		/* make a new work function */	JMethodDeclaration freqWork = makeNewWork(WORK, realWeightField, imagWeightField, partialField,						  filterSize, x, N);			LinearPrinter.println(" done building new IR nodes for " + self);		LinearPrinter.println(" creating new two stage filter...");	// Create a new filter that contains all of the new pieces that we have built	SIRTwoStageFilter freqFilter;	/* Note, we need to have initPeek-initPop == peek-Pop for some scheduling reason	 * so therefore, we set the peek rate of the work function to be N+2(x-1) even though	 * it really only needs to be N+x-1.*/	freqFilter = new SIRTwoStageFilter(self.getParent(),              /* parent */					   "TwoStageFreq" + self.getIdent(),/* ident */					   newFields,                     /* fields */					   new JMethodDeclaration[0],     /* methods -- init, work, and initWork are special*/					   new JIntLiteral(N+x-1 + x-1),  /* peek (w/ extra x-1 window...)*/					   new JIntLiteral(N+x-1),        /* pop */					   new JIntLiteral(N+x-1),        /* push */					   freqWork,                      /* work */					   N+x-1,                         /* initPeek */					   N,                             /* initPop */					   N,                             /* initPush */					   freqInitWork,                  /* initWork */					   self.getInputType(),           /* input type */					   self.getOutputType());         /* output type */	// need to explicitly set the init function	freqFilter.setInit(freqInit);	// now replace the current filter (self) with the frequency version	self.getParent().replace(self, freqFilter);		LinearPrinter.println(" done replacing.");	    }