 	#pragma unroll
 	for (int k = 0; k<tB/2; k++)
 	{
-		sR[k] = left[gid*tB+k];
+		shR[k] = left[gid*tB+k];
 		if (gid > 0)
 		{
-			sL[k] = right[(gid-1)*tB+k];
+			shL[k] = right[(gid-1)*tB+k];
 		}
 		else
 		{
-			sL[k] = right[(blockDim.x*gridDim.x-1)*tB+k];
+			shL[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

	// 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

	#pragma unroll
	for (int k = 0; k<tB; k++)
	{
		temper[k] = (IC[gid*tB+k]);
	}

	//Global to global
	right[gid*tB] = IC[gid*tB];
	right[gid*tB+1] = IC[gid*tB+1];
	left[gid*tB] = IC[ ((gid+1) * tB) - 2];
	left[gid*tB+1] = IC[ ((gid+1) * tB) - 1];

	int iter = tB;
	int iter2 = tB;

	//The initial conditions are timeslice 0 so start k at 1.
	#pragma unroll
	for (int k = 1; k<tB/2; k++)
	{

		for(int n = 0; n < (tB-2*k); n++)
		{
		//Each iteration the triangle narrows.  When k = 1, 30 points are
		//computed, k = 2, 28 points.
			temper[iter2+n] = fo * (temper[(iter2-iter)+n]  + temper[(iter2-iter)+2+n] ) + (1.-2.*fo) * temper[(iter2-iter)+1+n];
		}

		right[gid*tB+2*k] = temper[iter2];
		right[gid*tB+(2*k+1)] = temper[(iter2+1];

		iter -= 2
		iter2 += iter

		// Global memory version
		// Index math is kinda out of contol.
		// Could template this.

		left[gid*tB+2*k] =  temper[iter2-2];
		left[gid*tB+(2*k+1)] =  temper[iter2-1];

	}

