diff --git a/compute/zgeadd.c b/compute/zgeadd.c
index 93e709dfdc08c35447af4d3f5d797b20e44df630..ecf975a90088793b1f6455d4c7197c390f202d7e 100644
--- a/compute/zgeadd.c
+++ b/compute/zgeadd.c
@@ -153,32 +153,21 @@ int MORSE_zgeadd(MORSE_enum trans, int M, int N,
 
     morse_sequence_create(morse, &sequence);
 
-    /* if ( MORSE_TRANSLATION == MORSE_OUTOFPLACE ) { */
+    /* Submit the matrix conversion */
     morse_zlap2tile( morse, &descAl, &descAt, MorseUpperLower,
                      A, NB, NB, LDA, An, Am, An, sequence, &request );
     morse_zlap2tile( morse, &descBl, &descBt, MorseUpperLower,
                      B, NB, NB, LDB, N, M, N, sequence, &request );
-    /* } else { */
-    /*     morse_ziplap2tile( descA, A, NB, NB, LDA, An, 0, 0, Am, An, */
-    /*                         sequence, &request); */
-    /*     morse_ziplap2tile( descB, B, NB, NB, LDB, N, 0, 0, M, N, */
-    /*                         sequence, &request); */
-    /* } */
 
     /* Call the tile interface */
     MORSE_zgeadd_Tile_Async(
         trans, alpha, &descA, beta, &descB, sequence, &request);
 
-    /* if ( MORSE_TRANSLATION == MORSE_OUTOFPLACE ) { */
+    /* Submit the matrix conversion */
         morse_zooptile2lap( descB, B, NB, NB, LDB, N,  sequence, &request);
         morse_sequence_wait(morse, sequence);
         morse_desc_mat_free(&descA);
         morse_desc_mat_free(&descB);
-    /* } else { */
-    /*     morse_ziptile2lap( descA, A, NB, NB, LDA, An, sequence, &request); */
-    /*     morse_ziptile2lap( descB, B, NB, NB, LDB, N,  sequence, &request); */
-    /*     morse_dynamic_sync(); */
-    /* } */
 
     status = sequence->status;
     morse_sequence_destroy(morse, sequence);
diff --git a/compute/zgelqf.c b/compute/zgelqf.c
index 4fb713c04b4482a4348f28408bfafc0eef238df0..100a0e1300c3fc329641384374bcdeb35a31e5a7 100644
--- a/compute/zgelqf.c
+++ b/compute/zgelqf.c
@@ -122,25 +122,17 @@ int MORSE_zgelqf(int M, int N,
 
     morse_sequence_create(morse, &sequence);
 
-/*    if ( MORSE_TRANSLATION == MORSE_OUTOFPLACE ) {*/
+    /* Submit the matrix conversion */
     morse_zlap2tile( morse, &descAl, &descAt, MorseUpperLower,
                      A, NB, NB, LDA, N, M, N, sequence, &request );
-/*    } else {*/
-/*        morse_ziplap2tile( descA, A, NB, NB, LDA, N, 0, 0, M, N,*/
-/*                            sequence, &request);*/
-/*    }*/
 
     /* Call the tile interface */
     MORSE_zgelqf_Tile_Async(&descA, descT, sequence, &request);
 
-/*    if ( MORSE_TRANSLATION == MORSE_OUTOFPLACE ) {*/
+    /* Submit the matrix conversion */
         morse_zooptile2lap(descA, A, NB, NB, LDA, N,  sequence, &request);
         morse_sequence_wait(morse, sequence);
         morse_desc_mat_free(&descA);
-/*    } else {*/
-/*        morse_ziptile2lap( descA, A, NB, NB, LDA, N,  sequence, &request);*/
-/*        morse_sequence_wait(morse, sequence);*/
-/*    }*/
 
     status = sequence->status;
     morse_sequence_destroy(morse, sequence);
diff --git a/compute/zgelqf_param.c b/compute/zgelqf_param.c
index 1b0c5bf6121d669e92b191228f0791c9e84ebaf0..22d8dacdda0bbf8f64edc477821ea9bb4e10f61c 100644
--- a/compute/zgelqf_param.c
+++ b/compute/zgelqf_param.c
@@ -119,25 +119,17 @@ int MORSE_zgelqf_param(const libhqr_tree_t *qrtree, int M, int N,
 
     morse_sequence_create(morse, &sequence);
 
-/*    if ( MORSE_TRANSLATION == MORSE_OUTOFPLACE ) {*/
+    /* Submit the matrix conversion */
     morse_zlap2tile( morse, &descAl, &descAt, MorseUpperLower,
                      A, NB, NB, LDA, N, M, N, sequence, &request );
-/*    } else {*/
-/*        morse_ziplap2tile( descA, A, NB, NB, LDA, N, 0, 0, M, N,*/
-/*                            sequence, &request);*/
-/*    }*/
 
     /* Call the tile interface */
     MORSE_zgelqf_param_Tile_Async(qrtree, &descA, descTS, descTT, sequence, &request);
 
-/*    if ( MORSE_TRANSLATION == MORSE_OUTOFPLACE ) {*/
+    /* Submit the matrix conversion */
         morse_zooptile2lap(descA, A, NB, NB, LDA, N,  sequence, &request);
         morse_sequence_wait(morse, sequence);
         morse_desc_mat_free(&descA);
-/*    } else {*/
-/*        morse_ziptile2lap( descA, A, NB, NB, LDA, N,  sequence, &request);*/
-/*        morse_sequence_wait(morse, sequence);*/
-/*    }*/
 
     status = sequence->status;
     morse_sequence_destroy(morse, sequence);
diff --git a/compute/zgelqs.c b/compute/zgelqs.c
index dde651c6844f1ff3cf88d72286af23d577bb934b..b9f5013789ed5d171d19b20a5610b66e40c87282 100644
--- a/compute/zgelqs.c
+++ b/compute/zgelqs.c
@@ -137,32 +137,21 @@ int MORSE_zgelqs(int M, int N, int NRHS,
 
     morse_sequence_create(morse, &sequence);
 
-/*    if ( MORSE_TRANSLATION == MORSE_OUTOFPLACE ) {*/
+    /* Submit the matrix conversion */
     morse_zlap2tile( morse, &descAl, &descAt, MorseUpperLower,
                      A, NB, NB, LDA, N, M, N, sequence, &request );
     morse_zlap2tile( morse, &descBl, &descBt, MorseUpperLower,
                      B, NB, NB, LDB, NRHS, N, NRHS, sequence, &request );
-/*    } else {*/
-/*        morse_ziplap2tile( descA, A, NB, NB, LDA, N,    0, 0, M, N,   */
-/*                            sequence, &request);*/
-/*        morse_ziplap2tile( descB, B, NB, NB, LDB, NRHS, 0, 0, N, NRHS,*/
-/*                            sequence, &request);*/
-/*    }*/
 
     /* Call the tile interface */
     MORSE_zgelqs_Tile_Async(&descA, descT, &descB, sequence, &request);
 
-/*    if ( MORSE_TRANSLATION == MORSE_OUTOFPLACE ) {*/
+    /* Submit the matrix conversion */
         morse_zooptile2lap(descA, A, NB, NB, LDA, N,     sequence, &request);
         morse_zooptile2lap(descB, B, NB, NB, LDB, NRHS,  sequence, &request);
     morse_sequence_wait(morse, sequence);
     morse_desc_mat_free(&descA);
     morse_desc_mat_free(&descB);
-/*    } else {*/
-/*        morse_ziptile2lap( descA, A, NB, NB, LDA, N,     sequence, &request);*/
-/*        morse_ziptile2lap( descB, B, NB, NB, LDB, NRHS,  sequence, &request);*/
-/*        morse_sequence_wait(morse, sequence);*/
-/*    }*/
 
     status = sequence->status;
     morse_sequence_destroy(morse, sequence);
diff --git a/compute/zgelqs_param.c b/compute/zgelqs_param.c
index fc3d96ea60aee43829a72852c6076677d6c1ca6d..b6faae1ba51f504a29b3aec5e181714340396278 100644
--- a/compute/zgelqs_param.c
+++ b/compute/zgelqs_param.c
@@ -139,32 +139,21 @@ int MORSE_zgelqs_param(const libhqr_tree_t *qrtree, int M, int N, int NRHS,
 
     morse_sequence_create(morse, &sequence);
 
-/*    if ( MORSE_TRANSLATION == MORSE_OUTOFPLACE ) {*/
+    /* Submit the matrix conversion */
     morse_zlap2tile( morse, &descAl, &descAt, MorseUpperLower,
                      A, NB, NB, LDA, N, M, N, sequence, &request );
     morse_zlap2tile( morse, &descBl, &descBt, MorseUpperLower,
                      B, NB, NB, LDB, NRHS, N, NRHS, sequence, &request );
-/*    } else {*/
-/*        morse_ziplap2tile( descA, A, NB, NB, LDA, N,    0, 0, M, N,   */
-/*                            sequence, &request);*/
-/*        morse_ziplap2tile( descB, B, NB, NB, LDB, NRHS, 0, 0, N, NRHS,*/
-/*                            sequence, &request);*/
-/*    }*/
 
     /* Call the tile interface */
     MORSE_zgelqs_param_Tile_Async(qrtree, &descA, descTS, descTT, &descB, sequence, &request);
 
-/*    if ( MORSE_TRANSLATION == MORSE_OUTOFPLACE ) {*/
+    /* Submit the matrix conversion */
         morse_zooptile2lap(descA, A, NB, NB, LDA, N,     sequence, &request);
         morse_zooptile2lap(descB, B, NB, NB, LDB, NRHS,  sequence, &request);
     morse_sequence_wait(morse, sequence);
     morse_desc_mat_free(&descA);
     morse_desc_mat_free(&descB);
-/*    } else {*/
-/*        morse_ziptile2lap( descA, A, NB, NB, LDA, N,     sequence, &request);*/
-/*        morse_ziptile2lap( descB, B, NB, NB, LDB, NRHS,  sequence, &request);*/
-/*        morse_sequence_wait(morse, sequence);*/
-/*    }*/
 
     status = sequence->status;
     morse_sequence_destroy(morse, sequence);
diff --git a/compute/zgels.c b/compute/zgels.c
index a12abd3ca63c112d6847f3ab20f665936bf6023e..c3a7c852c4683105cd4d2a28631c5276213f3ede 100644
--- a/compute/zgels.c
+++ b/compute/zgels.c
@@ -171,47 +171,30 @@ int MORSE_zgels(MORSE_enum trans, int M, int N, int NRHS,
 
     morse_sequence_create(morse, &sequence);
 
+    /* Submit the matrix conversion */
     if ( M >= N ) {
-/*        if ( MORSE_TRANSLATION == MORSE_OUTOFPLACE ) {*/
-    morse_zlap2tile( morse, &descAl, &descAt, MorseUpperLower,
-                     A, NB, NB, LDA, N, M, N, sequence, &request );
-    morse_zlap2tile( morse, &descBl, &descBt, MorseUpperLower,
-                     B, NB, NB, LDB, NRHS, M, NRHS, sequence, &request );
-/*        } else {*/
-/*            morse_ziplap2tile( descA, A, NB, NB, LDA, N,    0, 0, M, N,*/
-/*                                sequence, &request);*/
-/*            morse_ziplap2tile( descB, B, NB, NB, LDB, NRHS, 0, 0, M, NRHS,*/
-/*                                sequence, &request);*/
-/*        }*/
+        morse_zlap2tile( morse, &descAl, &descAt, MorseUpperLower,
+                         A, NB, NB, LDA, N, M, N, sequence, &request );
+        morse_zlap2tile( morse, &descBl, &descBt, MorseUpperLower,
+                         B, NB, NB, LDB, NRHS, M, NRHS, sequence, &request );
     } else {
-/*        if ( MORSE_TRANSLATION == MORSE_OUTOFPLACE ) {*/
-    morse_zlap2tile( morse, &descAl, &descAt, MorseUpperLower,
-                     A, NB, NB, LDA, N, M, N, sequence, &request );
-    morse_zlap2tile( morse, &descBl, &descBt, MorseUpperLower,
-                     B, NB, NB, LDB, NRHS, N, NRHS, sequence, &request );
-/*        } else {*/
-/*            morse_ziplap2tile( descA, A, NB, NB, LDA, N,    0, 0, M, N,*/
-/*                                sequence, &request);*/
-/*            morse_ziplap2tile( descB, B, NB, NB, LDB, NRHS, 0, 0, N, NRHS,*/
-/*                                sequence, &request);*/
-/*        }*/
+        /* Submit the matrix conversion */
+        morse_zlap2tile( morse, &descAl, &descAt, MorseUpperLower,
+                         A, NB, NB, LDA, N, M, N, sequence, &request );
+        morse_zlap2tile( morse, &descBl, &descBt, MorseUpperLower,
+                         B, NB, NB, LDB, NRHS, N, NRHS, sequence, &request );
     }
 
     /* Call the tile interface */
     MORSE_zgels_Tile_Async(MorseNoTrans, &descA, descT, &descB, sequence, &request);
 
-/*    if ( MORSE_TRANSLATION == MORSE_OUTOFPLACE ) {*/
+    /* Submit the matrix conversion */
         morse_zooptile2lap(descA, A, NB, NB, LDA, N,     sequence, &request);
         morse_zooptile2lap(descB, B, NB, NB, LDB, NRHS,  sequence, &request);
         morse_sequence_wait(morse, sequence);
         morse_desc_mat_free(&descA);
         morse_desc_mat_free(&descB);
-/*    } else {*/
-/*        morse_ziptile2lap( descA, A, NB, NB, LDA, N,     sequence, &request);*/
-/*        morse_ziptile2lap( descB, B, NB, NB, LDB, NRHS,  sequence, &request);*/
-/*        morse_sequence_wait(morse, sequence);*/
-/*    }*/
-    
+
     status = sequence->status;
     morse_sequence_destroy(morse, sequence);
     return status;
diff --git a/compute/zgels_param.c b/compute/zgels_param.c
index 26d4ae18a61bed367dbbb16caa5ef58009d16994..733eeed65c9e6f817dd5d04aea67d5054bc3fb1a 100644
--- a/compute/zgels_param.c
+++ b/compute/zgels_param.c
@@ -173,46 +173,28 @@ int MORSE_zgels_param(const libhqr_tree_t *qrtree, MORSE_enum trans, int M, int
 
     morse_sequence_create(morse, &sequence);
 
+    /* Submit the matrix conversion */
     if ( M >= N ) {
-        /*        if ( MORSE_TRANSLATION == MORSE_OUTOFPLACE ) {*/
-    morse_zlap2tile( morse, &descAl, &descAt, MorseUpperLower,
-                     A, NB, NB, LDA, N, M, N, sequence, &request );
-    morse_zlap2tile( morse, &descBl, &descBt, MorseUpperLower,
-                     B, NB, NB, LDB, NRHS, M, NRHS, sequence, &request );
-        /*        } else {*/
-        /*            morse_ziplap2tile( descA, A, NB, NB, LDA, N,    0, 0, M, N,*/
-        /*                                sequence, &request);*/
-        /*            morse_ziplap2tile( descB, B, NB, NB, LDB, NRHS, 0, 0, M, NRHS,*/
-        /*                                sequence, &request);*/
-        /*        }*/
+        morse_zlap2tile( morse, &descAl, &descAt, MorseUpperLower,
+                         A, NB, NB, LDA, N, M, N, sequence, &request );
+        morse_zlap2tile( morse, &descBl, &descBt, MorseUpperLower,
+                         B, NB, NB, LDB, NRHS, M, NRHS, sequence, &request );
     } else {
-        /*        if ( MORSE_TRANSLATION == MORSE_OUTOFPLACE ) {*/
-    morse_zlap2tile( morse, &descAl, &descAt, MorseUpperLower,
-                     A, NB, NB, LDA, N, M, N, sequence, &request );
-    morse_zlap2tile( morse, &descBl, &descBt, MorseUpperLower,
-                     B, NB, NB, LDB, NRHS, N, NRHS, sequence, &request );
-        /*        } else {*/
-        /*            morse_ziplap2tile( descA, A, NB, NB, LDA, N,    0, 0, M, N,*/
-        /*                                sequence, &request);*/
-        /*            morse_ziplap2tile( descB, B, NB, NB, LDB, NRHS, 0, 0, N, NRHS,*/
-        /*                                sequence, &request);*/
-        /*        }*/
+        morse_zlap2tile( morse, &descAl, &descAt, MorseUpperLower,
+                         A, NB, NB, LDA, N, M, N, sequence, &request );
+        morse_zlap2tile( morse, &descBl, &descBt, MorseUpperLower,
+                         B, NB, NB, LDB, NRHS, N, NRHS, sequence, &request );
     }
 
     /* Call the tile interface */
     MORSE_zgels_param_Tile_Async(qrtree, MorseNoTrans, &descA, descTS, descTT, &descB, sequence, &request);
 
-    /*    if ( MORSE_TRANSLATION == MORSE_OUTOFPLACE ) {*/
+    /* Submit the matrix conversion */
     morse_zooptile2lap(descA, A, NB, NB, LDA, N,     sequence, &request);
     morse_zooptile2lap(descB, B, NB, NB, LDB, NRHS,  sequence, &request);
     morse_sequence_wait(morse, sequence);
     morse_desc_mat_free(&descA);
     morse_desc_mat_free(&descB);
-    /*    } else {*/
-    /*        morse_ziptile2lap( descA, A, NB, NB, LDA, N,     sequence, &request);*/
-    /*        morse_ziptile2lap( descB, B, NB, NB, LDB, NRHS,  sequence, &request);*/
-    /*        morse_sequence_wait(morse, sequence);*/
-    /*    }*/
 
     status = sequence->status;
     morse_sequence_destroy(morse, sequence);
diff --git a/compute/zgemm.c b/compute/zgemm.c
index 7d5fd72bd372ca856bdeea48a43393984da1ebe5..b830977a3164cf5cebdb521fc0a5021cfb476204 100644
--- a/compute/zgemm.c
+++ b/compute/zgemm.c
@@ -210,38 +210,24 @@ int MORSE_zgemm(MORSE_enum transA, MORSE_enum transB, int M, int N, int K,
 
     morse_sequence_create(morse, &sequence);
 
-/*    if ( MORSE_TRANSLATION == MORSE_OUTOFPLACE ) {*/
+    /* Submit the matrix conversion */
     morse_zlap2tile( morse, &descAl, &descAt, MorseUpperLower,
                      A, NB, NB, LDA, An, Am, An, sequence, &request );
     morse_zlap2tile( morse, &descBl, &descBt, MorseUpperLower,
                      B, NB, NB, LDB, Bn, Bm, Bn, sequence, &request );
     morse_zlap2tile( morse, &descCl, &descCt, MorseUpperLower,
                      C, NB, NB, LDC, N, M,  N, sequence, &request );
-/*    } else {*/
-/*        morse_ziplap2tile( descA, A, NB, NB, LDA, An, 0, 0, Am, An, */
-/*                            sequence, &request);*/
-/*        morse_ziplap2tile( descB, B, NB, NB, LDB, Bn, 0, 0, Bm, Bn, */
-/*                            sequence, &request);*/
-/*        morse_ziplap2tile( descC, C, NB, NB, LDC, N,  0, 0, M,  N,  */
-/*                            sequence, &request);*/
-/*    }*/
 
     /* Call the tile interface */
     MORSE_zgemm_Tile_Async(
         transA, transB, alpha, &descA, &descB, beta, &descC, sequence, &request);
 
-/*    if ( MORSE_TRANSLATION == MORSE_OUTOFPLACE ) {*/
-        morse_zooptile2lap(descC, C, NB, NB, LDC, N,  sequence, &request);
-        morse_sequence_wait(morse, sequence);
-        morse_desc_mat_free(&descA);
-        morse_desc_mat_free(&descB);
-        morse_desc_mat_free(&descC);
-/*    } else {*/
-/*        morse_ziptile2lap( descA, A, NB, NB, LDA, An,  sequence, &request);*/
-/*        morse_ziptile2lap( descB, B, NB, NB, LDB, Bn,  sequence, &request);*/
-/*        morse_ziptile2lap( descC, C, NB, NB, LDC, N,   sequence, &request);*/
-/*        morse_sequence_wait(morse, sequence);*/
-/*    }*/
+    /* Submit the matrix conversion */
+    morse_zooptile2lap(descC, C, NB, NB, LDC, N,  sequence, &request);
+    morse_sequence_wait(morse, sequence);
+    morse_desc_mat_free(&descA);
+    morse_desc_mat_free(&descB);
+    morse_desc_mat_free(&descC);
 
     status = sequence->status;
     morse_sequence_destroy(morse, sequence);
diff --git a/compute/zgeqrf.c b/compute/zgeqrf.c
index 08604a843530e8ba6a76514507296ebe1bf8b427..8e32eb570210bca1c1280bfe31338ec9181dba1a 100644
--- a/compute/zgeqrf.c
+++ b/compute/zgeqrf.c
@@ -121,25 +121,17 @@ int MORSE_zgeqrf(int M, int N,
 
     morse_sequence_create(morse, &sequence);
 
-/*    if ( MORSE_TRANSLATION == MORSE_OUTOFPLACE ) {*/
+    /* Submit the matrix conversion */
     morse_zlap2tile( morse, &descAl, &descAt, MorseUpperLower,
                      A, NB, NB, LDA, N, M, N, sequence, &request );
-/*    } else {*/
-/*        morse_ziplap2tile( descA, A, NB, NB, LDA, N, 0, 0, M, N,*/
-/*                            sequence, &request);*/
-/*    }*/
 
     /* Call the tile interface */
     MORSE_zgeqrf_Tile_Async(&descA, descT, sequence, &request);
 
-/*    if ( MORSE_TRANSLATION == MORSE_OUTOFPLACE ) {*/
+    /* Submit the matrix conversion */
         morse_zooptile2lap(descA, A, NB, NB, LDA, N,  sequence, &request);
         morse_sequence_wait(morse, sequence);
         morse_desc_mat_free(&descA);
-/*    } else {*/
-/*        morse_ziptile2lap( descA, A, NB, NB, LDA, N,  sequence, &request);*/
-/*        morse_sequence_wait(morse, sequence);*/
-/*    }*/
 
     status = sequence->status;
     morse_sequence_destroy(morse, sequence);
diff --git a/compute/zgeqrf_param.c b/compute/zgeqrf_param.c
index 4e1dbb61234bcdc89b7883529316be94fd0a4c80..00fce04afd9517d2f383589b565fed2124dfa6ce 100644
--- a/compute/zgeqrf_param.c
+++ b/compute/zgeqrf_param.c
@@ -124,25 +124,17 @@ int MORSE_zgeqrf_param(const libhqr_tree_t *qrtree, int M, int N,
 
     morse_sequence_create(morse, &sequence);
 
-/*    if ( MORSE_TRANSLATION == MORSE_OUTOFPLACE ) {*/
+    /* Submit the matrix conversion */
     morse_zlap2tile( morse, &descAl, &descAt, MorseUpperLower,
                      A, NB, NB, LDA, N, M, N, sequence, &request );
-/*    } else {*/
-/*        morse_ziplap2tile( descA, A, NB, NB, LDA, N, 0, 0, M, N,*/
-/*                            sequence, &request);*/
-/*    }*/
 
     /* Call the tile interface */
         MORSE_zgeqrf_param_Tile_Async(qrtree, &descA, descTS, descTT, sequence, &request);
 
-/*    if ( MORSE_TRANSLATION == MORSE_OUTOFPLACE ) {*/
+    /* Submit the matrix conversion */
         morse_zooptile2lap(descA, A, NB, NB, LDA, N,  sequence, &request);
         morse_sequence_wait(morse, sequence);
         morse_desc_mat_free(&descA);
-/*    } else {*/
-/*        morse_ziptile2lap( descA, A, NB, NB, LDA, N,  sequence, &request);*/
-/*        morse_sequence_wait(morse, sequence);*/
-/*    }*/
 
     status = sequence->status;
     morse_sequence_destroy(morse, sequence);
diff --git a/compute/zgeqrs.c b/compute/zgeqrs.c
index 615c1513a913c8d4cd6709f2d2de92368eff4bb5..2c9012db358f86d77424bfd6f57bcd0ade7ed0a6 100644
--- a/compute/zgeqrs.c
+++ b/compute/zgeqrs.c
@@ -137,32 +137,21 @@ int MORSE_zgeqrs(int M, int N, int NRHS,
 
     morse_sequence_create(morse, &sequence);
 
-/*    if ( MORSE_TRANSLATION == MORSE_OUTOFPLACE ) {*/
+    /* Submit the matrix conversion */
     morse_zlap2tile( morse, &descAl, &descAt, MorseUpperLower,
                      A, NB, NB, LDA, N, M, N, sequence, &request );
     morse_zlap2tile( morse, &descBl, &descBt, MorseUpperLower,
                      B, NB, NB, LDB, NRHS, M, NRHS, sequence, &request );
-/*    } else {*/
-/*        morse_ziplap2tile( descA, A, NB, NB, LDA, N,    0, 0, M, N,   */
-/*                            sequence, &request);*/
-/*        morse_ziplap2tile( descB, B, NB, NB, LDB, NRHS, 0, 0, M, NRHS,*/
-/*                            sequence, &request);*/
-/*    }*/
 
     /* Call the tile interface */
     MORSE_zgeqrs_Tile_Async(&descA, descT, &descB, sequence, &request);
 
-/*    if ( MORSE_TRANSLATION == MORSE_OUTOFPLACE ) {*/
+    /* Submit the matrix conversion */
         morse_zooptile2lap(descA, A, NB, NB, LDA, N,     sequence, &request);
         morse_zooptile2lap(descB, B, NB, NB, LDB, NRHS,  sequence, &request);
         morse_sequence_wait(morse, sequence);
         morse_desc_mat_free(&descA);
         morse_desc_mat_free(&descB);
-/*    } else {*/
-/*        morse_ziptile2lap( descA, A, NB, NB, LDA, N,     sequence, &request);*/
-/*        morse_ziptile2lap( descB, B, NB, NB, LDB, NRHS,  sequence, &request);*/
-/*        morse_sequence_wait(morse, sequence);*/
-/*    }*/
     
     status = sequence->status;
     morse_sequence_destroy(morse, sequence);
diff --git a/compute/zgeqrs_param.c b/compute/zgeqrs_param.c
index c14ee32b0608a5b9bac6c2a2df61c624aaf6ed46..f74ca15829cd7a8f94fc87a3c214b0e64862ae31 100644
--- a/compute/zgeqrs_param.c
+++ b/compute/zgeqrs_param.c
@@ -132,32 +132,21 @@ int MORSE_zgeqrs_param(const libhqr_tree_t *qrtree, int M, int N, int NRHS,
 
     morse_sequence_create(morse, &sequence);
 
-/*    if ( MORSE_TRANSLATION == MORSE_OUTOFPLACE ) {*/
+    /* Submit the matrix conversion */
     morse_zlap2tile( morse, &descAl, &descAt, MorseUpperLower,
                      A, NB, NB, LDA, N, M, N, sequence, &request );
     morse_zlap2tile( morse, &descBl, &descBt, MorseUpperLower,
                      B, NB, NB, LDB, NRHS, M, NRHS, sequence, &request );
-/*    } else {*/
-/*        morse_ziplap2tile( descA, A, NB, NB, LDA, N,    0, 0, M, N,   */
-/*                            sequence, &request);*/
-/*        morse_ziplap2tile( descB, B, NB, NB, LDB, NRHS, 0, 0, M, NRHS,*/
-/*                            sequence, &request);*/
-/*    }*/
 
     /* Call the tile interface */
     MORSE_zgeqrs_param_Tile_Async(qrtree, &descA, descTS, descTT, &descB, sequence, &request);
 
-/*    if ( MORSE_TRANSLATION == MORSE_OUTOFPLACE ) {*/
+    /* Submit the matrix conversion */
         morse_zooptile2lap(descA, A, NB, NB, LDA, N,     sequence, &request);
         morse_zooptile2lap(descB, B, NB, NB, LDB, NRHS,  sequence, &request);
         morse_sequence_wait(morse, sequence);
         morse_desc_mat_free(&descA);
         morse_desc_mat_free(&descB);
-/*    } else {*/
-/*        morse_ziptile2lap( descA, A, NB, NB, LDA, N,     sequence, &request);*/
-/*        morse_ziptile2lap( descB, B, NB, NB, LDB, NRHS,  sequence, &request);*/
-/*        morse_sequence_wait(morse, sequence);*/
-/*    }*/
 
     status = sequence->status;
     morse_sequence_destroy(morse, sequence);
diff --git a/compute/zgesv_incpiv.c b/compute/zgesv_incpiv.c
index f1431c24e26bdbc73791e0274b1a10b59c2f3636..f22c79585c122acc86f376485cede82bb82f8158 100644
--- a/compute/zgesv_incpiv.c
+++ b/compute/zgesv_incpiv.c
@@ -136,32 +136,21 @@ int MORSE_zgesv_incpiv(int N, int NRHS,
 
     morse_sequence_create(morse, &sequence);
 
-/*    if ( MORSE_TRANSLATION == MORSE_OUTOFPLACE ) {*/
+    /* Submit the matrix conversion */
     morse_zlap2tile( morse, &descAl, &descAt, MorseUpperLower,
                      A, NB, NB, LDA, N, N, N, sequence, &request );
     morse_zlap2tile( morse, &descBl, &descBt, MorseUpperLower,
                      B, NB, NB, LDB, NRHS, N, NRHS, sequence, &request );
-/*    } else {*/
-/*        morse_ziplap2tile( descA, A, NB, NB, LDA, N,    0, 0, N, N,   */
-/*                            sequence, &request);*/
-/*        morse_ziplap2tile( descB, B, NB, NB, LDB, NRHS, 0, 0, N, NRHS,*/
-/*                            sequence, &request);*/
-/*    }*/
 
     /* Call the tile interface */
     MORSE_zgesv_incpiv_Tile_Async(&descA, descL, IPIV, &descB, sequence, &request);
 
-/*    if ( MORSE_TRANSLATION == MORSE_OUTOFPLACE ) {*/
+    /* Submit the matrix conversion */
         morse_zooptile2lap(descA, A, NB, NB, LDA, N,     sequence, &request);
         morse_zooptile2lap(descB, B, NB, NB, LDB, NRHS,  sequence, &request);
         morse_sequence_wait(morse, sequence);
         morse_desc_mat_free(&descA);
         morse_desc_mat_free(&descB);
-/*    } else {*/
-/*        morse_ziptile2lap( descA, A, NB, NB, LDA, N,     sequence, &request);*/
-/*        morse_ziptile2lap( descB, B, NB, NB, LDB, NRHS,  sequence, &request);*/
-/*        morse_sequence_wait(morse, sequence);*/
-/*    }*/
     
     status = sequence->status;
     morse_sequence_destroy(morse, sequence);
diff --git a/compute/zgesv_nopiv.c b/compute/zgesv_nopiv.c
index 97a540d58f8d5739ea6c1a149e70be172e00fe86..164ee3109672d7fe7b27d71a6c09aa4a9c2422f0 100644
--- a/compute/zgesv_nopiv.c
+++ b/compute/zgesv_nopiv.c
@@ -135,32 +135,21 @@ int MORSE_zgesv_nopiv(int N, int NRHS,
 
     morse_sequence_create(morse, &sequence);
 
-/*    if ( MORSE_TRANSLATION == MORSE_OUTOFPLACE ) {*/
+    /* Submit the matrix conversion */
     morse_zlap2tile( morse, &descAl, &descAt, MorseUpperLower,
                      A, NB, NB, LDA, N, N, N, sequence, &request );
     morse_zlap2tile( morse, &descBl, &descBt, MorseUpperLower,
                      B, NB, NB, LDB, NRHS, N, NRHS, sequence, &request );
-/*    } else {*/
-/*        morse_ziplap2tile( descA, A, NB, NB, LDA, N,    0, 0, N, N,   */
-/*                            sequence, &request);*/
-/*        morse_ziplap2tile( descB, B, NB, NB, LDB, NRHS, 0, 0, N, NRHS,*/
-/*                            sequence, &request);*/
-/*    }*/
 
     /* Call the tile interface */
     MORSE_zgesv_nopiv_Tile_Async(&descA, &descB, sequence, &request);
 
-/*    if ( MORSE_TRANSLATION == MORSE_OUTOFPLACE ) {*/
+    /* Submit the matrix conversion */
         morse_zooptile2lap(descA, A, NB, NB, LDA, N,     sequence, &request);
         morse_zooptile2lap(descB, B, NB, NB, LDB, NRHS,  sequence, &request);
         morse_sequence_wait(morse, sequence);
         morse_desc_mat_free(&descA);
         morse_desc_mat_free(&descB);
-/*    } else {*/
-/*        morse_ziptile2lap( descA, A, NB, NB, LDA, N,     sequence, &request);*/
-/*        morse_ziptile2lap( descB, B, NB, NB, LDB, NRHS,  sequence, &request);*/
-/*        morse_sequence_wait(morse, sequence);*/
-/*    }*/
     
     status = sequence->status;
     morse_sequence_destroy(morse, sequence);
diff --git a/compute/zgesvd.c b/compute/zgesvd.c
index 7432a277f5b8372939e42ea64276edb4719389e6..d3f1e8b1def929b05bbda2da0f5aeee3b9f31115 100644
--- a/compute/zgesvd.c
+++ b/compute/zgesvd.c
@@ -214,25 +214,17 @@ int MORSE_zgesvd(MORSE_enum jobu, MORSE_enum jobvt,
 
     morse_sequence_create(morse, &sequence);
 
-    /* if ( MORSE_TRANSLATION == MORSE_OUTOFPLACE ) { */
+    /* Submit the matrix conversion */
     morse_zlap2tile( morse, &descAl, &descAt, MorseUpperLower,
                      A, NB, NB,  LDA, N, M, N, sequence, &request );
-    /* } else { */
-    /*     morse_ziplap2tile( descA,   A, NB, NB,  LDA, N, 0, 0, M, N, */
-    /*                         sequence, &request); */
-    /* } */
 
     /* Call the tile interface */
     MORSE_zgesvd_Tile_Async(jobu, jobvt, &descA, S, descT, U, LDU, VT, LDVT, sequence, &request);
 
-    /* if ( MORSE_TRANSLATION == MORSE_OUTOFPLACE ) { */
+    /* Submit the matrix conversion */
     morse_zooptile2lap( descA, A, NB, NB, LDA, N,  sequence, &request);
     morse_sequence_wait(morse, sequence);
     morse_desc_mat_free(&descA);
-    /* } else { */
-    /*     morse_ziptile2lap( descA, A, NB, NB, LDA, N,  sequence, &request); */
-    /*     morse_sequence_wait(morse, sequence); */
-    /* } */
 
     status = sequence->status;
     morse_sequence_destroy(morse, sequence);
diff --git a/compute/zgetrf_incpiv.c b/compute/zgetrf_incpiv.c
index 243e7f70c17902f58f9393f37f1ca8706aa3aef3..809df1bc273b65dec182250382ef869fe8e8997a 100644
--- a/compute/zgetrf_incpiv.c
+++ b/compute/zgetrf_incpiv.c
@@ -123,25 +123,17 @@ int MORSE_zgetrf_incpiv(int M, int N,
 
     morse_sequence_create(morse, &sequence);
 
-/*    if ( MORSE_TRANSLATION == MORSE_OUTOFPLACE ) {*/
+    /* Submit the matrix conversion */
     morse_zlap2tile( morse, &descAl, &descAt, MorseUpperLower,
                      A, NB, NB, LDA, N, M, N, sequence, &request );
-/*    } else {*/
-/*        morse_ziplap2tile( descA, A, NB, NB, LDA, N, 0, 0, M, N,*/
-/*                            sequence, &request);*/
-/*    }*/
 
     /* Call the tile interface */
     MORSE_zgetrf_incpiv_Tile_Async(&descA, descL, IPIV, sequence, &request);
 
-/*    if ( MORSE_TRANSLATION == MORSE_OUTOFPLACE ) {*/
+    /* Submit the matrix conversion */
         morse_zooptile2lap(descA, A, NB, NB, LDA, N,  sequence, &request);
         morse_sequence_wait(morse, sequence);
         morse_desc_mat_free(&descA);
-/*    } else {*/
-/*        morse_ziptile2lap( descA, A, NB, NB, LDA, N,  sequence, &request);*/
-/*        morse_sequence_wait(morse, sequence);*/
-/*    }*/
 
     status = sequence->status;
     morse_sequence_destroy(morse, sequence);
diff --git a/compute/zgetrf_nopiv.c b/compute/zgetrf_nopiv.c
index 447ed24f5d60e96d42d637f5ed1c865b3ca8cbc5..10e9270bf24e059360df192f5c0742b28e10f27d 100644
--- a/compute/zgetrf_nopiv.c
+++ b/compute/zgetrf_nopiv.c
@@ -116,26 +116,17 @@ int MORSE_zgetrf_nopiv(int M, int N,
 
     morse_sequence_create(morse, &sequence);
 
-/*    if ( MORSE_TRANSLATION == MORSE_OUTOFPLACE ) {*/
+    /* Submit the matrix conversion */
     morse_zlap2tile( morse, &descAl, &descAt, MorseUpperLower,
                      A, NB, NB, LDA, N, N, N, sequence, &request );
-/*    } else {*/
-/*        morse_ziplap2tile(  descA, A, NB, NB, LDA, N, 0, 0, N, N,*/
-/*                             sequence, &request);*/
-/*    }*/
 
     /* Call the tile interface */
     MORSE_zgetrf_nopiv_Tile_Async(&descA, sequence, &request);
 
-/*    if ( MORSE_TRANSLATION == MORSE_OUTOFPLACE ) {*/
+    /* Submit the matrix conversion */
         morse_zooptile2lap(descA, A, NB, NB, LDA, N, sequence, &request );
         morse_sequence_wait(morse, sequence);
         morse_desc_mat_free(&descA);
-/*    } else {*/
-/*        morse_ziptile2lap( descA, A, NB, NB, LDA, N,*/
-/*                             sequence, &request );*/
-/*        morse_sequence_wait(morse, sequence);*/
-/*    }*/
 
     status = sequence->status;
     morse_sequence_destroy(morse, sequence);
diff --git a/compute/zgetrs_incpiv.c b/compute/zgetrs_incpiv.c
index d2a410344c6a1ed36401ad756192844927f94c31..392f3c8aecbf82509ccb5e6384246eee9e5f8f71 100644
--- a/compute/zgetrs_incpiv.c
+++ b/compute/zgetrs_incpiv.c
@@ -142,31 +142,20 @@ int MORSE_zgetrs_incpiv(MORSE_enum trans, int N, int NRHS,
 
     morse_sequence_create(morse, &sequence);
 
-/*    if ( MORSE_TRANSLATION == MORSE_OUTOFPLACE ) {*/
+    /* Submit the matrix conversion */
     morse_zlap2tile( morse, &descAl, &descAt, MorseUpperLower,
                      A, NB, NB, LDA, N, N, N, sequence, &request );
     morse_zlap2tile( morse, &descBl, &descBt, MorseUpperLower,
                      B, NB, NB, LDB, NRHS, N, NRHS, sequence, &request );
-/*    } else {*/
-/*        morse_ziplap2tile( descA, A, NB, NB, LDA, N,    0, 0, N, N,   */
-/*                            sequence, &request);*/
-/*        morse_ziplap2tile( descB, B, NB, NB, LDB, NRHS, 0, 0, N, NRHS,*/
-/*                            sequence, &request);*/
-/*    }*/
 
     /* Call the tile interface */
     MORSE_zgetrs_incpiv_Tile_Async(&descA, descL, IPIV, &descB, sequence, &request);
 
-/*    if ( MORSE_TRANSLATION == MORSE_OUTOFPLACE ) {*/
+    /* Submit the matrix conversion */
         morse_zooptile2lap(descB, B, NB, NB, LDB, NRHS,  sequence, &request);
         morse_sequence_wait(morse, sequence);
         morse_desc_mat_free(&descA);
         morse_desc_mat_free(&descB);
-/*    } else {*/
-/*        morse_ziptile2lap( descA, A, NB, NB, LDA, N,     sequence, &request);*/
-/*        morse_ziptile2lap( descB, B, NB, NB, LDB, NRHS,  sequence, &request);*/
-/*        morse_sequence_wait(morse, sequence);*/
-/*    }*/
 
     status = sequence->status;
     morse_sequence_destroy(morse, sequence);
diff --git a/compute/zgetrs_nopiv.c b/compute/zgetrs_nopiv.c
index 72af580eaa3fc30251402d010dd606415cc379ff..5f4448f22024cb92a82cc86aa3f998560c93242a 100644
--- a/compute/zgetrs_nopiv.c
+++ b/compute/zgetrs_nopiv.c
@@ -136,31 +136,20 @@ int MORSE_zgetrs_nopiv(MORSE_enum trans, int N, int NRHS,
 
     morse_sequence_create(morse, &sequence);
 
-/*    if ( MORSE_TRANSLATION == MORSE_OUTOFPLACE ) {*/
+    /* Submit the matrix conversion */
     morse_zlap2tile( morse, &descAl, &descAt, MorseUpperLower,
                      A, NB, NB, LDA, N, N, N, sequence, &request );
     morse_zlap2tile( morse, &descBl, &descBt, MorseUpperLower,
                      B, NB, NB, LDB, NRHS, N, NRHS, sequence, &request );
-/*    } else {*/
-/*        morse_ziplap2tile( descA, A, NB, NB, LDA, N,    0, 0, N, N,   */
-/*                            sequence, &request);*/
-/*        morse_ziplap2tile( descB, B, NB, NB, LDB, NRHS, 0, 0, N, NRHS,*/
-/*                            sequence, &request);*/
-/*    }*/
 
     /* Call the tile interface */
     MORSE_zgetrs_nopiv_Tile_Async(&descA, &descB, sequence, &request);
 
-/*    if ( MORSE_TRANSLATION == MORSE_OUTOFPLACE ) {*/
+    /* Submit the matrix conversion */
         morse_zooptile2lap(descB, B, NB, NB, LDB, NRHS,  sequence, &request);
         morse_sequence_wait(morse, sequence);
         morse_desc_mat_free(&descA);
         morse_desc_mat_free(&descB);
-/*    } else {*/
-/*        morse_ziptile2lap( descA, A, NB, NB, LDA, N,     sequence, &request);*/
-/*        morse_ziptile2lap( descB, B, NB, NB, LDB, NRHS,  sequence, &request);*/
-/*        morse_sequence_wait(morse, sequence);*/
-/*    }*/
 
     status = sequence->status;
     morse_sequence_destroy(morse, sequence);
diff --git a/compute/zheevd.c b/compute/zheevd.c
index 864d50eb0846720e100dfea1b4ae185b4e84adde..5254ea76660203a0c3e3a287c063bf6f804d03ee 100644
--- a/compute/zheevd.c
+++ b/compute/zheevd.c
@@ -152,25 +152,17 @@ int MORSE_zheevd(MORSE_enum jobz, MORSE_enum uplo, int N,
 
     morse_sequence_create(morse, &sequence);
 
-    /* if ( MORSE_TRANSLATION == MORSE_OUTOFPLACE ) { */
+    /* Submit the matrix conversion */
     morse_zlap2tile( morse, &descAl, &descAt, MorseUpperLower,
                      A, NB, NB, LDA, N, N, N, sequence, &request );
-    /* } else { */
-    /*     morse_ziplap2tile( descA, A, NB, NB, LDA, N, 0, 0, N, N, */
-    /*                         sequence, &requoest); */
-    /* } */
 
     /* Call the tile interface */
     MORSE_zheevd_Tile_Async(jobz, uplo, &descA, W, descT, sequence, &request);
 
-    /* if ( MORSE_TRANSLATION == MORSE_OUTOFPLACE ) { */
+    /* Submit the matrix conversion */
     morse_zooptile2lap( descA, A, NB, NB, LDA, N,  sequence, &request);
     morse_sequence_wait(morse, sequence);
     morse_desc_mat_free(&descA);
-    /* } else { */
-    /*     morse_ziptile2lap( descA, A, NB, NB, LDA, N,  sequence, &request); */
-    /*     morse_sequence_wait(morse, sequence); */
-    /* } */
 
     status = sequence->status;
     morse_sequence_destroy(morse, sequence);
diff --git a/compute/zhemm.c b/compute/zhemm.c
index 1aa351cce7a9679d1c2bd5b22bd2edb352af1e3c..5d31cb37921eb7fd5471cbf99a52e8abb30fe466 100644
--- a/compute/zhemm.c
+++ b/compute/zhemm.c
@@ -173,38 +173,24 @@ int MORSE_zhemm(MORSE_enum side, MORSE_enum uplo, int M, int N,
 
     morse_sequence_create(morse, &sequence);
 
-/*    if ( MORSE_TRANSLATION == MORSE_OUTOFPLACE ) {*/
+    /* Submit the matrix conversion */
     morse_zlap2tile( morse, &descAl, &descAt, MorseUpperLower,
                      A, NB, NB, LDA, Am, Am, Am, sequence, &request );
     morse_zlap2tile( morse, &descBl, &descBt, MorseUpperLower,
                      B, NB, NB, LDB, N, M,  N, sequence, &request );
     morse_zlap2tile( morse, &descCl, &descCt, MorseUpperLower,
                      C, NB, NB, LDC, N, M,  N, sequence, &request );
-/*    } else {*/
-/*        morse_ziplap2tile( descA, A, NB, NB, LDA, Am, 0, 0, Am, Am,*/
-/*                            sequence, &request);*/
-/*        morse_ziplap2tile( descB, B, NB, NB, LDB, N,  0, 0, M,  N,*/
-/*                            sequence, &request);*/
-/*        morse_ziplap2tile( descC, C, NB, NB, LDC, N,  0, 0, M,  N,*/
-/*                            sequence, &request);*/
-/*    }*/
 
     /* Call the tile interface */
     MORSE_zhemm_Tile_Async(
         side, uplo, alpha, &descA, &descB, beta, &descC, sequence, &request);
 
-/*    if ( MORSE_TRANSLATION == MORSE_OUTOFPLACE ) {*/
+    /* Submit the matrix conversion */
         morse_zooptile2lap(descC, C, NB, NB, LDC, N,  sequence, &request);
         morse_sequence_wait(morse, sequence);
         morse_desc_mat_free(&descA);
         morse_desc_mat_free(&descB);
         morse_desc_mat_free(&descC);
-/*    } else {*/
-/*        morse_ziptile2lap( descA, A, NB, NB, LDA, Am,  sequence, &request);*/
-/*        morse_ziptile2lap( descB, B, NB, NB, LDB, N,  sequence, &request);*/
-/*        morse_ziptile2lap( descC, C, NB, NB, LDC, N,  sequence, &request);*/
-/*        morse_sequence_wait(morse, sequence);*/
-/*    }*/
 
     status = sequence->status;
     morse_sequence_destroy(morse, sequence);
diff --git a/compute/zher2k.c b/compute/zher2k.c
index b75b27348d2dec5237d40653b7bfbff833f9f592..93d3da9e1c09b2aa7c1163f443683a8189ac1b0c 100644
--- a/compute/zher2k.c
+++ b/compute/zher2k.c
@@ -178,37 +178,23 @@ int MORSE_zher2k(MORSE_enum uplo, MORSE_enum trans, int N, int K,
 
     morse_sequence_create(morse, &sequence);
 
-/*    if ( MORSE_TRANSLATION == MORSE_OUTOFPLACE ) {*/
+    /* Submit the matrix conversion */
     morse_zlap2tile( morse, &descAl, &descAt, MorseUpperLower,
                      A, NB, NB, LDA, An, Am, An, sequence, &request );
     morse_zlap2tile( morse, &descBl, &descBt, MorseUpperLower,
                      B, NB, NB, LDB, An, Am, An, sequence, &request );
     morse_zlap2tile( morse, &descCl, &descCt, MorseUpperLower,
                      C, NB, NB, LDC, N, N,  N, sequence, &request );
-/*    } else {*/
-/*        morse_ziplap2tile( descA, A, NB, NB, LDA, An, 0, 0, Am, An, */
-/*                            sequence, &request);*/
-/*        morse_ziplap2tile( descB, B, NB, NB, LDB, An, 0, 0, Am, An, */
-/*                            sequence, &request);*/
-/*        morse_ziplap2tile( descC, C, NB, NB, LDC, N,  0, 0, N,  N, */
-/*                            sequence, &request);*/
-/*    }*/
 
     /* Call the tile interface */
     MORSE_zher2k_Tile_Async(uplo, trans, alpha, &descA, &descB, beta, &descC, sequence, &request);
 
-/*    if ( MORSE_TRANSLATION == MORSE_OUTOFPLACE ) {*/
+    /* Submit the matrix conversion */
         morse_zooptile2lap(descC, C, NB, NB, LDC, N,  sequence, &request);
         morse_sequence_wait(morse, sequence);
         morse_desc_mat_free(&descA);
         morse_desc_mat_free(&descB);
         morse_desc_mat_free(&descC);
-/*    } else {*/
-/*        morse_ziptile2lap( descA, A, NB, NB, LDA, An,  sequence, &request);*/
-/*        morse_ziptile2lap( descB, B, NB, NB, LDB, An,  sequence, &request);*/
-/*        morse_ziptile2lap( descC, C, NB, NB, LDC, N,  sequence, &request);*/
-/*        morse_sequence_wait(morse, sequence);*/
-/*    }*/
 
     status = sequence->status;
     morse_sequence_destroy(morse, sequence);
diff --git a/compute/zherk.c b/compute/zherk.c
index 47e0048d7d6d833e82baffb56f38a7ec6a52116f..de717dd8c50b9573660598f78a9b57b0797662fd 100644
--- a/compute/zherk.c
+++ b/compute/zherk.c
@@ -164,31 +164,20 @@ int MORSE_zherk(MORSE_enum uplo, MORSE_enum trans, int N, int K,
 
     morse_sequence_create(morse, &sequence);
 
-/*    if ( MORSE_TRANSLATION == MORSE_OUTOFPLACE ) {*/
+    /* Submit the matrix conversion */
     morse_zlap2tile( morse, &descAl, &descAt, MorseUpperLower,
                      A, NB, NB, LDA, An, Am, An, sequence, &request );
     morse_zlap2tile( morse, &descCl, &descCt, MorseUpperLower,
                      C, NB, NB, LDC, N, N,  N, sequence, &request );
-/*    } else {*/
-/*        morse_ziplap2tile( descA, A, NB, NB, LDA, An, 0, 0, Am, An, */
-/*                            sequence, &request);*/
-/*        morse_ziplap2tile( descC, C, NB, NB, LDC, N,  0, 0, N,  N, */
-/*                            sequence, &request);*/
-/*    }*/
 
     /* Call the tile interface */
     MORSE_zherk_Tile_Async(uplo, trans, alpha, &descA, beta, &descC, sequence, &request);
 
-/*    if ( MORSE_TRANSLATION == MORSE_OUTOFPLACE ) {*/
+    /* Submit the matrix conversion */
         morse_zooptile2lap(descC, C, NB, NB, LDC, N,  sequence, &request);
         morse_sequence_wait(morse, sequence);
         morse_desc_mat_free(&descA);
         morse_desc_mat_free(&descC);
-/*    } else {*/
-/*        morse_ziptile2lap( descA, A, NB, NB, LDA, An,  sequence, &request);*/
-/*        morse_ziptile2lap( descC, C, NB, NB, LDC, N,  sequence, &request);*/
-/*        morse_sequence_wait(morse, sequence);*/
-/*    }*/
 
     status = sequence->status;
     morse_sequence_destroy(morse, sequence);
diff --git a/compute/zhetrd.c b/compute/zhetrd.c
index 5bf4718f4222dd775d9c544d326c7eff666ada66..e895ce6b55abb221590bb1b2aae28c4462c54fd7 100644
--- a/compute/zhetrd.c
+++ b/compute/zhetrd.c
@@ -166,25 +166,17 @@ int MORSE_zhetrd(MORSE_enum jobz, MORSE_enum uplo, int N,
 
     morse_sequence_create(morse, &sequence);
 
-    /* if ( MORSE_TRANSLATION == MORSE_OUTOFPLACE ) { */
+    /* Submit the matrix conversion */
     morse_zlap2tile( morse, &descAl, &descAt, MorseUpperLower,
                      A, NB, NB, LDA, N, N, N, sequence, &request );
-    /* } else { */
-    /*     morse_ziplap2tile( descA, A, NB, NB, LDA, N, 0, 0, N, N, */
-    /*                         sequence, &request); */
-    /* } */
 
     /* Call the tile interface */
     MORSE_zhetrd_Tile_Async(jobz, uplo, &descA, D, E, descT, Q, LDQ, sequence, &request);
 
-    /* if ( MORSE_TRANSLATION == MORSE_OUTOFPLACE ) { */
+    /* Submit the matrix conversion */
     morse_zooptile2lap( descA, A, NB, NB, LDA, N,  sequence, &request);
     morse_sequence_wait(morse, sequence);
     morse_desc_mat_free(&descA);
-    /* } else { */
-    /*     morse_ziptile2lap( descA, A, NB, NB, LDA, N,  sequence, &request); */
-    /* morse_sequence_wait(morse, sequence); */
-    /* } */
 
     status = sequence->status;
     morse_sequence_destroy(morse, sequence);
diff --git a/compute/zlacpy.c b/compute/zlacpy.c
index 9d7ca07851a75569e6422d6db0e1b73b96907ffa..828f80445530127605fdb91e1904ab14e840ef51 100644
--- a/compute/zlacpy.c
+++ b/compute/zlacpy.c
@@ -130,30 +130,20 @@ int MORSE_zlacpy(MORSE_enum uplo, int M, int N,
 
     morse_sequence_create(morse, &sequence);
 
-/*    if ( MORSE_TRANSLATION == MORSE_OUTOFPLACE ) {*/
+    /* Submit the matrix conversion */
     morse_zlap2tile( morse, &descAl, &descAt, MorseUpperLower,
                      A, NB, NB, LDA, N, M, N, sequence, &request );
     morse_zlap2tile( morse, &descBl, &descBt, MorseUpperLower,
                      B, NB, NB, LDB, N, M, N, sequence, &request );
-/*    } else {*/
-/*        morse_ziplap2tile(  descA, A, NB, NB, LDA, N, 0, 0, M, N,*/
-/*                            sequence, &request);*/
-/*        morse_ziplap2tile(  descB, B, NB, NB, LDA, N, 0, 0, M, N,*/
-/*                            sequence, &request);*/
-/*    }*/
 
     /* Call the tile interface */
     MORSE_zlacpy_Tile_Async(uplo, &descA, &descB, sequence, &request);
 
-/*    if ( MORSE_TRANSLATION == MORSE_OUTOFPLACE ) {*/
+    /* Submit the matrix conversion */
         morse_zooptile2lap(descB, B, NB, NB, LDB, N,  sequence, &request);
         morse_sequence_wait(morse, sequence);
         morse_desc_mat_free(&descA);
         morse_desc_mat_free(&descB);
-/*    } else {*/
-/*        morse_ziptile2lap( descB, B, NB, NB, LDB, N,  sequence, &request);*/
-/*        morse_sequence_wait(morse, sequence);*/
-/*    }*/
 
     morse_sequence_destroy(morse, sequence);
     return MORSE_SUCCESS;
diff --git a/compute/zlange.c b/compute/zlange.c
index 1ab8a57ecc57da86b05879a6d24bba0bb2edfd6e..8c196310e1f55949a83722cd24b8d90f875615e1 100644
--- a/compute/zlange.c
+++ b/compute/zlange.c
@@ -134,26 +134,18 @@ double MORSE_zlange(MORSE_enum norm, int M, int N,
 
     morse_sequence_create(morse, &sequence);
 
-/*    if ( MORSE_TRANSLATION == MORSE_OUTOFPLACE ) {*/
+    /* Submit the matrix conversion */
     morse_zlap2tile( morse, &descAl, &descAt, MorseUpperLower,
                      A, NB, NB, LDA, N, M, N, sequence, &request );
-/*    } else {*/
-/*        morse_ziplap2tile(  descA, A, NB, NB, LDA, N, 0, 0, M, N,*/
-/*                            sequence, &request);*/
-/*    }*/
 
     /* Call the tile interface */
     MORSE_zlange_Tile_Async(norm, &descA, &value, sequence, &request);
 
-/*    if ( MORSE_TRANSLATION == MORSE_OUTOFPLACE ) {*/
+    /* Submit the matrix conversion */
         morse_zooptile2lap(descA, A, NB, NB, LDA, N,  sequence, &request);
     RUNTIME_desc_flush( &descA, sequence );
         morse_sequence_wait(morse, sequence);
         morse_desc_mat_free(&descA);
-/*    } else {*/
-/*        morse_ziptile2lap( descA, A, NB, NB, LDA, N,  sequence, &request);*/
-/*        morse_sequence_wait(morse, sequence);*/
-/*    }*/
 
     morse_sequence_destroy(morse, sequence);
     return value;
diff --git a/compute/zlanhe.c b/compute/zlanhe.c
index 6733527096347de1dc334dbaa35761144a2ea418..29924659068e93217a8b1010c326956685dd4984 100644
--- a/compute/zlanhe.c
+++ b/compute/zlanhe.c
@@ -134,26 +134,18 @@ double MORSE_zlanhe(MORSE_enum norm, MORSE_enum uplo, int N,
 
     morse_sequence_create(morse, &sequence);
 
-/*    if ( MORSE_TRANSLATION == MORSE_OUTOFPLACE ) {*/
+    /* Submit the matrix conversion */
     morse_zlap2tile( morse, &descAl, &descAt, MorseUpperLower,
                      A, NB, NB, LDA, N, N, N, sequence, &request );
-/*    } else {*/
-/*        morse_ziplap2tile(  descA, A, NB, NB, LDA, N, 0, 0, N, N,*/
-/*                            sequence, &request);*/
-/*    }*/
 
     /* Call the tile interface */
     MORSE_zlanhe_Tile_Async(norm, uplo, &descA, &value, sequence, &request);
 
-/*    if ( MORSE_TRANSLATION == MORSE_OUTOFPLACE ) {*/
+    /* Submit the matrix conversion */
     morse_zooptile2lap(descA, A, NB, NB, LDA, N,  sequence, &request);
     RUNTIME_desc_flush( &descA, sequence );
     morse_sequence_wait(morse, sequence);
     morse_desc_mat_free(&descA);
-/*    } else {*/
-/*        morse_ziptile2lap( descA, A, NB, NB, LDA, N,  sequence, &request);*/
-/*        morse_sequence_wait(morse, sequence);*/
-/*    }*/
 
     morse_sequence_destroy(morse, sequence);
     return value;
diff --git a/compute/zlansy.c b/compute/zlansy.c
index 4186a9561239f2b774014a8f1c3ebfd92b82627e..3078ce2a90d7ab2a544b6737c39867b189e623ca 100644
--- a/compute/zlansy.c
+++ b/compute/zlansy.c
@@ -134,24 +134,16 @@ double MORSE_zlansy(MORSE_enum norm, MORSE_enum uplo, int N,
 
     morse_sequence_create(morse, &sequence);
 
-/*    if ( MORSE_TRANSLATION == MORSE_OUTOFPLACE ) {*/
+    /* Submit the matrix conversion */
     morse_zlap2tile( morse, &descAl, &descAt, MorseUpperLower,
                      A, NB, NB, LDA, N, N, N, sequence, &request );
-/*    } else {*/
-/*        morse_ziplap2tile(  descA, A, NB, NB, LDA, N, 0, 0, N, N,*/
-/*                            sequence, &request);*/
-/*    }*/
 
     /* Call the tile interface */
     MORSE_zlansy_Tile_Async(norm, uplo, &descA, &value, sequence, &request);
 
-/*    if ( MORSE_TRANSLATION == MORSE_OUTOFPLACE ) {*/
+    /* Submit the matrix conversion */
         morse_sequence_wait(morse, sequence);
         morse_desc_mat_free(&descA);
-/*    } else {*/
-/*        morse_ziptile2lap( descA, A, NB, NB, LDA, N,  sequence, &request);*/
-/*        morse_sequence_wait(morse, sequence);*/
-/*    }*/
 
     morse_sequence_destroy(morse, sequence);
     return value;
diff --git a/compute/zlantr.c b/compute/zlantr.c
index bf288ccf3ee8b507bb01413e2bc79bd26bf9123d..80ac583054523d0a83bef25a2ba5e01c8261aed8 100644
--- a/compute/zlantr.c
+++ b/compute/zlantr.c
@@ -154,24 +154,16 @@ double MORSE_zlantr(MORSE_enum norm, MORSE_enum uplo, MORSE_enum diag,
 
     morse_sequence_create(morse, &sequence);
 
-/*    if ( MORSE_TRANSLATION == MORSE_OUTOFPLACE ) {*/
+    /* Submit the matrix conversion */
     morse_zlap2tile( morse, &descAl, &descAt, MorseUpperLower,
                      A, NB, NB, LDA, N, M, N, sequence, &request );
-/*    } else {*/
-/*        morse_ziplap2tile(  descA, A, NB, NB, LDA, N, 0, 0, M, N,*/
-/*                            sequence, &request);*/
-/*    }*/
 
     /* Call the tile interface */
     MORSE_zlantr_Tile_Async(norm, uplo, diag, &descA, &value, sequence, &request);
 
-/*    if ( MORSE_TRANSLATION == MORSE_OUTOFPLACE ) {*/
+    /* Submit the matrix conversion */
         morse_sequence_wait(morse, sequence);
         morse_desc_mat_free(&descA);
-/*    } else {*/
-/*        morse_ziptile2lap( descA, A, NB, NB, LDA, N,  sequence, &request);*/
-/*        morse_sequence_wait(morse, sequence);*/
-/*    }*/
 
     morse_sequence_destroy(morse, sequence);
     return value;
diff --git a/compute/zlascal.c b/compute/zlascal.c
index 1ceb1ad8c665150288ae6db40cbecb022e44675f..91315d99493ebae9f0958623f85e807529ba5178 100644
--- a/compute/zlascal.c
+++ b/compute/zlascal.c
@@ -113,26 +113,18 @@ int MORSE_zlascal(MORSE_enum uplo, int M, int N,
 
     morse_sequence_create(morse, &sequence);
 
-/*    if ( MORSE_TRANSLATION == MORSE_OUTOFPLACE ) {*/
+    /* Submit the matrix conversion */
     morse_zlap2tile( morse, &descAl, &descAt, MorseUpperLower,
                      A, NB, NB, LDA, N, M, N, sequence, &request );
-/*    } else {*/
-/*        morse_ziplap2tile( descA, A, NB, NB, LDA, N , 0, 0, M, N,*/
-/*                            sequence, &request);*/
-/*    }*/
 
     /* Call the tile interface */
     MORSE_zlascal_Tile_Async(
         uplo, alpha, &descA, sequence, &request);
 
-/*    if ( MORSE_TRANSLATION == MORSE_OUTOFPLACE ) {*/
+    /* Submit the matrix conversion */
         morse_zooptile2lap( descA, A, NB, NB, LDA, N,  sequence, &request);
         RUNTIME_sequence_wait(morse, sequence);
         morse_desc_mat_free(&descA);
-/*    } else {*/
-/*        morse_ziptile2lap( descA, A, NB, NB, LDA, N, sequence, &request);*/
-/*        morse_dynamic_sync();*/
-/*    }*/
 
     status = sequence->status;
     morse_sequence_destroy(morse, sequence);
diff --git a/compute/zlaset.c b/compute/zlaset.c
index c9e404994f417c3ea43307ae0786380fd6068770..58fee1e2032fb5b5f971ba62afe8eb49c775856a 100644
--- a/compute/zlaset.c
+++ b/compute/zlaset.c
@@ -127,24 +127,16 @@ int MORSE_zlaset(MORSE_enum uplo, int M, int N,
 
     morse_sequence_create(morse, &sequence);
 
-/*    if ( MORSE_TRANSLATION == MORSE_OUTOFPLACE ) {*/
+    /* Submit the matrix conversion */
     morse_zlap2tile( morse, &descAl, &descAt, MorseUpperLower,
                      A, NB, NB, LDA, N, M, N, sequence, &request );
-/*    } else {*/
-/*        morse_ziplap2tile(  descA, A, NB, NB, LDA, N, 0, 0, M, N,*/
-/*                            sequence, &request);*/
-/*    }*/
 
     /* Call the tile interface */
     MORSE_zlaset_Tile_Async(uplo, alpha, beta, &descA, sequence, &request);
 
-/*    if ( MORSE_TRANSLATION == MORSE_OUTOFPLACE ) {*/
+    /* Submit the matrix conversion */
         morse_sequence_wait(morse, sequence);
         morse_desc_mat_free(&descA);
-/*    } else {*/
-/*        morse_ziptile2lap( descA, A, NB, NB, LDA, N,  sequence, &request);*/
-/*        morse_sequence_wait(morse, sequence);*/
-/*    }*/
 
     morse_sequence_destroy(morse, sequence);
     return MORSE_SUCCESS;
diff --git a/compute/zlauum.c b/compute/zlauum.c
index 0102c3269097dbd0caf6b03e7183a030364f4e0a..851a2adfe60343e5d45092bc57c3cfa1927c6c4a 100644
--- a/compute/zlauum.c
+++ b/compute/zlauum.c
@@ -121,25 +121,17 @@ int MORSE_zlauum(MORSE_enum uplo, int N,
 
     morse_sequence_create(morse, &sequence);
 
-/*    if ( MORSE_TRANSLATION == MORSE_OUTOFPLACE ) {*/
+    /* Submit the matrix conversion */
     morse_zlap2tile( morse, &descAl, &descAt, MorseUpperLower,
                      A, NB, NB, LDA, N, N, N, sequence, &request );
-/*    } else {*/
-/*        morse_ziplap2tile(  descA, A, NB, NB, LDA, N, 0, 0, N, N,*/
-/*                            sequence, &request);*/
-/*    }*/
 
     /* Call the tile interface */
     MORSE_zlauum_Tile_Async(uplo, &descA, sequence, &request);
 
-/*    if ( MORSE_TRANSLATION == MORSE_OUTOFPLACE ) {*/
+    /* Submit the matrix conversion */
         morse_zooptile2lap(descA, A, NB, NB, LDA, N,  sequence, &request);
         morse_sequence_wait(morse, sequence);
         morse_desc_mat_free(&descA);
-/*    } else {*/
-/*        morse_ziptile2lap( descA, A, NB, NB, LDA, N,  sequence, &request);*/
-/*        morse_sequence_wait(morse, sequence);*/
-/*    }*/
 
     status = sequence->status;
     morse_sequence_destroy(morse, sequence);
diff --git a/compute/zposv.c b/compute/zposv.c
index 49af7c7e823b35da511128c54a351b9442a336e2..f09a6f707dd437cc37e89faf27eeabca567554e2 100644
--- a/compute/zposv.c
+++ b/compute/zposv.c
@@ -149,33 +149,22 @@ int MORSE_zposv(MORSE_enum uplo, int N, int NRHS,
 
     morse_sequence_create(morse, &sequence);
 
-/*    if ( MORSE_TRANSLATION == MORSE_OUTOFPLACE ) {*/
+    /* Submit the matrix conversion */
     morse_zlap2tile( morse, &descAl, &descAt, MorseUpperLower,
                      A, NB, NB, LDA, N, N, N, sequence, &request );
     morse_zlap2tile( morse, &descBl, &descBt, MorseUpperLower,
                      B, NB, NB, LDB, NRHS, N, NRHS, sequence, &request );
-/*    } else {*/
-/*        morse_ziplap2tile( descA, A, NB, NB, LDA, N,    0, 0, N, N,   */
-/*                            sequence, &request);*/
-/*        morse_ziplap2tile( descB, B, NB, NB, LDB, NRHS, 0, 0, N, NRHS,*/
-/*                            sequence, &request);*/
-/*    }*/
 
     /* Call the tile interface */
     MORSE_zposv_Tile_Async(uplo, &descA, &descB, sequence, &request);
 
-/*    if ( MORSE_TRANSLATION == MORSE_OUTOFPLACE ) {*/
+    /* Submit the matrix conversion */
         morse_zooptile2lap(descA, A, NB, NB, LDA, N,     sequence, &request);
         morse_zooptile2lap(descB, B, NB, NB, LDB, NRHS,  sequence, &request);
         morse_sequence_wait(morse, sequence);
         morse_desc_mat_free(&descA);
         morse_desc_mat_free(&descB);
-/*    } else {*/
-/*        morse_ziptile2lap( descA, A, NB, NB, LDA, N,     sequence, &request);*/
-/*        morse_ziptile2lap( descB, B, NB, NB, LDB, NRHS,  sequence, &request);*/
-/*        morse_sequence_wait(morse, sequence);*/
-/*    }*/
-    
+
     status = sequence->status;
     morse_sequence_destroy(morse, sequence);
     return status;
diff --git a/compute/zpotri.c b/compute/zpotri.c
index d7456beb8e5c63397b3cdcf2879d0bfe884af6f3..5b5612914a22be661274cffa987a0d934c88efd1 100644
--- a/compute/zpotri.c
+++ b/compute/zpotri.c
@@ -118,25 +118,17 @@ int MORSE_zpotri(MORSE_enum uplo, int N,
 
     morse_sequence_create(morse, &sequence);
 
-/*    if ( MORSE_TRANSLATION == MORSE_OUTOFPLACE ) {*/
+    /* Submit the matrix conversion */
     morse_zlap2tile( morse, &descAl, &descAt, MorseUpperLower,
                      A, NB, NB, LDA, N, N, N, sequence, &request );
-/*    } else {*/
-/*        morse_ziplap2tile(  descA, A, NB, NB, LDA, N, 0, 0, N, N,*/
-/*                            sequence, &request);*/
-/*    }*/
 
     /* Call the tile interface */
     MORSE_zpotri_Tile_Async(uplo, &descA, sequence, &request);
 
-/*    if ( MORSE_TRANSLATION == MORSE_OUTOFPLACE ) {*/
+    /* Submit the matrix conversion */
         morse_zooptile2lap(descA, A, NB, NB, LDA, N,  sequence, &request);
         morse_sequence_wait(morse, sequence);
         morse_desc_mat_free(&descA);
-/*    } else {*/
-/*        morse_ziptile2lap( descA, A, NB, NB, LDA, N,  sequence, &request);*/
-/*        morse_sequence_wait(morse, sequence);*/
-/*    }*/
 
     status = sequence->status;
     morse_sequence_destroy(morse, sequence);
diff --git a/compute/zpotrimm.c b/compute/zpotrimm.c
index bd12cb16a04ac1220a42be61e988c88683725835..b92665ca6ab5eb5ea571d3ddbbb00b4d8c0d3980 100644
--- a/compute/zpotrimm.c
+++ b/compute/zpotrimm.c
@@ -128,22 +128,18 @@ int MORSE_zpotrimm(MORSE_enum uplo, int N,
 
     morse_sequence_create(morse, &sequence);
 
-/*    if ( MORSE_TRANSLATION == MORSE_OUTOFPLACE ) {*/
+    /* Submit the matrix conversion */
     morse_zlap2tile( morse, &descAl, &descAt, MorseUpperLower,
                      A, NB, NB, LDA, N, N, N, sequence, &request );
     morse_zlap2tile( morse, &descBl, &descBt, MorseUpperLower,
                      B, NB, NB, LDB, N, N, N, sequence, &request );
     morse_zlap2tile( morse, &descCl, &descCt, MorseUpperLower,
                      C, NB, NB, LDC, N, N, N, sequence, &request );
-/*    } else {*/
-/*        morse_ziplap2tile(  descA, A, NB, NB, LDA, N, 0, 0, N, N,*/
-/*                            sequence, &request);*/
-/*    }*/
 
     /* Call the tile interface */
     MORSE_zpotrimm_Tile_Async(uplo, &descA, &descB, &descC, sequence, &request);
 
-/*    if ( MORSE_TRANSLATION == MORSE_OUTOFPLACE ) {*/
+    /* Submit the matrix conversion */
         morse_zooptile2lap(descA, A, NB, NB, LDA, N,  sequence, &request);
         morse_zooptile2lap(descB, A, NB, NB, LDB, N,  sequence, &request);
         morse_zooptile2lap(descC, C, NB, NB, LDC, N,  sequence, &request);
@@ -151,10 +147,6 @@ int MORSE_zpotrimm(MORSE_enum uplo, int N,
         morse_desc_mat_free(&descA);
         morse_desc_mat_free(&descB);
         morse_desc_mat_free(&descC);
-/*    } else {*/
-/*        morse_ziptile2lap( descA, A, NB, NB, LDA, N,  sequence, &request);*/
-/*        morse_sequence_wait(morse, sequence);*/
-/*    }*/
 
     status = sequence->status;
     morse_sequence_destroy(morse, sequence);
diff --git a/compute/zpotrs.c b/compute/zpotrs.c
index 79cbe0d6e889e8366414fae74b8e299dc1c26fcf..8311a8b7d86e0845a5a0573153bf45d25ff978a3 100644
--- a/compute/zpotrs.c
+++ b/compute/zpotrs.c
@@ -133,31 +133,20 @@ int MORSE_zpotrs(MORSE_enum uplo, int N, int NRHS,
 
     morse_sequence_create(morse, &sequence);
 
-/*    if ( MORSE_TRANSLATION == MORSE_OUTOFPLACE ) {*/
+    /* Submit the matrix conversion */
     morse_zlap2tile( morse, &descAl, &descAt, MorseUpperLower,
                      A, NB, NB, LDA, N, N, N, sequence, &request );
     morse_zlap2tile( morse, &descBl, &descBt, MorseUpperLower,
                      B, NB, NB, LDB, NRHS, N, NRHS, sequence, &request );
-/*    } else {*/
-/*        morse_ziplap2tile( descA, A, NB, NB, LDA, N,    0, 0, N, N,   */
-/*                            sequence, &request);*/
-/*        morse_ziplap2tile( descB, B, NB, NB, LDB, NRHS, 0, 0, N, NRHS,*/
-/*                            sequence, &request);*/
-/*    }*/
 
     /* Call the tile interface */
     MORSE_zpotrs_Tile_Async(uplo, &descA, &descB, sequence, &request);
 
-/*    if ( MORSE_TRANSLATION == MORSE_OUTOFPLACE ) {*/
+    /* Submit the matrix conversion */
         morse_zooptile2lap(descB, B, NB, NB, LDB, NRHS,  sequence, &request);
         morse_sequence_wait(morse, sequence);
         morse_desc_mat_free(&descA);
         morse_desc_mat_free(&descB);
-/*    } else {*/
-/*        morse_ziptile2lap( descA, A, NB, NB, LDA, N,     sequence, &request);*/
-/*        morse_ziptile2lap( descB, B, NB, NB, LDB, NRHS,  sequence, &request);*/
-/*        morse_sequence_wait(morse, sequence);*/
-/*    }*/
     
     status = sequence->status;
     morse_sequence_destroy(morse, sequence);
diff --git a/compute/zsymm.c b/compute/zsymm.c
index 34aedb00effb262c79e44c8fa26a395c30871bc5..1bfd9b086618dfe1bf438657479e62b1ec94fca5 100644
--- a/compute/zsymm.c
+++ b/compute/zsymm.c
@@ -173,38 +173,24 @@ int MORSE_zsymm(MORSE_enum side, MORSE_enum uplo, int M, int N,
 
     morse_sequence_create(morse, &sequence);
 
-/*    if ( MORSE_TRANSLATION == MORSE_OUTOFPLACE ) {*/
+    /* Submit the matrix conversion */
     morse_zlap2tile( morse, &descAl, &descAt, MorseUpperLower,
                      A, NB, NB, LDA, Am, Am, Am, sequence, &request );
     morse_zlap2tile( morse, &descBl, &descBt, MorseUpperLower,
                      B, NB, NB, LDB, N, M,  N, sequence, &request );
     morse_zlap2tile( morse, &descCl, &descCt, MorseUpperLower,
                      C, NB, NB, LDC, N, M,  N, sequence, &request );
-/*    } else {*/
-/*        morse_ziplap2tile( descA, A, NB, NB, LDA, Am, 0, 0, Am, Am,*/
-/*                            sequence, &request);*/
-/*        morse_ziplap2tile( descB, B, NB, NB, LDB, N,  0, 0, M,  N,*/
-/*                            sequence, &request);*/
-/*        morse_ziplap2tile( descC, C, NB, NB, LDC, N,  0, 0, M,  N,*/
-/*                            sequence, &request);*/
-/*    }*/
 
     /* Call the tile interface */
     MORSE_zsymm_Tile_Async(
         side, uplo, alpha, &descA, &descB, beta, &descC, sequence, &request);
 
-/*    if ( MORSE_TRANSLATION == MORSE_OUTOFPLACE ) {*/
+    /* Submit the matrix conversion */
         morse_zooptile2lap(descC, C, NB, NB, LDC, N,  sequence, &request);
         morse_sequence_wait(morse, sequence);
         morse_desc_mat_free(&descA);
         morse_desc_mat_free(&descB);
         morse_desc_mat_free(&descC);
-/*    } else {*/
-/*        morse_ziptile2lap( descA, A, NB, NB, LDA, Am,  sequence, &request);*/
-/*        morse_ziptile2lap( descB, B, NB, NB, LDB, N,  sequence, &request);*/
-/*        morse_ziptile2lap( descC, C, NB, NB, LDC, N,  sequence, &request);*/
-/*        morse_sequence_wait(morse, sequence);*/
-/*    }*/
 
     status = sequence->status;
     morse_sequence_destroy(morse, sequence);
diff --git a/compute/zsyr2k.c b/compute/zsyr2k.c
index dbc9ec1edd86fd36e98fa427b9f2521501c9c9ab..835004eeb3591f87b94698878d9bd4179c4b5652 100644
--- a/compute/zsyr2k.c
+++ b/compute/zsyr2k.c
@@ -178,37 +178,23 @@ int MORSE_zsyr2k(MORSE_enum uplo, MORSE_enum trans, int N, int K,
 
     morse_sequence_create(morse, &sequence);
 
-/*    if ( MORSE_TRANSLATION == MORSE_OUTOFPLACE ) {*/
+    /* Submit the matrix conversion */
     morse_zlap2tile( morse, &descAl, &descAt, MorseUpperLower,
                      A, NB, NB, LDA, An, Am, An, sequence, &request );
     morse_zlap2tile( morse, &descBl, &descBt, MorseUpperLower,
                      B, NB, NB, LDB, An, Am, An, sequence, &request );
     morse_zlap2tile( morse, &descCl, &descCt, MorseUpperLower,
                      C, NB, NB, LDC, N, N,  N, sequence, &request );
-/*    } else {*/
-/*        morse_ziplap2tile( descA, A, NB, NB, LDA, An, 0, 0, Am, An, */
-/*                            sequence, &request);*/
-/*        morse_ziplap2tile( descB, B, NB, NB, LDB, An, 0, 0, Am, An, */
-/*                            sequence, &request);*/
-/*        morse_ziplap2tile( descC, C, NB, NB, LDC, N,  0, 0, N,  N, */
-/*                            sequence, &request);*/
-/*    }*/
 
     /* Call the tile interface */
     MORSE_zsyr2k_Tile_Async(uplo, trans, alpha, &descA, &descB, beta, &descC, sequence, &request);
 
-/*    if ( MORSE_TRANSLATION == MORSE_OUTOFPLACE ) {*/
+    /* Submit the matrix conversion */
         morse_zooptile2lap(descC, C, NB, NB, LDC, N,  sequence, &request);
         morse_sequence_wait(morse, sequence);
         morse_desc_mat_free(&descA);
         morse_desc_mat_free(&descB);
         morse_desc_mat_free(&descC);
-/*    } else {*/
-/*        morse_ziptile2lap( descA, A, NB, NB, LDA, An,  sequence, &request);*/
-/*        morse_ziptile2lap( descB, B, NB, NB, LDB, An,  sequence, &request);*/
-/*        morse_ziptile2lap( descC, C, NB, NB, LDC, N,  sequence, &request);*/
-/*        morse_sequence_wait(morse, sequence);*/
-/*    }*/
 
     status = sequence->status;
     morse_sequence_destroy(morse, sequence);
diff --git a/compute/zsyrk.c b/compute/zsyrk.c
index 16383776eb134dcbee68a4d7e2a57943f1b9644c..70cd975642a889c5c39dbed8d57734c459f7b0c2 100644
--- a/compute/zsyrk.c
+++ b/compute/zsyrk.c
@@ -164,31 +164,20 @@ int MORSE_zsyrk(MORSE_enum uplo, MORSE_enum trans, int N, int K,
 
     morse_sequence_create(morse, &sequence);
 
-/*    if ( MORSE_TRANSLATION == MORSE_OUTOFPLACE ) {*/
+    /* Submit the matrix conversion */
     morse_zlap2tile( morse, &descAl, &descAt, MorseUpperLower,
                      A, NB, NB, LDA, An, Am, An, sequence, &request );
     morse_zlap2tile( morse, &descCl, &descCt, MorseUpperLower,
                      C, NB, NB, LDC, N, N,  N, sequence, &request );
-/*    } else {*/
-/*        morse_ziplap2tile( descA, A, NB, NB, LDA, An, 0, 0, Am, An, */
-/*                            sequence, &request);*/
-/*        morse_ziplap2tile( descC, C, NB, NB, LDC, N,  0, 0, N,  N, */
-/*                            sequence, &request);*/
-/*    }*/
 
     /* Call the tile interface */
     MORSE_zsyrk_Tile_Async(uplo, trans, alpha, &descA, beta, &descC, sequence, &request);
 
-/*    if ( MORSE_TRANSLATION == MORSE_OUTOFPLACE ) {*/
+    /* Submit the matrix conversion */
         morse_zooptile2lap(descC, C, NB, NB, LDC, N,  sequence, &request);
         morse_sequence_wait(morse, sequence);
         morse_desc_mat_free(&descA);
         morse_desc_mat_free(&descC);
-/*    } else {*/
-/*        morse_ziptile2lap( descA, A, NB, NB, LDA, An,  sequence, &request);*/
-/*        morse_ziptile2lap( descC, C, NB, NB, LDC, N,  sequence, &request);*/
-/*        morse_sequence_wait(morse, sequence);*/
-/*    }*/
 
     status = sequence->status;
     morse_sequence_destroy(morse, sequence);
diff --git a/compute/zsysv.c b/compute/zsysv.c
index f2419e6bb868ba22c628f957aa1131f16ddf618a..bdec5fefc01a314f2c2c8d9cf9b7df817f1bb7a8 100644
--- a/compute/zsysv.c
+++ b/compute/zsysv.c
@@ -146,32 +146,21 @@ int MORSE_zsysv(MORSE_enum uplo, int N, int NRHS,
 
     morse_sequence_create(morse, &sequence);
 
-/*    if ( MORSE_TRANSLATION == MORSE_OUTOFPLACE ) {*/
+    /* Submit the matrix conversion */
     morse_zlap2tile( morse, &descAl, &descAt, MorseUpperLower,
                      A, NB, NB, LDA, N, N, N, sequence, &request );
     morse_zlap2tile( morse, &descBl, &descBt, MorseUpperLower,
                      B, NB, NB, LDB, NRHS, N, NRHS, sequence, &request );
-/*    } else {*/
-/*        morse_ziplap2tile( descA, A, NB, NB, LDA, N,    0, 0, N, N,   */
-/*                            sequence, &request);*/
-/*        morse_ziplap2tile( descB, B, NB, NB, LDB, NRHS, 0, 0, N, NRHS,*/
-/*                            sequence, &request);*/
-/*    }*/
 
     /* Call the tile interface */
     MORSE_zsysv_Tile_Async(uplo, &descA, &descB, sequence, &request);
 
-/*    if ( MORSE_TRANSLATION == MORSE_OUTOFPLACE ) {*/
+    /* Submit the matrix conversion */
         morse_zooptile2lap(descA, A, NB, NB, LDA, N,     sequence, &request);
         morse_zooptile2lap(descB, B, NB, NB, LDB, NRHS,  sequence, &request);
         morse_sequence_wait(morse, sequence);
         morse_desc_mat_free(&descA);
         morse_desc_mat_free(&descB);
-/*    } else {*/
-/*        morse_ziptile2lap( descA, A, NB, NB, LDA, N,     sequence, &request);*/
-/*        morse_ziptile2lap( descB, B, NB, NB, LDB, NRHS,  sequence, &request);*/
-/*        morse_sequence_wait(morse, sequence);*/
-/*    }*/
 
     status = sequence->status;
     morse_sequence_destroy(morse, sequence);
diff --git a/compute/zsytrf.c b/compute/zsytrf.c
index a902fabdf328f8ed3493a6eb1be69d65afa73191..424094d871c41b8c1c46209e86d47efc1579f248 100644
--- a/compute/zsytrf.c
+++ b/compute/zsytrf.c
@@ -122,25 +122,17 @@ int MORSE_zsytrf(MORSE_enum uplo, int N,
 
     morse_sequence_create(morse, &sequence);
 
-/*    if ( MORSE_TRANSLATION == MORSE_OUTOFPLACE ) {*/
+    /* Submit the matrix conversion */
     morse_zlap2tile( morse, &descAl, &descAt, MorseUpperLower,
                      A, NB, NB, LDA, N, N, N, sequence, &request );
-/*    } else {*/
-/*        morse_ziplap2tile( descA, A, NB, NB, LDA, N, 0, 0, N, N,*/
-/*                            sequence, &request);*/
-/*    }*/
 
     /* Call the tile interface */
     MORSE_zsytrf_Tile_Async(uplo, &descA, sequence, &request);
 
-/*    if ( MORSE_TRANSLATION == MORSE_OUTOFPLACE ) {*/
+    /* Submit the matrix conversion */
         morse_zooptile2lap(descA, A, NB, NB, LDA, N,  sequence, &request);
         morse_sequence_wait(morse, sequence);
         morse_desc_mat_free(&descA);
-/*    } else {*/
-/*        morse_ziptile2lap( descA, A, NB, NB, LDA, N,  sequence, &request);*/
-/*        morse_sequence_wait(morse, sequence);*/
-/*    }*/
 
     status = sequence->status;
     morse_sequence_destroy(morse, sequence);
diff --git a/compute/zsytrs.c b/compute/zsytrs.c
index 7649dd6ebc9b949d53de63c0b40c903311bfdde9..f1d1b42ee0b1f3f5e1d6fd603d049ac6301fd738 100644
--- a/compute/zsytrs.c
+++ b/compute/zsytrs.c
@@ -132,31 +132,20 @@ int MORSE_zsytrs(MORSE_enum uplo, int N, int NRHS,
 
     morse_sequence_create(morse, &sequence);
 
-/*    if ( MORSE_TRANSLATION == MORSE_OUTOFPLACE ) {*/
+    /* Submit the matrix conversion */
     morse_zlap2tile( morse, &descAl, &descAt, MorseUpperLower,
                      A, NB, NB, LDA, N, N, N, sequence, &request );
     morse_zlap2tile( morse, &descBl, &descBt, MorseUpperLower,
                      B, NB, NB, LDB, NRHS, N, NRHS, sequence, &request );
-/*    } else {*/
-/*        morse_ziplap2tile( descA, A, NB, NB, LDA, N,    0, 0, N, N,   */
-/*                            sequence, &request);*/
-/*        morse_ziplap2tile( descB, B, NB, NB, LDB, NRHS, 0, 0, N, NRHS,*/
-/*                            sequence, &request);*/
-/*    }*/
 
     /* Call the tile interface */
     MORSE_zsytrs_Tile_Async(uplo, &descA, &descB, sequence, &request);
 
-/*    if ( MORSE_TRANSLATION == MORSE_OUTOFPLACE ) {*/
+    /* Submit the matrix conversion */
         morse_zooptile2lap(descB, B, NB, NB, LDB, NRHS,  sequence, &request);
         morse_sequence_wait(morse, sequence);
         morse_desc_mat_free(&descA);
         morse_desc_mat_free(&descB);
-/*    } else {*/
-/*        morse_ziptile2lap( descA, A, NB, NB, LDA, N,     sequence, &request);*/
-/*        morse_ziptile2lap( descB, B, NB, NB, LDB, NRHS,  sequence, &request);*/
-/*        morse_sequence_wait(morse, sequence);*/
-/*    }*/
     
     status = sequence->status;
     morse_sequence_destroy(morse, sequence);
diff --git a/compute/ztpgqrt.c b/compute/ztpgqrt.c
index 4942e0d2f1168de89aaad78e70250919b227cc35..d2b174253810464bfcb061b95997e163242da052 100644
--- a/compute/ztpgqrt.c
+++ b/compute/ztpgqrt.c
@@ -207,7 +207,7 @@ int MORSE_ztpgqrt( int M, int N, int K, int L,
 
     morse_sequence_create(morse, &sequence);
 
-/*    if ( MORSE_TRANSLATION == MORSE_OUTOFPLACE ) {*/
+    /* Submit the matrix conversion */
     morse_zlap2tile( morse, &descV1l, &descV1t, MorseUpperLower,
                      V1, NB, NB, LDV1, K, M, K, sequence, &request );
     morse_zlap2tile( morse, &descV2l, &descV2t, MorseUpperLower,
@@ -216,15 +216,11 @@ int MORSE_ztpgqrt( int M, int N, int K, int L,
                      Q1, NB, NB, LDQ1, N, K, N, sequence, &request );
     morse_zlap2tile( morse, &descQ2l, &descQ2t, MorseUpperLower,
                      Q2, NB, NB, LDQ2, N, M, N, sequence, &request );
-/*    } else {*/
-/*        morse_ziplap2tile( descQ1, Q1, NB, NB, LDQ1, N, 0, 0, M, N,*/
-/*                            sequence, &request);*/
-/*    }*/
 
     /* Call the tile interface */
     MORSE_ztpgqrt_Tile_Async(L, &descV1, descT1, &descV2, descT2, &descQ1, &descQ2, sequence, &request);
 
-/*    if ( MORSE_TRANSLATION == MORSE_OUTOFPLACE ) {*/
+    /* Submit the matrix conversion */
         morse_zooptile2lap(descQ1, Q1, NB, NB, LDQ1, N, sequence, &request);
         morse_zooptile2lap(descQ2, Q2, NB, NB, LDQ2, N, sequence, &request);
         morse_sequence_wait(morse, sequence);
@@ -232,13 +228,6 @@ int MORSE_ztpgqrt( int M, int N, int K, int L,
         morse_desc_mat_free(&descV2);
         morse_desc_mat_free(&descQ1);
         morse_desc_mat_free(&descQ2);
-/*    } else {*/
-/*        morse_ziptile2lap( descV1, V1, NB, NB, LDV1, K,  sequence, &request);*/
-/*        morse_ziptile2lap( descV2, V2, NB, NB, LDV2, K,  sequence, &request);*/
-/*        morse_ziptile2lap( descQ1, Q1, NB, NB, LDQ1, N,  sequence, &request);*/
-/*        morse_ziptile2lap( descQ2, Q2, NB, NB, LDQ2, N,  sequence, &request);*/
-/*        morse_sequence_wait(morse, sequence);*/
-/*    }*/
 
     status = sequence->status;
     morse_sequence_destroy(morse, sequence);
diff --git a/compute/ztpqrt.c b/compute/ztpqrt.c
index a80b0c9110205fe01958dd086fa1b403b65659dd..ed352901ba033f6fefb7f434a30017aba29a1f4e 100644
--- a/compute/ztpqrt.c
+++ b/compute/ztpqrt.c
@@ -185,30 +185,21 @@ int MORSE_ztpqrt( int M, int N, int L,
 
     morse_sequence_create(morse, &sequence);
 
-/*    if ( MORSE_TRANSLATION == MORSE_OUTOFPLACE ) {*/
+    /* Submit the matrix conversion */
     morse_zlap2tile( morse, &descAl, &descAt, MorseUpperLower,
                      A, NB, NB, LDA, N, N, N, sequence, &request );
     morse_zlap2tile( morse, &descBl, &descBt, MorseUpperLower,
                      B, NB, NB, LDB, N, M, N, sequence, &request );
-/*    } else {*/
-/*        morse_ziplap2tile( descA, A, NB, NB, LDA, N, 0, 0, M, N,*/
-/*                            sequence, &request);*/
-/*    }*/
 
     /* Call the tile interface */
     MORSE_ztpqrt_Tile_Async(L, &descA, &descB, descT, sequence, &request);
 
-/*    if ( MORSE_TRANSLATION == MORSE_OUTOFPLACE ) {*/
+    /* Submit the matrix conversion */
         morse_zooptile2lap(descA, A, NB, NB, LDA, N, sequence, &request);
         morse_zooptile2lap(descB, B, NB, NB, LDB, N, sequence, &request);
         morse_sequence_wait(morse, sequence);
         morse_desc_mat_free(&descA);
         morse_desc_mat_free(&descB);
-/*    } else {*/
-/*        morse_ziptile2lap( descA, A, NB, NB, LDA, N,  sequence, &request);*/
-/*        morse_ziptile2lap( descB, B, NB, NB, LDB, N,  sequence, &request);*/
-/*        morse_sequence_wait(morse, sequence);*/
-/*    }*/
 
     status = sequence->status;
     morse_sequence_destroy(morse, sequence);
diff --git a/compute/ztradd.c b/compute/ztradd.c
index 8deb69a6009417dba28778122c43d3847e1f0296..2aa2175b7327af92bb32a1b6adcb402716e07471 100644
--- a/compute/ztradd.c
+++ b/compute/ztradd.c
@@ -163,32 +163,21 @@ int MORSE_ztradd(MORSE_enum uplo, MORSE_enum trans, int M, int N,
 
     morse_sequence_create(morse, &sequence);
 
-    /* if ( MORSE_TRANSLATION == MORSE_OUTOFPLACE ) { */
+    /* Submit the matrix conversion */
     morse_zlap2tile( morse, &descAl, &descAt, MorseUpperLower,
                      A, NB, NB, LDA, An, Am, An, sequence, &request );
     morse_zlap2tile( morse, &descBl, &descBt, MorseUpperLower,
                      B, NB, NB, LDB, N, M, N, sequence, &request );
-    /* } else { */
-    /*     morse_ziplap2tile( descA, A, NB, NB, LDA, An, 0, 0, Am, An, */
-    /*                         sequence, &request); */
-    /*     morse_ziplap2tile( descB, B, NB, NB, LDB, N, 0, 0, M, N, */
-    /*                         sequence, &request); */
-    /* } */
 
     /* Call the tile interface */
     MORSE_ztradd_Tile_Async(
         uplo, trans, alpha, &descA, beta, &descB, sequence, &request);
 
-    /* if ( MORSE_TRANSLATION == MORSE_OUTOFPLACE ) { */
+    /* Submit the matrix conversion */
         morse_zooptile2lap( descB, B, NB, NB, LDB, N,  sequence, &request);
         morse_sequence_wait(morse, sequence);
         morse_desc_mat_free(&descA);
         morse_desc_mat_free(&descB);
-    /* } else { */
-    /*     morse_ziptile2lap( descA, A, NB, NB, LDA, An, sequence, &request); */
-    /*     morse_ziptile2lap( descB, B, NB, NB, LDB, N,  sequence, &request); */
-    /*     morse_dynamic_sync(); */
-    /* } */
 
     status = sequence->status;
     morse_sequence_destroy(morse, sequence);
diff --git a/compute/ztrmm.c b/compute/ztrmm.c
index cf6a4b5df384567e1c181cfbf540447787af44f4..e20dad68661b92e1ca42af6284f5a49a6245eb51 100644
--- a/compute/ztrmm.c
+++ b/compute/ztrmm.c
@@ -177,32 +177,21 @@ int MORSE_ztrmm(MORSE_enum side, MORSE_enum uplo,
 
     morse_sequence_create(morse, &sequence);
 
-/*    if ( MORSE_TRANSLATION == MORSE_OUTOFPLACE ) {*/
+    /* Submit the matrix conversion */
     morse_zlap2tile( morse, &descAl, &descAt, MorseUpperLower,
                      A, NB, NB, LDA, NA, NA, NA, sequence, &request );
     morse_zlap2tile( morse, &descBl, &descBt, MorseUpperLower,
                      B, NB, NB, LDB, NRHS, N,  NRHS, sequence, &request );
-/*    } else {*/
-/*        morse_ziplap2tile( descA, A, NB, NB, LDA, NA,   0, 0, NA, NA,  */
-/*                            sequence, &request);*/
-/*        morse_ziplap2tile( descB, B, NB, NB, LDB, NRHS, 0, 0, N,  NRHS,*/
-/*                            sequence, &request);*/
-/*    }*/
 
     /* Call the tile interface */
     MORSE_ztrmm_Tile_Async(
         side, uplo, transA, diag, alpha, &descA, &descB, sequence, &request);
 
-/*    if ( MORSE_TRANSLATION == MORSE_OUTOFPLACE ) {*/
+    /* Submit the matrix conversion */
         morse_zooptile2lap(descB, B, NB, NB, LDB, NRHS,  sequence, &request);
         morse_sequence_wait(morse, sequence);
         morse_desc_mat_free(&descA);
         morse_desc_mat_free(&descB);
-/*    } else {*/
-/*        morse_ziptile2lap( descA, A, NB, NB, LDA, NA,    sequence, &request);*/
-/*        morse_ziptile2lap( descB, B, NB, NB, LDB, NRHS,  sequence, &request);*/
-/*        morse_sequence_wait(morse, sequence);*/
-/*    }*/
 
     status = sequence->status;
     morse_sequence_destroy(morse, sequence);
diff --git a/compute/ztrsm.c b/compute/ztrsm.c
index 10b23920427ec6936bc24927a075833a5a8b31da..620a8609d0d8af47ce884bba1a0297cbe1206492 100644
--- a/compute/ztrsm.c
+++ b/compute/ztrsm.c
@@ -175,32 +175,21 @@ int MORSE_ztrsm(MORSE_enum side, MORSE_enum uplo,
 
     morse_sequence_create(morse, &sequence);
 
-/*    if ( MORSE_TRANSLATION == MORSE_OUTOFPLACE ) {*/
+    /* Submit the matrix conversion */
     morse_zlap2tile( morse, &descAl, &descAt, MorseUpperLower,
                      A, NB, NB, LDA, NA, NA, NA, sequence, &request );
     morse_zlap2tile( morse, &descBl, &descBt, MorseUpperLower,
                      B, NB, NB, LDB, NRHS, N,  NRHS, sequence, &request );
-/*    } else {*/
-/*        morse_ziplap2tile( descA, A, NB, NB, LDA, NA,   0, 0, NA, NA,  */
-/*                            sequence, &request);*/
-/*        morse_ziplap2tile( descB, B, NB, NB, LDB, NRHS, 0, 0, N,  NRHS,*/
-/*                            sequence, &request);*/
-/*    }*/
 
     /* Call the tile interface */
     MORSE_ztrsm_Tile_Async(
         side, uplo, transA, diag, alpha, &descA, &descB, sequence, &request);
 
-/*    if ( MORSE_TRANSLATION == MORSE_OUTOFPLACE ) {*/
+    /* Submit the matrix conversion */
         morse_zooptile2lap(descB, B, NB, NB, LDB, NRHS,  sequence, &request);
         morse_sequence_wait(morse, sequence);
         morse_desc_mat_free(&descA);
         morse_desc_mat_free(&descB);
-/*    } else {*/
-/*        morse_ziptile2lap( descA, A, NB, NB, LDA, NA,    sequence, &request);*/
-/*        morse_ziptile2lap( descB, B, NB, NB, LDB, NRHS,  sequence, &request);*/
-/*        morse_sequence_wait(morse, sequence);*/
-/*    }*/
 
     status = sequence->status;
     morse_sequence_destroy(morse, sequence);
diff --git a/compute/ztrsmpl.c b/compute/ztrsmpl.c
index 4666f2b8799ea508726bcb4b19aa0db807ba5fb7..0fe3372c90e4f104d2590e13da866eb962b4273d 100644
--- a/compute/ztrsmpl.c
+++ b/compute/ztrsmpl.c
@@ -130,31 +130,20 @@ int MORSE_ztrsmpl(int N, int NRHS,
 
     morse_sequence_create(morse, &sequence);
 
-/*    if ( MORSE_TRANSLATION == MORSE_OUTOFPLACE ) {*/
+    /* Submit the matrix conversion */
     morse_zlap2tile( morse, &descAl, &descAt, MorseUpperLower,
                      A, NB, NB, LDA, N, N, N, sequence, &request );
     morse_zlap2tile( morse, &descBl, &descBt, MorseUpperLower,
                      B, NB, NB, LDB, NRHS, N, NRHS, sequence, &request );
-/*    } else {*/
-/*        morse_ziplap2tile( descA, A, NB, NB, LDA, N,    0, 0, N, N,   */
-/*                            sequence, &request);*/
-/*        morse_ziplap2tile( descB, B, NB, NB, LDB, NRHS, 0, 0, N, NRHS,*/
-/*                            sequence, &request);*/
-/*    }*/
 
     /* Call the tile interface */
     MORSE_ztrsmpl_Tile_Async(&descA, descL, IPIV, &descB, sequence, &request);
 
-/*    if ( MORSE_TRANSLATION == MORSE_OUTOFPLACE ) {*/
+    /* Submit the matrix conversion */
         morse_zooptile2lap(descB, B, NB, NB, LDB, NRHS,  sequence, &request);
         morse_sequence_wait(morse, sequence);
         morse_desc_mat_free(&descA);
         morse_desc_mat_free(&descB);
-/*    } else {*/
-/*        morse_ziptile2lap( descA, A, NB, NB, LDA, N,     sequence, &request);*/
-/*        morse_ziptile2lap( descB, B, NB, NB, LDB, NRHS,  sequence, &request);*/
-/*        morse_sequence_wait(morse, sequence);*/
-/*    }*/
 
     status = sequence->status;
     morse_sequence_destroy(morse, sequence);
diff --git a/compute/ztrtri.c b/compute/ztrtri.c
index 522fe747a0023173d342163732b45d0e28179e55..d5462b5555e871cf5dd1229f06fc7cae21d4cb59 100644
--- a/compute/ztrtri.c
+++ b/compute/ztrtri.c
@@ -130,25 +130,17 @@ int MORSE_ztrtri(MORSE_enum uplo, MORSE_enum diag, int N,
 
     morse_sequence_create(morse, &sequence);
 
-/*    if ( MORSE_TRANSLATION == MORSE_OUTOFPLACE ) {*/
+    /* Submit the matrix conversion */
     morse_zlap2tile( morse, &descAl, &descAt, MorseUpperLower,
                      A, NB, NB, LDA, N, N, N, sequence, &request );
-/*    } else {*/
-/*        morse_ziplap2tile(  descA, A, NB, NB, LDA, N, 0, 0, N, N,*/
-/*                            sequence, &request);*/
-/*    }*/
 
     /* Call the tile interface */
     MORSE_ztrtri_Tile_Async(uplo, diag, &descA, sequence, &request);
 
-/*    if ( MORSE_TRANSLATION == MORSE_OUTOFPLACE ) {*/
+    /* Submit the matrix conversion */
         morse_zooptile2lap(descA, A, NB, NB, LDA, N,  sequence, &request);
         morse_sequence_wait(morse, sequence);
         morse_desc_mat_free(&descA);
-/*    } else {*/
-/*        morse_ziptile2lap( descA, A, NB, NB, LDA, N,  sequence, &request);*/
-/*        morse_sequence_wait(morse, sequence);*/
-/*    }*/
 
     status = sequence->status;
     morse_sequence_destroy(morse, sequence);
diff --git a/compute/zunglq.c b/compute/zunglq.c
index 73f6193e5c889ee3cc66f3422567114e5941a5ee..c3d30f23059e7428fd7befaaf835437b22d8bd75 100644
--- a/compute/zunglq.c
+++ b/compute/zunglq.c
@@ -136,31 +136,20 @@ int MORSE_zunglq(int M, int N, int K,
 
     morse_sequence_create(morse, &sequence);
 
-/*    if ( MORSE_TRANSLATION == MORSE_OUTOFPLACE ) {*/
+    /* Submit the matrix conversion */
     morse_zlap2tile( morse, &descAl, &descAt, MorseUpperLower,
                      A, NB, NB, LDA, N, K, N, sequence, &request );
     morse_zlap2tile( morse, &descQl, &descQt, MorseUpperLower,
                      Q, NB, NB, LDQ, N, M, N, sequence, &request );
-/*    } else {*/
-/*        morse_ziplap2tile( descA, A, NB, NB, LDA, N, 0, 0, K, N,*/
-/*                            sequence, &request);*/
-/*        morse_ziplap2tile( descQ, Q, NB, NB, LDQ, N, 0, 0, M, N,*/
-/*                            sequence, &request);*/
-/*    }*/
 
     /* Call the tile interface */
     MORSE_zunglq_Tile_Async(&descA, descT, &descQ, sequence, &request);
 
-/*    if ( MORSE_TRANSLATION == MORSE_OUTOFPLACE ) {*/
+    /* Submit the matrix conversion */
         morse_zooptile2lap(descQ, Q, NB, NB, LDQ, N,  sequence, &request);
         morse_sequence_wait(morse, sequence);
         morse_desc_mat_free(&descA);
         morse_desc_mat_free(&descQ);
-/*    } else {*/
-/*        morse_ziptile2lap( descA, A, NB, NB, LDA, N,  sequence, &request);*/
-/*        morse_ziptile2lap( descQ, Q, NB, NB, LDQ, N,  sequence, &request);*/
-/*        morse_sequence_wait(morse, sequence);*/
-/*    }*/
 
     status = sequence->status;
     morse_sequence_destroy(morse, sequence);
diff --git a/compute/zunglq_param.c b/compute/zunglq_param.c
index 5f1a5ee3fe420aec9d5963219beb63c9fa713159..39a2250deb544f9eac69d4f498b254d5c1055fdf 100644
--- a/compute/zunglq_param.c
+++ b/compute/zunglq_param.c
@@ -133,31 +133,20 @@ int MORSE_zunglq_param(const libhqr_tree_t *qrtree, int M, int N, int K,
 
     morse_sequence_create(morse, &sequence);
 
-/*    if ( MORSE_TRANSLATION == MORSE_OUTOFPLACE ) {*/
+    /* Submit the matrix conversion */
     morse_zlap2tile( morse, &descAl, &descAt, MorseUpperLower,
                      A, NB, NB, LDA, N, K, N, sequence, &request );
     morse_zlap2tile( morse, &descQl, &descQt, MorseUpperLower,
                      Q, NB, NB, LDQ, N, M, N, sequence, &request );
-/*    } else {*/
-/*        morse_ziplap2tile( descA, A, NB, NB, LDA, N, 0, 0, K, N,*/
-/*                            sequence, &request);*/
-/*        morse_ziplap2tile( descQ, Q, NB, NB, LDQ, N, 0, 0, M, N,*/
-/*                            sequence, &request);*/
-/*    }*/
 
     /* Call the tile interface */
     MORSE_zunglq_param_Tile_Async(qrtree, &descA, descTS, descTT, &descQ, sequence, &request);
 
-/*    if ( MORSE_TRANSLATION == MORSE_OUTOFPLACE ) {*/
+    /* Submit the matrix conversion */
         morse_zooptile2lap(descQ, Q, NB, NB, LDQ, N,  sequence, &request);
         morse_sequence_wait(morse, sequence);
         morse_desc_mat_free(&descA);
         morse_desc_mat_free(&descQ);
-/*    } else {*/
-/*        morse_ziptile2lap( descA, A, NB, NB, LDA, N,  sequence, &request);*/
-/*        morse_ziptile2lap( descQ, Q, NB, NB, LDQ, N,  sequence, &request);*/
-/*        morse_sequence_wait(morse, sequence);*/
-/*    }*/
 
     status = sequence->status;
     morse_sequence_destroy(morse, sequence);
diff --git a/compute/zungqr.c b/compute/zungqr.c
index b62905220bc49c837b89bb782bf0971f81ba7d8a..d271bb095453fe3232783d8f1ae735ad26eac13f 100644
--- a/compute/zungqr.c
+++ b/compute/zungqr.c
@@ -135,31 +135,20 @@ int MORSE_zungqr(int M, int N, int K,
 
     morse_sequence_create(morse, &sequence);
 
-/*    if ( MORSE_TRANSLATION == MORSE_OUTOFPLACE ) {*/
+    /* Submit the matrix conversion */
     morse_zlap2tile( morse, &descAl, &descAt, MorseUpperLower,
                      A, NB, NB, LDA, N, M, K, sequence, &request );
     morse_zlap2tile( morse, &descQl, &descQt, MorseUpperLower,
                      Q, NB, NB, LDQ, N, M, N, sequence, &request );
-/*    } else {*/
-/*        morse_ziplap2tile( descA, A, NB, NB, LDA, N, 0, 0, M, K,*/
-/*                            sequence, &request);*/
-/*        morse_ziplap2tile( descQ, Q, NB, NB, LDQ, N, 0, 0, M, N,*/
-/*                            sequence, &request);*/
-/*    }*/
 
     /* Call the tile interface */
     MORSE_zungqr_Tile_Async(&descA, descT, &descQ, sequence, &request);
 
-/*    if ( MORSE_TRANSLATION == MORSE_OUTOFPLACE ) {*/
+    /* Submit the matrix conversion */
         morse_zooptile2lap(descQ, Q, NB, NB, LDQ, N,  sequence, &request);
         morse_sequence_wait(morse, sequence);
         morse_desc_mat_free(&descA);
         morse_desc_mat_free(&descQ);
-/*    } else {*/
-/*        morse_ziptile2lap( descA, A, NB, NB, LDA, K,  sequence, &request);*/
-/*        morse_ziptile2lap( descQ, Q, NB, NB, LDQ, N,  sequence, &request);*/
-/*        morse_sequence_wait(morse, sequence);*/
-/*    }*/
 
     status = sequence->status;
     morse_sequence_destroy(morse, sequence);
diff --git a/compute/zungqr_param.c b/compute/zungqr_param.c
index c99631434b396f13643a10e24ec43d9bb8ff6256..5b99249ad99c3f644d909250585278c1595dc557 100644
--- a/compute/zungqr_param.c
+++ b/compute/zungqr_param.c
@@ -134,31 +134,20 @@ int MORSE_zungqr_param(const libhqr_tree_t *qrtree,
 
     morse_sequence_create(morse, &sequence);
 
-    /*    if ( MORSE_TRANSLATION == MORSE_OUTOFPLACE ) {*/
+    /* Submit the matrix conversion */
     morse_zlap2tile( morse, &descAl, &descAt, MorseUpperLower,
                      A, NB, NB, LDA, N, M, K, sequence, &request );
     morse_zlap2tile( morse, &descQl, &descQt, MorseUpperLower,
                      Q, NB, NB, LDQ, N, M, N, sequence, &request );
-    /*    } else {*/
-    /*        morse_ziplap2tile( descA, A, NB, NB, LDA, N, 0, 0, M, K,*/
-    /*                            sequence, &request);*/
-    /*        morse_ziplap2tile( descQ, Q, NB, NB, LDQ, N, 0, 0, M, N,*/
-    /*                            sequence, &request);*/
-    /*    }*/
 
     /* Call the tile interface */
     MORSE_zungqr_param_Tile_Async(qrtree, &descA, descTS, descTT, &descQ, sequence, &request);
 
-    /*    if ( MORSE_TRANSLATION == MORSE_OUTOFPLACE ) {*/
+    /* Submit the matrix conversion */
     morse_zooptile2lap(descQ, Q, NB, NB, LDQ, N,  sequence, &request);
     morse_sequence_wait(morse, sequence);
     morse_desc_mat_free(&descA);
     morse_desc_mat_free(&descQ);
-    /*    } else {*/
-    /*        morse_ziptile2lap( descA, A, NB, NB, LDA, K,  sequence, &request);*/
-    /*        morse_ziptile2lap( descQ, Q, NB, NB, LDQ, N,  sequence, &request);*/
-    /*        morse_sequence_wait(morse, sequence);*/
-    /*    }*/
 
     status = sequence->status;
     morse_sequence_destroy(morse, sequence);
diff --git a/compute/zunmlq.c b/compute/zunmlq.c
index ba2f34e5d88d57664239b76ef1626705db686713..fb497ddee9261a3aaff306738f3ca3ddf9758669 100644
--- a/compute/zunmlq.c
+++ b/compute/zunmlq.c
@@ -173,32 +173,21 @@ int MORSE_zunmlq(MORSE_enum side, MORSE_enum trans, int M, int N, int K,
     NB   = MORSE_NB;
     morse_sequence_create(morse, &sequence);
 
-/*    if ( MORSE_TRANSLATION == MORSE_OUTOFPLACE ) {*/
+    /* Submit the matrix conversion */
     morse_zlap2tile( morse, &descAl, &descAt, MorseUpperLower,
                      A, NB, NB, LDA, An, K, An, sequence, &request );
     morse_zlap2tile( morse, &descCl, &descCt, MorseUpperLower,
                      C, NB, NB, LDC, N, M,  N, sequence, &request );
-/*    } else {*/
-/*        morse_ziplap2tile( descA, A, NB, NB, LDA, An, 0, 0, K, An,*/
-/*                            sequence, &request);*/
-/*        morse_ziplap2tile( descC, C, NB, NB, LDC, N, 0, 0, M,  N,*/
-/*                            sequence, &request);*/
-/*    }*/
 
     /* Call the tile interface */
     MORSE_zunmlq_Tile_Async(
         side, trans, &descA, descT, &descC, sequence, &request);
 
-/*    if ( MORSE_TRANSLATION == MORSE_OUTOFPLACE ) {*/
+    /* Submit the matrix conversion */
         morse_zooptile2lap(descC, C, NB, NB, LDC, N,  sequence, &request);
         morse_sequence_wait(morse, sequence);
         morse_desc_mat_free(&descA);
         morse_desc_mat_free(&descC);
-/*    } else {*/
-/*        morse_ziptile2lap( descA, A, NB, NB, LDA, An, sequence, &request);*/
-/*        morse_ziptile2lap( descC, C, NB, NB, LDC, N,  sequence, &request);*/
-/*        morse_sequence_wait(morse, sequence);*/
-/*    }*/
 
     status = sequence->status;
     morse_sequence_destroy(morse, sequence);
diff --git a/compute/zunmlq_param.c b/compute/zunmlq_param.c
index 36da968cfb829e0abdd5444de013ef61759ce546..4492c2eed8edcaec9bd717414d87f07ebad882c8 100644
--- a/compute/zunmlq_param.c
+++ b/compute/zunmlq_param.c
@@ -172,32 +172,21 @@ int MORSE_zunmlq_param(const libhqr_tree_t *qrtree, MORSE_enum side, MORSE_enum
     NB   = MORSE_NB;
     morse_sequence_create(morse, &sequence);
 
-/*    if ( MORSE_TRANSLATION == MORSE_OUTOFPLACE ) {*/
+    /* Submit the matrix conversion */
     morse_zlap2tile( morse, &descAl, &descAt, MorseUpperLower,
                      A, NB, NB, LDA, An, K, An, sequence, &request );
     morse_zlap2tile( morse, &descCl, &descCt, MorseUpperLower,
                      C, NB, NB, LDC, N, M,  N, sequence, &request );
-/*    } else {*/
-/*        morse_ziplap2tile( descA, A, NB, NB, LDA, An, 0, 0, K, An,*/
-/*                            sequence, &request);*/
-/*        morse_ziplap2tile( descC, C, NB, NB, LDC, N, 0, 0, M,  N,*/
-/*                            sequence, &request);*/
-/*    }*/
 
     /* Call the tile interface */
     MORSE_zunmlq_param_Tile_Async(
         qrtree, side, trans, &descA, descTS, descTT, &descC, sequence, &request);
 
-/*    if ( MORSE_TRANSLATION == MORSE_OUTOFPLACE ) {*/
+    /* Submit the matrix conversion */
         morse_zooptile2lap(descC, C, NB, NB, LDC, N,  sequence, &request);
         morse_sequence_wait(morse, sequence);
         morse_desc_mat_free(&descA);
         morse_desc_mat_free(&descC);
-/*    } else {*/
-/*        morse_ziptile2lap( descA, A, NB, NB, LDA, An, sequence, &request);*/
-/*        morse_ziptile2lap( descC, C, NB, NB, LDC, N,  sequence, &request);*/
-/*        morse_sequence_wait(morse, sequence);*/
-/*    }*/
 
     status = sequence->status;
     morse_sequence_destroy(morse, sequence);
diff --git a/compute/zunmqr.c b/compute/zunmqr.c
index 6f8563d2e497204443284633fe396b93d22a6f70..b6eb340da4bb4f23aa556e8c45b72d6b227cfa0c 100644
--- a/compute/zunmqr.c
+++ b/compute/zunmqr.c
@@ -176,32 +176,21 @@ int MORSE_zunmqr(MORSE_enum side, MORSE_enum trans, int M, int N, int K,
     NB   = MORSE_NB;
     morse_sequence_create(morse, &sequence);
 
-/*    if ( MORSE_TRANSLATION == MORSE_OUTOFPLACE ) {*/
+    /* Submit the matrix conversion */
     morse_zlap2tile( morse, &descAl, &descAt, MorseUpperLower,
                      A, NB, NB, LDA, K, Am, K, sequence, &request );
     morse_zlap2tile( morse, &descCl, &descCt, MorseUpperLower,
                      C, NB, NB, LDC, N, M,  N, sequence, &request );
-/*    } else {*/
-/*        morse_ziplap2tile( descA, A, NB, NB, LDA, K, 0, 0, Am, K,*/
-/*                            sequence, &request);*/
-/*        morse_ziplap2tile( descC, C, NB, NB, LDC, N, 0, 0, M,  N,*/
-/*                            sequence, &request);*/
-/*    }*/
 
     /* Call the tile interface */
     MORSE_zunmqr_Tile_Async(
         side, trans, &descA, descT, &descC, sequence, &request);
 
-/*    if ( MORSE_TRANSLATION == MORSE_OUTOFPLACE ) {*/
+    /* Submit the matrix conversion */
         morse_zooptile2lap(descC, C, NB, NB, LDC, N,  sequence, &request);
         morse_sequence_wait(morse, sequence);
         morse_desc_mat_free(&descA);
         morse_desc_mat_free(&descC);
-/*    } else {*/
-/*        morse_ziptile2lap( descA, A, NB, NB, LDA, K,  sequence, &request);*/
-/*        morse_ziptile2lap( descC, C, NB, NB, LDC, N,  sequence, &request);*/
-/*        morse_sequence_wait(morse, sequence);*/
-/*    }*/
 
     status = sequence->status;
     morse_sequence_destroy(morse, sequence);
diff --git a/compute/zunmqr_param.c b/compute/zunmqr_param.c
index 5101156244a54a8ea8585d1667c93dafa5904118..bd5ab11c8eb60122bf2d9e715c9b0229c2189ee9 100644
--- a/compute/zunmqr_param.c
+++ b/compute/zunmqr_param.c
@@ -177,32 +177,21 @@ int MORSE_zunmqr_param(const libhqr_tree_t *qrtree,
     NB   = MORSE_NB;
     morse_sequence_create(morse, &sequence);
 
-/*    if ( MORSE_TRANSLATION == MORSE_OUTOFPLACE ) {*/
+    /* Submit the matrix conversion */
     morse_zlap2tile( morse, &descAl, &descAt, MorseUpperLower,
                      A, NB, NB, LDA, K, Am, K, sequence, &request );
     morse_zlap2tile( morse, &descCl, &descCt, MorseUpperLower,
                      C, NB, NB, LDC, N, M,  N, sequence, &request );
-/*    } else {*/
-/*        morse_ziplap2tile( descA, A, NB, NB, LDA, K, 0, 0, Am, K,*/
-/*                            sequence, &request);*/
-/*        morse_ziplap2tile( descC, C, NB, NB, LDC, N, 0, 0, M,  N,*/
-/*                            sequence, &request);*/
-/*    }*/
 
     /* Call the tile interface */
         MORSE_zunmqr_param_Tile_Async(
             qrtree, side, trans, &descA, descTS, descTT, &descC, sequence, &request);
 
-/*    if ( MORSE_TRANSLATION == MORSE_OUTOFPLACE ) {*/
+    /* Submit the matrix conversion */
         morse_zooptile2lap(descC, C, NB, NB, LDC, N,  sequence, &request);
         morse_sequence_wait(morse, sequence);
         morse_desc_mat_free(&descA);
         morse_desc_mat_free(&descC);
-/*    } else {*/
-/*        morse_ziptile2lap( descA, A, NB, NB, LDA, K,  sequence, &request);*/
-/*        morse_ziptile2lap( descC, C, NB, NB, LDC, N,  sequence, &request);*/
-/*        morse_sequence_wait(morse, sequence);*/
-/*    }*/
 
     status = sequence->status;
     morse_sequence_destroy(morse, sequence);