// this is pretty insane coding
	register real tmp1;
	new_v[36-17] = -(new_v[4] = (new_v[12] = p[7]) + p[5]) - p[6];
	new_v[44-17] = -p[6] - p[7] - p[4];
	new_v[6] = (new_v[10] = (new_v[14] = p[15]) + p[11]) + p[13];
	new_v[34-17] = -(new_v[2] = p[15] + p[13] + p[9]) - p[14];
	new_v[38-17] = (tmp1 = -p[14] - p[15] - p[10] - p[11]) - p[13];
	new_v[46-17] = -p[14] - p[15] - p[12] - p[8];
	new_v[42-17] = tmp1 - p[12];
	new_v[48-17] = -p[0];
	new_v[0] = p[1];
	new_v[40-17] = -(new_v[8] = p[3]) - p[2];
	}

	{
	register real *x1 = samples;

	p[0] = (x1[0] - x1[31]) * cos1_64;
	p[1] = (x1[1] - x1[30]) * cos3_64;
	p[2] = (x1[2] - x1[29]) * cos5_64;
	p[3] = (x1[3] - x1[28]) * cos7_64;
	p[4] = (x1[4] - x1[27]) * cos9_64;
	p[5] = (x1[5] - x1[26]) * cos11_64;
	p[6] = (x1[6] - x1[25]) * cos13_64;
	p[7] = (x1[7] - x1[24]) * cos15_64;
	p[8] = (x1[8] - x1[23]) * cos17_64;
	p[9] = (x1[9] - x1[22]) * cos19_64;
	p[10] = (x1[10] - x1[21]) * cos21_64;
	p[11] = (x1[11] - x1[20]) * cos23_64;
	p[12] = (x1[12] - x1[19]) * cos25_64;
	p[13] = (x1[13] - x1[18]) * cos27_64;
	p[14] = (x1[14] - x1[17]) * cos29_64;
	p[15] = (x1[15] - x1[16]) * cos31_64;
	}

	{
	pp[0] = p[0] + p[15];
	pp[1] = p[1] + p[14];
	pp[2] = p[2] + p[13];
	pp[3] = p[3] + p[12];
	pp[4] = p[4] + p[11];
	pp[5] = p[5] + p[10];
	pp[6] = p[6] + p[9];
	pp[7] = p[7] + p[8];
	pp[8] = (p[0] - p[15]) * cos1_32;
	pp[9] = (p[1] - p[14]) * cos3_32;
	pp[10] = (p[2] - p[13]) * cos5_32;
	pp[11] = (p[3] - p[12]) * cos7_32;
	pp[12] = (p[4] - p[11]) * cos9_32;
	pp[13] = (p[5] - p[10]) * cos11_32;
	pp[14] = (p[6] - p[9]) * cos13_32;
	pp[15] = (p[7] - p[8]) * cos15_32;
	}

	{
	p[0] = pp[0] + pp[7];
	p[1] = pp[1] + pp[6];
	p[2] = pp[2] + pp[5];
	p[3] = pp[3] + pp[4];
	p[4] = (pp[0] - pp[7]) * cos1_16;
	p[5] = (pp[1] - pp[6]) * cos3_16;
	p[6] = (pp[2] - pp[5]) * cos5_16;
	p[7] = (pp[3] - pp[4]) * cos7_16;
	p[8] = pp[8] + pp[15];
	p[9] = pp[9] + pp[14];
	p[10] = pp[10] + pp[13];
	p[11] = pp[11] + pp[12];
	p[12] = (pp[8] - pp[15]) * cos1_16;
	p[13] = (pp[9] - pp[14]) * cos3_16;
	p[14] = (pp[10] - pp[13]) * cos5_16;
	p[15] = (pp[11] - pp[12]) * cos7_16;
	}

	{
	pp[0] = p[0] + p[3];
	pp[1] = p[1] + p[2];
	pp[2] = (p[0] - p[3]) * cos1_8;
	pp[3] = (p[1] - p[2]) * cos3_8;
	pp[4] = p[4] + p[7];
	pp[5] = p[5] + p[6];
	pp[6] = (p[4] - p[7]) * cos1_8;
	pp[7] = (p[5] - p[6]) * cos3_8;
	pp[8] = p[8] + p[11];
	pp[9] = p[9] + p[10];
	pp[10] = (p[8] - p[11]) * cos1_8;
	pp[11] = (p[9] - p[10]) * cos3_8;
	pp[12] = p[12] + p[15];
	pp[13] = p[13] + p[14];
	pp[14] = (p[12] - p[15]) * cos1_8;
	pp[15] = (p[13] - p[14]) * cos3_8;
	}

	{
	p[0] = pp[0] + pp[1];
	p[1] = (pp[0] - pp[1]) * cos1_4;
	p[2] = pp[2] + pp[3];
	p[3] = (pp[2] - pp[3]) * cos1_4;
	p[4] = pp[4] + pp[5];
	p[5] = (pp[4] - pp[5]) * cos1_4;
	p[6] = pp[6] + pp[7];
	p[7] = (pp[6] - pp[7]) * cos1_4;
	p[8] = pp[8] + pp[9];
	p[9] = (pp[8] - pp[9]) * cos1_4;
	p[10] = pp[10] + pp[11];
	p[11] = (pp[10] - pp[11]) * cos1_4;
	p[12] = pp[12] + pp[13];
	p[13] = (pp[12] - pp[13]) * cos1_4;
	p[14] = pp[14] + pp[15];
	p[15] = (pp[14] - pp[15]) * cos1_4;
	}

	{
	// manually doing something that a compiler should handle sucks
	// coding like this is hard to read
	register real tmp1, tmp2;
	new_v[5] = (new_v[11] = (new_v[13] = (new_v[15] = p[15]) + p[7]) + p[11])
							+ p[5] + p[13];
	new_v[7] = (new_v[9] = p[15] + p[11] + p[3]) + p[13];
	new_v[33-17] = -(new_v[1] = (tmp1 = p[13] + p[15] + p[9]) + p[1]) - p[14];
	new_v[35-17] = -(new_v[3] = tmp1 + p[5] + p[7]) - p[6] - p[14];

	new_v[39-17] = (tmp1 = -p[10] - p[11] - p[14] - p[15])
									- p[13] - p[2] - p[3];
	new_v[37-17] = tmp1 - p[13] - p[5] - p[6] - p[7];
	new_v[41-17] = tmp1 - p[12] - p[2] - p[3];
	new_v[43-17] = tmp1 - p[12] - (tmp2 = p[4] + p[6] + p[7]);
	new_v[47-17] = (tmp1 = -p[8] - p[12] - p[14] - p[15]) - p[0];
	new_v[45-17] = tmp1 - tmp2;
	}

	{
	// insert V[0-15] (== new_v[0-15]) into actual v:
	register real *x1 = new_v;
	register real *x2 = actual_v + actual_write_pos;
	x2[0] = x1[0];
	x2[16] = x1[1];
	x2[32] = x1[2];
	x2[48] = x1[3];
	x2[64] = x1[4];
	x2[80] = x1[5];
	x2[96] = x1[6];
	x2[112] = x1[7];
	x2[128] = x1[8];
	x2[144] = x1[9];
	x2[160] = x1[10];
	x2[176] = x1[11];
	x2[192] = x1[12];
	x2[208] = x1[13];
	x2[224] = x1[14];
	x2[240] = x1[15];

	// V[16] is always 0.0:
	x2[256] = 0.0f;

	// insert V[17-31] (== -new_v[15-1]) into actual v:
	x2[272] = -x1[15];
	x2[288] = -x1[14];
	x2[304] = -x1[13];
	x2[320] = -x1[12];
	x2[336] = -x1[11];
	x2[352] = -x1[10];
	x2[368] = -x1[9];
	x2[384] = -x1[8];
	x2[400] = -x1[7];
	x2[416] = -x1[6];
	x2[432] = -x1[5];
	x2[448] = -x1[4];
	x2[464] = -x1[3];
	x2[480] = -x1[2];
	x2[496] = -x1[1];

	// insert V[32] (== -new_v[0]) into other v:
	x2 = (actual_v == v1 ? v2 : v1) + actual_write_pos;
	x2[0] = -x1[0];

	// insert V[33-48] (== new_v[16-31]) into other v:
	x2[16] = x1[16];
	x2[32] = x1[17];
	x2[48] = x1[18];
	x2[64] = x1[19];
	x2[80] = x1[20];
	x2[96] = x1[21];
	x2[112] = x1[22];
	x2[128] = x1[23];
	x2[144] = x1[24];
	x2[160] = x1[25];
	x2[176] = x1[26];
	x2[192] = x1[27];
	x2[208] = x1[28];
	x2[224] = x1[29];
	x2[240] = x1[30];
	x2[256] = x1[31];

	// insert V[49-63] (== new_v[30-16]) into other v:
	x2[272] = x1[30];
	x2[288] = x1[29];
	x2[304] = x1[28];
	x2[320] = x1[27];
	x2[336] = x1[26];
	x2[352] = x1[25];
	x2[368] = x1[24];
	x2[384] = x1[23];
	x2[400] = x1[22];
	x2[416] = x1[21];
	x2[432] = x1[20];
	x2[448] = x1[19];
	x2[464] = x1[18];
	x2[480] = x1[17];
	x2[496] = x1[16];
	}
}

void SynthesisFilter::compute_pcm_samples(Obuffer *buffer)
{
	// scoping variables makes it easier to optimize for the compiler
	register real *vp = actual_v;
	//real a[32];
	//real * pa=a;
	// switch depending on the value for actual_write_pos
	switch (actual_write_pos) {
		case 0: {
			// fat chance of having this loop unroll
			for( register const real *dp = d;
					 dp < d + (32 * 16);
					 dp += 16, vp += 16 ) {
				register real pcm_sample;

				pcm_sample = (real)(((vp[0] * dp[0]) +
					(vp[15] * dp[1]) +
					(vp[14] * dp[2]) +
					(vp[13] * dp[3]) +
					(vp[12] * dp[4]) +
					(vp[11] * dp[5]) +
					(vp[10] * dp[6]) +
					(vp[9] * dp[7]) +
					(vp[8] * dp[8]) +
					(vp[7] * dp[9]) +
					(vp[6] * dp[10]) +
					(vp[5] * dp[11]) +
					(vp[4] * dp[12]) +
					(vp[3] * dp[13]) +
					(vp[2] * dp[14]) +
					(vp[1] * dp[15])
					) /* * scalefactor */);
            buffer->append (channel, (int16)pcm_sample);
			} // for
		} break; // case 0:

		case 1: {
			// fat chance of having this loop unroll
			for( register const real *dp = d;
					 dp < d + (32 * 16);
					 dp += 16, vp += 16 ) {
				register real pcm_sample;

				pcm_sample = (real)(((vp[1] * dp[0]) +
					(vp[0] * dp[1]) +
					(vp[15] * dp[2]) +
					(vp[14] * dp[3]) +
					(vp[13] * dp[4]) +
					(vp[12] * dp[5]) +
					(vp[11] * dp[6]) +
					(vp[10] * dp[7]) +
					(vp[9] * dp[8]) +
					(vp[8] * dp[9]) +
					(vp[7] * dp[10]) +
					(vp[6] * dp[11]) +
					(vp[5] * dp[12]) +
					(vp[4] * dp[13]) +
					(vp[3] * dp[14]) +
					(vp[2] * dp[15])
					) /* * scalefactor */);

            buffer->append (channel, (int16)pcm_sample);
         } // for
		} break; // case 1:

		case 2: {
			// fat chance of having this loop unroll
			for( register const real *dp = d;
					 dp < d + (32 * 16);
					 dp += 16, vp += 16 ) {
				register real pcm_sample;

				pcm_sample = (real)(((vp[2] * dp[0]) +
					(vp[1] * dp[1]) +
					(vp[0] * dp[2]) +
					(vp[15] * dp[3]) +
					(vp[14] * dp[4]) +
					(vp[13] * dp[5]) +
					(vp[12] * dp[6]) +
					(vp[11] * dp[7]) +
					(vp[10] * dp[8]) +
					(vp[9] * dp[9]) +
					(vp[8] * dp[10]) +
					(vp[7] * dp[11]) +
					(vp[6] * dp[12]) +
					(vp[5] * dp[13]) +
					(vp[4] * dp[14]) +
					(vp[3] * dp[15])
					) /* * scalefactor */);

            buffer->append (channel, (int16)pcm_sample);
			} // for
		} break; // case 2:

		case 3: {
			// fat chance of having this loop unroll
			for( register const real *dp = d;
					 dp < d + (32 * 16);
					 dp += 16, vp += 16 ) {
				register real pcm_sample;

				pcm_sample = (real)(((vp[3] * dp[0]) +
					(vp[2] * dp[1]) +
					(vp[1] * dp[2]) +
					(vp[0] * dp[3]) +
					(vp[15] * dp[4]) +
					(vp[14] * dp[5]) +
					(vp[13] * dp[6]) +
					(vp[12] * dp[7]) +
					(vp[11] * dp[8]) +
					(vp[10] * dp[9]) +
					(vp[9] * dp[10]) +
					(vp[8] * dp[11]) +
					(vp[7] * dp[12]) +
					(vp[6] * dp[13]) +
					(vp[5] * dp[14]) +
					(vp[4] * dp[15])
					) /* * scalefactor */);

				buffer->append (channel, (int16)pcm_sample);
			} // for
		} break; // case 3:

		case 4: {
			// fat chance of having this loop unroll
			for( register const real *dp = d;
					 dp < d + (32 * 16);
					 dp += 16, vp += 16 ) {
				register real pcm_sample;

				pcm_sample = (real)(((vp[4] * dp[0]) +
					(vp[3] * dp[1]) +
					(vp[2] * dp[2]) +
					(vp[1] * dp[3]) +
					(vp[0] * dp[4]) +
					(vp[15] * dp[5]) +
					(vp[14] * dp[6]) +
					(vp[13] * dp[7]) +
					(vp[12] * dp[8]) +