         __syncthreads();    // Perf-sync
 
         // Compute the thread's merge path segment
-        CoordinateT         thread_current_coord = thread_start_coord;
+        CoordinateT         thread_coord = thread_start_coord;
         ItemOffsetPairT     thread_segment[ITEMS_PER_THREAD];
         OffsetT             flags[ITEMS_PER_THREAD];
 
         #pragma unroll
         for (int ITEM = 0; ITEM < ITEMS_PER_THREAD; ++ITEM)
         {
-            OffsetT nonzero_idx         = CUB_MIN(tile_nonzero_indices[thread_current_coord.y], num_nonzeros - 1);
+            OffsetT nonzero_idx         = CUB_MIN(tile_nonzero_indices[thread_coord.y], num_nonzeros - 1);
             OffsetT column_index        = d_matrix_column_indices[nonzero_idx];
             ValueT  matrix_value        = d_matrix_values[nonzero_idx];
             ValueT  vector_value        = d_vector_x[column_index];
             ValueT  nonzero             = matrix_value * vector_value;
 
-            bool accumulate = (tile_nonzero_indices[thread_current_coord.y] < tile_row_end_offsets[thread_current_coord.x]);
+            bool accumulate = (tile_nonzero_indices[thread_coord.y] < tile_row_end_offsets[thread_coord.x]);
             if (accumulate)
             {
                 // Move down (accumulate)
                 thread_segment[ITEM].value = nonzero;
                 thread_segment[ITEM].offset = 0;
-                ++thread_current_coord.y;
+                ++thread_coord.y;
             }
             else
             {
                 // Move right (reset)
                 thread_segment[ITEM].value = 0.0;
                 thread_segment[ITEM].offset = 1;
-                ++thread_current_coord.x;
+                ++thread_coord.x;
             }
 
             flags[ITEM] = thread_segment[ITEM].offset;

        for (int item = threadIdx.x; item < tile_num_rows; item += BLOCK_THREADS)
        {
            d_vector_y[tile_coord.x + item] = row_partials[item];

        }

        // Update the block coordinate


        // Compute the thread's merge path segment
        ItemOffsetPairT thread_segment[ITEMS_PER_THREAD];
        CoordinateT     thread_coord = thread_start_coord;
        OffsetT         flags[ITEMS_PER_THREAD];

        #pragma unroll
        for (int ITEM = 0; ITEM < ITEMS_PER_THREAD; ++ITEM)
        {
            bool accumulate = (tile_nonzero_indices[thread_coord.y] < tile_row_end_offsets[thread_coord.x]);

            if (accumulate)
            {
                // Move down (accumulate)
                thread_segment[ITEM].offset = 0;
                thread_segment[ITEM].value  = tile_nonzeros[thread_coord.y];
                ++thread_coord.y;
            }
            else
            {
                // Move right (reset)
                thread_segment[ITEM].offset = 1;
                thread_segment[ITEM].value  = 0.0;
                ++thread_coord.x;
            }
            flags[ITEM] = thread_segment[ITEM].offset;
        }
