 	#pragma unroll
 	for (int k = 0; k<tB; k++)
 	{
-		temper[0][k] = (IC[gid*tB+k]);
-	}
-
-	//Global to global or register to global?
+		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 = k; n < (tB-k); n++)
+		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[k][n] = fo * (temper[k-1][n+1]  + temper[k-1][n-1] ) + (1-2.*fo) * temper[k-1][n];
-		}
+			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.
-		right[gid*tB+2*k] = temper[k][k];
-		right[gid*tB+(2*k+1)] = temper[k][k+1];
-		left[gid*tB+2*k] =  temper[k][tB-k-1];
-		left[gid*tB+(2*k+1)] =  temper[k][tB-k-2];
+		// Could template this.
+
+		left[gid*tB+2*k] =  temper[iter2-2];
+		left[gid*tB+(2*k+1)] =  temper[iter2-1];
 
 	}
 

	int itr2 = 18;
	//k needs to insert the relevant left right values around the computed values
	//every timestep.  Since it grows larger the loop is reversed.
	for (int k = 1; k<(tB/2+2); k++)
	{

		for (int n = (tB/2-k+1); n < (tB/2+k+1); n++)
		{
		//Block 0 is split so it needs a different algorithm.  This algorithm
		//is slightly different than top triangle as described in the note above.
		if gid > 0)
		{

			temper[k][n] = fo * (temper[k-1][n+1]  + temper[k-1][n-1] ) + (1-2.*fo) * temper[k-1][n];

{

	//Need pieces of information:
	//base of triangle (tB)  Ok we'll use 2D

	REAL temper[tB*tB/4];

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