         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

        __syncthreads();    // Perf-sync

        // Compute the thread's merge path segment
        CoordinateT         thread_current_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 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]);
            if (accumulate)
            {
                // Move down (accumulate)
                thread_segment[ITEM].value = nonzero;
                thread_segment[ITEM].offset = 0;
                ++thread_current_coord.y;
            }
            else
            {
                // Move right (reset)
                thread_segment[ITEM].value = 0.0;
                thread_segment[ITEM].offset = 1;
                ++thread_current_coord.x;
            }

            flags[ITEM] = thread_segment[ITEM].offset;


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