From 835769e6d052b7848a7ada83c51fd02cefde3873 Mon Sep 17 00:00:00 2001
From: Mathieu Faverge <mathieu.faverge@inria.fr>
Date: Mon, 31 Jul 2017 18:08:34 +0200
Subject: [PATCH] Cleanup headers in quark directory

---
 runtime/quark/CMakeLists.txt                  | 104 +++++++------
 runtime/quark/codelets/codelet_dataflush.c    |   2 +-
 runtime/quark/codelets/codelet_zasum.c        |  32 ++--
 runtime/quark/codelets/codelet_zaxpy.c        |  30 ++--
 runtime/quark/codelets/codelet_zbuild.c       |  47 +++---
 runtime/quark/codelets/codelet_zgeadd.c       |   3 +-
 runtime/quark/codelets/codelet_zgelqt.c       |  37 +++--
 runtime/quark/codelets/codelet_zgemm.c        |  77 ++++------
 runtime/quark/codelets/codelet_zgeqrt.c       |  36 +++--
 runtime/quark/codelets/codelet_zgessm.c       |  40 +++--
 runtime/quark/codelets/codelet_zgessq.c       |  34 ++---
 runtime/quark/codelets/codelet_zgetrf.c       |  42 +++---
 .../quark/codelets/codelet_zgetrf_incpiv.c    |  46 +++---
 runtime/quark/codelets/codelet_zgetrf_nopiv.c |  41 +++--
 runtime/quark/codelets/codelet_zhe2ge.c       |   3 +-
 runtime/quark/codelets/codelet_zhemm.c        |  57 +++----
 runtime/quark/codelets/codelet_zher2k.c       |  52 +++----
 runtime/quark/codelets/codelet_zherfb.c       |   3 +-
 runtime/quark/codelets/codelet_zherk.c        |  52 +++----
 runtime/quark/codelets/codelet_zhessq.c       |  28 ++--
 runtime/quark/codelets/codelet_zlacpy.c       |   8 +-
 runtime/quark/codelets/codelet_zlag2c.c       |  72 ++++-----
 runtime/quark/codelets/codelet_zlange.c       |  43 +++---
 runtime/quark/codelets/codelet_zlanhe.c       |  31 ++--
 runtime/quark/codelets/codelet_zlansy.c       |  31 ++--
 runtime/quark/codelets/codelet_zlantr.c       |  31 ++--
 runtime/quark/codelets/codelet_zlascal.c      |   8 +-
 runtime/quark/codelets/codelet_zlaset.c       |  32 ++--
 runtime/quark/codelets/codelet_zlaset2.c      |  29 ++--
 runtime/quark/codelets/codelet_zlatro.c       |   7 +-
 runtime/quark/codelets/codelet_zlauum.c       |  30 ++--
 runtime/quark/codelets/codelet_zpamm.c        |  60 ++++----
 runtime/quark/codelets/codelet_zplghe.c       |  35 ++---
 runtime/quark/codelets/codelet_zplgsy.c       |  35 ++---
 runtime/quark/codelets/codelet_zplrnt.c       |  33 ++--
 runtime/quark/codelets/codelet_zplssq.c       |  42 +++---
 runtime/quark/codelets/codelet_zpotrf.c       |  47 +++---
 runtime/quark/codelets/codelet_zssssm.c       |  49 +++---
 runtime/quark/codelets/codelet_zsymm.c        |  54 +++----
 runtime/quark/codelets/codelet_zsyr2k.c       |  48 +++---
 runtime/quark/codelets/codelet_zsyrk.c        |  48 +++---
 runtime/quark/codelets/codelet_zsyssq.c       |  28 ++--
 runtime/quark/codelets/codelet_zsytrf_nopiv.c |  37 +++--
 runtime/quark/codelets/codelet_ztile_zero.c   |  39 +++--
 runtime/quark/codelets/codelet_ztpmqrt.c      |   3 +-
 runtime/quark/codelets/codelet_ztpqrt.c       |   3 +-
 runtime/quark/codelets/codelet_ztradd.c       |   3 +-
 runtime/quark/codelets/codelet_ztrasm.c       |  34 ++---
 runtime/quark/codelets/codelet_ztrmm.c        |  54 +++----
 runtime/quark/codelets/codelet_ztrsm.c        |  52 +++----
 runtime/quark/codelets/codelet_ztrssq.c       |  32 ++--
 runtime/quark/codelets/codelet_ztrtri.c       |  46 +++---
 runtime/quark/codelets/codelet_ztslqt.c       |  39 +++--
 runtime/quark/codelets/codelet_ztsmlq.c       |  59 ++++----
 .../quark/codelets/codelet_ztsmlq_hetra1.c    |   3 +-
 runtime/quark/codelets/codelet_ztsmqr.c       |  59 ++++----
 .../quark/codelets/codelet_ztsmqr_hetra1.c    |   3 +-
 runtime/quark/codelets/codelet_ztsqrt.c       |  40 +++--
 runtime/quark/codelets/codelet_ztstrf.c       |  61 ++++----
 runtime/quark/codelets/codelet_zttlqt.c       |  40 +++--
 runtime/quark/codelets/codelet_zttmlq.c       |  59 ++++----
 runtime/quark/codelets/codelet_zttmqr.c       |  59 ++++----
 runtime/quark/codelets/codelet_zttqrt.c       |  40 +++--
 runtime/quark/codelets/codelet_zunmlq.c       |  51 +++----
 runtime/quark/codelets/codelet_zunmqr.c       |  50 +++---
 runtime/quark/control/runtime_async.c         |   2 +-
 runtime/quark/control/runtime_context.c       |   2 +-
 runtime/quark/control/runtime_control.c       |   2 +-
 runtime/quark/control/runtime_descriptor.c    |   2 +-
 runtime/quark/control/runtime_options.c       |   2 +-
 runtime/quark/control/runtime_profiling.c     |   2 +-
 runtime/quark/control/runtime_zlocality.c     |   2 +-
 runtime/quark/control/runtime_zprofiling.c    |   2 +-
 .../{morse_quark.h => chameleon_quark.h}      |   7 +-
 runtime/quark/include/quark_blas.h            |  42 ------
 runtime/quark/include/quark_zblas.h           | 142 ------------------
 runtime/quark/include/quark_zcblas.h          |  50 ------
 77 files changed, 1151 insertions(+), 1539 deletions(-)
 rename runtime/quark/include/{morse_quark.h => chameleon_quark.h} (89%)
 delete mode 100644 runtime/quark/include/quark_blas.h
 delete mode 100644 runtime/quark/include/quark_zblas.h
 delete mode 100644 runtime/quark/include/quark_zcblas.h

diff --git a/runtime/quark/CMakeLists.txt b/runtime/quark/CMakeLists.txt
index e1cff5885..c535a55a1 100644
--- a/runtime/quark/CMakeLists.txt
+++ b/runtime/quark/CMakeLists.txt
@@ -1,10 +1,10 @@
 ###
 #
-# @copyright (c) 2009-2014 The University of Tennessee and The University
+# @copyright (c) 2009-2015 The University of Tennessee and The University
 #                          of Tennessee Research Foundation.
 #                          All rights reserved.
-# @copyright (c) 2012-2016 Inria. All rights reserved.
-# @copyright (c) 2012-2014 Bordeaux INP, CNRS (LaBRI UMR 5800), Inria, Univ. Bordeaux. All rights reserved.
+# @copyright (c) 2012-2017 Bordeaux INP, CNRS (LaBRI UMR 5800), Inria,
+#                          Univ. Bordeaux. All rights reserved.
 #
 ###
 #
@@ -26,72 +26,80 @@
 #  @date 13-07-2012
 #
 ###
-
 cmake_minimum_required(VERSION 2.8)
 
-# Generate the quark headers for all possible precisions
-# ------------------------------------------------------
-set(RUNTIME_HDRS_GENERATED "")
-set(ZHDR
-  include/quark_zblas.h
-  include/quark_zcblas.h
-)
+include_directories( ${CMAKE_CURRENT_SOURCE_DIR}/include )
+include_directories( ${CMAKE_CURRENT_BINARY_DIR}/include )
 
-precisions_rules_py(RUNTIME_HDRS_GENERATED "${ZHDR}"
-                    PRECISIONS "s;d;c;z;ds;zc"
-                    TARGETDIR  "include")
+# # Generate headers for all possible precisions
+# # --------------------------------------------
+# set(RUNTIME_HDRS_GENERATED "")
+# set(ZHDR
+# )
+#
+# precisions_rules_py(RUNTIME_HDRS_GENERATED "${ZHDR}"
+#   PRECISIONS "s;d;c;z;ds;zc"
+#   TARGETDIR  "include")
 
 # Define the list of headers
 # --------------------------
 set(RUNTIME_HDRS
-    include/morse_quark.h
-    include/quark_blas.h
-    include/core_blas_dag.h
-    ${RUNTIME_HDRS_GENERATED}
-    )
+  include/chameleon_quark.h
+  include/core_blas_dag.h
+  )
+
+# # Add generated headers
+# # ---------------------
+# foreach( hdr_file ${RUNTIME_HDRS_GENERATED} )
+#   list(APPEND RUNTIME_HDRS ${CMAKE_CURRENT_BINARY_DIR}/${hdr_file})
+# endforeach()
 
 # Force generation of headers
 # ---------------------------
-add_custom_target(runtime_quark_include ALL SOURCES ${RUNTIME_HDRS})
+add_custom_target(
+  runtime_quark_include
+  ALL SOURCES ${RUNTIME_HDRS})
 
-# installation
+# Installation
 # ------------
-#install(FILES ${RUNTIME_HDRS}
-#        DESTINATION include)
+install(
+  FILES ${RUNTIME_HDRS}
+  DESTINATION include/runtime/quark )
 
-# Generate the morse common for all possible precisions
-# -----------------------------------------------------
+# Generate the Chameleon common for all possible precisions
+# ---------------------------------------------------------
 set(RUNTIME_COMMON_GENERATED "")
 set(ZSRC
-    control/runtime_zprofiling.c
-    control/runtime_zlocality.c
-    )
+  control/runtime_zprofiling.c
+  control/runtime_zlocality.c
+  )
 
-precisions_rules_py(RUNTIME_COMMON_GENERATED "${ZSRC}"
-                    PRECISIONS "${CHAMELEON_PRECISION}"
-                    TARGETDIR "control")
+precisions_rules_py(
+  RUNTIME_COMMON_GENERATED "${ZSRC}"
+  PRECISIONS "${CHAMELEON_PRECISION}"
+  TARGETDIR "control")
 
 set(RUNTIME_COMMON
-    control/runtime_async.c
-    control/runtime_context.c
-    control/runtime_control.c
-    control/runtime_descriptor.c
-    control/runtime_options.c
-    control/runtime_profiling.c
-    codelets/codelet_dataflush.c
-    ${RUNTIME_COMMON_GENERATED}
-    )
-
-# Generate the morse sources for all possible precisions
-# ------------------------------------------------------
+  control/runtime_async.c
+  control/runtime_context.c
+  control/runtime_control.c
+  control/runtime_descriptor.c
+  control/runtime_options.c
+  control/runtime_profiling.c
+  codelets/codelet_dataflush.c
+  ${RUNTIME_COMMON_GENERATED}
+  )
+
+# Generate the Chameleon sources for all possible precisions
+# ----------------------------------------------------------
 set(RUNTIME_SRCS_GENERATED "")
 set(ZSRC
-    ${CODELETS_ZSRC}
-    )
+  ${CODELETS_ZSRC}
+  )
 
 precisions_rules_py(RUNTIME_SRCS_GENERATED "${ZSRC}"
-                    PRECISIONS "${CHAMELEON_PRECISION}"
-                    TARGETDIR "codelets")
+  PRECISIONS "${CHAMELEON_PRECISION}"
+  TARGETDIR "codelets")
 
 set(RUNTIME_SRCS
   ${RUNTIME_COMMON}
@@ -122,7 +130,7 @@ endif()
 # installation
 # ------------
 install(TARGETS chameleon_quark
-        DESTINATION lib)
+  DESTINATION lib)
 
 ###
 ### END CMakeLists.txt
diff --git a/runtime/quark/codelets/codelet_dataflush.c b/runtime/quark/codelets/codelet_dataflush.c
index 1334e8959..300f33584 100644
--- a/runtime/quark/codelets/codelet_dataflush.c
+++ b/runtime/quark/codelets/codelet_dataflush.c
@@ -24,7 +24,7 @@
  * @date 2014-02-05
  *
  **/
-#include "runtime/quark/include/morse_quark.h"
+#include "chameleon_quark.h"
 
 void MORSE_TASK_dataflush(const MORSE_option_t *options,
                           const MORSE_desc_t *A, int Am, int An)
diff --git a/runtime/quark/codelets/codelet_zasum.c b/runtime/quark/codelets/codelet_zasum.c
index 4857e086e..4dde79a0f 100644
--- a/runtime/quark/codelets/codelet_zasum.c
+++ b/runtime/quark/codelets/codelet_zasum.c
@@ -24,7 +24,22 @@
  * @precisions normal z -> c d s
  *
  **/
-#include "runtime/quark/include/morse_quark.h"
+#include "chameleon_quark.h"
+#include "chameleon/morse_tasks_z.h"
+
+void CORE_dzasum_quark(Quark *quark)
+{
+    MORSE_enum storev;
+    MORSE_enum uplo;
+    int M;
+    int N;
+    MORSE_Complex64_t *A;
+    int lda;
+    double *work;
+
+    quark_unpack_args_7(quark, storev, uplo, M, N, A, lda, work);
+    CORE_dzasum(storev, uplo, M, N, A, lda, work);
+}
 
 void MORSE_TASK_dzasum(const MORSE_option_t *options,
                        MORSE_enum storev, MORSE_enum uplo, int M, int N,
@@ -43,18 +58,3 @@ void MORSE_TASK_dzasum(const MORSE_option_t *options,
         sizeof(double),                   RTBLKADDR(B, double, Bm, Bn), INOUT,
         0);
 }
-
-
-void CORE_dzasum_quark(Quark *quark)
-{
-    MORSE_enum storev;
-    MORSE_enum uplo;
-    int M;
-    int N;
-    MORSE_Complex64_t *A;
-    int lda;
-    double *work;
-
-    quark_unpack_args_7(quark, storev, uplo, M, N, A, lda, work);
-    CORE_dzasum(storev, uplo, M, N, A, lda, work);
-}
diff --git a/runtime/quark/codelets/codelet_zaxpy.c b/runtime/quark/codelets/codelet_zaxpy.c
index 875471e89..36e76787f 100644
--- a/runtime/quark/codelets/codelet_zaxpy.c
+++ b/runtime/quark/codelets/codelet_zaxpy.c
@@ -24,7 +24,21 @@
  * @precisions normal z -> c d s
  *
  **/
-#include "runtime/quark/include/morse_quark.h"
+#include "chameleon_quark.h"
+#include "chameleon/morse_tasks_z.h"
+
+void CORE_zaxpy_quark(Quark *quark)
+{
+    int M;
+    MORSE_Complex64_t alpha;
+    MORSE_Complex64_t *A;
+    int incA;
+    MORSE_Complex64_t *B;
+    int incB;
+
+    quark_unpack_args_6(quark, M, alpha, A, incA, B, incB);
+    CORE_zaxpy(M, alpha, A, incA, B, incB);
+}
 
 void MORSE_TASK_zaxpy(const MORSE_option_t *options,
                       int M, MORSE_Complex64_t *alpha,
@@ -42,17 +56,3 @@ void MORSE_TASK_zaxpy(const MORSE_option_t *options,
         sizeof(int),                        &incB,      VALUE,
         0);
 }
-
-
-void CORE_zaxpy_quark(Quark *quark)
-{
-    int M;
-    MORSE_Complex64_t alpha;
-    MORSE_Complex64_t *A;
-    int incA;
-    MORSE_Complex64_t *B;
-    int incB;
-
-    quark_unpack_args_6(quark, M, alpha, A, incA, B, incB);
-    CORE_zaxpy(M, alpha, A, incA, B, incB);
-}
diff --git a/runtime/quark/codelets/codelet_zbuild.c b/runtime/quark/codelets/codelet_zbuild.c
index 68f115ecf..7e88fd1a1 100644
--- a/runtime/quark/codelets/codelet_zbuild.c
+++ b/runtime/quark/codelets/codelet_zbuild.c
@@ -29,9 +29,21 @@
  * @precisions normal z -> c d s
  *
  **/
-#include "runtime/quark/include/morse_quark.h"
+#include "chameleon_quark.h"
+#include "chameleon/morse_tasks_z.h"
 
+void CORE_zbuild_quark(Quark *quark)
+{
+    MORSE_Complex64_t *A;
+    int lda;
+    void *user_data;
+    void (*user_build_callback)(int row_min, int row_max, int col_min, int col_max, void *buffer, int ld, void *user_data) ;
+    int row_min, row_max, col_min, col_max;
 
+    quark_unpack_args_8( quark, row_min, row_max, col_min, col_max, A, lda, user_data, user_build_callback);
+
+    user_build_callback(row_min, row_max, col_min, col_max, A, lda, user_data);
+}
 
 void MORSE_TASK_zbuild( const MORSE_option_t *options,
                         const MORSE_desc_t *A, int Am, int An, int lda,
@@ -46,28 +58,13 @@ void MORSE_TASK_zbuild( const MORSE_option_t *options,
     col_max = An == A->nt-1 ? A->n-1 : col_min+A->nb-1 ;
 
     QUARK_Insert_Task(opt->quark, CORE_zbuild_quark, (Quark_Task_Flags*)opt,
-        sizeof(int),                      &row_min,    VALUE,
-        sizeof(int),                      &row_max,    VALUE,
-        sizeof(int),                      &col_min,    VALUE,
-        sizeof(int),                      &col_max,    VALUE,
-        sizeof(MORSE_Complex64_t)*lda*A->nb, RTBLKADDR(A, MORSE_Complex64_t, Am, An),         OUTPUT,
-        sizeof(int),                      &lda,  VALUE,
-        sizeof(void*),                    &user_data,  VALUE,
-        sizeof(void*),                    &user_build_callback,   VALUE,
-        0);
-}
-
-
-void CORE_zbuild_quark(Quark *quark)
-{
-    MORSE_Complex64_t *A;
-    int lda;
-    void *user_data;
-    void (*user_build_callback)(int row_min, int row_max, int col_min, int col_max, void *buffer, int ld, void *user_data) ;
-    int row_min, row_max, col_min, col_max;
-
-    quark_unpack_args_8( quark, row_min, row_max, col_min, col_max, A, lda, user_data, user_build_callback);
-
-    user_build_callback(row_min, row_max, col_min, col_max, A, lda, user_data);
+                      sizeof(int),                      &row_min,    VALUE,
+                      sizeof(int),                      &row_max,    VALUE,
+                      sizeof(int),                      &col_min,    VALUE,
+                      sizeof(int),                      &col_max,    VALUE,
+                      sizeof(MORSE_Complex64_t)*lda*A->nb, RTBLKADDR(A, MORSE_Complex64_t, Am, An),         OUTPUT,
+                      sizeof(int),                      &lda,  VALUE,
+                      sizeof(void*),                    &user_data,  VALUE,
+                      sizeof(void*),                    &user_build_callback,   VALUE,
+                      0);
 }
-
diff --git a/runtime/quark/codelets/codelet_zgeadd.c b/runtime/quark/codelets/codelet_zgeadd.c
index 4fc1c22cf..f97921b5b 100644
--- a/runtime/quark/codelets/codelet_zgeadd.c
+++ b/runtime/quark/codelets/codelet_zgeadd.c
@@ -26,7 +26,8 @@
  * @precisions normal z -> c d s
  *
  **/
-#include "runtime/quark/include/morse_quark.h"
+#include "chameleon_quark.h"
+#include "chameleon/morse_tasks_z.h"
 
 void CORE_zgeadd_quark(Quark *quark)
 {
diff --git a/runtime/quark/codelets/codelet_zgelqt.c b/runtime/quark/codelets/codelet_zgelqt.c
index a0cc3b1f8..e41d566f6 100644
--- a/runtime/quark/codelets/codelet_zgelqt.c
+++ b/runtime/quark/codelets/codelet_zgelqt.c
@@ -29,7 +29,24 @@
  *
  **/
 
-#include "runtime/quark/include/morse_quark.h"
+#include "chameleon_quark.h"
+#include "chameleon/morse_tasks_z.h"
+
+void CORE_zgelqt_quark(Quark *quark)
+{
+    int m;
+    int n;
+    int ib;
+    MORSE_Complex64_t *A;
+    int lda;
+    MORSE_Complex64_t *T;
+    int ldt;
+    MORSE_Complex64_t *TAU;
+    MORSE_Complex64_t *WORK;
+
+    quark_unpack_args_9(quark, m, n, ib, A, lda, T, ldt, TAU, WORK);
+    CORE_zgelqt(m, n, ib, A, lda, T, ldt, TAU, WORK);
+}
 
 /**
  *
@@ -92,7 +109,6 @@
  *          \retval <0 if -i, the i-th argument had an illegal value
  *
  ******************************************************************************/
-
 void MORSE_TASK_zgelqt(const MORSE_option_t *options,
                        int m, int n, int ib, int nb,
                        const MORSE_desc_t *A, int Am, int An, int lda,
@@ -112,20 +128,3 @@ void MORSE_TASK_zgelqt(const MORSE_option_t *options,
         sizeof(MORSE_Complex64_t)*ib*nb,    NULL,          SCRATCH,
         0);
 }
-
-
-void CORE_zgelqt_quark(Quark *quark)
-{
-    int m;
-    int n;
-    int ib;
-    MORSE_Complex64_t *A;
-    int lda;
-    MORSE_Complex64_t *T;
-    int ldt;
-    MORSE_Complex64_t *TAU;
-    MORSE_Complex64_t *WORK;
-
-    quark_unpack_args_9(quark, m, n, ib, A, lda, T, ldt, TAU, WORK);
-    CORE_zgelqt(m, n, ib, A, lda, T, ldt, TAU, WORK);
-}
diff --git a/runtime/quark/codelets/codelet_zgemm.c b/runtime/quark/codelets/codelet_zgemm.c
index b83bee0aa..0e06cef9c 100644
--- a/runtime/quark/codelets/codelet_zgemm.c
+++ b/runtime/quark/codelets/codelet_zgemm.c
@@ -28,41 +28,8 @@
  * @precisions normal z -> c d s
  *
  **/
-#include "runtime/quark/include/morse_quark.h"
-
-/***************************************************************************//**
- *
- * @ingroup CORE_MORSE_Complex64_t
- *
- **/
-
-void MORSE_TASK_zgemm(const MORSE_option_t *options,
-                      MORSE_enum transA, int transB,
-                      int m, int n, int k, int nb,
-                      MORSE_Complex64_t alpha, const MORSE_desc_t *A, int Am, int An, int lda,
-                                                const MORSE_desc_t *B, int Bm, int Bn, int ldb,
-                      MORSE_Complex64_t beta, const MORSE_desc_t *C, int Cm, int Cn, int ldc)
-{
-    quark_option_t *opt = (quark_option_t*)(options->schedopt);
-    DAG_CORE_GEMM;
-    QUARK_Insert_Task(opt->quark, CORE_zgemm_quark, (Quark_Task_Flags*)opt,
-        sizeof(MORSE_enum),                &transA,    VALUE,
-        sizeof(MORSE_enum),                &transB,    VALUE,
-        sizeof(int),                        &m,         VALUE,
-        sizeof(int),                        &n,         VALUE,
-        sizeof(int),                        &k,         VALUE,
-        sizeof(MORSE_Complex64_t),         &alpha,     VALUE,
-        sizeof(MORSE_Complex64_t)*nb*nb,    RTBLKADDR(A, MORSE_Complex64_t, Am, An),                 INPUT,
-        sizeof(int),                        &lda,       VALUE,
-        sizeof(MORSE_Complex64_t)*nb*nb,    RTBLKADDR(B, MORSE_Complex64_t, Bm, Bn),                 INPUT,
-        sizeof(int),                        &ldb,       VALUE,
-        sizeof(MORSE_Complex64_t),         &beta,      VALUE,
-        sizeof(MORSE_Complex64_t)*nb*nb,    RTBLKADDR(C, MORSE_Complex64_t, Cm, Cn),                 INOUT,
-        sizeof(int),                        &ldc,       VALUE,
-        0);
-}
-
-
+#include "chameleon_quark.h"
+#include "chameleon/morse_tasks_z.h"
 
 void CORE_zgemm_quark(Quark *quark)
 {
@@ -82,16 +49,34 @@ void CORE_zgemm_quark(Quark *quark)
 
     quark_unpack_args_13(quark, transA, transB, m, n, k, alpha, A, lda, B, ldb, beta, C, ldc);
     CORE_zgemm(transA, transB,
-        m, n, k,
-        alpha, A, lda,
-        B, ldb,
-        beta, C, ldc);
+               m, n, k,
+               alpha, A, lda,
+               B, ldb,
+               beta, C, ldc);
 }
 
-
-
-
-
-
-
-
+void MORSE_TASK_zgemm(const MORSE_option_t *options,
+                      MORSE_enum transA, int transB,
+                      int m, int n, int k, int nb,
+                      MORSE_Complex64_t alpha, const MORSE_desc_t *A, int Am, int An, int lda,
+                      const MORSE_desc_t *B, int Bm, int Bn, int ldb,
+                      MORSE_Complex64_t beta, const MORSE_desc_t *C, int Cm, int Cn, int ldc)
+{
+    quark_option_t *opt = (quark_option_t*)(options->schedopt);
+    DAG_CORE_GEMM;
+    QUARK_Insert_Task(opt->quark, CORE_zgemm_quark, (Quark_Task_Flags*)opt,
+                      sizeof(MORSE_enum),                &transA,    VALUE,
+                      sizeof(MORSE_enum),                &transB,    VALUE,
+                      sizeof(int),                        &m,         VALUE,
+                      sizeof(int),                        &n,         VALUE,
+                      sizeof(int),                        &k,         VALUE,
+                      sizeof(MORSE_Complex64_t),         &alpha,     VALUE,
+                      sizeof(MORSE_Complex64_t)*nb*nb,    RTBLKADDR(A, MORSE_Complex64_t, Am, An),                 INPUT,
+                      sizeof(int),                        &lda,       VALUE,
+                      sizeof(MORSE_Complex64_t)*nb*nb,    RTBLKADDR(B, MORSE_Complex64_t, Bm, Bn),                 INPUT,
+                      sizeof(int),                        &ldb,       VALUE,
+                      sizeof(MORSE_Complex64_t),         &beta,      VALUE,
+                      sizeof(MORSE_Complex64_t)*nb*nb,    RTBLKADDR(C, MORSE_Complex64_t, Cm, Cn),                 INOUT,
+                      sizeof(int),                        &ldc,       VALUE,
+                      0);
+}
diff --git a/runtime/quark/codelets/codelet_zgeqrt.c b/runtime/quark/codelets/codelet_zgeqrt.c
index d1906b28d..1b8680211 100644
--- a/runtime/quark/codelets/codelet_zgeqrt.c
+++ b/runtime/quark/codelets/codelet_zgeqrt.c
@@ -28,8 +28,24 @@
  * @precisions normal z -> c d s
  *
  **/
+#include "chameleon_quark.h"
+#include "chameleon/morse_tasks_z.h"
 
-#include "runtime/quark/include/morse_quark.h"
+void CORE_zgeqrt_quark(Quark *quark)
+{
+    int m;
+    int n;
+    int ib;
+    MORSE_Complex64_t *A;
+    int lda;
+    MORSE_Complex64_t *T;
+    int ldt;
+    MORSE_Complex64_t *TAU;
+    MORSE_Complex64_t *WORK;
+
+    quark_unpack_args_9(quark, m, n, ib, A, lda, T, ldt, TAU, WORK);
+    CORE_zgeqrt(m, n, ib, A, lda, T, ldt, TAU, WORK);
+}
 
 /**
  *
@@ -93,7 +109,6 @@
  *          \retval <0 if -i, the i-th argument had an illegal value
  *
  ******************************************************************************/
-
 void MORSE_TASK_zgeqrt(const MORSE_option_t *options,
                        int m, int n, int ib, int nb,
                        const MORSE_desc_t *A, int Am, int An, int lda,
@@ -113,20 +128,3 @@ void MORSE_TASK_zgeqrt(const MORSE_option_t *options,
         sizeof(MORSE_Complex64_t)*ib*nb,    NULL,          SCRATCH,
         0);
 }
-
-
-void CORE_zgeqrt_quark(Quark *quark)
-{
-    int m;
-    int n;
-    int ib;
-    MORSE_Complex64_t *A;
-    int lda;
-    MORSE_Complex64_t *T;
-    int ldt;
-    MORSE_Complex64_t *TAU;
-    MORSE_Complex64_t *WORK;
-
-    quark_unpack_args_9(quark, m, n, ib, A, lda, T, ldt, TAU, WORK);
-    CORE_zgeqrt(m, n, ib, A, lda, T, ldt, TAU, WORK);
-}
diff --git a/runtime/quark/codelets/codelet_zgessm.c b/runtime/quark/codelets/codelet_zgessm.c
index e4e767a7b..9ce245661 100644
--- a/runtime/quark/codelets/codelet_zgessm.c
+++ b/runtime/quark/codelets/codelet_zgessm.c
@@ -29,8 +29,26 @@
  *
  **/
 #include "coreblas/cblas.h"
+#include "chameleon_quark.h"
+#include "chameleon/morse_tasks_z.h"
 
-#include "runtime/quark/include/morse_quark.h"
+void CORE_zgessm_quark(Quark *quark)
+{
+    int m;
+    int n;
+    int k;
+    int ib;
+    int *IPIV;
+    MORSE_Complex64_t *L;
+    int ldl;
+    MORSE_Complex64_t *D;
+    int ldd;
+    MORSE_Complex64_t *A;
+    int lda;
+
+    quark_unpack_args_11(quark, m, n, k, ib, IPIV, L, ldl, D, ldd, A, lda);
+    CORE_zgessm(m, n, k, ib, IPIV, D, ldd, A, lda);
+}
 
 /***************************************************************************//**
  *
@@ -77,7 +95,6 @@
  *         \retval <0 if INFO = -k, the k-th argument had an illegal value
  *
  ******************************************************************************/
-
 void MORSE_TASK_zgessm(const MORSE_option_t *options,
                        int m, int n, int k, int ib, int nb,
                        int *IPIV,
@@ -101,22 +118,3 @@ void MORSE_TASK_zgessm(const MORSE_option_t *options,
         sizeof(int),                        &lda,   VALUE,
         0);
 }
-
-
-void CORE_zgessm_quark(Quark *quark)
-{
-    int m;
-    int n;
-    int k;
-    int ib;
-    int *IPIV;
-    MORSE_Complex64_t *L;
-    int ldl;
-    MORSE_Complex64_t *D;
-    int ldd;
-    MORSE_Complex64_t *A;
-    int lda;
-
-    quark_unpack_args_11(quark, m, n, k, ib, IPIV, L, ldl, D, ldd, A, lda);
-    CORE_zgessm(m, n, k, ib, IPIV, D, ldd, A, lda);
-}
diff --git a/runtime/quark/codelets/codelet_zgessq.c b/runtime/quark/codelets/codelet_zgessq.c
index 546dad02a..632c18b1c 100644
--- a/runtime/quark/codelets/codelet_zgessq.c
+++ b/runtime/quark/codelets/codelet_zgessq.c
@@ -24,23 +24,8 @@
  * @precisions normal z -> c d s
  *
  **/
-#include "runtime/quark/include/morse_quark.h"
-
-void MORSE_TASK_zgessq( const MORSE_option_t *options,
-                        int m, int n,
-                        const MORSE_desc_t *A, int Am, int An, int lda,
-                        const MORSE_desc_t *SCALESUMSQ, int SCALESUMSQm, int SCALESUMSQn )
-{
-    quark_option_t *opt = (quark_option_t*)(options->schedopt);
-    QUARK_Insert_Task(opt->quark, CORE_zgessq_quark, (Quark_Task_Flags*)opt,
-        sizeof(int),                     &m,    VALUE,
-        sizeof(int),                     &n,    VALUE,
-        sizeof(MORSE_Complex64_t)*lda*n, RTBLKADDR(A, MORSE_Complex64_t, Am, An), INPUT,
-        sizeof(int),                     &lda,  VALUE,
-        sizeof(double)*2,                RTBLKADDR(SCALESUMSQ, double, SCALESUMSQm, SCALESUMSQn), INOUT,
-        0);
-}
-
+#include "chameleon_quark.h"
+#include "chameleon/morse_tasks_z.h"
 
 void CORE_zgessq_quark(Quark *quark)
 {
@@ -53,3 +38,18 @@ void CORE_zgessq_quark(Quark *quark)
     quark_unpack_args_5( quark, m, n, A, lda, SCALESUMSQ );
     CORE_zgessq( m, n, A, lda, &SCALESUMSQ[0], &SCALESUMSQ[1]);
 }
+
+void MORSE_TASK_zgessq( const MORSE_option_t *options,
+                        int m, int n,
+                        const MORSE_desc_t *A, int Am, int An, int lda,
+                        const MORSE_desc_t *SCALESUMSQ, int SCALESUMSQm, int SCALESUMSQn )
+{
+    quark_option_t *opt = (quark_option_t*)(options->schedopt);
+    QUARK_Insert_Task(opt->quark, CORE_zgessq_quark, (Quark_Task_Flags*)opt,
+                      sizeof(int),                     &m,    VALUE,
+                      sizeof(int),                     &n,    VALUE,
+                      sizeof(MORSE_Complex64_t)*lda*n, RTBLKADDR(A, MORSE_Complex64_t, Am, An), INPUT,
+                      sizeof(int),                     &lda,  VALUE,
+                      sizeof(double)*2,                RTBLKADDR(SCALESUMSQ, double, SCALESUMSQm, SCALESUMSQn), INOUT,
+                      0);
+}
diff --git a/runtime/quark/codelets/codelet_zgetrf.c b/runtime/quark/codelets/codelet_zgetrf.c
index e9e62c4ce..5888529c6 100644
--- a/runtime/quark/codelets/codelet_zgetrf.c
+++ b/runtime/quark/codelets/codelet_zgetrf.c
@@ -27,7 +27,27 @@
  *
  **/
 
-#include "runtime/quark/include/morse_quark.h"
+#include "chameleon_quark.h"
+#include "chameleon/morse_tasks_z.h"
+
+void CORE_zgetrf_quark(Quark *quark)
+{
+    int m;
+    int n;
+    MORSE_Complex64_t *A;
+    int lda;
+    int *IPIV;
+    MORSE_sequence_t *sequence;
+    MORSE_request_t *request;
+    MORSE_bool check_info;
+    int iinfo;
+    int info;
+
+    quark_unpack_args_9(quark, m, n, A, lda, IPIV, sequence, request, check_info, iinfo);
+    CORE_zgetrf( m, n, A, lda, IPIV, &info );
+    if (info != MORSE_SUCCESS && check_info)
+        RUNTIME_sequence_flush(quark, sequence, request, iinfo+info);
+}
 
 void MORSE_TASK_zgetrf(const MORSE_option_t *options,
                        int m, int n, int nb,
@@ -49,23 +69,3 @@ void MORSE_TASK_zgetrf(const MORSE_option_t *options,
         sizeof(int),                        &iinfo,         VALUE,
         0);
 }
-
-
-void CORE_zgetrf_quark(Quark *quark)
-{
-    int m;
-    int n;
-    MORSE_Complex64_t *A;
-    int lda;
-    int *IPIV;
-    MORSE_sequence_t *sequence;
-    MORSE_request_t *request;
-    MORSE_bool check_info;
-    int iinfo;
-    int info;
-
-    quark_unpack_args_9(quark, m, n, A, lda, IPIV, sequence, request, check_info, iinfo);
-    CORE_zgetrf( m, n, A, lda, IPIV, &info );
-    if (info != MORSE_SUCCESS && check_info)
-        RUNTIME_sequence_flush(quark, sequence, request, iinfo+info);
-}
diff --git a/runtime/quark/codelets/codelet_zgetrf_incpiv.c b/runtime/quark/codelets/codelet_zgetrf_incpiv.c
index d383dd2f5..2c1b8388a 100644
--- a/runtime/quark/codelets/codelet_zgetrf_incpiv.c
+++ b/runtime/quark/codelets/codelet_zgetrf_incpiv.c
@@ -28,8 +28,29 @@
  * @precisions normal z -> c d s
  *
  **/
+#include "chameleon_quark.h"
+#include "chameleon/morse_tasks_z.h"
 
-#include "runtime/quark/include/morse_quark.h"
+void CORE_zgetrf_incpiv_quark(Quark *quark)
+{
+    int m;
+    int n;
+    int ib;
+    MORSE_Complex64_t *A;
+    int lda;
+    int *IPIV;
+    MORSE_sequence_t *sequence;
+    MORSE_request_t *request;
+    MORSE_bool check_info;
+    int iinfo;
+
+    int info;
+
+    quark_unpack_args_10(quark, m, n, ib, A, lda, IPIV, sequence, request, check_info, iinfo);
+    CORE_zgetrf_incpiv(m, n, ib, A, lda, IPIV, &info);
+    if (info != MORSE_SUCCESS && check_info)
+        RUNTIME_sequence_flush(quark, sequence, request, iinfo+info);
+}
 
 /***************************************************************************//**
  *
@@ -85,7 +106,6 @@
  *              to solve a system of equations.
  *
  ******************************************************************************/
-
 void MORSE_TASK_zgetrf_incpiv(const MORSE_option_t *options,
                               int m, int n, int ib, int nb,
                               const MORSE_desc_t *A, int Am, int An, int lda,
@@ -110,25 +130,3 @@ void MORSE_TASK_zgetrf_incpiv(const MORSE_option_t *options,
 
     (void)L; (void)Lm; (void)Ln; (void)ldl;
 }
-
-
-void CORE_zgetrf_incpiv_quark(Quark *quark)
-{
-    int m;
-    int n;
-    int ib;
-    MORSE_Complex64_t *A;
-    int lda;
-    int *IPIV;
-    MORSE_sequence_t *sequence;
-    MORSE_request_t *request;
-    MORSE_bool check_info;
-    int iinfo;
-
-    int info;
-
-    quark_unpack_args_10(quark, m, n, ib, A, lda, IPIV, sequence, request, check_info, iinfo);
-    CORE_zgetrf_incpiv(m, n, ib, A, lda, IPIV, &info);
-    if (info != MORSE_SUCCESS && check_info)
-        RUNTIME_sequence_flush(quark, sequence, request, iinfo+info);
-}
diff --git a/runtime/quark/codelets/codelet_zgetrf_nopiv.c b/runtime/quark/codelets/codelet_zgetrf_nopiv.c
index 19bb17f1b..10f031052 100644
--- a/runtime/quark/codelets/codelet_zgetrf_nopiv.c
+++ b/runtime/quark/codelets/codelet_zgetrf_nopiv.c
@@ -25,7 +25,26 @@
  * @precisions normal z -> c d s
  *
  **/
-#include "runtime/quark/include/morse_quark.h"
+#include "chameleon_quark.h"
+#include "chameleon/morse_tasks_z.h"
+
+void CORE_zgetrf_nopiv_quark(Quark *quark)
+{
+    int m;
+    int n;
+    int ib;
+    MORSE_Complex64_t *A;
+    int lda;
+    MORSE_sequence_t *sequence;
+    MORSE_request_t *request;
+    int iinfo;
+    int info;
+
+    quark_unpack_args_8(quark, m, n, ib, A, lda, sequence, request, iinfo);
+    CORE_zgetrf_nopiv(m, n, ib, A, lda, &info);
+    if (info != MORSE_SUCCESS)
+        RUNTIME_sequence_flush(quark, sequence, request, iinfo+info);
+}
 
 /***************************************************************************//**
  *
@@ -74,7 +93,6 @@
  *              to solve a system of equations.
  *
  ******************************************************************************/
-
 void MORSE_TASK_zgetrf_nopiv(const MORSE_option_t *options,
                              int m, int n, int ib, int nb,
                              const MORSE_desc_t *A, int Am, int An, int lda,
@@ -94,22 +112,3 @@ void MORSE_TASK_zgetrf_nopiv(const MORSE_option_t *options,
         sizeof(int),                        &iinfo,         VALUE,
         0);
 }
-
-
-void CORE_zgetrf_nopiv_quark(Quark *quark)
-{
-    int m;
-    int n;
-    int ib;
-    MORSE_Complex64_t *A;
-    int lda;
-    MORSE_sequence_t *sequence;
-    MORSE_request_t *request;
-    int iinfo;
-    int info;
-
-    quark_unpack_args_8(quark, m, n, ib, A, lda, sequence, request, iinfo);
-    CORE_zgetrf_nopiv(m, n, ib, A, lda, &info);
-    if (info != MORSE_SUCCESS)
-        RUNTIME_sequence_flush(quark, sequence, request, iinfo+info);
-}
diff --git a/runtime/quark/codelets/codelet_zhe2ge.c b/runtime/quark/codelets/codelet_zhe2ge.c
index 474ea51dc..702a86eb5 100644
--- a/runtime/quark/codelets/codelet_zhe2ge.c
+++ b/runtime/quark/codelets/codelet_zhe2ge.c
@@ -20,7 +20,8 @@
  *
  **/
 
-#include "runtime/quark/include/morse_quark.h"
+#include "chameleon_quark.h"
+#include "chameleon/morse_tasks_z.h"
 
 /**
  *
diff --git a/runtime/quark/codelets/codelet_zhemm.c b/runtime/quark/codelets/codelet_zhemm.c
index b814fe232..77461f1d0 100644
--- a/runtime/quark/codelets/codelet_zhemm.c
+++ b/runtime/quark/codelets/codelet_zhemm.c
@@ -28,16 +28,31 @@
  * @precisions normal z -> c
  *
  **/
-#include "runtime/quark/include/morse_quark.h"
+#include "chameleon_quark.h"
+#include "chameleon/morse_tasks_z.h"
 
-#undef REAL
-#define COMPLEX
-#ifdef COMPLEX
-/***************************************************************************//**
- *
- * @ingroup CORE_MORSE_Complex64_t
- *
- **/
+void CORE_zhemm_quark(Quark *quark)
+{
+    MORSE_enum side;
+    MORSE_enum uplo;
+    int M;
+    int N;
+    MORSE_Complex64_t alpha;
+    MORSE_Complex64_t *A;
+    int LDA;
+    MORSE_Complex64_t *B;
+    int LDB;
+    MORSE_Complex64_t beta;
+    MORSE_Complex64_t *C;
+    int LDC;
+
+    quark_unpack_args_12(quark, side, uplo, M, N, alpha, A, LDA, B, LDB, beta, C, LDC);
+    CORE_zhemm(side, uplo,
+        M, N,
+        alpha, A, LDA,
+        B, LDB,
+        beta, C, LDC);
+}
 
 void MORSE_TASK_zhemm(const MORSE_option_t *options,
                       MORSE_enum side, MORSE_enum uplo,
@@ -64,27 +79,3 @@ void MORSE_TASK_zhemm(const MORSE_option_t *options,
         0);
 }
 
-
-void CORE_zhemm_quark(Quark *quark)
-{
-    MORSE_enum side;
-    MORSE_enum uplo;
-    int M;
-    int N;
-    MORSE_Complex64_t alpha;
-    MORSE_Complex64_t *A;
-    int LDA;
-    MORSE_Complex64_t *B;
-    int LDB;
-    MORSE_Complex64_t beta;
-    MORSE_Complex64_t *C;
-    int LDC;
-
-    quark_unpack_args_12(quark, side, uplo, M, N, alpha, A, LDA, B, LDB, beta, C, LDC);
-    CORE_zhemm(side, uplo,
-        M, N,
-        alpha, A, LDA,
-        B, LDB,
-        beta, C, LDC);
-}
-#endif
diff --git a/runtime/quark/codelets/codelet_zher2k.c b/runtime/quark/codelets/codelet_zher2k.c
index bb4c07e43..b78a8c1e1 100644
--- a/runtime/quark/codelets/codelet_zher2k.c
+++ b/runtime/quark/codelets/codelet_zher2k.c
@@ -28,16 +28,28 @@
  * @precisions normal z -> c
  *
  **/
-#include "runtime/quark/include/morse_quark.h"
+#include "chameleon_quark.h"
+#include "chameleon/morse_tasks_z.h"
 
-#undef REAL
-#define COMPLEX
-#ifdef COMPLEX
-/***************************************************************************//**
- *
- * @ingroup CORE_MORSE_Complex64_t
- *
- **/
+void CORE_zher2k_quark(Quark *quark)
+{
+    MORSE_enum uplo;
+    MORSE_enum trans;
+    int n;
+    int k;
+    MORSE_Complex64_t alpha;
+    MORSE_Complex64_t *A;
+    int lda;
+    MORSE_Complex64_t *B;
+    int ldb;
+    double beta;
+    MORSE_Complex64_t *C;
+    int ldc;
+
+    quark_unpack_args_12(quark, uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C, ldc);
+    CORE_zher2k(uplo, trans,
+                n, k, alpha, A, lda, B, ldb, beta, C, ldc);
+}
 
 void MORSE_TASK_zher2k(const MORSE_option_t *options,
                        MORSE_enum uplo, MORSE_enum trans,
@@ -63,25 +75,3 @@ void MORSE_TASK_zher2k(const MORSE_option_t *options,
         sizeof(int),                        &ldc,       VALUE,
         0);
 }
-
-
-void CORE_zher2k_quark(Quark *quark)
-{
-    MORSE_enum uplo;
-    MORSE_enum trans;
-    int n;
-    int k;
-    MORSE_Complex64_t alpha;
-    MORSE_Complex64_t *A;
-    int lda;
-    MORSE_Complex64_t *B;
-    int ldb;
-    double beta;
-    MORSE_Complex64_t *C;
-    int ldc;
-
-    quark_unpack_args_12(quark, uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C, ldc);
-    CORE_zher2k(uplo, trans,
-                n, k, alpha, A, lda, B, ldb, beta, C, ldc);
-}
-#endif
diff --git a/runtime/quark/codelets/codelet_zherfb.c b/runtime/quark/codelets/codelet_zherfb.c
index b254c1ed1..7d4224f90 100644
--- a/runtime/quark/codelets/codelet_zherfb.c
+++ b/runtime/quark/codelets/codelet_zherfb.c
@@ -22,7 +22,8 @@
  * @precisions normal z -> c d s
  *
  **/
-#include "runtime/quark/include/morse_quark.h"
+#include "chameleon_quark.h"
+#include "chameleon/morse_tasks_z.h"
 
 void CORE_zherfb_quark(Quark *quark)
 {
diff --git a/runtime/quark/codelets/codelet_zherk.c b/runtime/quark/codelets/codelet_zherk.c
index 27cb1df90..4911c7132 100644
--- a/runtime/quark/codelets/codelet_zherk.c
+++ b/runtime/quark/codelets/codelet_zherk.c
@@ -28,16 +28,28 @@
  * @precisions normal z -> c
  *
  **/
-#include "runtime/quark/include/morse_quark.h"
+#include "chameleon_quark.h"
+#include "chameleon/morse_tasks_z.h"
 
-#undef REAL
-#define COMPLEX
-#ifdef COMPLEX
-/***************************************************************************//**
- *
- * @ingroup CORE_MORSE_Complex64_t
- *
- **/
+void CORE_zherk_quark(Quark *quark)
+{
+    MORSE_enum uplo;
+    MORSE_enum trans;
+    int n;
+    int k;
+    double alpha;
+    MORSE_Complex64_t *A;
+    int lda;
+    double beta;
+    MORSE_Complex64_t *C;
+    int ldc;
+
+    quark_unpack_args_10(quark, uplo, trans, n, k, alpha, A, lda, beta, C, ldc);
+    CORE_zherk(uplo, trans,
+        n, k,
+        alpha, A, lda,
+        beta, C, ldc);
+}
 
 void MORSE_TASK_zherk(const MORSE_option_t *options,
                       MORSE_enum uplo, MORSE_enum trans,
@@ -60,25 +72,3 @@ void MORSE_TASK_zherk(const MORSE_option_t *options,
         sizeof(int),                        &ldc,       VALUE,
         0);
 }
-
-
-void CORE_zherk_quark(Quark *quark)
-{
-    MORSE_enum uplo;
-    MORSE_enum trans;
-    int n;
-    int k;
-    double alpha;
-    MORSE_Complex64_t *A;
-    int lda;
-    double beta;
-    MORSE_Complex64_t *C;
-    int ldc;
-
-    quark_unpack_args_10(quark, uplo, trans, n, k, alpha, A, lda, beta, C, ldc);
-    CORE_zherk(uplo, trans,
-        n, k,
-        alpha, A, lda,
-        beta, C, ldc);
-}
-#endif
diff --git a/runtime/quark/codelets/codelet_zhessq.c b/runtime/quark/codelets/codelet_zhessq.c
index 34d026a94..f7fc02d9a 100644
--- a/runtime/quark/codelets/codelet_zhessq.c
+++ b/runtime/quark/codelets/codelet_zhessq.c
@@ -24,7 +24,20 @@
  * @precisions normal z -> c
  *
  **/
-#include "runtime/quark/include/morse_quark.h"
+#include "chameleon_quark.h"
+#include "chameleon/morse_tasks_z.h"
+
+void CORE_zhessq_quark(Quark *quark)
+{
+    MORSE_enum uplo;
+    int n;
+    MORSE_Complex64_t *A;
+    int lda;
+    double *SCALESUMSQ;
+
+    quark_unpack_args_5( quark, uplo, n, A, lda, SCALESUMSQ );
+    CORE_zhessq( uplo, n, A, lda, &SCALESUMSQ[0], &SCALESUMSQ[1]);
+}
 
 void MORSE_TASK_zhessq( const MORSE_option_t *options,
                         MORSE_enum uplo, int n,
@@ -40,16 +53,3 @@ void MORSE_TASK_zhessq( const MORSE_option_t *options,
         sizeof(double)*2,                RTBLKADDR(SCALESUMSQ, double, SCALESUMSQm, SCALESUMSQn), INOUT,
         0);
 }
-
-
-void CORE_zhessq_quark(Quark *quark)
-{
-    MORSE_enum uplo;
-    int n;
-    MORSE_Complex64_t *A;
-    int lda;
-    double *SCALESUMSQ;
-
-    quark_unpack_args_5( quark, uplo, n, A, lda, SCALESUMSQ );
-    CORE_zhessq( uplo, n, A, lda, &SCALESUMSQ[0], &SCALESUMSQ[1]);
-}
diff --git a/runtime/quark/codelets/codelet_zlacpy.c b/runtime/quark/codelets/codelet_zlacpy.c
index ee78ca67b..11d6dc67f 100644
--- a/runtime/quark/codelets/codelet_zlacpy.c
+++ b/runtime/quark/codelets/codelet_zlacpy.c
@@ -29,13 +29,9 @@
  *
  **/
 
-#include "runtime/quark/include/morse_quark.h"
+#include "chameleon_quark.h"
+#include "chameleon/morse_tasks_z.h"
 
-/***************************************************************************//**
- *
- * @ingroup CORE_MORSE_Complex64_t
- *
- **/
 static inline void CORE_zlacpy_quark(Quark *quark)
 {
     MORSE_enum uplo;
diff --git a/runtime/quark/codelets/codelet_zlag2c.c b/runtime/quark/codelets/codelet_zlag2c.c
index 0267ddc25..6e0489819 100644
--- a/runtime/quark/codelets/codelet_zlag2c.c
+++ b/runtime/quark/codelets/codelet_zlag2c.c
@@ -27,33 +27,8 @@
  *
  **/
 
-#include "runtime/quark/include/morse_quark.h"
-
-/***************************************************************************//**
- *
- * @ingroup CORE_MORSE_Complex64_t
- *
- **/
-void MORSE_TASK_zlag2c(const MORSE_option_t *options,
-                       int m, int n, int nb,
-                       const MORSE_desc_t *A, int Am, int An, int lda,
-                       const MORSE_desc_t *B, int Bm, int Bn, int ldb)
-{
-    quark_option_t *opt = (quark_option_t*)(options->schedopt);
-    DAG_CORE_LAG2C;
-    QUARK_Insert_Task(opt->quark, CORE_zlag2c_quark, (Quark_Task_Flags*)opt,
-        sizeof(int),                        &m,         VALUE,
-        sizeof(int),                        &n,         VALUE,
-        sizeof(MORSE_Complex64_t)*nb*nb,    RTBLKADDR(A, MORSE_Complex64_t, Am, An),                 INPUT,
-        sizeof(int),                        &lda,       VALUE,
-        sizeof(MORSE_Complex32_t)*nb*nb,    RTBLKADDR(B, MORSE_Complex32_t, Bm, Bn),                 OUTPUT,
-        sizeof(int),                        &ldb,       VALUE,
-        sizeof(MORSE_sequence_t*),           &(options->sequence),  VALUE,
-        sizeof(MORSE_request_t*),            &(options->request),   VALUE,
-        0);
-}
-
-
+#include "chameleon_quark.h"
+#include "chameleon/morse_tasks_z.h"
 
 void CORE_zlag2c_quark(Quark *quark)
 {
@@ -73,28 +48,25 @@ void CORE_zlag2c_quark(Quark *quark)
         RUNTIME_sequence_flush(quark, sequence, request, info);
 }
 
-/***************************************************************************//**
- *
- * @ingroup CORE_MORSE_Complex64_t
- *
- **/
-
-void MORSE_TASK_clag2z(const MORSE_option_t *options,
+void MORSE_TASK_zlag2c(const MORSE_option_t *options,
                        int m, int n, int nb,
                        const MORSE_desc_t *A, int Am, int An, int lda,
                        const MORSE_desc_t *B, int Bm, int Bn, int ldb)
 {
-    QUARK_Insert_Task(opt->quark, CORE_clag2z_quark, (Quark_Task_Flags*)opt,
-        sizeof(int),                        &m,     VALUE,
-        sizeof(int),                        &n,     VALUE,
-        sizeof(MORSE_Complex32_t)*nb*nb,    RTBLKADDR(A, MORSE_Complex32_t, Am, An),             INPUT,
-        sizeof(int),                        &lda,   VALUE,
-        sizeof(MORSE_Complex64_t)*nb*nb,    RTBLKADDR(B, MORSE_Complex64_t, Bm, Bn),             INOUT,
-        sizeof(int),                        &ldb,   VALUE,
-        0);
+    quark_option_t *opt = (quark_option_t*)(options->schedopt);
+    DAG_CORE_LAG2C;
+    QUARK_Insert_Task(opt->quark, CORE_zlag2c_quark, (Quark_Task_Flags*)opt,
+                      sizeof(int),                        &m,         VALUE,
+                      sizeof(int),                        &n,         VALUE,
+                      sizeof(MORSE_Complex64_t)*nb*nb,    RTBLKADDR(A, MORSE_Complex64_t, Am, An),                 INPUT,
+                      sizeof(int),                        &lda,       VALUE,
+                      sizeof(MORSE_Complex32_t)*nb*nb,    RTBLKADDR(B, MORSE_Complex32_t, Bm, Bn),                 OUTPUT,
+                      sizeof(int),                        &ldb,       VALUE,
+                      sizeof(MORSE_sequence_t*),           &(options->sequence),  VALUE,
+                      sizeof(MORSE_request_t*),            &(options->request),   VALUE,
+                      0);
 }
 
-
 void CORE_clag2z_quark(Quark *quark)
 {
     int m;
@@ -108,3 +80,17 @@ void CORE_clag2z_quark(Quark *quark)
     CORE_clag2z( m, n, A, lda, B, ldb);
 }
 
+void MORSE_TASK_clag2z(const MORSE_option_t *options,
+                       int m, int n, int nb,
+                       const MORSE_desc_t *A, int Am, int An, int lda,
+                       const MORSE_desc_t *B, int Bm, int Bn, int ldb)
+{
+    QUARK_Insert_Task(opt->quark, CORE_clag2z_quark, (Quark_Task_Flags*)opt,
+                      sizeof(int),                        &m,     VALUE,
+                      sizeof(int),                        &n,     VALUE,
+                      sizeof(MORSE_Complex32_t)*nb*nb,    RTBLKADDR(A, MORSE_Complex32_t, Am, An),             INPUT,
+                      sizeof(int),                        &lda,   VALUE,
+                      sizeof(MORSE_Complex64_t)*nb*nb,    RTBLKADDR(B, MORSE_Complex64_t, Bm, Bn),             INOUT,
+                      sizeof(int),                        &ldb,   VALUE,
+                      0);
+}
diff --git a/runtime/quark/codelets/codelet_zlange.c b/runtime/quark/codelets/codelet_zlange.c
index e3a6b92ec..f492d7eaa 100644
--- a/runtime/quark/codelets/codelet_zlange.c
+++ b/runtime/quark/codelets/codelet_zlange.c
@@ -27,7 +27,22 @@
  *
  **/
 
-#include "runtime/quark/include/morse_quark.h"
+#include "chameleon_quark.h"
+#include "chameleon/morse_tasks_z.h"
+
+void CORE_zlange_quark(Quark *quark)
+{
+    double *normA;
+    MORSE_enum norm;
+    int M;
+    int N;
+    MORSE_Complex64_t *A;
+    int LDA;
+    double *work;
+
+    quark_unpack_args_7(quark, norm, M, N, A, LDA, work, normA);
+    CORE_zlange( norm, M, N, A, LDA, work, normA);
+}
 
 void MORSE_TASK_zlange(const MORSE_option_t *options,
                        MORSE_enum norm, int M, int N, int NB,
@@ -49,21 +64,16 @@ void MORSE_TASK_zlange(const MORSE_option_t *options,
         0);
 }
 
-void CORE_zlange_quark(Quark *quark)
+void CORE_zlange_max_quark(Quark *quark)
 {
+    double *A;
     double *normA;
-    MORSE_enum norm;
-    int M;
-    int N;
-    MORSE_Complex64_t *A;
-    int LDA;
-    double *work;
 
-    quark_unpack_args_7(quark, norm, M, N, A, LDA, work, normA);
-    CORE_zlange( norm, M, N, A, LDA, work, normA);
+    quark_unpack_args_2(quark, A, normA);
+    if ( A[0] > *normA )
+        *normA = A[0];
 }
 
-
 void MORSE_TASK_zlange_max(const MORSE_option_t *options,
                            const MORSE_desc_t *A, int Am, int An,
                            const MORSE_desc_t *B, int Bm, int Bn)
@@ -77,14 +87,3 @@ void MORSE_TASK_zlange_max(const MORSE_option_t *options,
         0);
 }
 
-
-void CORE_zlange_max_quark(Quark *quark)
-{
-    double *A;
-    double *normA;
-
-    quark_unpack_args_2(quark, A, normA);
-    if ( A[0] > *normA )
-        *normA = A[0];
-}
-
diff --git a/runtime/quark/codelets/codelet_zlanhe.c b/runtime/quark/codelets/codelet_zlanhe.c
index 70ab4cf8f..82e6bbdd2 100644
--- a/runtime/quark/codelets/codelet_zlanhe.c
+++ b/runtime/quark/codelets/codelet_zlanhe.c
@@ -27,7 +27,22 @@
  *
  **/
 
-#include "runtime/quark/include/morse_quark.h"
+#include "chameleon_quark.h"
+#include "chameleon/morse_tasks_z.h"
+
+void CORE_zlanhe_quark(Quark *quark)
+{
+    double *normA;
+    MORSE_enum norm;
+    MORSE_enum uplo;
+    int N;
+    MORSE_Complex64_t *A;
+    int LDA;
+    double *work;
+
+    quark_unpack_args_7(quark, norm, uplo, N, A, LDA, work, normA);
+    CORE_zlanhe( norm, uplo, N, A, LDA, work, normA);
+}
 
 void MORSE_TASK_zlanhe(const MORSE_option_t *options,
                        MORSE_enum norm, MORSE_enum uplo, int N, int NB,
@@ -48,17 +63,3 @@ void MORSE_TASK_zlanhe(const MORSE_option_t *options,
         sizeof(double),                  RTBLKADDR(B, double, Bm, Bn), OUTPUT,
         0);
 }
-
-void CORE_zlanhe_quark(Quark *quark)
-{
-    double *normA;
-    MORSE_enum norm;
-    MORSE_enum uplo;
-    int N;
-    MORSE_Complex64_t *A;
-    int LDA;
-    double *work;
-
-    quark_unpack_args_7(quark, norm, uplo, N, A, LDA, work, normA);
-    CORE_zlanhe( norm, uplo, N, A, LDA, work, normA);
-}
diff --git a/runtime/quark/codelets/codelet_zlansy.c b/runtime/quark/codelets/codelet_zlansy.c
index 43e2132e1..c1d7f5020 100644
--- a/runtime/quark/codelets/codelet_zlansy.c
+++ b/runtime/quark/codelets/codelet_zlansy.c
@@ -27,7 +27,22 @@
  *
  **/
 
-#include "runtime/quark/include/morse_quark.h"
+#include "chameleon_quark.h"
+#include "chameleon/morse_tasks_z.h"
+
+void CORE_zlansy_quark(Quark *quark)
+{
+    double *normA;
+    int norm;
+    MORSE_enum uplo;
+    int N;
+    MORSE_Complex64_t *A;
+    int LDA;
+    double *work;
+
+    quark_unpack_args_7(quark, norm, uplo, N, A, LDA, work, normA);
+    CORE_zlansy( norm, uplo, N, A, LDA, work, normA);
+}
 
 void MORSE_TASK_zlansy(const MORSE_option_t *options,
                        MORSE_enum norm, MORSE_enum uplo, int N, int NB,
@@ -48,17 +63,3 @@ void MORSE_TASK_zlansy(const MORSE_option_t *options,
         sizeof(double),                  RTBLKADDR(B, double, Bm, Bn), OUTPUT,
         0);
 }
-
-void CORE_zlansy_quark(Quark *quark)
-{
-    double *normA;
-    int norm;
-    MORSE_enum uplo;
-    int N;
-    MORSE_Complex64_t *A;
-    int LDA;
-    double *work;
-
-    quark_unpack_args_7(quark, norm, uplo, N, A, LDA, work, normA);
-    CORE_zlansy( norm, uplo, N, A, LDA, work, normA);
-}
diff --git a/runtime/quark/codelets/codelet_zlantr.c b/runtime/quark/codelets/codelet_zlantr.c
index a6d0009b5..839692464 100644
--- a/runtime/quark/codelets/codelet_zlantr.c
+++ b/runtime/quark/codelets/codelet_zlantr.c
@@ -24,7 +24,22 @@
  * @precisions normal z -> c d s
  *
  **/
-#include "runtime/quark/include/morse_quark.h"
+#include "chameleon_quark.h"
+#include "chameleon/morse_tasks_z.h"
+
+void CORE_zlantr_quark(Quark *quark)
+{
+    double *normA;
+    MORSE_enum norm, uplo, diag;
+    int M;
+    int N;
+    MORSE_Complex64_t *A;
+    int LDA;
+    double *work;
+
+    quark_unpack_args_9(quark, norm, uplo, diag, M, N, A, LDA, work, normA);
+    CORE_zlantr( norm, uplo, diag, M, N, A, LDA, work, normA);
+}
 
 void MORSE_TASK_zlantr(const MORSE_option_t *options,
                        MORSE_enum norm, MORSE_enum uplo, MORSE_enum diag,
@@ -48,17 +63,3 @@ void MORSE_TASK_zlantr(const MORSE_option_t *options,
         sizeof(double),                  RTBLKADDR(B, double, Bm, Bn), OUTPUT,
         0);
 }
-
-void CORE_zlantr_quark(Quark *quark)
-{
-    double *normA;
-    MORSE_enum norm, uplo, diag;
-    int M;
-    int N;
-    MORSE_Complex64_t *A;
-    int LDA;
-    double *work;
-
-    quark_unpack_args_9(quark, norm, uplo, diag, M, N, A, LDA, work, normA);
-    CORE_zlantr( norm, uplo, diag, M, N, A, LDA, work, normA);
-}
diff --git a/runtime/quark/codelets/codelet_zlascal.c b/runtime/quark/codelets/codelet_zlascal.c
index 747695ef4..0ec86aebb 100644
--- a/runtime/quark/codelets/codelet_zlascal.c
+++ b/runtime/quark/codelets/codelet_zlascal.c
@@ -29,13 +29,9 @@
  *
  **/
 
-#include "runtime/quark/include/morse_quark.h"
+#include "chameleon_quark.h"
+#include "chameleon/morse_tasks_z.h"
 
-/***************************************************************************//**
- *
- * @ingroup CORE_MORSE_Complex64_t
- *
- **/
 static inline void CORE_zlascal_quark(Quark *quark)
 {
     MORSE_enum uplo;
diff --git a/runtime/quark/codelets/codelet_zlaset.c b/runtime/quark/codelets/codelet_zlaset.c
index dfa4b0279..ee4da1eba 100644
--- a/runtime/quark/codelets/codelet_zlaset.c
+++ b/runtime/quark/codelets/codelet_zlaset.c
@@ -28,8 +28,22 @@
  *
  **/
 
-#include "runtime/quark/include/morse_quark.h"
+#include "chameleon_quark.h"
+#include "chameleon/morse_tasks_z.h"
 
+void CORE_zlaset_quark(Quark *quark)
+{
+    MORSE_enum uplo;
+    int M;
+    int N;
+    MORSE_Complex64_t alpha;
+    MORSE_Complex64_t beta;
+    MORSE_Complex64_t *A;
+    int LDA;
+
+    quark_unpack_args_7(quark, uplo, M, N, alpha, beta, A, LDA);
+    CORE_zlaset(uplo, M, N, alpha, beta, A, LDA);
+}
 
 /**
  *
@@ -66,7 +80,6 @@
  *         The leading dimension of the array A.  LDA >= max(1,M).
  *
  **/
-
 void MORSE_TASK_zlaset(const MORSE_option_t *options,
                        MORSE_enum uplo, int M, int N,
                        MORSE_Complex64_t alpha, MORSE_Complex64_t beta,
@@ -84,18 +97,3 @@ void MORSE_TASK_zlaset(const MORSE_option_t *options,
         sizeof(int),                        &LDA,   VALUE,
         0);
 }
-
-
-void CORE_zlaset_quark(Quark *quark)
-{
-    MORSE_enum uplo;
-    int M;
-    int N;
-    MORSE_Complex64_t alpha;
-    MORSE_Complex64_t beta;
-    MORSE_Complex64_t *A;
-    int LDA;
-
-    quark_unpack_args_7(quark, uplo, M, N, alpha, beta, A, LDA);
-    CORE_zlaset(uplo, M, N, alpha, beta, A, LDA);
-}
diff --git a/runtime/quark/codelets/codelet_zlaset2.c b/runtime/quark/codelets/codelet_zlaset2.c
index 4195739b1..c816bcadc 100644
--- a/runtime/quark/codelets/codelet_zlaset2.c
+++ b/runtime/quark/codelets/codelet_zlaset2.c
@@ -28,8 +28,21 @@
  *
  **/
 
-#include "runtime/quark/include/morse_quark.h"
+#include "chameleon_quark.h"
+#include "chameleon/morse_tasks_z.h"
 
+void CORE_zlaset2_quark(Quark *quark)
+{
+    MORSE_enum uplo;
+    int M;
+    int N;
+    MORSE_Complex64_t alpha;
+    MORSE_Complex64_t *A;
+    int LDA;
+
+    quark_unpack_args_6(quark, uplo, M, N, alpha, A, LDA);
+    CORE_zlaset2(uplo, M, N, alpha, A, LDA);
+}
 
 /**
  *
@@ -80,17 +93,3 @@ void MORSE_TASK_zlaset2(const MORSE_option_t *options,
         sizeof(int),                        &LDA,   VALUE,
         0);
 }
-
-
-void CORE_zlaset2_quark(Quark *quark)
-{
-    MORSE_enum uplo;
-    int M;
-    int N;
-    MORSE_Complex64_t alpha;
-    MORSE_Complex64_t *A;
-    int LDA;
-
-    quark_unpack_args_6(quark, uplo, M, N, alpha, A, LDA);
-    CORE_zlaset2(uplo, M, N, alpha, A, LDA);
-}
diff --git a/runtime/quark/codelets/codelet_zlatro.c b/runtime/quark/codelets/codelet_zlatro.c
index 342f1b430..c6e4406fc 100644
--- a/runtime/quark/codelets/codelet_zlatro.c
+++ b/runtime/quark/codelets/codelet_zlatro.c
@@ -21,8 +21,8 @@
  * @precisions normal z -> c d s
  *
  **/
-#include "runtime/quark/include/morse_quark.h"
-
+#include "chameleon_quark.h"
+#include "chameleon/morse_tasks_z.h"
 
 void CORE_zlatro_quark(Quark *quark)
 {
@@ -39,9 +39,6 @@ void CORE_zlatro_quark(Quark *quark)
     CORE_zlatro(uplo, trans, M, N, A, LDA, B, LDB);
 }
 
-/***************************************************************************//**
- *
- **/
 void MORSE_TASK_zlatro(const MORSE_option_t *options,
                        MORSE_enum uplo, MORSE_enum trans,
                        int m, int n, int mb,
diff --git a/runtime/quark/codelets/codelet_zlauum.c b/runtime/quark/codelets/codelet_zlauum.c
index 1a47efcec..1437ad52a 100644
--- a/runtime/quark/codelets/codelet_zlauum.c
+++ b/runtime/quark/codelets/codelet_zlauum.c
@@ -29,13 +29,19 @@
  *
  **/
 
-#include "runtime/quark/include/morse_quark.h"
+#include "chameleon_quark.h"
+#include "chameleon/morse_tasks_z.h"
 
-/***************************************************************************//**
- *
- * @ingroup CORE_MORSE_Complex64_t
- *
- **/
+void CORE_zlauum_quark(Quark *quark)
+{
+    MORSE_enum uplo;
+    int N;
+    MORSE_Complex64_t *A;
+    int LDA;
+
+    quark_unpack_args_4(quark, uplo, N, A, LDA);
+    CORE_zlauum(uplo, N, A, LDA);
+}
 
 void MORSE_TASK_zlauum(const MORSE_option_t *options,
                        MORSE_enum uplo, int n, int nb,
@@ -50,15 +56,3 @@ void MORSE_TASK_zlauum(const MORSE_option_t *options,
         sizeof(int),                        &lda,   VALUE,
         0);
 }
-
-
-void CORE_zlauum_quark(Quark *quark)
-{
-    MORSE_enum uplo;
-    int N;
-    MORSE_Complex64_t *A;
-    int LDA;
-
-    quark_unpack_args_4(quark, uplo, N, A, LDA);
-    CORE_zlauum(uplo, N, A, LDA);
-}
diff --git a/runtime/quark/codelets/codelet_zpamm.c b/runtime/quark/codelets/codelet_zpamm.c
index dcf944d4f..830f78d8d 100644
--- a/runtime/quark/codelets/codelet_zpamm.c
+++ b/runtime/quark/codelets/codelet_zpamm.c
@@ -28,10 +28,35 @@
  *
  **/
 #include "coreblas/cblas.h"
+#include "chameleon_quark.h"
+#include "chameleon/morse_tasks_z.h"
 
-#include "runtime/quark/include/morse_quark.h"
+void
+CORE_zpamm_quark(Quark *quark)
+{
+    int op;
+    MORSE_enum side;
+    int storev;
+    int M;
+    int N;
+    int K;
+    int L;
+    MORSE_Complex64_t *A1;
+    int LDA1;
+    MORSE_Complex64_t *A2;
+    int LDA2;
+    MORSE_Complex64_t *V;
+    int LDV;
+    MORSE_Complex64_t *W;
+    int LDW;
+
+    quark_unpack_args_15(quark, op, side, storev, M, N, K, L,
+            A1, LDA1, A2, LDA2, V, LDV, W, LDW);
 
-/***************************************************************************//**
+    CORE_zpamm( op, side, storev, M, N, K, L, A1, LDA1, A2, LDA2, V, LDV, W, LDW);
+}
+
+/**
  *
  * @ingroup CORE_MORSE_Complex64_t
  *
@@ -171,11 +196,6 @@
  *          \retval <0 if -i, the i-th argument had an illegal value
  *
  ******************************************************************************/
-
-
-/***************************************************************************/
-
-
 void
 MORSE_TASK_zpamm(const MORSE_option_t *options,
                  int op, MORSE_enum side, int storev,
@@ -203,29 +223,3 @@ MORSE_TASK_zpamm(const MORSE_option_t *options,
         sizeof(int),                        &ldw,     VALUE,
         0);
 }
-
-void
-CORE_zpamm_quark(Quark *quark)
-{
-    int op;
-    MORSE_enum side;
-    int storev;
-    int M;
-    int N;
-    int K;
-    int L;
-    MORSE_Complex64_t *A1;
-    int LDA1;
-    MORSE_Complex64_t *A2;
-    int LDA2;
-    MORSE_Complex64_t *V;
-    int LDV;
-    MORSE_Complex64_t *W;
-    int LDW;
-
-    quark_unpack_args_15(quark, op, side, storev, M, N, K, L,
-            A1, LDA1, A2, LDA2, V, LDV, W, LDW);
-
-    CORE_zpamm( op, side, storev, M, N, K, L, A1, LDA1, A2, LDA2, V, LDV, W, LDW);
-}
-
diff --git a/runtime/quark/codelets/codelet_zplghe.c b/runtime/quark/codelets/codelet_zplghe.c
index 42f7f353b..7b861fcac 100644
--- a/runtime/quark/codelets/codelet_zplghe.c
+++ b/runtime/quark/codelets/codelet_zplghe.c
@@ -28,9 +28,24 @@
  * @precisions normal z -> c
  *
  **/
-#include "runtime/quark/include/morse_quark.h"
+#include "chameleon_quark.h"
+#include "chameleon/morse_tasks_z.h"
 
+void CORE_zplghe_quark(Quark *quark)
+{
+    double bump;
+    int m;
+    int n;
+    MORSE_Complex64_t *A;
+    int lda;
+    int bigM;
+    int m0;
+    int n0;
+    unsigned long long int seed;
 
+    quark_unpack_args_9( quark, bump, m, n, A, lda, bigM, m0, n0, seed );
+    CORE_zplghe( bump, m, n, A, lda, bigM, m0, n0, seed );
+}
 
 void MORSE_TASK_zplghe( const MORSE_option_t *options,
                         double bump, int m, int n, const MORSE_desc_t *A, int Am, int An, int lda,
@@ -50,21 +65,3 @@ void MORSE_TASK_zplghe( const MORSE_option_t *options,
         sizeof(unsigned long long int),   &seed, VALUE,
         0);
 }
-
-
-void CORE_zplghe_quark(Quark *quark)
-{
-    double bump;
-    int m;
-    int n;
-    MORSE_Complex64_t *A;
-    int lda;
-    int bigM;
-    int m0;
-    int n0;
-    unsigned long long int seed;
-
-    quark_unpack_args_9( quark, bump, m, n, A, lda, bigM, m0, n0, seed );
-    CORE_zplghe( bump, m, n, A, lda, bigM, m0, n0, seed );
-}
-
diff --git a/runtime/quark/codelets/codelet_zplgsy.c b/runtime/quark/codelets/codelet_zplgsy.c
index f454988bd..46dd487ce 100644
--- a/runtime/quark/codelets/codelet_zplgsy.c
+++ b/runtime/quark/codelets/codelet_zplgsy.c
@@ -28,9 +28,24 @@
  * @precisions normal z -> c d s
  *
  **/
-#include "runtime/quark/include/morse_quark.h"
+#include "chameleon_quark.h"
+#include "chameleon/morse_tasks_z.h"
 
+void CORE_zplgsy_quark(Quark *quark)
+{
+    MORSE_Complex64_t bump;
+    int m;
+    int n;
+    MORSE_Complex64_t *A;
+    int lda;
+    int bigM;
+    int m0;
+    int n0;
+    unsigned long long int seed;
 
+    quark_unpack_args_9( quark, bump, m, n, A, lda, bigM, m0, n0, seed );
+    CORE_zplgsy( bump, m, n, A, lda, bigM, m0, n0, seed );
+}
 
 void MORSE_TASK_zplgsy( const MORSE_option_t *options,
                         MORSE_Complex64_t bump, int m, int n, const MORSE_desc_t *A, int Am, int An, int lda,
@@ -50,21 +65,3 @@ void MORSE_TASK_zplgsy( const MORSE_option_t *options,
         sizeof(unsigned long long int),   &seed, VALUE,
         0);
 }
-
-
-void CORE_zplgsy_quark(Quark *quark)
-{
-    MORSE_Complex64_t bump;
-    int m;
-    int n;
-    MORSE_Complex64_t *A;
-    int lda;
-    int bigM;
-    int m0;
-    int n0;
-    unsigned long long int seed;
-
-    quark_unpack_args_9( quark, bump, m, n, A, lda, bigM, m0, n0, seed );
-    CORE_zplgsy( bump, m, n, A, lda, bigM, m0, n0, seed );
-}
-
diff --git a/runtime/quark/codelets/codelet_zplrnt.c b/runtime/quark/codelets/codelet_zplrnt.c
index 3c01d78c2..5f5288493 100644
--- a/runtime/quark/codelets/codelet_zplrnt.c
+++ b/runtime/quark/codelets/codelet_zplrnt.c
@@ -28,9 +28,23 @@
  * @precisions normal z -> c d s
  *
  **/
-#include "runtime/quark/include/morse_quark.h"
+#include "chameleon_quark.h"
+#include "chameleon/morse_tasks_z.h"
 
+void CORE_zplrnt_quark(Quark *quark)
+{
+    int m;
+    int n;
+    MORSE_Complex64_t *A;
+    int lda;
+    int bigM;
+    int m0;
+    int n0;
+    unsigned long long int seed;
 
+    quark_unpack_args_8( quark, m, n, A, lda, bigM, m0, n0, seed );
+    CORE_zplrnt( m, n, A, lda, bigM, m0, n0, seed );
+}
 
 void MORSE_TASK_zplrnt( const MORSE_option_t *options,
                         int m, int n, const MORSE_desc_t *A, int Am, int An, int lda,
@@ -49,20 +63,3 @@ void MORSE_TASK_zplrnt( const MORSE_option_t *options,
         sizeof(unsigned long long int),   &seed, VALUE,
         0);
 }
-
-
-void CORE_zplrnt_quark(Quark *quark)
-{
-    int m;
-    int n;
-    MORSE_Complex64_t *A;
-    int lda;
-    int bigM;
-    int m0;
-    int n0;
-    unsigned long long int seed;
-
-    quark_unpack_args_8( quark, m, n, A, lda, bigM, m0, n0, seed );
-    CORE_zplrnt( m, n, A, lda, bigM, m0, n0, seed );
-}
-
diff --git a/runtime/quark/codelets/codelet_zplssq.c b/runtime/quark/codelets/codelet_zplssq.c
index a838cbbf0..e08ea2b0e 100644
--- a/runtime/quark/codelets/codelet_zplssq.c
+++ b/runtime/quark/codelets/codelet_zplssq.c
@@ -25,7 +25,23 @@
  *
  **/
 #include <math.h>
-#include "runtime/quark/include/morse_quark.h"
+#include "chameleon_quark.h"
+#include "chameleon/morse_tasks_z.h"
+
+void CORE_zplssq_quark(Quark *quark)
+{
+    double *SCALESUMSQ;
+    double *SCLSSQ;
+
+    quark_unpack_args_2( quark, SCALESUMSQ, SCLSSQ );
+
+    if( SCLSSQ[0] < SCALESUMSQ[0] ) {
+        SCLSSQ[1] = SCALESUMSQ[1] + (SCLSSQ[1]     * (( SCLSSQ[0] / SCALESUMSQ[0] ) * ( SCLSSQ[0] / SCALESUMSQ[0] )));
+        SCLSSQ[0] = SCALESUMSQ[0];
+    } else {
+        SCLSSQ[1] = SCLSSQ[1]     + (SCALESUMSQ[1] * (( SCALESUMSQ[0] / SCLSSQ[0] ) * ( SCALESUMSQ[0] / SCLSSQ[0] )));
+    }
+}
 
 /*****************************************************************************
  *
@@ -70,19 +86,12 @@ void MORSE_TASK_zplssq( const MORSE_option_t *options,
 }
 
 
-void CORE_zplssq_quark(Quark *quark)
+void CORE_zplssq2_quark(Quark *quark)
 {
-    double *SCALESUMSQ;
-    double *SCLSSQ;
-
-    quark_unpack_args_2( quark, SCALESUMSQ, SCLSSQ );
+    double *RESULT;
 
-    if( SCLSSQ[0] < SCALESUMSQ[0] ) {
-        SCLSSQ[1] = SCALESUMSQ[1] + (SCLSSQ[1]     * (( SCLSSQ[0] / SCALESUMSQ[0] ) * ( SCLSSQ[0] / SCALESUMSQ[0] )));
-        SCLSSQ[0] = SCALESUMSQ[0];
-    } else {
-        SCLSSQ[1] = SCLSSQ[1]     + (SCALESUMSQ[1] * (( SCALESUMSQ[0] / SCLSSQ[0] ) * ( SCALESUMSQ[0] / SCLSSQ[0] )));
-    }
+    quark_unpack_args_1( quark, RESULT );
+    RESULT[0] = RESULT[0] * sqrt( RESULT[1] );
 }
 
 void MORSE_TASK_zplssq2( const MORSE_option_t *options,
@@ -93,12 +102,3 @@ void MORSE_TASK_zplssq2( const MORSE_option_t *options,
         sizeof(double)*2, RTBLKADDR(RESULT, double, RESULTm, RESULTn), INOUT,
         0);
 }
-
-
-void CORE_zplssq2_quark(Quark *quark)
-{
-    double *RESULT;
-
-    quark_unpack_args_1( quark, RESULT );
-    RESULT[0] = RESULT[0] * sqrt( RESULT[1] );
-}
diff --git a/runtime/quark/codelets/codelet_zpotrf.c b/runtime/quark/codelets/codelet_zpotrf.c
index e90669e83..6b09e1575 100644
--- a/runtime/quark/codelets/codelet_zpotrf.c
+++ b/runtime/quark/codelets/codelet_zpotrf.c
@@ -28,33 +28,8 @@
  * @precisions normal z -> c d s
  *
  **/
-
-#include "runtime/quark/include/morse_quark.h"
-
-/***************************************************************************//**
- *
- * @ingroup CORE_MORSE_Complex64_t
- *
- **/
-
-void MORSE_TASK_zpotrf(const MORSE_option_t *options,
-                       MORSE_enum uplo, int n, int nb,
-                       const MORSE_desc_t *A, int Am, int An, int lda,
-                       int iinfo)
-{
-    quark_option_t *opt = (quark_option_t*)(options->schedopt);
-    DAG_CORE_POTRF;
-    QUARK_Insert_Task(opt->quark, CORE_zpotrf_quark, (Quark_Task_Flags*)opt,
-        sizeof(MORSE_enum),                &uplo,      VALUE,
-        sizeof(int),                        &n,         VALUE,
-        sizeof(MORSE_Complex64_t)*nb*nb,    RTBLKADDR(A, MORSE_Complex64_t, Am, An),                 INOUT,
-        sizeof(int),                        &lda,       VALUE,
-        sizeof(MORSE_sequence_t*),           &(options->sequence),  VALUE,
-        sizeof(MORSE_request_t*),            &(options->request),   VALUE,
-        sizeof(int),                        &iinfo,     VALUE,
-        0);
-}
-
+#include "chameleon_quark.h"
+#include "chameleon/morse_tasks_z.h"
 
 void CORE_zpotrf_quark(Quark *quark)
 {
@@ -73,3 +48,21 @@ void CORE_zpotrf_quark(Quark *quark)
     if (sequence->status == MORSE_SUCCESS && info != 0)
         RUNTIME_sequence_flush(quark, sequence, request, iinfo+info);
 }
+
+void MORSE_TASK_zpotrf(const MORSE_option_t *options,
+                       MORSE_enum uplo, int n, int nb,
+                       const MORSE_desc_t *A, int Am, int An, int lda,
+                       int iinfo)
+{
+    quark_option_t *opt = (quark_option_t*)(options->schedopt);
+    DAG_CORE_POTRF;
+    QUARK_Insert_Task(opt->quark, CORE_zpotrf_quark, (Quark_Task_Flags*)opt,
+                      sizeof(MORSE_enum),                &uplo,      VALUE,
+                      sizeof(int),                        &n,         VALUE,
+                      sizeof(MORSE_Complex64_t)*nb*nb,    RTBLKADDR(A, MORSE_Complex64_t, Am, An),                 INOUT,
+                      sizeof(int),                        &lda,       VALUE,
+                      sizeof(MORSE_sequence_t*),           &(options->sequence),  VALUE,
+                      sizeof(MORSE_request_t*),            &(options->request),   VALUE,
+                      sizeof(int),                        &iinfo,     VALUE,
+                      0);
+}
diff --git a/runtime/quark/codelets/codelet_zssssm.c b/runtime/quark/codelets/codelet_zssssm.c
index 25466a851..33289267d 100644
--- a/runtime/quark/codelets/codelet_zssssm.c
+++ b/runtime/quark/codelets/codelet_zssssm.c
@@ -29,7 +29,30 @@
  *
  **/
 #include "coreblas/cblas.h"
-#include "runtime/quark/include/morse_quark.h"
+#include "chameleon_quark.h"
+#include "chameleon/morse_tasks_z.h"
+
+void CORE_zssssm_quark(Quark *quark)
+{
+    int m1;
+    int n1;
+    int m2;
+    int n2;
+    int k;
+    int ib;
+    MORSE_Complex64_t *A1;
+    int lda1;
+    MORSE_Complex64_t *A2;
+    int lda2;
+    MORSE_Complex64_t *L1;
+    int ldl1;
+    MORSE_Complex64_t *L2;
+    int ldl2;
+    int *IPIV;
+
+    quark_unpack_args_15(quark, m1, n1, m2, n2, k, ib, A1, lda1, A2, lda2, L1, ldl1, L2, ldl2, IPIV);
+    CORE_zssssm(m1, n1, m2, n2, k, ib, A1, lda1, A2, lda2, L1, ldl1, L2, ldl2, IPIV);
+}
 
 /***************************************************************************//**
  *
@@ -101,7 +124,6 @@
  *         \retval <0 if INFO = -k, the k-th argument had an illegal value
  *
  ******************************************************************************/
-
 void MORSE_TASK_zssssm(const MORSE_option_t *options,
                        int m1, int n1, int m2, int n2, int k, int ib, int nb,
                        const MORSE_desc_t *A1, int A1m, int A1n, int lda1,
@@ -130,26 +152,3 @@ void MORSE_TASK_zssssm(const MORSE_option_t *options,
         sizeof(int)*nb,                      IPIV,          INPUT,
         0);
 }
-
-
-void CORE_zssssm_quark(Quark *quark)
-{
-    int m1;
-    int n1;
-    int m2;
-    int n2;
-    int k;
-    int ib;
-    MORSE_Complex64_t *A1;
-    int lda1;
-    MORSE_Complex64_t *A2;
-    int lda2;
-    MORSE_Complex64_t *L1;
-    int ldl1;
-    MORSE_Complex64_t *L2;
-    int ldl2;
-    int *IPIV;
-
-    quark_unpack_args_15(quark, m1, n1, m2, n2, k, ib, A1, lda1, A2, lda2, L1, ldl1, L2, ldl2, IPIV);
-    CORE_zssssm(m1, n1, m2, n2, k, ib, A1, lda1, A2, lda2, L1, ldl1, L2, ldl2, IPIV);
-}
diff --git a/runtime/quark/codelets/codelet_zsymm.c b/runtime/quark/codelets/codelet_zsymm.c
index ff980afb2..eb05b3ccb 100644
--- a/runtime/quark/codelets/codelet_zsymm.c
+++ b/runtime/quark/codelets/codelet_zsymm.c
@@ -28,13 +28,31 @@
  * @precisions normal z -> c d s
  *
  **/
-#include "runtime/quark/include/morse_quark.h"
+#include "chameleon_quark.h"
+#include "chameleon/morse_tasks_z.h"
 
-/***************************************************************************//**
- *
- * @ingroup CORE_MORSE_Complex64_t
- *
- **/
+void CORE_zsymm_quark(Quark *quark)
+{
+    MORSE_enum side;
+    MORSE_enum uplo;
+    int M;
+    int N;
+    MORSE_Complex64_t alpha;
+    MORSE_Complex64_t *A;
+    int LDA;
+    MORSE_Complex64_t *B;
+    int LDB;
+    MORSE_Complex64_t beta;
+    MORSE_Complex64_t *C;
+    int LDC;
+
+    quark_unpack_args_12(quark, side, uplo, M, N, alpha, A, LDA, B, LDB, beta, C, LDC);
+    CORE_zsymm(side, uplo,
+        M, N,
+        alpha, A, LDA,
+        B, LDB,
+        beta, C, LDC);
+}
 
 void MORSE_TASK_zsymm(const MORSE_option_t *options,
                       MORSE_enum side, MORSE_enum uplo,
@@ -60,27 +78,3 @@ void MORSE_TASK_zsymm(const MORSE_option_t *options,
         sizeof(int),                        &ldc,     VALUE,
         0);
 }
-
-
-void CORE_zsymm_quark(Quark *quark)
-{
-    MORSE_enum side;
-    MORSE_enum uplo;
-    int M;
-    int N;
-    MORSE_Complex64_t alpha;
-    MORSE_Complex64_t *A;
-    int LDA;
-    MORSE_Complex64_t *B;
-    int LDB;
-    MORSE_Complex64_t beta;
-    MORSE_Complex64_t *C;
-    int LDC;
-
-    quark_unpack_args_12(quark, side, uplo, M, N, alpha, A, LDA, B, LDB, beta, C, LDC);
-    CORE_zsymm(side, uplo,
-        M, N,
-        alpha, A, LDA,
-        B, LDB,
-        beta, C, LDC);
-}
diff --git a/runtime/quark/codelets/codelet_zsyr2k.c b/runtime/quark/codelets/codelet_zsyr2k.c
index dac5ea842..1286c95fd 100644
--- a/runtime/quark/codelets/codelet_zsyr2k.c
+++ b/runtime/quark/codelets/codelet_zsyr2k.c
@@ -28,13 +28,28 @@
  * @precisions normal z -> c d s
  *
  **/
-#include "runtime/quark/include/morse_quark.h"
+#include "chameleon_quark.h"
+#include "chameleon/morse_tasks_z.h"
 
-/***************************************************************************//**
- *
- * @ingroup CORE_MORSE_Complex64_t
- *
- **/
+void CORE_zsyr2k_quark(Quark *quark)
+{
+    MORSE_enum uplo;
+    MORSE_enum trans;
+    int n;
+    int k;
+    MORSE_Complex64_t alpha;
+    MORSE_Complex64_t *A;
+    int lda;
+    MORSE_Complex64_t *B;
+    int ldb;
+    MORSE_Complex64_t beta;
+    MORSE_Complex64_t *C;
+    int ldc;
+
+    quark_unpack_args_12(quark, uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C, ldc);
+    CORE_zsyr2k(uplo, trans,
+                n, k, alpha, A, lda, B, ldb, beta, C, ldc);
+}
 
 void MORSE_TASK_zsyr2k(const MORSE_option_t *options,
                        MORSE_enum uplo, MORSE_enum trans,
@@ -60,24 +75,3 @@ void MORSE_TASK_zsyr2k(const MORSE_option_t *options,
         sizeof(int),                        &ldc,       VALUE,
         0);
 }
-
-
-void CORE_zsyr2k_quark(Quark *quark)
-{
-    MORSE_enum uplo;
-    MORSE_enum trans;
-    int n;
-    int k;
-    MORSE_Complex64_t alpha;
-    MORSE_Complex64_t *A;
-    int lda;
-    MORSE_Complex64_t *B;
-    int ldb;
-    MORSE_Complex64_t beta;
-    MORSE_Complex64_t *C;
-    int ldc;
-
-    quark_unpack_args_12(quark, uplo, trans, n, k, alpha, A, lda, B, ldb, beta, C, ldc);
-    CORE_zsyr2k(uplo, trans,
-                n, k, alpha, A, lda, B, ldb, beta, C, ldc);
-}
diff --git a/runtime/quark/codelets/codelet_zsyrk.c b/runtime/quark/codelets/codelet_zsyrk.c
index 8621679e6..6483481ff 100644
--- a/runtime/quark/codelets/codelet_zsyrk.c
+++ b/runtime/quark/codelets/codelet_zsyrk.c
@@ -28,13 +28,28 @@
  * @precisions normal z -> c d s
  *
  **/
-#include "runtime/quark/include/morse_quark.h"
+#include "chameleon_quark.h"
+#include "chameleon/morse_tasks_z.h"
 
-/***************************************************************************//**
- *
- * @ingroup CORE_MORSE_Complex64_t
- *
- **/
+void CORE_zsyrk_quark(Quark *quark)
+{
+    MORSE_enum uplo;
+    MORSE_enum trans;
+    int n;
+    int k;
+    MORSE_Complex64_t alpha;
+    MORSE_Complex64_t *A;
+    int lda;
+    MORSE_Complex64_t beta;
+    MORSE_Complex64_t *C;
+    int ldc;
+
+    quark_unpack_args_10(quark, uplo, trans, n, k, alpha, A, lda, beta, C, ldc);
+    CORE_zsyrk(uplo, trans,
+        n, k,
+        alpha, A, lda,
+        beta, C, ldc);
+}
 
 void MORSE_TASK_zsyrk(const MORSE_option_t *options,
                       MORSE_enum uplo, MORSE_enum trans,
@@ -57,24 +72,3 @@ void MORSE_TASK_zsyrk(const MORSE_option_t *options,
         sizeof(int),                        &ldc,       VALUE,
         0);
 }
-
-
-void CORE_zsyrk_quark(Quark *quark)
-{
-    MORSE_enum uplo;
-    MORSE_enum trans;
-    int n;
-    int k;
-    MORSE_Complex64_t alpha;
-    MORSE_Complex64_t *A;
-    int lda;
-    MORSE_Complex64_t beta;
-    MORSE_Complex64_t *C;
-    int ldc;
-
-    quark_unpack_args_10(quark, uplo, trans, n, k, alpha, A, lda, beta, C, ldc);
-    CORE_zsyrk(uplo, trans,
-        n, k,
-        alpha, A, lda,
-        beta, C, ldc);
-}
diff --git a/runtime/quark/codelets/codelet_zsyssq.c b/runtime/quark/codelets/codelet_zsyssq.c
index 5eab60ccc..d919213a5 100644
--- a/runtime/quark/codelets/codelet_zsyssq.c
+++ b/runtime/quark/codelets/codelet_zsyssq.c
@@ -24,7 +24,20 @@
  * @precisions normal z -> c d s
  *
  **/
-#include "runtime/quark/include/morse_quark.h"
+#include "chameleon_quark.h"
+#include "chameleon/morse_tasks_z.h"
+
+void CORE_zsyssq_quark(Quark *quark)
+{
+    MORSE_enum uplo;
+    int n;
+    MORSE_Complex64_t *A;
+    int lda;
+    double *SCALESUMSQ;
+
+    quark_unpack_args_5( quark, uplo, n, A, lda, SCALESUMSQ );
+    CORE_zsyssq( uplo, n, A, lda, &SCALESUMSQ[0], &SCALESUMSQ[1]);
+}
 
 void MORSE_TASK_zsyssq( const MORSE_option_t *options,
                         MORSE_enum uplo, int n,
@@ -40,16 +53,3 @@ void MORSE_TASK_zsyssq( const MORSE_option_t *options,
         sizeof(double)*2,                RTBLKADDR(SCALESUMSQ, double, SCALESUMSQm, SCALESUMSQn), INOUT,
         0);
 }
-
-
-void CORE_zsyssq_quark(Quark *quark)
-{
-    MORSE_enum uplo;
-    int n;
-    MORSE_Complex64_t *A;
-    int lda;
-    double *SCALESUMSQ;
-
-    quark_unpack_args_5( quark, uplo, n, A, lda, SCALESUMSQ );
-    CORE_zsyssq( uplo, n, A, lda, &SCALESUMSQ[0], &SCALESUMSQ[1]);
-}
diff --git a/runtime/quark/codelets/codelet_zsytrf_nopiv.c b/runtime/quark/codelets/codelet_zsytrf_nopiv.c
index 421cbae16..f2821e798 100644
--- a/runtime/quark/codelets/codelet_zsytrf_nopiv.c
+++ b/runtime/quark/codelets/codelet_zsytrf_nopiv.c
@@ -28,8 +28,25 @@
  * @precisions normal z -> c
  *
  **/
-#include "runtime/quark/include/morse_quark.h"
+#include "chameleon_quark.h"
+#include "chameleon/morse_tasks_z.h"
 
+void CORE_zsytrf_nopiv_quark(Quark *quark)
+{
+    MORSE_enum uplo;
+    int n;
+    MORSE_Complex64_t *A;
+    int lda;
+    MORSE_sequence_t *sequence;
+    MORSE_request_t *request;
+    int iinfo;
+    int info = 0;
+
+    quark_unpack_args_7(quark, uplo, n, A, lda, sequence, request, iinfo);
+    info = CORE_zsytf2_nopiv(uplo, n, A, lda);
+    if (sequence->status == MORSE_SUCCESS && info != 0)
+        RUNTIME_sequence_flush(quark, sequence, request, iinfo+info);
+}
 
 void MORSE_TASK_zsytrf_nopiv(const MORSE_option_t *options,
                              MORSE_enum uplo, int n, int nb,
@@ -48,21 +65,3 @@ void MORSE_TASK_zsytrf_nopiv(const MORSE_option_t *options,
         sizeof(int),                     &iinfo,               VALUE,
         0);
 }
-
-
-void CORE_zsytrf_nopiv_quark(Quark *quark)
-{
-    MORSE_enum uplo;
-    int n;
-    MORSE_Complex64_t *A;
-    int lda;
-    MORSE_sequence_t *sequence;
-    MORSE_request_t *request;
-    int iinfo;
-    int info = 0;
-
-    quark_unpack_args_7(quark, uplo, n, A, lda, sequence, request, iinfo);
-    info = CORE_zsytf2_nopiv(uplo, n, A, lda);
-    if (sequence->status == MORSE_SUCCESS && info != 0)
-        RUNTIME_sequence_flush(quark, sequence, request, iinfo+info);
-}
diff --git a/runtime/quark/codelets/codelet_ztile_zero.c b/runtime/quark/codelets/codelet_ztile_zero.c
index 19beb4362..f1f77319e 100644
--- a/runtime/quark/codelets/codelet_ztile_zero.c
+++ b/runtime/quark/codelets/codelet_ztile_zero.c
@@ -24,29 +24,9 @@
  * @precisions normal z -> c d s
  *
  **/
-#include "runtime/quark/include/morse_quark.h"
+#include "chameleon_quark.h"
+#include "chameleon/morse_tasks_z.h"
 
-/*****************************************************************************
- *
- **/
-void MORSE_TASK_ztile_zero(const const MORSE_option_t *options,
-                           int X1, int X2, int Y1, int Y2,
-                           const MORSE_desc_t *A, int Am, int An, int lda)
-{
-    quark_option_t *opt = (quark_option_t*)(options->schedopt);
-    QUARK_Insert_Task(opt->quark, CORE_ztile_zero_quark, (Quark_Task_Flags*)opt,
-        sizeof(int),                       &X1,                                       VALUE,
-        sizeof(int),                       &X2,                                       VALUE,
-        sizeof(int),                       &Y1,                                       VALUE,
-        sizeof(int),                       &Y2,                                       VALUE,
-        sizeof(MORSE_Complex64_t)*A->bsiz,  RTBLKADDR(A, MORSE_Complex64_t, Am, An),  OUTPUT | LOCALITY,
-        sizeof(int),                       &lda,                                      VALUE,
-        0);
-}
-
-/*****************************************************************************
- *
- **/
 void CORE_ztile_zero_quark(Quark *quark)
 {
     int X1;
@@ -65,3 +45,18 @@ void CORE_ztile_zero_quark(Quark *quark)
             A[lda*x+y] = 0.0;
 
 }
+
+void MORSE_TASK_ztile_zero(const const MORSE_option_t *options,
+                           int X1, int X2, int Y1, int Y2,
+                           const MORSE_desc_t *A, int Am, int An, int lda)
+{
+    quark_option_t *opt = (quark_option_t*)(options->schedopt);
+    QUARK_Insert_Task(opt->quark, CORE_ztile_zero_quark, (Quark_Task_Flags*)opt,
+        sizeof(int),                       &X1,                                       VALUE,
+        sizeof(int),                       &X2,                                       VALUE,
+        sizeof(int),                       &Y1,                                       VALUE,
+        sizeof(int),                       &Y2,                                       VALUE,
+        sizeof(MORSE_Complex64_t)*A->bsiz,  RTBLKADDR(A, MORSE_Complex64_t, Am, An),  OUTPUT | LOCALITY,
+        sizeof(int),                       &lda,                                      VALUE,
+        0);
+}
diff --git a/runtime/quark/codelets/codelet_ztpmqrt.c b/runtime/quark/codelets/codelet_ztpmqrt.c
index 25bd5ac83..20bddecdc 100644
--- a/runtime/quark/codelets/codelet_ztpmqrt.c
+++ b/runtime/quark/codelets/codelet_ztpmqrt.c
@@ -22,7 +22,8 @@
  * @precisions normal z -> s d c
  *
  **/
-#include "runtime/quark/include/morse_quark.h"
+#include "chameleon_quark.h"
+#include "chameleon/morse_tasks_z.h"
 
 static void
 CORE_ztpmqrt_quark( Quark *quark )
diff --git a/runtime/quark/codelets/codelet_ztpqrt.c b/runtime/quark/codelets/codelet_ztpqrt.c
index 9b7e09876..4a3a8d957 100644
--- a/runtime/quark/codelets/codelet_ztpqrt.c
+++ b/runtime/quark/codelets/codelet_ztpqrt.c
@@ -22,7 +22,8 @@
  * @precisions normal z -> s d c
  *
  **/
-#include "runtime/quark/include/morse_quark.h"
+#include "chameleon_quark.h"
+#include "chameleon/morse_tasks_z.h"
 
 static void
 CORE_ztpqrt_quark( Quark *quark )
diff --git a/runtime/quark/codelets/codelet_ztradd.c b/runtime/quark/codelets/codelet_ztradd.c
index f5b566b51..b75ea4010 100644
--- a/runtime/quark/codelets/codelet_ztradd.c
+++ b/runtime/quark/codelets/codelet_ztradd.c
@@ -24,7 +24,8 @@
  * @precisions normal z -> c d s
  *
  **/
-#include "runtime/quark/include/morse_quark.h"
+#include "chameleon_quark.h"
+#include "chameleon/morse_tasks_z.h"
 
 void CORE_ztradd_quark(Quark *quark)
 {
diff --git a/runtime/quark/codelets/codelet_ztrasm.c b/runtime/quark/codelets/codelet_ztrasm.c
index bb2a2e3bf..d2a782341 100644
--- a/runtime/quark/codelets/codelet_ztrasm.c
+++ b/runtime/quark/codelets/codelet_ztrasm.c
@@ -24,7 +24,23 @@
  * @precisions normal z -> c d s
  *
  **/
-#include "runtime/quark/include/morse_quark.h"
+#include "chameleon_quark.h"
+#include "chameleon/morse_tasks_z.h"
+
+void CORE_ztrasm_quark(Quark *quark)
+{
+    MORSE_enum storev;
+    MORSE_enum uplo;
+    MORSE_enum diag;
+    int M;
+    int N;
+    MORSE_Complex64_t *A;
+    int lda;
+    double *work;
+
+    quark_unpack_args_8(quark, storev, uplo, diag, M, N, A, lda, work);
+    CORE_ztrasm(storev, uplo, diag, M, N, A, lda, work);
+}
 
 void MORSE_TASK_ztrasm(const MORSE_option_t *options,
                        MORSE_enum storev, MORSE_enum uplo, MORSE_enum diag, int M, int N,
@@ -44,19 +60,3 @@ void MORSE_TASK_ztrasm(const MORSE_option_t *options,
         sizeof(double)*szeW,             RTBLKADDR(B, double, Bm, Bn), INOUT,
         0);
 }
-
-
-void CORE_ztrasm_quark(Quark *quark)
-{
-    MORSE_enum storev;
-    MORSE_enum uplo;
-    MORSE_enum diag;
-    int M;
-    int N;
-    MORSE_Complex64_t *A;
-    int lda;
-    double *work;
-
-    quark_unpack_args_8(quark, storev, uplo, diag, M, N, A, lda, work);
-    CORE_ztrasm(storev, uplo, diag, M, N, A, lda, work);
-}
diff --git a/runtime/quark/codelets/codelet_ztrmm.c b/runtime/quark/codelets/codelet_ztrmm.c
index c11a2d245..b85c0740c 100644
--- a/runtime/quark/codelets/codelet_ztrmm.c
+++ b/runtime/quark/codelets/codelet_ztrmm.c
@@ -28,13 +28,30 @@
  * @precisions normal z -> c d s
  *
  **/
-#include "runtime/quark/include/morse_quark.h"
+#include "chameleon_quark.h"
+#include "chameleon/morse_tasks_z.h"
 
-/***************************************************************************//**
- *
- * @ingroup CORE_MORSE_Complex64_t
- *
- **/
+void CORE_ztrmm_quark(Quark *quark)
+{
+    MORSE_enum side;
+    MORSE_enum uplo;
+    MORSE_enum transA;
+    MORSE_enum diag;
+    int M;
+    int N;
+    MORSE_Complex64_t alpha;
+    MORSE_Complex64_t *A;
+    int LDA;
+    MORSE_Complex64_t *B;
+    int LDB;
+
+    quark_unpack_args_11(quark, side, uplo, transA, diag, M, N, alpha, A, LDA, B, LDB);
+    CORE_ztrmm(side, uplo,
+        transA, diag,
+        M, N,
+        alpha, A, LDA,
+        B, LDB);
+}
 
 void MORSE_TASK_ztrmm(const MORSE_option_t *options,
                       MORSE_enum side, MORSE_enum uplo, MORSE_enum transA, MORSE_enum diag,
@@ -58,28 +75,3 @@ void MORSE_TASK_ztrmm(const MORSE_option_t *options,
         sizeof(int),                        &ldb,       VALUE,
         0);
 }
-
-
-void CORE_ztrmm_quark(Quark *quark)
-{
-    MORSE_enum side;
-    MORSE_enum uplo;
-    MORSE_enum transA;
-    MORSE_enum diag;
-    int M;
-    int N;
-    MORSE_Complex64_t alpha;
-    MORSE_Complex64_t *A;
-    int LDA;
-    MORSE_Complex64_t *B;
-    int LDB;
-
-    quark_unpack_args_11(quark, side, uplo, transA, diag, M, N, alpha, A, LDA, B, LDB);
-    CORE_ztrmm(side, uplo,
-        transA, diag,
-        M, N,
-        alpha, A, LDA,
-        B, LDB);
-}
-
-
diff --git a/runtime/quark/codelets/codelet_ztrsm.c b/runtime/quark/codelets/codelet_ztrsm.c
index c8e52c2b1..5b57184eb 100644
--- a/runtime/quark/codelets/codelet_ztrsm.c
+++ b/runtime/quark/codelets/codelet_ztrsm.c
@@ -28,13 +28,30 @@
  * @precisions normal z -> c d s
  *
  **/
-#include "runtime/quark/include/morse_quark.h"
+#include "chameleon_quark.h"
+#include "chameleon/morse_tasks_z.h"
 
-/***************************************************************************//**
- *
- * @ingroup CORE_MORSE_Complex64_t
- *
- **/
+void CORE_ztrsm_quark(Quark *quark)
+{
+    MORSE_enum side;
+    MORSE_enum uplo;
+    MORSE_enum transA;
+    MORSE_enum diag;
+    int m;
+    int n;
+    MORSE_Complex64_t alpha;
+    MORSE_Complex64_t *A;
+    int lda;
+    MORSE_Complex64_t *B;
+    int ldb;
+
+    quark_unpack_args_11(quark, side, uplo, transA, diag, m, n, alpha, A, lda, B, ldb);
+    CORE_ztrsm(side, uplo,
+        transA, diag,
+        m, n,
+        alpha, A, lda,
+        B, ldb);
+}
 
 void MORSE_TASK_ztrsm(const MORSE_option_t *options,
                       MORSE_enum side, MORSE_enum uplo, MORSE_enum transA, MORSE_enum diag,
@@ -58,26 +75,3 @@ void MORSE_TASK_ztrsm(const MORSE_option_t *options,
         sizeof(int),                        &ldb,       VALUE,
         0);
 }
-
-
-void CORE_ztrsm_quark(Quark *quark)
-{
-    MORSE_enum side;
-    MORSE_enum uplo;
-    MORSE_enum transA;
-    MORSE_enum diag;
-    int m;
-    int n;
-    MORSE_Complex64_t alpha;
-    MORSE_Complex64_t *A;
-    int lda;
-    MORSE_Complex64_t *B;
-    int ldb;
-
-    quark_unpack_args_11(quark, side, uplo, transA, diag, m, n, alpha, A, lda, B, ldb);
-    CORE_ztrsm(side, uplo,
-        transA, diag,
-        m, n,
-        alpha, A, lda,
-        B, ldb);
-}
diff --git a/runtime/quark/codelets/codelet_ztrssq.c b/runtime/quark/codelets/codelet_ztrssq.c
index 4492dbe87..df70c2201 100644
--- a/runtime/quark/codelets/codelet_ztrssq.c
+++ b/runtime/quark/codelets/codelet_ztrssq.c
@@ -24,7 +24,22 @@
  * @precisions normal z -> c d s
  *
  **/
-#include "runtime/quark/include/morse_quark.h"
+#include "chameleon_quark.h"
+#include "chameleon/morse_tasks_z.h"
+
+void CORE_ztrssq_quark(Quark *quark)
+{
+    MORSE_enum uplo;
+    MORSE_enum diag;
+    int m;
+    int n;
+    MORSE_Complex64_t *A;
+    int lda;
+    double *SCALESUMSQ;
+
+    quark_unpack_args_7( quark, uplo, diag, m, n, A, lda, SCALESUMSQ );
+    CORE_ztrssq( uplo, diag, m, n, A, lda, &SCALESUMSQ[0], &SCALESUMSQ[1]);
+}
 
 void MORSE_TASK_ztrssq( const MORSE_option_t *options,
                         MORSE_enum uplo, MORSE_enum diag,
@@ -43,18 +58,3 @@ void MORSE_TASK_ztrssq( const MORSE_option_t *options,
         sizeof(double)*2,                RTBLKADDR(SCALESUMSQ, double, SCALESUMSQm, SCALESUMSQn), INOUT,
         0);
 }
-
-
-void CORE_ztrssq_quark(Quark *quark)
-{
-    MORSE_enum uplo;
-    MORSE_enum diag;
-    int m;
-    int n;
-    MORSE_Complex64_t *A;
-    int lda;
-    double *SCALESUMSQ;
-
-    quark_unpack_args_7( quark, uplo, diag, m, n, A, lda, SCALESUMSQ );
-    CORE_ztrssq( uplo, diag, m, n, A, lda, &SCALESUMSQ[0], &SCALESUMSQ[1]);
-}
diff --git a/runtime/quark/codelets/codelet_ztrtri.c b/runtime/quark/codelets/codelet_ztrtri.c
index 963ae940e..1a9d8a6c6 100644
--- a/runtime/quark/codelets/codelet_ztrtri.c
+++ b/runtime/quark/codelets/codelet_ztrtri.c
@@ -29,13 +29,27 @@
  *
  **/
 
-#include "runtime/quark/include/morse_quark.h"
+#include "chameleon_quark.h"
+#include "chameleon/morse_tasks_z.h"
 
-/***************************************************************************//**
- *
- * @ingroup CORE_MORSE_Complex64_t
- *
- **/
+void CORE_ztrtri_quark(Quark *quark)
+{
+    MORSE_enum uplo;
+    MORSE_enum diag;
+    int N;
+    MORSE_Complex64_t *A;
+    int LDA;
+    MORSE_sequence_t *sequence;
+    MORSE_request_t *request;
+    int iinfo;
+
+    int info;
+
+    quark_unpack_args_8(quark, uplo, diag, N, A, LDA, sequence, request, iinfo);
+    CORE_ztrtri(uplo, diag, N, A, LDA, &info);
+    if ((sequence->status == MORSE_SUCCESS) && (info > 0))
+        RUNTIME_sequence_flush(quark, sequence, request, iinfo + info);
+}
 
 void MORSE_TASK_ztrtri(const MORSE_option_t *options,
                        MORSE_enum uplo, MORSE_enum diag,
@@ -56,23 +70,3 @@ void MORSE_TASK_ztrtri(const MORSE_option_t *options,
         sizeof(int),                        &iinfo,     VALUE,
         0);
 }
-
-
-void CORE_ztrtri_quark(Quark *quark)
-{
-    MORSE_enum uplo;
-    MORSE_enum diag;
-    int N;
-    MORSE_Complex64_t *A;
-    int LDA;
-    MORSE_sequence_t *sequence;
-    MORSE_request_t *request;
-    int iinfo;
-
-    int info;
-
-    quark_unpack_args_8(quark, uplo, diag, N, A, LDA, sequence, request, iinfo);
-    CORE_ztrtri(uplo, diag, N, A, LDA, &info);
-    if ((sequence->status == MORSE_SUCCESS) && (info > 0))
-        RUNTIME_sequence_flush(quark, sequence, request, iinfo + info);
-}
diff --git a/runtime/quark/codelets/codelet_ztslqt.c b/runtime/quark/codelets/codelet_ztslqt.c
index 1f2e181b7..af82add0e 100644
--- a/runtime/quark/codelets/codelet_ztslqt.c
+++ b/runtime/quark/codelets/codelet_ztslqt.c
@@ -28,8 +28,26 @@
  * @precisions normal z -> c d s
  *
  **/
+#include "chameleon_quark.h"
+#include "chameleon/morse_tasks_z.h"
 
-#include "runtime/quark/include/morse_quark.h"
+void CORE_ztslqt_quark(Quark *quark)
+{
+    int m;
+    int n;
+    int ib;
+    MORSE_Complex64_t *A1;
+    int lda1;
+    MORSE_Complex64_t *A2;
+    int lda2;
+    MORSE_Complex64_t *T;
+    int ldt;
+    MORSE_Complex64_t *TAU;
+    MORSE_Complex64_t *WORK;
+
+    quark_unpack_args_11(quark, m, n, ib, A1, lda1, A2, lda2, T, ldt, TAU, WORK);
+    CORE_ztslqt(m, n, ib, A1, lda1, A2, lda2, T, ldt, TAU, WORK);
+}
 
 /**
  *
@@ -127,22 +145,3 @@ void MORSE_TASK_ztslqt(const MORSE_option_t *options,
         sizeof(MORSE_Complex64_t)*ib*nb,    NULL,          SCRATCH,
         0);
 }
-
-
-void CORE_ztslqt_quark(Quark *quark)
-{
-    int m;
-    int n;
-    int ib;
-    MORSE_Complex64_t *A1;
-    int lda1;
-    MORSE_Complex64_t *A2;
-    int lda2;
-    MORSE_Complex64_t *T;
-    int ldt;
-    MORSE_Complex64_t *TAU;
-    MORSE_Complex64_t *WORK;
-
-    quark_unpack_args_11(quark, m, n, ib, A1, lda1, A2, lda2, T, ldt, TAU, WORK);
-    CORE_ztslqt(m, n, ib, A1, lda1, A2, lda2, T, ldt, TAU, WORK);
-}
diff --git a/runtime/quark/codelets/codelet_ztsmlq.c b/runtime/quark/codelets/codelet_ztsmlq.c
index 81dc27110..fad50baaf 100644
--- a/runtime/quark/codelets/codelet_ztsmlq.c
+++ b/runtime/quark/codelets/codelet_ztsmlq.c
@@ -30,7 +30,35 @@
  * @precisions normal z -> c d s
  *
  **/
-#include "runtime/quark/include/morse_quark.h"
+#include "chameleon_quark.h"
+#include "chameleon/morse_tasks_z.h"
+
+void CORE_ztsmlq_quark(Quark *quark)
+{
+    MORSE_enum side;
+    MORSE_enum trans;
+    int m1;
+    int n1;
+    int m2;
+    int n2;
+    int k;
+    int ib;
+    MORSE_Complex64_t *A1;
+    int lda1;
+    MORSE_Complex64_t *A2;
+    int lda2;
+    MORSE_Complex64_t *V;
+    int ldv;
+    MORSE_Complex64_t *T;
+    int ldt;
+    MORSE_Complex64_t *WORK;
+    int ldwork;
+
+    quark_unpack_args_18(quark, side, trans, m1, n1, m2, n2, k, ib,
+                         A1, lda1, A2, lda2, V, ldv, T, ldt, WORK, ldwork);
+    CORE_ztsmlq(side, trans, m1, n1, m2, n2, k, ib,
+                A1, lda1, A2, lda2, V, ldv, T, ldt, WORK, ldwork);
+}
 
 /**
  *
@@ -131,7 +159,6 @@
  *          \retval <0 if -i, the i-th argument had an illegal value
  *
  ******************************************************************************/
-
 void MORSE_TASK_ztsmlq(const MORSE_option_t *options,
                        MORSE_enum side, MORSE_enum trans,
                        int m1, int n1, int m2, int n2, int k, int ib, int nb,
@@ -165,31 +192,3 @@ void MORSE_TASK_ztsmlq(const MORSE_option_t *options,
         sizeof(int),                        &ldwork, VALUE,
         0);
 }
-
-
-void CORE_ztsmlq_quark(Quark *quark)
-{
-    MORSE_enum side;
-    MORSE_enum trans;
-    int m1;
-    int n1;
-    int m2;
-    int n2;
-    int k;
-    int ib;
-    MORSE_Complex64_t *A1;
-    int lda1;
-    MORSE_Complex64_t *A2;
-    int lda2;
-    MORSE_Complex64_t *V;
-    int ldv;
-    MORSE_Complex64_t *T;
-    int ldt;
-    MORSE_Complex64_t *WORK;
-    int ldwork;
-
-    quark_unpack_args_18(quark, side, trans, m1, n1, m2, n2, k, ib,
-                         A1, lda1, A2, lda2, V, ldv, T, ldt, WORK, ldwork);
-    CORE_ztsmlq(side, trans, m1, n1, m2, n2, k, ib,
-                A1, lda1, A2, lda2, V, ldv, T, ldt, WORK, ldwork);
-}
diff --git a/runtime/quark/codelets/codelet_ztsmlq_hetra1.c b/runtime/quark/codelets/codelet_ztsmlq_hetra1.c
index b381e12e2..3b358ea00 100644
--- a/runtime/quark/codelets/codelet_ztsmlq_hetra1.c
+++ b/runtime/quark/codelets/codelet_ztsmlq_hetra1.c
@@ -25,7 +25,8 @@
  * @precisions normal z -> c d s
  *
  **/
-#include "runtime/quark/include/morse_quark.h"
+#include "chameleon_quark.h"
+#include "chameleon/morse_tasks_z.h"
 
 void CORE_ztsmlq_hetra1_quark(Quark *quark)
 {
diff --git a/runtime/quark/codelets/codelet_ztsmqr.c b/runtime/quark/codelets/codelet_ztsmqr.c
index aaff66e28..b29f61561 100644
--- a/runtime/quark/codelets/codelet_ztsmqr.c
+++ b/runtime/quark/codelets/codelet_ztsmqr.c
@@ -30,7 +30,35 @@
  * @precisions normal z -> c d s
  *
  **/
-#include "runtime/quark/include/morse_quark.h"
+#include "chameleon_quark.h"
+#include "chameleon/morse_tasks_z.h"
+
+void CORE_ztsmqr_quark(Quark *quark)
+{
+    MORSE_enum side;
+    MORSE_enum trans;
+    int m1;
+    int n1;
+    int m2;
+    int n2;
+    int k;
+    int ib;
+    MORSE_Complex64_t *A1;
+    int lda1;
+    MORSE_Complex64_t *A2;
+    int lda2;
+    MORSE_Complex64_t *V;
+    int ldv;
+    MORSE_Complex64_t *T;
+    int ldt;
+    MORSE_Complex64_t *WORK;
+    int ldwork;
+
+    quark_unpack_args_18(quark, side, trans, m1, n1, m2, n2, k, ib,
+                         A1, lda1, A2, lda2, V, ldv, T, ldt, WORK, ldwork);
+    CORE_ztsmqr(side, trans, m1, n1, m2, n2, k, ib,
+                A1, lda1, A2, lda2, V, ldv, T, ldt, WORK, ldwork);
+}
 
 /**
  *
@@ -131,7 +159,6 @@
  *          \retval <0 if -i, the i-th argument had an illegal value
  *
  ******************************************************************************/
-
 void MORSE_TASK_ztsmqr(const MORSE_option_t *options,
                        MORSE_enum side, MORSE_enum trans,
                        int m1, int n1, int m2, int n2, int k, int ib, int nb,
@@ -165,31 +192,3 @@ void MORSE_TASK_ztsmqr(const MORSE_option_t *options,
         sizeof(int),                        &ldwork, VALUE,
         0);
 }
-
-
-void CORE_ztsmqr_quark(Quark *quark)
-{
-    MORSE_enum side;
-    MORSE_enum trans;
-    int m1;
-    int n1;
-    int m2;
-    int n2;
-    int k;
-    int ib;
-    MORSE_Complex64_t *A1;
-    int lda1;
-    MORSE_Complex64_t *A2;
-    int lda2;
-    MORSE_Complex64_t *V;
-    int ldv;
-    MORSE_Complex64_t *T;
-    int ldt;
-    MORSE_Complex64_t *WORK;
-    int ldwork;
-
-    quark_unpack_args_18(quark, side, trans, m1, n1, m2, n2, k, ib,
-                         A1, lda1, A2, lda2, V, ldv, T, ldt, WORK, ldwork);
-    CORE_ztsmqr(side, trans, m1, n1, m2, n2, k, ib,
-                A1, lda1, A2, lda2, V, ldv, T, ldt, WORK, ldwork);
-}
diff --git a/runtime/quark/codelets/codelet_ztsmqr_hetra1.c b/runtime/quark/codelets/codelet_ztsmqr_hetra1.c
index 5e7277eef..df680204c 100644
--- a/runtime/quark/codelets/codelet_ztsmqr_hetra1.c
+++ b/runtime/quark/codelets/codelet_ztsmqr_hetra1.c
@@ -25,7 +25,8 @@
  * @precisions normal z -> c d s
  *
  **/
-#include "runtime/quark/include/morse_quark.h"
+#include "chameleon_quark.h"
+#include "chameleon/morse_tasks_z.h"
 
 void CORE_ztsmqr_hetra1_quark(Quark *quark)
 {
diff --git a/runtime/quark/codelets/codelet_ztsqrt.c b/runtime/quark/codelets/codelet_ztsqrt.c
index 76546d31e..73858e634 100644
--- a/runtime/quark/codelets/codelet_ztsqrt.c
+++ b/runtime/quark/codelets/codelet_ztsqrt.c
@@ -28,8 +28,26 @@
  * @precisions normal z -> c d s
  *
  **/
+#include "chameleon_quark.h"
+#include "chameleon/morse_tasks_z.h"
 
-#include "runtime/quark/include/morse_quark.h"
+void CORE_ztsqrt_quark(Quark *quark)
+{
+    int m;
+    int n;
+    int ib;
+    MORSE_Complex64_t *A1;
+    int lda1;
+    MORSE_Complex64_t *A2;
+    int lda2;
+    MORSE_Complex64_t *T;
+    int ldt;
+    MORSE_Complex64_t *TAU;
+    MORSE_Complex64_t *WORK;
+
+    quark_unpack_args_11(quark, m, n, ib, A1, lda1, A2, lda2, T, ldt, TAU, WORK);
+    CORE_ztsqrt(m, n, ib, A1, lda1, A2, lda2, T, ldt, TAU, WORK);
+}
 
 /**
  *
@@ -93,7 +111,6 @@
  *          \retval <0 if -i, the i-th argument had an illegal value
  *
  ******************************************************************************/
-
 void MORSE_TASK_ztsqrt(const MORSE_option_t *options,
                        int m, int n, int ib, int nb,
                        const MORSE_desc_t *A1, int A1m, int A1n, int lda1,
@@ -116,22 +133,3 @@ void MORSE_TASK_ztsqrt(const MORSE_option_t *options,
         sizeof(MORSE_Complex64_t)*ib*nb,    NULL,          SCRATCH,
         0);
 }
-
-
-void CORE_ztsqrt_quark(Quark *quark)
-{
-    int m;
-    int n;
-    int ib;
-    MORSE_Complex64_t *A1;
-    int lda1;
-    MORSE_Complex64_t *A2;
-    int lda2;
-    MORSE_Complex64_t *T;
-    int ldt;
-    MORSE_Complex64_t *TAU;
-    MORSE_Complex64_t *WORK;
-
-    quark_unpack_args_11(quark, m, n, ib, A1, lda1, A2, lda2, T, ldt, TAU, WORK);
-    CORE_ztsqrt(m, n, ib, A1, lda1, A2, lda2, T, ldt, TAU, WORK);
-}
diff --git a/runtime/quark/codelets/codelet_ztstrf.c b/runtime/quark/codelets/codelet_ztstrf.c
index 6243a2aa9..c035d2cac 100644
--- a/runtime/quark/codelets/codelet_ztstrf.c
+++ b/runtime/quark/codelets/codelet_ztstrf.c
@@ -28,10 +28,39 @@
  * @precisions normal z -> c d s
  *
  **/
-#include "runtime/quark/include/morse_quark.h"
+#include "chameleon_quark.h"
+#include "chameleon/morse_tasks_z.h"
 #include "coreblas/cblas.h"
 #include <math.h>
 
+void CORE_ztstrf_quark(Quark *quark)
+{
+    int m;
+    int n;
+    int ib;
+    int nb;
+    MORSE_Complex64_t *U;
+    int ldu;
+    MORSE_Complex64_t *A;
+    int lda;
+    MORSE_Complex64_t *L;
+    int ldl;
+    int *IPIV;
+    MORSE_Complex64_t *WORK;
+    int ldwork;
+    MORSE_sequence_t *sequence;
+    MORSE_request_t *request;
+    MORSE_bool check_info;
+    int iinfo;
+
+    int info;
+
+    quark_unpack_args_17(quark, m, n, ib, nb, U, ldu, A, lda, L, ldl, IPIV, WORK, ldwork, sequence, request, check_info, iinfo);
+    CORE_ztstrf(m, n, ib, nb, U, ldu, A, lda, L, ldl, IPIV, WORK, ldwork, &info);
+    if (info != MORSE_SUCCESS && check_info)
+        RUNTIME_sequence_flush(quark, sequence, request, iinfo + info);
+}
+
 /***************************************************************************//**
  *
  * @ingroup CORE_MORSE_Complex64_t
@@ -98,7 +127,6 @@
  *              to solve a system of equations.
  *
  ******************************************************************************/
-
 void MORSE_TASK_ztstrf(const MORSE_option_t *options,
                        int m, int n, int ib, int nb,
                        const MORSE_desc_t *U, int Um, int Un, int ldu,
@@ -129,32 +157,3 @@ void MORSE_TASK_ztstrf(const MORSE_option_t *options,
         sizeof(int),                        &iinfo,         VALUE,
         0);
 }
-
-
-void CORE_ztstrf_quark(Quark *quark)
-{
-    int m;
-    int n;
-    int ib;
-    int nb;
-    MORSE_Complex64_t *U;
-    int ldu;
-    MORSE_Complex64_t *A;
-    int lda;
-    MORSE_Complex64_t *L;
-    int ldl;
-    int *IPIV;
-    MORSE_Complex64_t *WORK;
-    int ldwork;
-    MORSE_sequence_t *sequence;
-    MORSE_request_t *request;
-    MORSE_bool check_info;
-    int iinfo;
-
-    int info;
-
-    quark_unpack_args_17(quark, m, n, ib, nb, U, ldu, A, lda, L, ldl, IPIV, WORK, ldwork, sequence, request, check_info, iinfo);
-    CORE_ztstrf(m, n, ib, nb, U, ldu, A, lda, L, ldl, IPIV, WORK, ldwork, &info);
-    if (info != MORSE_SUCCESS && check_info)
-        RUNTIME_sequence_flush(quark, sequence, request, iinfo + info);
-}
diff --git a/runtime/quark/codelets/codelet_zttlqt.c b/runtime/quark/codelets/codelet_zttlqt.c
index 98b42550b..2113531de 100644
--- a/runtime/quark/codelets/codelet_zttlqt.c
+++ b/runtime/quark/codelets/codelet_zttlqt.c
@@ -28,8 +28,26 @@
  * @precisions normal z -> c d s
  *
  **/
+#include "chameleon_quark.h"
+#include "chameleon/morse_tasks_z.h"
 
-#include "runtime/quark/include/morse_quark.h"
+void CORE_zttlqt_quark(Quark *quark)
+{
+    int m;
+    int n;
+    int ib;
+    MORSE_Complex64_t *A1;
+    int lda1;
+    MORSE_Complex64_t *A2;
+    int lda2;
+    MORSE_Complex64_t *T;
+    int ldt;
+    MORSE_Complex64_t *TAU;
+    MORSE_Complex64_t *WORK;
+
+    quark_unpack_args_11(quark, m, n, ib, A1, lda1, A2, lda2, T, ldt, TAU, WORK);
+    CORE_zttlqt(m, n, ib, A1, lda1, A2, lda2, T, ldt, TAU, WORK);
+}
 
 /**
  *
@@ -105,7 +123,6 @@
  *          \retval <0 if -i, the i-th argument had an illegal value
  *
  ******************************************************************************/
-
 void MORSE_TASK_zttlqt(const MORSE_option_t *options,
                        int m, int n, int ib, int nb,
                        const MORSE_desc_t *A1, int A1m, int A1n, int lda1,
@@ -128,22 +145,3 @@ void MORSE_TASK_zttlqt(const MORSE_option_t *options,
         sizeof(MORSE_Complex64_t)*ib*nb,    NULL,          SCRATCH,
         0);
 }
-
-
-void CORE_zttlqt_quark(Quark *quark)
-{
-    int m;
-    int n;
-    int ib;
-    MORSE_Complex64_t *A1;
-    int lda1;
-    MORSE_Complex64_t *A2;
-    int lda2;
-    MORSE_Complex64_t *T;
-    int ldt;
-    MORSE_Complex64_t *TAU;
-    MORSE_Complex64_t *WORK;
-
-    quark_unpack_args_11(quark, m, n, ib, A1, lda1, A2, lda2, T, ldt, TAU, WORK);
-    CORE_zttlqt(m, n, ib, A1, lda1, A2, lda2, T, ldt, TAU, WORK);
-}
diff --git a/runtime/quark/codelets/codelet_zttmlq.c b/runtime/quark/codelets/codelet_zttmlq.c
index cab48f44c..3900a4fb9 100644
--- a/runtime/quark/codelets/codelet_zttmlq.c
+++ b/runtime/quark/codelets/codelet_zttmlq.c
@@ -28,7 +28,35 @@
  * @precisions normal z -> c d s
  *
  **/
-#include "runtime/quark/include/morse_quark.h"
+#include "chameleon_quark.h"
+#include "chameleon/morse_tasks_z.h"
+
+void CORE_zttmlq_quark(Quark *quark)
+{
+    MORSE_enum side;
+    MORSE_enum trans;
+    int m1;
+    int n1;
+    int m2;
+    int n2;
+    int k;
+    int ib;
+    MORSE_Complex64_t *A1;
+    int lda1;
+    MORSE_Complex64_t *A2;
+    int lda2;
+    MORSE_Complex64_t *V;
+    int ldv;
+    MORSE_Complex64_t *T;
+    int ldt;
+    MORSE_Complex64_t *WORK;
+    int ldwork;
+
+    quark_unpack_args_18(quark, side, trans, m1, n1, m2, n2, k, ib,
+                         A1, lda1, A2, lda2, V, ldv, T, ldt, WORK, ldwork);
+    CORE_zttmlq(side, trans, m1, n1, m2, n2, k, ib, A1, lda1,
+                A2, lda2, V, ldv, T, ldt, WORK, ldwork);
+}
 
 /**
  *
@@ -123,7 +151,6 @@
  *          \retval <0 if -i, the i-th argument had an illegal value
  *
  ******************************************************************************/
-
 void MORSE_TASK_zttmlq(const MORSE_option_t *options,
                        MORSE_enum side, MORSE_enum trans,
                        int m1, int n1, int m2, int n2, int k, int ib, int nb,
@@ -157,31 +184,3 @@ void MORSE_TASK_zttmlq(const MORSE_option_t *options,
         sizeof(int),                        &ldwork,    VALUE,
         0);
 }
-
-
-void CORE_zttmlq_quark(Quark *quark)
-{
-    MORSE_enum side;
-    MORSE_enum trans;
-    int m1;
-    int n1;
-    int m2;
-    int n2;
-    int k;
-    int ib;
-    MORSE_Complex64_t *A1;
-    int lda1;
-    MORSE_Complex64_t *A2;
-    int lda2;
-    MORSE_Complex64_t *V;
-    int ldv;
-    MORSE_Complex64_t *T;
-    int ldt;
-    MORSE_Complex64_t *WORK;
-    int ldwork;
-
-    quark_unpack_args_18(quark, side, trans, m1, n1, m2, n2, k, ib,
-                         A1, lda1, A2, lda2, V, ldv, T, ldt, WORK, ldwork);
-    CORE_zttmlq(side, trans, m1, n1, m2, n2, k, ib, A1, lda1,
-                A2, lda2, V, ldv, T, ldt, WORK, ldwork);
-}
diff --git a/runtime/quark/codelets/codelet_zttmqr.c b/runtime/quark/codelets/codelet_zttmqr.c
index 849a5454d..ed3a77323 100644
--- a/runtime/quark/codelets/codelet_zttmqr.c
+++ b/runtime/quark/codelets/codelet_zttmqr.c
@@ -28,7 +28,35 @@
  * @precisions normal z -> c d s
  *
  **/
-#include "runtime/quark/include/morse_quark.h"
+#include "chameleon_quark.h"
+#include "chameleon/morse_tasks_z.h"
+
+void CORE_zttmqr_quark(Quark *quark)
+{
+    MORSE_enum side;
+    MORSE_enum trans;
+    int m1;
+    int n1;
+    int m2;
+    int n2;
+    int k;
+    int ib;
+    MORSE_Complex64_t *A1;
+    int lda1;
+    MORSE_Complex64_t *A2;
+    int lda2;
+    MORSE_Complex64_t *V;
+    int ldv;
+    MORSE_Complex64_t *T;
+    int ldt;
+    MORSE_Complex64_t *WORK;
+    int ldwork;
+
+    quark_unpack_args_18(quark, side, trans, m1, n1, m2, n2, k, ib,
+                         A1, lda1, A2, lda2, V, ldv, T, ldt, WORK, ldwork);
+    CORE_zttmqr(side, trans, m1, n1, m2, n2, k, ib,
+                A1, lda1, A2, lda2, V, ldv, T, ldt, WORK, ldwork);
+}
 
 /**
  *
@@ -123,7 +151,6 @@
  *          \retval <0 if -i, the i-th argument had an illegal value
  *
  ******************************************************************************/
-
 void MORSE_TASK_zttmqr(const MORSE_option_t *options,
                        MORSE_enum side, MORSE_enum trans,
                        int m1, int n1, int m2, int n2, int k, int ib, int nb,
@@ -157,31 +184,3 @@ void MORSE_TASK_zttmqr(const MORSE_option_t *options,
         sizeof(int),                        &ldwork,    VALUE,
         0);
 }
-
-
-void CORE_zttmqr_quark(Quark *quark)
-{
-    MORSE_enum side;
-    MORSE_enum trans;
-    int m1;
-    int n1;
-    int m2;
-    int n2;
-    int k;
-    int ib;
-    MORSE_Complex64_t *A1;
-    int lda1;
-    MORSE_Complex64_t *A2;
-    int lda2;
-    MORSE_Complex64_t *V;
-    int ldv;
-    MORSE_Complex64_t *T;
-    int ldt;
-    MORSE_Complex64_t *WORK;
-    int ldwork;
-
-    quark_unpack_args_18(quark, side, trans, m1, n1, m2, n2, k, ib,
-                         A1, lda1, A2, lda2, V, ldv, T, ldt, WORK, ldwork);
-    CORE_zttmqr(side, trans, m1, n1, m2, n2, k, ib,
-                A1, lda1, A2, lda2, V, ldv, T, ldt, WORK, ldwork);
-}
diff --git a/runtime/quark/codelets/codelet_zttqrt.c b/runtime/quark/codelets/codelet_zttqrt.c
index 06106fc5a..8c3f9c4f5 100644
--- a/runtime/quark/codelets/codelet_zttqrt.c
+++ b/runtime/quark/codelets/codelet_zttqrt.c
@@ -28,8 +28,26 @@
  * @precisions normal z -> c d s
  *
  **/
+#include "chameleon_quark.h"
+#include "chameleon/morse_tasks_z.h"
 
-#include "runtime/quark/include/morse_quark.h"
+void CORE_zttqrt_quark(Quark *quark)
+{
+    int m;
+    int n;
+    int ib;
+    MORSE_Complex64_t *A1;
+    int lda1;
+    MORSE_Complex64_t *A2;
+    int lda2;
+    MORSE_Complex64_t *T;
+    int ldt;
+    MORSE_Complex64_t *TAU;
+    MORSE_Complex64_t *WORK;
+
+    quark_unpack_args_11(quark, m, n, ib, A1, lda1, A2, lda2, T, ldt, TAU, WORK);
+    CORE_zttqrt(m, n, ib, A1, lda1, A2, lda2, T, ldt, TAU, WORK);
+}
 
 /**
  *
@@ -105,7 +123,6 @@
  *          \retval <0 if -i, the i-th argument had an illegal value
  *
  ******************************************************************************/
-
 void MORSE_TASK_zttqrt(const MORSE_option_t *options,
                        int m, int n, int ib, int nb,
                        const MORSE_desc_t *A1, int A1m, int A1n, int lda1,
@@ -128,22 +145,3 @@ void MORSE_TASK_zttqrt(const MORSE_option_t *options,
         sizeof(MORSE_Complex64_t)*ib*nb,    NULL,          SCRATCH,
         0);
 }
-
-
-void CORE_zttqrt_quark(Quark *quark)
-{
-    int m;
-    int n;
-    int ib;
-    MORSE_Complex64_t *A1;
-    int lda1;
-    MORSE_Complex64_t *A2;
-    int lda2;
-    MORSE_Complex64_t *T;
-    int ldt;
-    MORSE_Complex64_t *TAU;
-    MORSE_Complex64_t *WORK;
-
-    quark_unpack_args_11(quark, m, n, ib, A1, lda1, A2, lda2, T, ldt, TAU, WORK);
-    CORE_zttqrt(m, n, ib, A1, lda1, A2, lda2, T, ldt, TAU, WORK);
-}
diff --git a/runtime/quark/codelets/codelet_zunmlq.c b/runtime/quark/codelets/codelet_zunmlq.c
index 1ae6b0899..774acb280 100644
--- a/runtime/quark/codelets/codelet_zunmlq.c
+++ b/runtime/quark/codelets/codelet_zunmlq.c
@@ -30,7 +30,31 @@
  *
  **/
 
-#include "runtime/quark/include/morse_quark.h"
+#include "chameleon_quark.h"
+#include "chameleon/morse_tasks_z.h"
+
+void CORE_zunmlq_quark(Quark *quark)
+{
+    MORSE_enum side;
+    MORSE_enum trans;
+    int m;
+    int n;
+    int k;
+    int ib;
+    MORSE_Complex64_t *A;
+    int lda;
+    MORSE_Complex64_t *T;
+    int ldt;
+    MORSE_Complex64_t *C;
+    int ldc;
+    MORSE_Complex64_t *WORK;
+    int ldwork;
+
+    quark_unpack_args_14(quark, side, trans, m, n, k, ib,
+                         A, lda, T, ldt, C, ldc, WORK, ldwork);
+    CORE_zunmlq(side, trans, m, n, k, ib,
+                A, lda, T, ldt, C, ldc, WORK, ldwork);
+}
 
 /**
  *
@@ -115,7 +139,6 @@
  *          \retval <0 if -i, the i-th argument had an illegal value
  *
  ******************************************************************************/
-
 void MORSE_TASK_zunmlq(const MORSE_option_t *options,
                        MORSE_enum side, MORSE_enum trans,
                        int m, int n, int k, int ib, int nb,
@@ -142,27 +165,3 @@ void MORSE_TASK_zunmlq(const MORSE_option_t *options,
         sizeof(int),                     &nb,    VALUE,
         0);
 }
-
-
-void CORE_zunmlq_quark(Quark *quark)
-{
-    MORSE_enum side;
-    MORSE_enum trans;
-    int m;
-    int n;
-    int k;
-    int ib;
-    MORSE_Complex64_t *A;
-    int lda;
-    MORSE_Complex64_t *T;
-    int ldt;
-    MORSE_Complex64_t *C;
-    int ldc;
-    MORSE_Complex64_t *WORK;
-    int ldwork;
-
-    quark_unpack_args_14(quark, side, trans, m, n, k, ib,
-                         A, lda, T, ldt, C, ldc, WORK, ldwork);
-    CORE_zunmlq(side, trans, m, n, k, ib,
-                A, lda, T, ldt, C, ldc, WORK, ldwork);
-}
diff --git a/runtime/quark/codelets/codelet_zunmqr.c b/runtime/quark/codelets/codelet_zunmqr.c
index 01e9f150b..ce8e8ea12 100644
--- a/runtime/quark/codelets/codelet_zunmqr.c
+++ b/runtime/quark/codelets/codelet_zunmqr.c
@@ -28,8 +28,31 @@
  * @precisions normal z -> c d s
  *
  **/
+#include "chameleon_quark.h"
+#include "chameleon/morse_tasks_z.h"
 
-#include "runtime/quark/include/morse_quark.h"
+void CORE_zunmqr_quark(Quark *quark)
+{
+    MORSE_enum side;
+    MORSE_enum trans;
+    int m;
+    int n;
+    int k;
+    int ib;
+    MORSE_Complex64_t *A;
+    int lda;
+    MORSE_Complex64_t *T;
+    int ldt;
+    MORSE_Complex64_t *C;
+    int ldc;
+    MORSE_Complex64_t *WORK;
+    int ldwork;
+
+    quark_unpack_args_14(quark, side, trans, m, n, k, ib,
+                         A, lda, T, ldt, C, ldc, WORK, ldwork);
+    CORE_zunmqr(side, trans, m, n, k, ib,
+                A, lda, T, ldt, C, ldc, WORK, ldwork);
+}
 
 /**
  *
@@ -115,7 +138,6 @@
  *          \retval <0 if -i, the i-th argument had an illegal value
  *
  ******************************************************************************/
-
 void MORSE_TASK_zunmqr(const MORSE_option_t *options,
                        MORSE_enum side, MORSE_enum trans,
                        int m, int n, int k, int ib, int nb,
@@ -142,27 +164,3 @@ void MORSE_TASK_zunmqr(const MORSE_option_t *options,
         sizeof(int),                     &nb,    VALUE,
         0);
 }
-
-
-void CORE_zunmqr_quark(Quark *quark)
-{
-    MORSE_enum side;
-    MORSE_enum trans;
-    int m;
-    int n;
-    int k;
-    int ib;
-    MORSE_Complex64_t *A;
-    int lda;
-    MORSE_Complex64_t *T;
-    int ldt;
-    MORSE_Complex64_t *C;
-    int ldc;
-    MORSE_Complex64_t *WORK;
-    int ldwork;
-
-    quark_unpack_args_14(quark, side, trans, m, n, k, ib,
-                         A, lda, T, ldt, C, ldc, WORK, ldwork);
-    CORE_zunmqr(side, trans, m, n, k, ib,
-                A, lda, T, ldt, C, ldc, WORK, ldwork);
-}
diff --git a/runtime/quark/control/runtime_async.c b/runtime/quark/control/runtime_async.c
index 8b7fc2c78..78692bba5 100644
--- a/runtime/quark/control/runtime_async.c
+++ b/runtime/quark/control/runtime_async.c
@@ -24,7 +24,7 @@
  *
  **/
 #include <stdlib.h>
-#include "runtime/quark/include/morse_quark.h"
+#include "chameleon_quark.h"
 
 /** *****************************************************************************
  *  Create a sequence
diff --git a/runtime/quark/control/runtime_context.c b/runtime/quark/control/runtime_context.c
index 1352ad511..8dca38a9a 100644
--- a/runtime/quark/control/runtime_context.c
+++ b/runtime/quark/control/runtime_context.c
@@ -23,7 +23,7 @@
  *
  **/
 #include <stdlib.h>
-#include "runtime/quark/include/morse_quark.h"
+#include "chameleon_quark.h"
 
 /*******************************************************************************
  *  Create new context
diff --git a/runtime/quark/control/runtime_control.c b/runtime/quark/control/runtime_control.c
index fc4639fbe..a92f726d0 100644
--- a/runtime/quark/control/runtime_control.c
+++ b/runtime/quark/control/runtime_control.c
@@ -24,7 +24,7 @@
  **/
 #include <stdio.h>
 #include <stdlib.h>
-#include "runtime/quark/include/morse_quark.h"
+#include "chameleon_quark.h"
 
 /*******************************************************************************
  * Thread rank.
diff --git a/runtime/quark/control/runtime_descriptor.c b/runtime/quark/control/runtime_descriptor.c
index 6e4dfa9d2..b1e47144b 100644
--- a/runtime/quark/control/runtime_descriptor.c
+++ b/runtime/quark/control/runtime_descriptor.c
@@ -23,7 +23,7 @@
  *
  **/
 #include <stdlib.h>
-#include "runtime/quark/include/morse_quark.h"
+#include "chameleon_quark.h"
 
 void RUNTIME_user_tag_size(int user_tag_width, int user_tag_sep) {
   (void)user_tag_width;
diff --git a/runtime/quark/control/runtime_options.c b/runtime/quark/control/runtime_options.c
index 9cd642706..827e2b4b1 100644
--- a/runtime/quark/control/runtime_options.c
+++ b/runtime/quark/control/runtime_options.c
@@ -24,7 +24,7 @@
  **/
 #include <stdio.h>
 #include <stdlib.h>
-#include "runtime/quark/include/morse_quark.h"
+#include "chameleon_quark.h"
 
 void RUNTIME_options_init( MORSE_option_t *options, MORSE_context_t *morse,
                            MORSE_sequence_t *sequence, MORSE_request_t *request )
diff --git a/runtime/quark/control/runtime_profiling.c b/runtime/quark/control/runtime_profiling.c
index 0db7e5513..552ee387c 100644
--- a/runtime/quark/control/runtime_profiling.c
+++ b/runtime/quark/control/runtime_profiling.c
@@ -22,7 +22,7 @@
  * @date 2011-10-29 
  *
  **/
-#include "runtime/quark/include/morse_quark.h"
+#include "chameleon_quark.h"
 
 #if defined( _WIN32 ) || defined( _WIN64 )
 #include <windows.h>
diff --git a/runtime/quark/control/runtime_zlocality.c b/runtime/quark/control/runtime_zlocality.c
index 1cf57754b..4d5ed31f7 100644
--- a/runtime/quark/control/runtime_zlocality.c
+++ b/runtime/quark/control/runtime_zlocality.c
@@ -23,7 +23,7 @@
  *  @precisions normal z -> s d c
  *
  **/
-#include "runtime/quark/include/morse_quark.h"
+#include "chameleon_quark.h"
 
 void RUNTIME_zlocality_allrestrict( uint32_t where )
 {
diff --git a/runtime/quark/control/runtime_zprofiling.c b/runtime/quark/control/runtime_zprofiling.c
index 29fdb7797..519dc9543 100644
--- a/runtime/quark/control/runtime_zprofiling.c
+++ b/runtime/quark/control/runtime_zprofiling.c
@@ -25,7 +25,7 @@
  *  @precisions normal z -> s d c
  *
  **/
-#include "runtime/quark/include/morse_quark.h"
+#include "chameleon_quark.h"
 
 void RUNTIME_zdisplay_allprofile()
 {
diff --git a/runtime/quark/include/morse_quark.h b/runtime/quark/include/chameleon_quark.h
similarity index 89%
rename from runtime/quark/include/morse_quark.h
rename to runtime/quark/include/chameleon_quark.h
index 668531873..50d11f521 100644
--- a/runtime/quark/include/morse_quark.h
+++ b/runtime/quark/include/chameleon_quark.h
@@ -10,7 +10,7 @@
 
 /**
  *
- * @file morse_quark.h
+ * @file chameleon_quark.h
  *
  *  MORSE codelets kernel
  *  MORSE is a software package provided by Univ. of Tennessee,
@@ -27,9 +27,8 @@
 #define _MORSE_QUARK_H_
 
 #include <quark.h>
-#include "coreblas/coreblas.h"
-#include "runtime/quark/include/quark_blas.h"
-#include "runtime/quark/include/core_blas_dag.h"
+#include "coreblas.h"
+#include "core_blas_dag.h"
 
 #include "control/common.h"
 
diff --git a/runtime/quark/include/quark_blas.h b/runtime/quark/include/quark_blas.h
deleted file mode 100644
index fc175fdfe..000000000
--- a/runtime/quark/include/quark_blas.h
+++ /dev/null
@@ -1,42 +0,0 @@
-/**
- *
- * @copyright (c) 2009-2014 The University of Tennessee and The University
- *                          of Tennessee Research Foundation.
- *                          All rights reserved.
- * @copyright (c) 2012-2014 Inria. All rights reserved.
- * @copyright (c) 2012-2014 Bordeaux INP, CNRS (LaBRI UMR 5800), Inria, Univ. Bordeaux. All rights reserved.
- *
- **/
-
-/**
- *
- * @file quark_blas.h
- *
- *  MORSE auxiliary routines
- *  MORSE is a software package provided by Univ. of Tennessee,
- *  Univ. of California Berkeley and Univ. of Colorado Denver
- *
- * @version 0.9.0
- * @author Jakub Kurzak
- * @author Hatem Ltaief
- * @date 2010-11-15
- *
- **/
-#ifndef _QUARK_BLAS_H_
-#define _QUARK_BLAS_H_
-
-#include "coreblas/cblas.h"
-
-#include "runtime/quark/include/quark_zblas.h"
-#include "runtime/quark/include/quark_dblas.h"
-#include "runtime/quark/include/quark_cblas.h"
-#include "runtime/quark/include/quark_sblas.h"
-#include "runtime/quark/include/quark_zcblas.h"
-#include "runtime/quark/include/quark_dsblas.h"
-
-void CORE_ztile_zero_quark(Quark *quark);
-void CORE_dtile_zero_quark(Quark *quark);
-void CORE_ctile_zero_quark(Quark *quark);
-void CORE_stile_zero_quark(Quark *quark);
-
-#endif
diff --git a/runtime/quark/include/quark_zblas.h b/runtime/quark/include/quark_zblas.h
deleted file mode 100644
index e5fe96bac..000000000
--- a/runtime/quark/include/quark_zblas.h
+++ /dev/null
@@ -1,142 +0,0 @@
-/**
- *
- * @copyright (c) 2009-2014 The University of Tennessee and The University
- *                          of Tennessee Research Foundation.
- *                          All rights reserved.
- * @copyright (c) 2012-2014 Inria. All rights reserved.
- * @copyright (c) 2012-2014 Bordeaux INP, CNRS (LaBRI UMR 5800), Inria, Univ. Bordeaux. All rights reserved.
- *
- **/
-
-/**
- *
- * @file quark_zblas.h
- *
- *  MORSE auxiliary routines
- *  MORSE is a software package provided by Univ. of Tennessee,
- *  Univ. of California Berkeley and Univ. of Colorado Denver
- *
- * @version 2.5.0
- * @comment This file has been automatically generated
- *          from Plasma 2.5.0 for MORSE 1.0.0
- * @author Jakub Kurzak
- * @author Hatem Ltaief
- * @author Azzam Haidar
- * @author Mathieu Faverge
- * @author Emmanuel Agullo
- * @author Cedric Castagnede
- * @date 2010-11-15
- * @precisions normal z -> c d s
- *
- **/
-#ifndef _QUARK_ZBLAS_H_
-#define _QUARK_ZBLAS_H_
-
-#define COMPLEX
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-
-
-/** ****************************************************************************
- *  Declarations of QUARK wrappers (called by QUARK) - alphabetical order
- **/
-void CORE_dzasum_quark(Quark *quark);
-void CORE_dzasum_f1_quark(Quark *quark);
-void CORE_zaxpy_quark(Quark *quark);
-void CORE_zgeadd_quark(Quark *quark);
-void CORE_zbrdalg_quark(Quark *quark);
-void CORE_zgelqt_quark(Quark *quark);
-void CORE_zgemm_quark(Quark *quark);
-void CORE_zgeqrt_quark(Quark *quark);
-void CORE_zgessm_quark(Quark *quark);
-void CORE_zgessq_quark(Quark *quark);
-void CORE_zgetrf_quark(Quark *quark);
-void CORE_zgetrf_incpiv_quark(Quark *quark);
-void CORE_zgetrf_nopiv_quark(Quark *quark);
-void CORE_zgetrf_reclap_quark(Quark *quark);
-void CORE_zgetrf_rectil_quark(Quark* quark);
-void CORE_zgetrip_quark(Quark *quark);
-void CORE_zgetrip_f1_quark(Quark *quark);
-void CORE_zgetrip_f2_quark(Quark *quark);
-#ifdef COMPLEX
-void CORE_zhemm_quark(Quark *quark);
-void CORE_zherk_quark(Quark *quark);
-void CORE_zher2k_quark(Quark *quark);
-#endif
-void CORE_zhegst_quark(Quark *quark);
-void CORE_zherfb_quark(Quark *quark);
-void CORE_zhessq_quark(Quark *quark);
-void CORE_zlatro_quark(Quark *quark);
-void CORE_zlange_quark(Quark *quark);
-void CORE_zlange_max_quark(Quark *quark);
-#ifdef COMPLEX
-void CORE_zlanhe_quark(Quark *quark);
-#endif
-void CORE_zlansy_quark(Quark *quark);
-void CORE_zlantr_quark(Quark *quark);
-void CORE_zlaset_quark(Quark *quark);
-void CORE_zlaset2_quark(Quark *quark);
-void CORE_zlatro_quark(Quark *quark);
-void CORE_zlauum_quark(Quark *quark);
-void CORE_zpamm_quark(Quark *quark);
-void CORE_zplghe_quark(Quark *quark);
-void CORE_zplgsy_quark(Quark *quark);
-void CORE_zplrnt_quark(Quark *quark);
-void CORE_zplssq_quark(Quark *quark);
-void CORE_zplssq2_quark(Quark *quark);
-void CORE_zpotrf_quark(Quark *quark);
-void CORE_zshift_quark(Quark *quark);
-void CORE_zshiftw_quark(Quark *quark);
-void CORE_zssssm_quark(Quark *quark);
-void CORE_zsymm_quark(Quark *quark);
-void CORE_zsyrk_quark(Quark *quark);
-void CORE_zsyr2k_quark(Quark *quark);
-void CORE_zsyssq_quark(Quark *quark);
-void CORE_zsytrf_nopiv_quark(Quark *quark);
-void CORE_zswpab_quark(Quark *quark);
-void CORE_zswptr_ontile_quark(Quark *quark);
-void CORE_ztrasm_quark(Quark *quark);
-void CORE_ztrdalg_quark(Quark *quark);
-void CORE_ztrmm_quark(Quark *quark);
-void CORE_ztrsm_quark(Quark *quark);
-void CORE_ztrssq_quark(Quark *quark);
-void CORE_ztrtri_quark(Quark *quark);
-void CORE_ztslqt_quark(Quark *quark);
-void CORE_ztsmlq_quark(Quark *quark);
-void CORE_ztsmlq_hetra1_quark(Quark *quark);
-void CORE_ztsmlq_corner_quark(Quark *quark);
-void CORE_ztsmqr_quark(Quark *quark);
-void CORE_ztsmqr_hetra1_quark(Quark *quark);
-void CORE_ztsmqr_corner_quark(Quark *quark);
-void CORE_ztsqrt_quark(Quark *quark);
-void CORE_ztstrf_quark(Quark *quark);
-void CORE_zttmqr_quark(Quark *quark);
-void CORE_zttqrt_quark(Quark *quark);
-void CORE_zttmlq_quark(Quark *quark);
-void CORE_zttlqt_quark(Quark *quark);
-void CORE_zunmlq_quark(Quark *quark);
-void CORE_zunmqr_quark(Quark *quark);
-
-void CORE_zlaswp_quark(Quark* quark);
-void CORE_zlaswp_f2_quark(Quark* quark);
-void CORE_zlaswp_ontile_quark(Quark *quark);
-void CORE_zlaswp_ontile_f2_quark(Quark *quark);
-void CORE_zlaswpc_ontile_quark(Quark *quark);
-void CORE_ztrmm_p2_quark(Quark* quark);
-void CORE_zgemm_f2_quark(Quark* quark);
-void CORE_zgemm_p2_quark(Quark* quark);
-void CORE_zgemm_p2f1_quark(Quark* quark);
-void CORE_zgemm_p3_quark(Quark* quark);
-
-void CORE_zbuild_quark(Quark *quark);
-
-#ifdef __cplusplus
-}
-#endif
-
-#undef COMPLEX
-
-#endif
diff --git a/runtime/quark/include/quark_zcblas.h b/runtime/quark/include/quark_zcblas.h
deleted file mode 100644
index 2f14a3ae6..000000000
--- a/runtime/quark/include/quark_zcblas.h
+++ /dev/null
@@ -1,50 +0,0 @@
-/**
- *
- * @copyright (c) 2009-2014 The University of Tennessee and The University
- *                          of Tennessee Research Foundation.
- *                          All rights reserved.
- * @copyright (c) 2012-2014 Inria. All rights reserved.
- * @copyright (c) 2012-2014 Bordeaux INP, CNRS (LaBRI UMR 5800), Inria, Univ. Bordeaux. All rights reserved.
- *
- **/
-
-/**
- *
- * @file quark_zcblas.h
- *
- *  MORSE auxiliary routines
- *  MORSE is a software package provided by Univ. of Tennessee,
- *  Univ. of California Berkeley and Univ. of Colorado Denver
- *
- * @version 2.5.0
- * @comment This file has been automatically generated
- *          from Plasma 2.5.0 for MORSE 1.0.0
- * @author Jakub Kurzak
- * @author Hatem Ltaief
- * @author Mathieu Faverge
- * @author Emmanuel Agullo
- * @author Cedric Castagnede
- * @date 2010-11-15
- * @precisions mixed zc -> ds
- *
- **/
-#ifndef _QUARK_ZCBLAS_H_
-#define _QUARK_ZCBLAS_H_
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-
-
-/** ****************************************************************************
- *  Declarations of QUARK wrappers (called by QUARK) - alphabetical order
- **/
-void CORE_clag2z_quark(Quark *quark);
-void CORE_zlag2c_quark(Quark *quark);
-
-#ifdef __cplusplus
-}
-#endif
-
-#endif
-- 
GitLab