 
     for (z = 0; z < nBlocks; z++) {
 
-        // I check to see if the column and line are within the range of the Matrix C here
-        // because apparently all threads within a block must reach the __syncthreads()
-        // otherwise they get stuck (deadlock). That means that I cannot just use a return; at the
-        // beggining of the kernel.
-        //I am not 100% sure about this but I am leaving it like this for this moment
-        if (column < c_ncolumns && line < c_nlines) {
-            // Load Matrix A
-            a_tLine = (blockIdx.y * NTHREADS_Y + threadIdx.y);
-            a_tColumn = (z * NTHREADS_X + threadIdx.x);
-            if (a_tLine < c_nlines && a_tColumn < a_ncolumns) {
-                s_a[threadIdx.y][threadIdx.x] = a[ (a_ncolumns * a_tLine) + a_tColumn];
-            }
-
-
-            // Load Matrix B
-            b_tLine = (z * NTHREADS_Y + threadIdx.y);
-            b_tColumn = (blockIdx.x * NTHREADS_X + threadIdx.x);
-            if (b_tLine < a_ncolumns && b_tColumn < c_ncolumns) {
-                s_b[threadIdx.y][threadIdx.x] = b[ (c_ncolumns * b_tLine) + b_tColumn ];
-            }
+        // Load Matrix A
+        a_tLine = (blockIdx.y * NTHREADS_Y + threadIdx.y);
+        a_tColumn = (z * NTHREADS_X + threadIdx.x);
+        if (a_tLine < c_nlines && a_tColumn < a_ncolumns) {
+            s_a[threadIdx.y][threadIdx.x] = a[ (a_ncolumns * a_tLine) + a_tColumn];
+        }
+
+        // Load Matrix B
+        b_tLine = (z * NTHREADS_Y + threadIdx.y);
+        b_tColumn = (blockIdx.x * NTHREADS_X + threadIdx.x);
+        if (b_tLine < a_ncolumns && b_tColumn < c_ncolumns) {
+            s_b[threadIdx.y][threadIdx.x] = b[ (c_ncolumns * b_tLine) + b_tColumn ];
         }
 
         __syncthreads();
 
-        // Check line 43 for an explanation about this if.
+        /* Checkin to see if that thread actually belongs to a valid position in
+         * the Matrix C
+         */
         if (column < c_ncolumns && line < c_nlines) {
             if (nMultiplications < NTHREADS_Y) {
                 multiplicationsInBlock = nMultiplications;
-
             }
 
             for (i = 0; i < multiplicationsInBlock; i++) {

 #include <stdlib.h>
 #include <time.h>
 #include <sys/time.h>

// Credit to: http://stackoverflow.com/a/14038590 for the gpuErrchk macro.
#define gpuErrchk(ans) { gpuAssert((ans), __FILE__, __LINE__); }

    }

    gettimeofday(&timevalA,NULL);

    gpuErrchk( cudaMemcpy(d_a, a, a_size, cudaMemcpyHostToDevice) );
    gpuErrchk( cudaMemcpy(d_b, b, b_size, cudaMemcpyHostToDevice) );

    dim3 tbloco = dim3(
                    (int) std::ceil( (double) c_ncolumns / NTHREADS_X ),
                    (int) std::ceil( (double) c_nlines / NTHREADS_Y ),
                    1
                );

