 			itr+=2;
 
 		}
-		__syncthreads();
 
 	}
 


	//Need pieces of information:
	//sum(2:2:base) (matlabese) of triangle (tA)
	//base of triangle (tB)

	REAL temper[tA];

	int gid = blockDim.x * blockIdx.x + threadIdx.x; //Global Thread ID
	int tid = threadIdx.x; //Warp or node ID

	//Now temper needs to accommodate a longer row by 2, one on each side.
	//since it has two rows that's 4 extra floats.  The last row will still be
	//32 numbers long.
	REAL temper[tB+2][tB/2+1];
	REAL sR[tB/2];
	REAL sL[tB/2];

	//Same as upTriangle
	int gid = blockDim.x * blockIdx.x + threadIdx.x;
	int tid = threadIdx.x;

	// Pass to the left so all checks are for block 0 (this reduces arithmetic).
	// The left ridge is always kept by the block. Max gid = block*grid-1
	#pragma unroll
	for (int k = 0; k<tB/2; k++)
	{
		sR[k] = left[gid*tB+k];
		if (gid > 0)
		{
			sL[k] = right[(gid-1)*tB+k];
		}
		else
		{
			sL[k] = right[(blockDim.x*gridDim.x-1)*tB+k];
		}
	}
	// The right ridge is passed, each block 1-end gets the right of 0-end-1
	// Block 0 gets the right of the last block.
	// Damn thread divergence!

	// Initialize temper. Kind of an unrolled for loop.  This is actually at
	// Timestep 0.

	temper[0][tB/2-1] = sL[0];
	temper[0][tB/2] = sL[1];
	temper[0][tB/2+1] = sR[0];
	temper[0][tB/2+2] = sR[1];

	//Now we need two counters since we need to use sL and sR EVERY iteration
	//instead of every other iteration and instead of growing smaller with every
