 {
 
 	//Need pieces of information:
-	//sum(2:2:base) (matlabese) of triangle (tA)
 	//base of triangle (tB)  Ok we'll use 2D
 
-	REAL temper[tB][tB/2];
+	REAL temper[tB*tB/4];
 
 	int gid = blockDim.x * blockIdx.x + threadIdx.x; //Global Thread ID
 	int tid = threadIdx.x; //Warp or node ID

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

	//Global to global or register 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];

	//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++)
		{
		//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];
		}

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

	}


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