/**
 *
 * @file chameleon_zf77.c
 *
 * @copyright 2009-2014 The University of Tennessee and The University of
 *                      Tennessee Research Foundation. All rights reserved.
 * @copyright 2012-2021 Bordeaux INP, CNRS (LaBRI UMR 5800), Inria,
 *                      Univ. Bordeaux. All rights reserved.
 *
 ***
 *
 * @brief Chameleon Fortran77 computational routines
 *
 * @version 1.1.0
 * @comment This file has been automatically generated
 *          from Plasma 2.5.0 for CHAMELEON 0.9.2
 * @comment This file is automatically generated by tools/genf77interface.pl
 * @author Bilel Hadri
 * @author Mathieu Faverge
 * @author Emmanuel Agullo
 * @author Cedric Castagnede
 * @author Florent Pruvost
 * @date 2021-03-17
 * @precisions normal z -> c d s
 *
 */
#include <stdlib.h>
#include "control/common.h"
#include "control/chameleon_f77.h"

/**
 *  FORTRAN API - math functions (simple interface)
 */
#define CHAMELEON_ZLAPACK_TO_TILE CHAMELEON_FNAME(zlapack_to_tile, ZLAPACK_TO_TILE)
#define CHAMELEON_ZTILE_TO_LAPACK CHAMELEON_FNAME(ztile_to_lapack, ZTILE_TO_LAPACK)
//#define CHAMELEON_ZGEBRD          CHAMELEON_FNAME(zgebrd       , ZGEBRD       )
//#define CHAMELEON_ZGECFI          CHAMELEON_FNAME(zgecfi       , ZGECFI       )
//#define CHAMELEON_ZGECFI_ASYNC    CHAMELEON_FNAME(zgecfi_async , ZGECFI_ASYNC )
#define CHAMELEON_ZGELQF          CHAMELEON_FNAME(zgelqf       , ZGELQF       )
#define CHAMELEON_ZGELQS          CHAMELEON_FNAME(zgelqs       , ZGELQS       )
#define CHAMELEON_ZGELS           CHAMELEON_FNAME(zgels        , ZGELS        )
#define CHAMELEON_ZGEMM           CHAMELEON_FNAME(zgemm        , ZGEMM        )
#define CHAMELEON_ZGEQRF          CHAMELEON_FNAME(zgeqrf       , ZGEQRF       )
#define CHAMELEON_ZGEQRS          CHAMELEON_FNAME(zgeqrs       , ZGEQRS       )
//#define CHAMELEON_ZGESV           CHAMELEON_FNAME(zgesv        , ZGESV        )
#define CHAMELEON_ZGESV_INCPIV    CHAMELEON_FNAME(zgesv_incpiv , ZGESV_INCPIV )
#define CHAMELEON_ZGESV_NOPIV     CHAMELEON_FNAME(zgesv_nopiv  , ZGESV_NOPIV )
//#define CHAMELEON_ZGESVD          CHAMELEON_FNAME(zgesvd       , ZGESVD       )
//#define CHAMELEON_ZGETMI          CHAMELEON_FNAME(zgetmi       , ZGETMI       )
//#define CHAMELEON_ZGETMI_ASYNC    CHAMELEON_FNAME(zgetmi_async , ZGETMI_ASYNC )
//#define CHAMELEON_ZGETRF          CHAMELEON_FNAME(zgetrf       , ZGETRF       )
#define CHAMELEON_ZGETRF_INCPIV   CHAMELEON_FNAME(zgetrf_incpiv, ZGETRF_INCPIV)
#define CHAMELEON_ZGETRF_NOPIV    CHAMELEON_FNAME(zgetrf_nopiv , ZGETRF_NOPIV)
//#define CHAMELEON_ZGETRI          CHAMELEON_FNAME(zgetri       , ZGETRI       )
//#define CHAMELEON_ZGETRS          CHAMELEON_FNAME(zgetrs       , ZGETRS       )
#define CHAMELEON_ZGETRS_INCPIV   CHAMELEON_FNAME(zgetrs_incpiv, ZGETRS_INCPIV)
#define CHAMELEON_ZGETRS_NOPIV    CHAMELEON_FNAME(zgetrs_nopiv , ZGETRS_NOPIV)
//#define CHAMELEON_ZHEEV           CHAMELEON_FNAME(zheev        , ZHEEV        )
//#define CHAMELEON_ZHEEVD          CHAMELEON_FNAME(zheevd       , ZHEEVD       )
//#define CHAMELEON_ZHEGST          CHAMELEON_FNAME(zhegst       , ZHEGST       )
//#define CHAMELEON_ZHEGV           CHAMELEON_FNAME(zhegv        , ZHEGV        )
//#define CHAMELEON_ZHEGVD          CHAMELEON_FNAME(zhegvd       , ZHEGVD       )
#if defined(PRECISION_z) || defined(PRECISION_c)
#define CHAMELEON_ZHEMM           CHAMELEON_FNAME(zhemm        , ZHEMM        )
#endif
#if defined(PRECISION_z) || defined(PRECISION_c)
#define CHAMELEON_ZHER2K          CHAMELEON_FNAME(zher2k       , ZHER2K       )
#endif
#if defined(PRECISION_z) || defined(PRECISION_c)
#define CHAMELEON_ZHERK           CHAMELEON_FNAME(zherk        , ZHERK        )
#endif
//#define CHAMELEON_ZHETRD          CHAMELEON_FNAME(zhetrd       , ZHETRD       )
#define CHAMELEON_ZLACPY          CHAMELEON_FNAME(zlacpy       , ZLACPY       )
#define CHAMELEON_ZLANGE          CHAMELEON_FNAME(zlange       , ZLANGE       )
#if defined(PRECISION_z) || defined(PRECISION_c)
#define CHAMELEON_ZLANHE          CHAMELEON_FNAME(zlanhe       , ZLANHE       )
#endif
#define CHAMELEON_ZLANSY          CHAMELEON_FNAME(zlansy       , ZLANSY       )
#define CHAMELEON_ZLANTR          CHAMELEON_FNAME(zlantr       , ZLANTR       )
#define CHAMELEON_ZLASET          CHAMELEON_FNAME(zlaset       , ZLASET       )
//#define CHAMELEON_ZLASWP          CHAMELEON_FNAME(zlaswp       , ZLASWP       )
//#define CHAMELEON_ZLASWPC         CHAMELEON_FNAME(zlaswpc      , ZLASWPC      )
#define CHAMELEON_ZLAUUM          CHAMELEON_FNAME(zlauum       , ZLAUUM       )
#if defined(PRECISION_z) || defined(PRECISION_c)
#define CHAMELEON_ZPLGHE          CHAMELEON_FNAME(zplghe       , ZPLGHE       )
#endif
#define CHAMELEON_ZPLGSY          CHAMELEON_FNAME(zplgsy       , ZPLGSY       )
#define CHAMELEON_ZPLRNT          CHAMELEON_FNAME(zplrnt       , ZPLRNT       )
#define CHAMELEON_ZPLRNK          CHAMELEON_FNAME(zplrnk       , ZPLRNK       )
#define CHAMELEON_ZPOSV           CHAMELEON_FNAME(zposv        , ZPOSV        )
#define CHAMELEON_ZPOTRF          CHAMELEON_FNAME(zpotrf       , ZPOTRF       )
#define CHAMELEON_ZPOTRI          CHAMELEON_FNAME(zpotri       , ZPOTRI       )
#define CHAMELEON_ZPOTRS          CHAMELEON_FNAME(zpotrs       , ZPOTRS       )
#if defined (PRECISION_c) || defined(PRECISION_z)
#define CHAMELEON_ZSYSV           CHAMELEON_FNAME(zsysv        , ZSYSV        )
#define CHAMELEON_ZSYTRF          CHAMELEON_FNAME(zsytrf       , ZSYTRF       )
#define CHAMELEON_ZSYTRS          CHAMELEON_FNAME(zsytrs       , ZSYTRS       )
#endif
#define CHAMELEON_ZSYMM           CHAMELEON_FNAME(zsymm        , ZSYMM        )
#define CHAMELEON_ZSYR2K          CHAMELEON_FNAME(zsyr2k       , ZSYR2K       )
#define CHAMELEON_ZSYRK           CHAMELEON_FNAME(zsyrk        , ZSYRK        )
#define CHAMELEON_ZTRMM           CHAMELEON_FNAME(ztrmm        , ZTRMM        )
#define CHAMELEON_ZTRSM           CHAMELEON_FNAME(ztrsm        , ZTRSM        )
#define CHAMELEON_ZTRSMPL         CHAMELEON_FNAME(ztrsmpl      , ZTRSMPL      )
//#define CHAMELEON_ZTRSMRV         CHAMELEON_FNAME(ztrsmrv      , ZTRSMRV      )
#define CHAMELEON_ZTRTRI          CHAMELEON_FNAME(ztrtri       , ZTRTRI       )
#define CHAMELEON_ZUNGLQ          CHAMELEON_FNAME(zunglq       , ZUNGLQ       )
#define CHAMELEON_ZUNGQR          CHAMELEON_FNAME(zungqr       , ZUNGQR       )
#define CHAMELEON_ZUNMLQ          CHAMELEON_FNAME(zunmlq       , ZUNMLQ       )
#define CHAMELEON_ZUNMQR          CHAMELEON_FNAME(zunmqr       , ZUNMQR       )

/**
 *  FORTRAN API - math functions (native interface)
 */
//#define CHAMELEON_ZGEBRD_TILE          CHAMELEON_TILE_FNAME(zgebrd       , ZGEBRD       )
#define CHAMELEON_ZGELQF_TILE          CHAMELEON_TILE_FNAME(zgelqf       , ZGELQF       )
#define CHAMELEON_ZGELQS_TILE          CHAMELEON_TILE_FNAME(zgelqs       , ZGELQS       )
#define CHAMELEON_ZGELS_TILE           CHAMELEON_TILE_FNAME(zgels        , ZGELS        )
#define CHAMELEON_ZGEMM_TILE           CHAMELEON_TILE_FNAME(zgemm        , ZGEMM        )
#define CHAMELEON_ZGEQRF_TILE          CHAMELEON_TILE_FNAME(zgeqrf       , ZGEQRF       )
#define CHAMELEON_ZGEQRS_TILE          CHAMELEON_TILE_FNAME(zgeqrs       , ZGEQRS       )
//#define CHAMELEON_ZGESV_TILE           CHAMELEON_TILE_FNAME(zgesv        , ZGESV        )
#define CHAMELEON_ZGESV_INCPIV_TILE    CHAMELEON_TILE_FNAME(zgesv_incpiv , ZGESV_INCPIV )
#define CHAMELEON_ZGESV_NOPIV_TILE     CHAMELEON_TILE_FNAME(zgesv_nopiv  , ZGESV_NOPIV  )
//#define CHAMELEON_ZGESVD_TILE          CHAMELEON_TILE_FNAME(zgesvd       , ZGESVD       )
//#define CHAMELEON_ZGETRF_TILE          CHAMELEON_TILE_FNAME(zgetrf       , ZGETRF       )
#define CHAMELEON_ZGETRF_INCPIV_TILE   CHAMELEON_TILE_FNAME(zgetrf_incpiv, ZGETRF_INCPIV)
#define CHAMELEON_ZGETRF_NOPIV_TILE    CHAMELEON_TILE_FNAME(zgetrf_nopiv , ZGETRF_NOPIV )
//#define CHAMELEON_ZGETRI_TILE          CHAMELEON_TILE_FNAME(zgetri       , ZGETRI       )
//#define CHAMELEON_ZGETRS_TILE          CHAMELEON_TILE_FNAME(zgetrs       , ZGETRS       )
#define CHAMELEON_ZGETRS_INCPIV_TILE   CHAMELEON_TILE_FNAME(zgetrs_incpiv, ZGETRS_INCPIV)
#define CHAMELEON_ZGETRS_NOPIV_TILE    CHAMELEON_TILE_FNAME(zgetrs_nopiv , ZGETRS_NOPIV )
//#define CHAMELEON_ZHEEV_TILE           CHAMELEON_TILE_FNAME(zheev        , ZHEEV        )
//#define CHAMELEON_ZHEEVD_TILE          CHAMELEON_TILE_FNAME(zheevd       , ZHEEVD       )
//#define CHAMELEON_ZHEGST_TILE          CHAMELEON_TILE_FNAME(zhegst       , ZHEGST       )
//#define CHAMELEON_ZHEGV_TILE           CHAMELEON_TILE_FNAME(zhegv        , ZHEGV        )
//#define CHAMELEON_ZHEGVD_TILE          CHAMELEON_TILE_FNAME(zhegvd       , ZHEGVD       )
#if defined(PRECISION_z) || defined(PRECISION_c)
#define CHAMELEON_ZHEMM_TILE           CHAMELEON_TILE_FNAME(zhemm        , ZHEMM        )
#endif
#if defined(PRECISION_z) || defined(PRECISION_c)
#define CHAMELEON_ZHER2K_TILE          CHAMELEON_TILE_FNAME(zher2k       , ZHER2K       )
#endif
#if defined(PRECISION_z) || defined(PRECISION_c)
#define CHAMELEON_ZHERK_TILE           CHAMELEON_TILE_FNAME(zherk        , ZHERK        )
#endif
//#define CHAMELEON_ZHETRD_TILE          CHAMELEON_TILE_FNAME(zhetrd       , ZHETRD       )
#define CHAMELEON_ZLACPY_TILE          CHAMELEON_TILE_FNAME(zlacpy       , ZLACPY       )
#define CHAMELEON_ZLANGE_TILE          CHAMELEON_TILE_FNAME(zlange       , ZLANGE       )
#if defined(PRECISION_z) || defined(PRECISION_c)
#define CHAMELEON_ZLANHE_TILE          CHAMELEON_TILE_FNAME(zlanhe       , ZLANHE       )
#endif
#define CHAMELEON_ZLANSY_TILE          CHAMELEON_TILE_FNAME(zlansy       , ZLANSY       )
#define CHAMELEON_ZLASET_TILE          CHAMELEON_TILE_FNAME(zlaset       , ZLASET       )
//#define CHAMELEON_ZLASWP_TILE          CHAMELEON_TILE_FNAME(zlaswp       , ZLASWP       )
//#define CHAMELEON_ZLASWPC_TILE         CHAMELEON_TILE_FNAME(zlaswpc      , ZLASWPC      )
#define CHAMELEON_ZLAUUM_TILE          CHAMELEON_TILE_FNAME(zlauum       , ZLAUUM       )
#if defined(PRECISION_z) || defined(PRECISION_c)
#define CHAMELEON_ZPLGHE_TILE          CHAMELEON_TILE_FNAME(zplghe       , ZPLGHE       )
#endif
#define CHAMELEON_ZPLGSY_TILE          CHAMELEON_TILE_FNAME(zplgsy       , ZPLGSY       )
#define CHAMELEON_ZPLRNT_TILE          CHAMELEON_TILE_FNAME(zplrnt       , ZPLRNT       )
#define CHAMELEON_ZPLRNK_TILE          CHAMELEON_TILE_FNAME(zplrnk       , ZPLRNK       )
#define CHAMELEON_ZPOSV_TILE           CHAMELEON_TILE_FNAME(zposv        , ZPOSV        )
#define CHAMELEON_ZPOTRF_TILE          CHAMELEON_TILE_FNAME(zpotrf       , ZPOTRF       )
#define CHAMELEON_ZPOTRI_TILE          CHAMELEON_TILE_FNAME(zpotri       , ZPOTRI       )
#define CHAMELEON_ZPOTRS_TILE          CHAMELEON_TILE_FNAME(zpotrs       , ZPOTRS       )
#if defined (PRECISION_c) || defined(PRECISION_z)
#define CHAMELEON_ZSYSV_TILE           CHAMELEON_TILE_FNAME(zsysv        , ZSYSV        )
#define CHAMELEON_ZSYTRF_TILE          CHAMELEON_TILE_FNAME(zsytrf       , ZSYTRF       )
#define CHAMELEON_ZSYTRS_TILE          CHAMELEON_TILE_FNAME(zsytrs       , ZSYTRS       )
#endif
#define CHAMELEON_ZSYMM_TILE           CHAMELEON_TILE_FNAME(zsymm        , ZSYMM        )
#define CHAMELEON_ZSYR2K_TILE          CHAMELEON_TILE_FNAME(zsyr2k       , ZSYR2K       )
#define CHAMELEON_ZSYRK_TILE           CHAMELEON_TILE_FNAME(zsyrk        , ZSYRK        )
#define CHAMELEON_ZTRMM_TILE           CHAMELEON_TILE_FNAME(ztrmm        , ZTRMM        )
#define CHAMELEON_ZTRSM_TILE           CHAMELEON_TILE_FNAME(ztrsm        , ZTRSM        )
#define CHAMELEON_ZTRSMPL_TILE         CHAMELEON_TILE_FNAME(ztrsmpl      , ZTRSMPL      )
//#define CHAMELEON_ZTRSMRV_TILE         CHAMELEON_TILE_FNAME(ztrsmrv      , ZTRSMRV      )
#define CHAMELEON_ZTRTRI_TILE          CHAMELEON_TILE_FNAME(ztrtri       , ZTRTRI       )
#define CHAMELEON_ZUNGLQ_TILE          CHAMELEON_TILE_FNAME(zunglq       , ZUNGLQ       )
#define CHAMELEON_ZUNGQR_TILE          CHAMELEON_TILE_FNAME(zungqr       , ZUNGQR       )
#define CHAMELEON_ZUNMLQ_TILE          CHAMELEON_TILE_FNAME(zunmlq       , ZUNMLQ       )
#define CHAMELEON_ZUNMQR_TILE          CHAMELEON_TILE_FNAME(zunmqr       , ZUNMQR       )

/**
 *  FORTRAN API - math functions (asynchronous interface)
 */
//#define CHAMELEON_ZGEBRD_TILE_ASYNC          CHAMELEON_ASYNC_FNAME(zgebrd       , ZGEBRD       )
#define CHAMELEON_ZGELQF_TILE_ASYNC          CHAMELEON_ASYNC_FNAME(zgelqf       , ZGELQF       )
#define CHAMELEON_ZGELQS_TILE_ASYNC          CHAMELEON_ASYNC_FNAME(zgelqs       , ZGELQS       )
#define CHAMELEON_ZGELS_TILE_ASYNC           CHAMELEON_ASYNC_FNAME(zgels        , ZGELS        )
#define CHAMELEON_ZGEMM_TILE_ASYNC           CHAMELEON_ASYNC_FNAME(zgemm        , ZGEMM        )
#define CHAMELEON_ZGEQRF_TILE_ASYNC          CHAMELEON_ASYNC_FNAME(zgeqrf       , ZGEQRF       )
#define CHAMELEON_ZGEQRS_TILE_ASYNC          CHAMELEON_ASYNC_FNAME(zgeqrs       , ZGEQRS       )
//#define CHAMELEON_ZGESV_TILE_ASYNC           CHAMELEON_ASYNC_FNAME(zgesv        , ZGESV        )
#define CHAMELEON_ZGESV_INCPIV_TILE_ASYNC    CHAMELEON_ASYNC_FNAME(zgesv_incpiv , ZGESV_INCPIV )
#define CHAMELEON_ZGESV_NOPIV_TILE_ASYNC     CHAMELEON_ASYNC_FNAME(zgesv_nopiv  , ZGESV_NOPIV  )
//#define CHAMELEON_ZGESVD_TILE_ASYNC          CHAMELEON_ASYNC_FNAME(zgesvd       , ZGESVD       )
//#define CHAMELEON_ZGETRF_TILE_ASYNC          CHAMELEON_ASYNC_FNAME(zgetrf       , ZGETRF       )
#define CHAMELEON_ZGETRF_INCPIV_TILE_ASYNC   CHAMELEON_ASYNC_FNAME(zgetrf_incpiv, ZGETRF_INCPIV)
#define CHAMELEON_ZGETRF_NOPIV_TILE_ASYNC    CHAMELEON_ASYNC_FNAME(zgetrf_nopiv , ZGETRF_NOPIV )
//#define CHAMELEON_ZGETRI_TILE_ASYNC          CHAMELEON_ASYNC_FNAME(zgetri       , ZGETRI       )
//#define CHAMELEON_ZGETRS_TILE_ASYNC          CHAMELEON_ASYNC_FNAME(zgetrs       , ZGETRS       )
#define CHAMELEON_ZGETRS_INCPIV_TILE_ASYNC   CHAMELEON_ASYNC_FNAME(zgetrs_incpiv, ZGETRS_INCPIV)
#define CHAMELEON_ZGETRS_NOPIV_TILE_ASYNC    CHAMELEON_ASYNC_FNAME(zgetrs_nopiv , ZGETRS_NOPIV )
//#define CHAMELEON_ZHEEV_TILE_ASYNC           CHAMELEON_ASYNC_FNAME(zheev        , ZHEEV        )
//#define CHAMELEON_ZHEEVD_TILE_ASYNC          CHAMELEON_ASYNC_FNAME(zheevd       , ZHEEVD       )
//#define CHAMELEON_ZHEGST_TILE_ASYNC          CHAMELEON_ASYNC_FNAME(zhegst       , ZHEGST       )
//#define CHAMELEON_ZHEGV_TILE_ASYNC           CHAMELEON_ASYNC_FNAME(zhegv        , ZHEGV        )
//#define CHAMELEON_ZHEGVD_TILE_ASYNC          CHAMELEON_ASYNC_FNAME(zhegvd       , ZHEGVD       )
#if defined(PRECISION_z) || defined(PRECISION_c)
#define CHAMELEON_ZHEMM_TILE_ASYNC           CHAMELEON_ASYNC_FNAME(zhemm        , ZHEMM        )
#define CHAMELEON_ZHER2K_TILE_ASYNC          CHAMELEON_ASYNC_FNAME(zher2k       , ZHER2K       )
#define CHAMELEON_ZHERK_TILE_ASYNC           CHAMELEON_ASYNC_FNAME(zherk        , ZHERK        )
#endif
//#define CHAMELEON_ZHETRD_TILE_ASYNC          CHAMELEON_ASYNC_FNAME(zhetrd       , ZHETRD       )
#define CHAMELEON_ZLACPY_TILE_ASYNC          CHAMELEON_ASYNC_FNAME(zlacpy       , ZLACPY       )
#define CHAMELEON_ZLANGE_TILE_ASYNC          CHAMELEON_ASYNC_FNAME(zlange       , ZLANGE       )
#if defined(PRECISION_z) || defined(PRECISION_c)
#define CHAMELEON_ZLANHE_TILE_ASYNC          CHAMELEON_ASYNC_FNAME(zlanhe       , ZLANHE       )
#endif
#define CHAMELEON_ZLANSY_TILE_ASYNC          CHAMELEON_ASYNC_FNAME(zlansy       , ZLANSY       )
#define CHAMELEON_ZLANTR_TILE_ASYNC          CHAMELEON_ASYNC_FNAME(zlantr       , ZLANTR       )
#define CHAMELEON_ZLASET_TILE_ASYNC          CHAMELEON_ASYNC_FNAME(zlaset       , ZLASET       )
//#define CHAMELEON_ZLASWP_TILE_ASYNC          CHAMELEON_ASYNC_FNAME(zlaswp       , ZLASWP       )
//#define CHAMELEON_ZLASWPC_TILE_ASYNC         CHAMELEON_ASYNC_FNAME(zlaswpc      , ZLASWPC      )
#define CHAMELEON_ZLAUUM_TILE_ASYNC          CHAMELEON_ASYNC_FNAME(zlauum       , ZLAUUM       )
#if defined(PRECISION_z) || defined(PRECISION_c)
#define CHAMELEON_ZPLGHE_TILE_ASYNC          CHAMELEON_ASYNC_FNAME(zplghe       , ZPLGHE       )
#endif
#define CHAMELEON_ZPLGSY_TILE_ASYNC          CHAMELEON_ASYNC_FNAME(zplgsy       , ZPLGSY       )
#define CHAMELEON_ZPLRNT_TILE_ASYNC          CHAMELEON_ASYNC_FNAME(zplrnt       , ZPLRNT       )
#define CHAMELEON_ZPLRNK_TILE_ASYNC          CHAMELEON_ASYNC_FNAME(zplrnk       , ZPLRNK       )
#define CHAMELEON_ZPOSV_TILE_ASYNC           CHAMELEON_ASYNC_FNAME(zposv        , ZPOSV        )
#define CHAMELEON_ZPOTRF_TILE_ASYNC          CHAMELEON_ASYNC_FNAME(zpotrf       , ZPOTRF       )
#define CHAMELEON_ZPOTRI_TILE_ASYNC          CHAMELEON_ASYNC_FNAME(zpotri       , ZPOTRI       )
#define CHAMELEON_ZPOTRS_TILE_ASYNC          CHAMELEON_ASYNC_FNAME(zpotrs       , ZPOTRS       )
#if defined (PRECISION_c) || defined(PRECISION_z)
#define CHAMELEON_ZSYSV_TILE_ASYNC           CHAMELEON_ASYNC_FNAME(zsysv        , ZSYSV        )
#define CHAMELEON_ZSYTRF_TILE_ASYNC          CHAMELEON_ASYNC_FNAME(zsytrf       , ZSYTRF       )
#define CHAMELEON_ZSYTRS_TILE_ASYNC          CHAMELEON_ASYNC_FNAME(zsytrs       , ZSYTRS       )
#endif
#define CHAMELEON_ZSYMM_TILE_ASYNC           CHAMELEON_ASYNC_FNAME(zsymm        , ZSYMM        )
#define CHAMELEON_ZSYR2K_TILE_ASYNC          CHAMELEON_ASYNC_FNAME(zsyr2k       , ZSYR2K       )
#define CHAMELEON_ZSYRK_TILE_ASYNC           CHAMELEON_ASYNC_FNAME(zsyrk        , ZSYRK        )
#define CHAMELEON_ZTRMM_TILE_ASYNC           CHAMELEON_ASYNC_FNAME(ztrmm        , ZTRMM        )
#define CHAMELEON_ZTRSM_TILE_ASYNC           CHAMELEON_ASYNC_FNAME(ztrsm        , ZTRSM        )
#define CHAMELEON_ZTRSMPL_TILE_ASYNC         CHAMELEON_ASYNC_FNAME(ztrsmpl      , ZTRSMPL      )
//#define CHAMELEON_ZTRSMRV_TILE_ASYNC         CHAMELEON_ASYNC_FNAME(ztrsmrv      , ZTRSMRV      )
#define CHAMELEON_ZTRTRI_TILE_ASYNC          CHAMELEON_ASYNC_FNAME(ztrtri       , ZTRTRI       )
#define CHAMELEON_ZUNGLQ_TILE_ASYNC          CHAMELEON_ASYNC_FNAME(zunglq       , ZUNGLQ       )
#define CHAMELEON_ZUNGQR_TILE_ASYNC          CHAMELEON_ASYNC_FNAME(zungqr       , ZUNGQR       )
#define CHAMELEON_ZUNMLQ_TILE_ASYNC          CHAMELEON_ASYNC_FNAME(zunmlq       , ZUNMLQ       )
#define CHAMELEON_ZUNMQR_TILE_ASYNC          CHAMELEON_ASYNC_FNAME(zunmqr       , ZUNMQR       )

/**
 *  FORTRAN API - workspace allocation
 */
//#define CHAMELEON_ALLOC_WORKSPACE_ZGEBRD              CHAMELEON_WS_FNAME(zgebrd            , ZGEBRD            )
//#define CHAMELEON_ALLOC_WORKSPACE_ZGEEV               CHAMELEON_WS_FNAME(zgeev             , ZGEEV             )
//#define CHAMELEON_ALLOC_WORKSPACE_ZGEHRD              CHAMELEON_WS_FNAME(zgehrd            , ZGEHRD            )
#define CHAMELEON_ALLOC_WORKSPACE_ZGELQF              CHAMELEON_WS_FNAME(zgelqf            , ZGELQF            )
#define CHAMELEON_ALLOC_WORKSPACE_ZGELQF_TILE         CHAMELEON_WS_FNAME(zgelqf_tile       , ZGELQF_TILE       )
#define CHAMELEON_ALLOC_WORKSPACE_ZGELS               CHAMELEON_WS_FNAME(zgels             , ZGELS             )
#define CHAMELEON_ALLOC_WORKSPACE_ZGELS_TILE          CHAMELEON_WS_FNAME(zgels_tile        , ZGELS_TILE        )
#define CHAMELEON_ALLOC_WORKSPACE_ZGEQRF              CHAMELEON_WS_FNAME(zgeqrf            , ZGEQRF            )
#define CHAMELEON_ALLOC_WORKSPACE_ZGEQRF_TILE         CHAMELEON_WS_FNAME(zgeqrf_tile       , ZGEQRF_TILE       )
#define CHAMELEON_ALLOC_WORKSPACE_ZGESV_INCPIV        CHAMELEON_WS_FNAME(zgesv_incpiv      , ZGESV_INCPIV      )
#define CHAMELEON_ALLOC_WORKSPACE_ZGESV_INCPIV_TILE   CHAMELEON_WS_FNAME(zgesv_incpiv_tile , ZGESV_INCPIV_TILE )
//#define CHAMELEON_ALLOC_WORKSPACE_ZGESVD              CHAMELEON_WS_FNAME(zgesvd            , ZGESVD            )
#define CHAMELEON_ALLOC_WORKSPACE_ZGETRF_INCPIV       CHAMELEON_WS_FNAME(zgetrf_incpiv     , ZGETRF_INCPIV     )
#define CHAMELEON_ALLOC_WORKSPACE_ZGETRF_INCPIV_TILE  CHAMELEON_WS_FNAME(zgetrf_incpiv_tile, ZGETRF_INCPIV_TILE)
//#define CHAMELEON_ALLOC_WORKSPACE_ZGETRI_TILE_ASYNC   CHAMELEON_WS_FNAME(zgetri_tile_async , ZGETRI_TILE_ASYNC )
//#define CHAMELEON_ALLOC_WORKSPACE_ZHEEV               CHAMELEON_WS_FNAME(zheev             , ZHEEV             )
//#define CHAMELEON_ALLOC_WORKSPACE_ZHEEVD              CHAMELEON_WS_FNAME(zheevd            , ZHEEVD            )
//#define CHAMELEON_ALLOC_WORKSPACE_ZHEGV               CHAMELEON_WS_FNAME(zhegv             , ZHEGV             )
//#define CHAMELEON_ALLOC_WORKSPACE_ZHEGVD              CHAMELEON_WS_FNAME(zhegvd            , ZHEGVD            )
//#define CHAMELEON_ALLOC_WORKSPACE_ZHETRD              CHAMELEON_WS_FNAME(zhetrd            , ZHETRD            )



/**
 *  FORTRAN API - math functions (simple interface)
 */
void CHAMELEON_ZLAPACK_TO_TILE(CHAMELEON_Complex64_t *Af77, int *LDA, CHAM_desc_t *A, int *info)
{ *info = CHAMELEON_zLap2Desc( ChamUpperLower, Af77, *LDA, A ); }

void CHAMELEON_ZTILE_TO_LAPACK(CHAM_desc_t *A, CHAMELEON_Complex64_t *Af77, int *LDA, int *info)
{ *info = CHAMELEON_zDesc2Lap( ChamUpperLower, A, Af77, *LDA ); }

//void CHAMELEON_ZGEBRD(int *M, int *N, CHAMELEON_Complex64_t *A, int *LDA, double *D, double *E, CHAM_desc_t **descT, int *info)
//{ *info = CHAMELEON_zgebrd(*M, *N, A, *LDA, D, E, *descT); }
//
//void CHAMELEON_ZGECFI(int *m, int *n, CHAMELEON_Complex64_t *A, CHAMELEON_enum *fin, int *imb, int *inb, CHAMELEON_enum *fout, int *omb, int *onb, int *info)
//{ *info = CHAMELEON_zgecfi(*m, *n, A, *fin, *imb, *inb, *fout, *omb, *onb); }
//
//void CHAMELEON_ZGECFI_ASYNC(int *m, int *n, CHAMELEON_Complex64_t *A, CHAMELEON_enum *f_in, int *imb, int *inb, CHAMELEON_enum *f_out, int *omb, int *onb, RUNTIME_sequence_t *sequence, RUNTIME_request_t *request, int *info)
//{ *info = CHAMELEON_zgecfi_Async(*m, *n, A, *f_in, *imb, *inb, *f_out, *omb, *onb, sequence, request); }

void CHAMELEON_ZGELQF(int *M, int *N, CHAMELEON_Complex64_t *A, int *LDA, CHAM_desc_t **descT, int *info)
{ *info = CHAMELEON_zgelqf(*M, *N, A, *LDA, *descT); }

void CHAMELEON_ZGELQS(int *M, int *N, int *NRHS, CHAMELEON_Complex64_t *A, int *LDA, CHAM_desc_t **descT, CHAMELEON_Complex64_t *B, int *LDB, int *info)
{ *info = CHAMELEON_zgelqs(*M, *N, *NRHS, A, *LDA, *descT, B, *LDB); }

void CHAMELEON_ZGELS(cham_trans_t *trans, int *M, int *N, int *NRHS, CHAMELEON_Complex64_t *A, int *LDA, CHAM_desc_t **descT, CHAMELEON_Complex64_t *B, int *LDB, int *info)
{ *info = CHAMELEON_zgels(*trans, *M, *N, *NRHS, A, *LDA, *descT, B, *LDB); }

void CHAMELEON_ZGEMM(cham_trans_t *transA, cham_trans_t *transB, int *M, int *N, int *K, CHAMELEON_Complex64_t *alpha, CHAMELEON_Complex64_t *A, int *LDA, CHAMELEON_Complex64_t *B, int *LDB, CHAMELEON_Complex64_t *beta, CHAMELEON_Complex64_t *C, int *LDC, int *info)
{ *info = CHAMELEON_zgemm(*transA, *transB, *M, *N, *K, *alpha, A, *LDA, B, *LDB, *beta, C, *LDC); }

void CHAMELEON_ZGEQRF(int *M, int *N, CHAMELEON_Complex64_t *A, int *LDA, CHAM_desc_t **descT, int *info)
{ *info = CHAMELEON_zgeqrf(*M, *N, A, *LDA, *descT); }

void CHAMELEON_ZGEQRS(int *M, int *N, int *NRHS, CHAMELEON_Complex64_t *A, int *LDA, CHAM_desc_t **descT, CHAMELEON_Complex64_t *B, int *LDB, int *info)
{ *info = CHAMELEON_zgeqrs(*M, *N, *NRHS, A, *LDA, *descT, B, *LDB); }

//void CHAMELEON_ZGESV(int *N, int *NRHS, CHAMELEON_Complex64_t *A, int *LDA, int *IPIV, CHAMELEON_Complex64_t *B, int *LDB, int *info)
//{ *info = CHAMELEON_zgesv(*N, *NRHS, A, *LDA, IPIV, B, *LDB); }

void CHAMELEON_ZGESV_INCPIV(int *N, int *NRHS, CHAMELEON_Complex64_t *A, int *LDA, CHAM_desc_t **descL, int *IPIV, CHAMELEON_Complex64_t *B, int *LDB, int *info)
{ *info = CHAMELEON_zgesv_incpiv(*N, *NRHS, A, *LDA, *descL, IPIV, B, *LDB); }

void CHAMELEON_ZGESV_NOPIV(int *N, int *NRHS, CHAMELEON_Complex64_t *A, int *LDA, CHAMELEON_Complex64_t *B, int *LDB, int *info)
{ *info = CHAMELEON_zgesv_nopiv(*N, *NRHS, A, *LDA, B, *LDB); }

//void CHAMELEON_ZGESVD(CHAMELEON_enum *jobu, CHAMELEON_enum *jobvt, int *M, int *N, CHAMELEON_Complex64_t *A, int *LDA, double *S, CHAMELEON_Complex64_t *U, int *LDU, CHAMELEON_Complex64_t *VT, int *LDVT, CHAM_desc_t **descT, int *info)
//{ *info = CHAMELEON_zgesvd(*jobu, *jobvt, *M, *N, A, *LDA, S, U, *LDU, VT, *LDVT, *descT); }

//void CHAMELEON_ZGETMI(int *m, int *n, CHAMELEON_Complex64_t *A, CHAMELEON_enum *fin, int *mb, int *nb, int *info)
//{ *info = CHAMELEON_zgetmi(*m, *n, A, *fin, *mb, *nb); }
//
//void CHAMELEON_ZGETMI_ASYNC(int *m, int *n, CHAMELEON_Complex64_t *A, CHAMELEON_enum *f_in, int *mb, int *inb, RUNTIME_sequence_t *sequence, RUNTIME_request_t *request, int *info)
//{ *info = CHAMELEON_zgetmi_Async(*m, *n, A, *f_in, *mb, *inb, sequence, request); }
//
//void CHAMELEON_ZGETRF(int *M, int *N, CHAMELEON_Complex64_t *A, int *LDA, int *IPIV, int *info)
//{ *info = CHAMELEON_zgetrf(*M, *N, A, *LDA, IPIV); }

void CHAMELEON_ZGETRF_INCPIV(int *M, int *N, CHAMELEON_Complex64_t *A, int *LDA, CHAM_desc_t **descL, int *IPIV, int *info)
{ *info = CHAMELEON_zgetrf_incpiv(*M, *N, A, *LDA, *descL, IPIV); }

void CHAMELEON_ZGETRF_NOPIV(int *M, int *N, CHAMELEON_Complex64_t *A, int *LDA, int *info)
{ *info = CHAMELEON_zgetrf_nopiv(*M, *N, A, *LDA); }

//void CHAMELEON_ZGETRI(int *N, CHAMELEON_Complex64_t *A, int *LDA, int *IPIV, int *info)
//{ *info = CHAMELEON_zgetri(*N, A, *LDA, IPIV); }
//
//void CHAMELEON_ZGETRS(cham_trans_t *trans, int *N, int *NRHS, CHAMELEON_Complex64_t *A, int *LDA, int *IPIV, CHAMELEON_Complex64_t *B, int *LDB, int *info)
//{ *info = CHAMELEON_zgetrs(*trans, *N, *NRHS, A, *LDA, IPIV, B, *LDB); }

void CHAMELEON_ZGETRS_INCPIV(cham_trans_t *trans, int *N, int *NRHS, CHAMELEON_Complex64_t *A, int *LDA, CHAM_desc_t **descL, int *IPIV, CHAMELEON_Complex64_t *B, int *LDB, int *info)
{ *info = CHAMELEON_zgetrs_incpiv(*trans, *N, *NRHS, A, *LDA, *descL, IPIV, B, *LDB); }

void CHAMELEON_ZGETRS_NOPIV(cham_trans_t *trans, int *N, int *NRHS, CHAMELEON_Complex64_t *A, int *LDA, CHAMELEON_Complex64_t *B, int *LDB, int *info)
{ *info = CHAMELEON_zgetrs_nopiv(*trans, *N, *NRHS, A, *LDA, B, *LDB); }

//void CHAMELEON_ZHEEV(CHAMELEON_enum *jobz, cham_uplo_t *uplo, int *N, CHAMELEON_Complex64_t *A, int *LDA, double *W, CHAM_desc_t **descT, CHAMELEON_Complex64_t *Q, int *LDQ, int *info)
//{ *info = CHAMELEON_zheev(*jobz, *uplo, *N, A, *LDA, W, *descT, Q, *LDQ); }
//
//void CHAMELEON_ZHEEVD(CHAMELEON_enum *jobz, cham_uplo_t *uplo, int *N, CHAMELEON_Complex64_t *A, int *LDA, double *W, CHAM_desc_t **descT, CHAMELEON_Complex64_t *Q, int *LDQ, int *info)
//{ *info = CHAMELEON_zheevd(*jobz, *uplo, *N, A, *LDA, W, *descT, Q, *LDQ); }
//
//void CHAMELEON_ZHEGST(CHAMELEON_enum *itype, cham_uplo_t *uplo, int *N, CHAMELEON_Complex64_t *A, int *LDA, CHAMELEON_Complex64_t *B, int *LDB, int *info)
//{ *info = CHAMELEON_zhegst(*itype, *uplo, *N, A, *LDA, B, *LDB); }
//
//void CHAMELEON_ZHEGV(CHAMELEON_enum *itype, CHAMELEON_enum *jobz, cham_uplo_t *uplo, int *N, CHAMELEON_Complex64_t *A, int *LDA, CHAMELEON_Complex64_t *B, int *LDB, double *W, CHAM_desc_t **descT, CHAMELEON_Complex64_t *Q, int *LDQ, int *info)
//{ *info = CHAMELEON_zhegv(*itype, *jobz, *uplo, *N, A, *LDA, B, *LDB, W, *descT, Q, *LDQ); }
//
//void CHAMELEON_ZHEGVD(CHAMELEON_enum *itype, CHAMELEON_enum *jobz, cham_uplo_t *uplo, int *N, CHAMELEON_Complex64_t *A, int *LDA, CHAMELEON_Complex64_t *B, int *LDB, double *W, CHAM_desc_t **descT, CHAMELEON_Complex64_t *Q, int *LDQ, int *info)
//{ *info = CHAMELEON_zhegvd(*itype, *jobz, *uplo, *N, A, *LDA, B, *LDB, W, *descT, Q, *LDQ); }

#if defined(PRECISION_z) || defined(PRECISION_c)
void CHAMELEON_ZHEMM(cham_side_t *side, cham_uplo_t *uplo, int *M, int *N, CHAMELEON_Complex64_t *alpha, CHAMELEON_Complex64_t *A, int *LDA, CHAMELEON_Complex64_t *B, int *LDB, CHAMELEON_Complex64_t *beta, CHAMELEON_Complex64_t *C, int *LDC, int *info)
{ *info = CHAMELEON_zhemm(*side, *uplo, *M, *N, *alpha, A, *LDA, B, *LDB, *beta, C, *LDC); }
#endif

#if defined(PRECISION_z) || defined(PRECISION_c)
void CHAMELEON_ZHER2K(cham_uplo_t *uplo, cham_trans_t *trans, int *N, int *K, CHAMELEON_Complex64_t *alpha, CHAMELEON_Complex64_t *A, int *LDA, CHAMELEON_Complex64_t *B, int *LDB, double *beta, CHAMELEON_Complex64_t *C, int *LDC, int *info)
{ *info = CHAMELEON_zher2k(*uplo, *trans, *N, *K, *alpha, A, *LDA, B, *LDB, *beta, C, *LDC); }
#endif

#if defined(PRECISION_z) || defined(PRECISION_c)
void CHAMELEON_ZHERK(cham_uplo_t *uplo, cham_trans_t *trans, int *N, int *K, double *alpha, CHAMELEON_Complex64_t *A, int *LDA, double *beta, CHAMELEON_Complex64_t *C, int *LDC, int *info)
{ *info = CHAMELEON_zherk(*uplo, *trans, *N, *K, *alpha, A, *LDA, *beta, C, *LDC); }
#endif

//void CHAMELEON_ZHETRD(CHAMELEON_enum *jobz, cham_uplo_t *uplo, int *N, CHAMELEON_Complex64_t *A, int *LDA, double *D, double *E, CHAM_desc_t **descT, CHAMELEON_Complex64_t *Q, int *LDQ, int *info)
//{ *info = CHAMELEON_zhetrd(*jobz, *uplo, *N, A, *LDA, D, E, *descT, Q, *LDQ); }

void CHAMELEON_ZLACPY(cham_uplo_t *uplo, int *M, int *N, CHAMELEON_Complex64_t *A, int *LDA, CHAMELEON_Complex64_t *B, int *LDB, int *info)
{ *info = CHAMELEON_zlacpy(*uplo, *M, *N, A, *LDA, B, *LDB); }

void CHAMELEON_ZLANGE(cham_normtype_t *norm, int *M, int *N, CHAMELEON_Complex64_t *A, int *LDA, double *result)
{ *result = CHAMELEON_zlange(*norm, *M, *N, A, *LDA); }

#if defined(PRECISION_z) || defined(PRECISION_c)
void CHAMELEON_ZLANHE(cham_normtype_t *norm, cham_uplo_t *uplo, int *N, CHAMELEON_Complex64_t *A, int *LDA, double *result)
{ *result = CHAMELEON_zlanhe(*norm, *uplo, *N, A, *LDA); }
#endif

void CHAMELEON_ZLANSY(cham_normtype_t *norm, cham_uplo_t *uplo, int *N, CHAMELEON_Complex64_t *A, int *LDA, double *result)
{ *result = CHAMELEON_zlansy(*norm, *uplo, *N, A, *LDA); }

void CHAMELEON_ZLANTR(cham_normtype_t *norm, cham_uplo_t *uplo, cham_diag_t *diag, int *M, int *N, CHAMELEON_Complex64_t *A, int *LDA, double *result)
{ *result = CHAMELEON_zlantr(*norm, *uplo, *diag, *M, *N, A, *LDA); }

void CHAMELEON_ZLASET(cham_uplo_t *uplo, int *M, int *N, CHAMELEON_Complex64_t *alpha, CHAMELEON_Complex64_t *beta, CHAMELEON_Complex64_t *A, int *LDA, int *info)
{ *info = CHAMELEON_zlaset(*uplo, *M, *N, *alpha, *beta, A, *LDA); }

//void CHAMELEON_ZLASWP(int *N, CHAMELEON_Complex64_t *A, int *LDA, int *K1, int *K2, int *IPIV, int *INCX, int *info)
//{ *info = CHAMELEON_zlaswp(*N, A, *LDA, *K1, *K2, IPIV, *INCX); }
//
//void CHAMELEON_ZLASWPC(int *N, CHAMELEON_Complex64_t *A, int *LDA, int *K1, int *K2, int *IPIV, int *INCX, int *info)
//{ *info = CHAMELEON_zlaswpc(*N, A, *LDA, *K1, *K2, IPIV, *INCX); }

void CHAMELEON_ZLAUUM(cham_uplo_t *uplo, int *N, CHAMELEON_Complex64_t *A, int *LDA, int *info)
{ *info = CHAMELEON_zlauum(*uplo, *N, A, *LDA); }

#if defined(PRECISION_z) || defined(PRECISION_c)
void CHAMELEON_ZPLGHE(double *bump, cham_uplo_t *uplo, int *N, CHAMELEON_Complex64_t *A, int *LDA, unsigned long long int  *seed, int *info)
{ *info = CHAMELEON_zplghe(*bump, *uplo, *N, A, *LDA, *seed); }
#endif

void CHAMELEON_ZPLGSY(CHAMELEON_Complex64_t *bump, cham_uplo_t *uplo, int *N, CHAMELEON_Complex64_t *A, int *LDA, unsigned long long int  *seed, int *info)
{ *info = CHAMELEON_zplgsy(*bump, *uplo, *N, A, *LDA, *seed); }

void CHAMELEON_ZPLRNT(int *M, int *N, CHAMELEON_Complex64_t *A, int *LDA, unsigned long long int  *seed, int *info)
{ *info = CHAMELEON_zplrnt(*M, *N, A, *LDA, *seed); }

void CHAMELEON_ZPLRNK(int *M, int *N, int *K, CHAMELEON_Complex64_t *C, int *LDC, unsigned long long int  *seedA, unsigned long long int  *seedB, int *info)
{ *info = CHAMELEON_zplrnk(*M, *N, *K, C, *LDC, *seedA, *seedB); }

void CHAMELEON_ZPOSV(cham_uplo_t *uplo, int *N, int *NRHS, CHAMELEON_Complex64_t *A, int *LDA, CHAMELEON_Complex64_t *B, int *LDB, int *info)
{ *info = CHAMELEON_zposv(*uplo, *N, *NRHS, A, *LDA, B, *LDB); }

void CHAMELEON_ZPOTRF(cham_uplo_t *uplo, int *N, CHAMELEON_Complex64_t *A, int *LDA, int *info)
{ *info = CHAMELEON_zpotrf(*uplo, *N, A, *LDA); }

void CHAMELEON_ZPOTRI(cham_uplo_t *uplo, int *N, CHAMELEON_Complex64_t *A, int *LDA, int *info)
{ *info = CHAMELEON_zpotri(*uplo, *N, A, *LDA); }

void CHAMELEON_ZPOTRS(cham_uplo_t *uplo, int *N, int *NRHS, CHAMELEON_Complex64_t *A, int *LDA, CHAMELEON_Complex64_t *B, int *LDB, int *info)
{ *info = CHAMELEON_zpotrs(*uplo, *N, *NRHS, A, *LDA, B, *LDB); }

#if defined (PRECISION_c) || defined(PRECISION_z)
void CHAMELEON_ZSYSV(cham_uplo_t *uplo, int *N, int *NRHS, CHAMELEON_Complex64_t *A, int *LDA, CHAMELEON_Complex64_t *B, int *LDB, int *info)
{ *info = CHAMELEON_zsysv(*uplo, *N, *NRHS, A, *LDA, B, *LDB); }

void CHAMELEON_ZSYTRF(cham_uplo_t *uplo, int *N, CHAMELEON_Complex64_t *A, int *LDA, int *info)
{ *info = CHAMELEON_zsytrf(*uplo, *N, A, *LDA); }

void CHAMELEON_ZSYTRS(cham_uplo_t *uplo, int *N, int *NRHS, CHAMELEON_Complex64_t *A, int *LDA, CHAMELEON_Complex64_t *B, int *LDB, int *info)
{ *info = CHAMELEON_zsytrs(*uplo, *N, *NRHS, A, *LDA, B, *LDB); }
#endif

void CHAMELEON_ZSYMM(cham_side_t *side, cham_uplo_t *uplo, int *M, int *N, CHAMELEON_Complex64_t *alpha, CHAMELEON_Complex64_t *A, int *LDA, CHAMELEON_Complex64_t *B, int *LDB, CHAMELEON_Complex64_t *beta, CHAMELEON_Complex64_t *C, int *LDC, int *info)
{ *info = CHAMELEON_zsymm(*side, *uplo, *M, *N, *alpha, A, *LDA, B, *LDB, *beta, C, *LDC); }

void CHAMELEON_ZSYR2K(cham_uplo_t *uplo, cham_trans_t *trans, int *N, int *K, CHAMELEON_Complex64_t *alpha, CHAMELEON_Complex64_t *A, int *LDA, CHAMELEON_Complex64_t *B, int *LDB, CHAMELEON_Complex64_t *beta, CHAMELEON_Complex64_t *C, int *LDC, int *info)
{ *info = CHAMELEON_zsyr2k(*uplo, *trans, *N, *K, *alpha, A, *LDA, B, *LDB, *beta, C, *LDC); }

void CHAMELEON_ZSYRK(cham_uplo_t *uplo, cham_trans_t *trans, int *N, int *K, CHAMELEON_Complex64_t *alpha, CHAMELEON_Complex64_t *A, int *LDA, CHAMELEON_Complex64_t *beta, CHAMELEON_Complex64_t *C, int *LDC, int *info)
{ *info = CHAMELEON_zsyrk(*uplo, *trans, *N, *K, *alpha, A, *LDA, *beta, C, *LDC); }

void CHAMELEON_ZTRMM(cham_side_t *side, cham_uplo_t *uplo, cham_trans_t *transA, cham_diag_t *diag, int *N, int *NRHS, CHAMELEON_Complex64_t *alpha, CHAMELEON_Complex64_t *A, int *LDA, CHAMELEON_Complex64_t *B, int *LDB, int *info)
{ *info = CHAMELEON_ztrmm(*side, *uplo, *transA, *diag, *N, *NRHS, *alpha, A, *LDA, B, *LDB); }

void CHAMELEON_ZTRSM(cham_side_t *side, cham_uplo_t *uplo, cham_trans_t *transA, cham_diag_t *diag, int *N, int *NRHS, CHAMELEON_Complex64_t *alpha, CHAMELEON_Complex64_t *A, int *LDA, CHAMELEON_Complex64_t *B, int *LDB, int *info)
{ *info = CHAMELEON_ztrsm(*side, *uplo, *transA, *diag, *N, *NRHS, *alpha, A, *LDA, B, *LDB); }

void CHAMELEON_ZTRSMPL(int *N, int *NRHS, CHAMELEON_Complex64_t *A, int *LDA, CHAM_desc_t **descL, int *IPIV, CHAMELEON_Complex64_t *B, int *LDB, int *info)
{ *info = CHAMELEON_ztrsmpl(*N, *NRHS, A, *LDA, *descL, IPIV, B, *LDB); }

//void CHAMELEON_ZTRSMRV(cham_side_t *side, cham_uplo_t *uplo, cham_trans_t *transA, cham_diag_t *diag, int *N, int *NRHS, CHAMELEON_Complex64_t *alpha, CHAMELEON_Complex64_t *A, int *LDA, CHAMELEON_Complex64_t *B, int *LDB, int *info)
//{ *info = CHAMELEON_ztrsmrv(*side, *uplo, *transA, *diag, *N, *NRHS, *alpha, A, *LDA, B, *LDB); }

void CHAMELEON_ZTRTRI(cham_uplo_t *uplo, cham_diag_t *diag, int *N, CHAMELEON_Complex64_t *A, int *LDA, int *info)
{ *info = CHAMELEON_ztrtri(*uplo, *diag, *N, A, *LDA); }

void CHAMELEON_ZUNGLQ(int *M, int *N, int *K, CHAMELEON_Complex64_t *A, int *LDA, CHAM_desc_t **descT, CHAMELEON_Complex64_t *B, int *LDB, int *info)
{ *info = CHAMELEON_zunglq(*M, *N, *K, A, *LDA, *descT, B, *LDB); }

void CHAMELEON_ZUNGQR(int *M, int *N, int *K, CHAMELEON_Complex64_t *A, int *LDA, CHAM_desc_t **descT, CHAMELEON_Complex64_t *B, int *LDB, int *info)
{ *info = CHAMELEON_zungqr(*M, *N, *K, A, *LDA, *descT, B, *LDB); }

void CHAMELEON_ZUNMLQ(cham_side_t *side, cham_trans_t *trans, int *M, int *N, int *K, CHAMELEON_Complex64_t *A, int *LDA, CHAM_desc_t **descT, CHAMELEON_Complex64_t *B, int *LDB, int *info)
{ *info = CHAMELEON_zunmlq(*side, *trans, *M, *N, *K, A, *LDA, *descT, B, *LDB); }

void CHAMELEON_ZUNMQR(cham_side_t *side, cham_trans_t *trans, int *M, int *N, int *K, CHAMELEON_Complex64_t *A, int *LDA, CHAM_desc_t **descT, CHAMELEON_Complex64_t *B, int *LDB, int *info)
{ *info = CHAMELEON_zunmqr(*side, *trans, *M, *N, *K, A, *LDA, *descT, B, *LDB); }


/**
 *  FORTRAN API - math functions (native interface)
 */
//void CHAMELEON_ZGEBRD_TILE(CHAM_desc_t *A, double *D, double *E, CHAM_desc_t *T, int *info)
//{ *info = CHAMELEON_zgebrd_Tile(A, D, E, T); }

void CHAMELEON_ZGELQF_TILE(CHAM_desc_t *A, CHAM_desc_t *T, int *info)
{ *info = CHAMELEON_zgelqf_Tile(A, T); }

void CHAMELEON_ZGELQS_TILE(CHAM_desc_t *A, CHAM_desc_t *T, CHAM_desc_t *B, int *info)
{ *info = CHAMELEON_zgelqs_Tile(A, T, B); }

void CHAMELEON_ZGELS_TILE(cham_trans_t *trans, CHAM_desc_t *A, CHAM_desc_t *T, CHAM_desc_t *B, int *info)
{ *info = CHAMELEON_zgels_Tile(*trans, A, T, B); }

void CHAMELEON_ZGEMM_TILE(cham_trans_t *transA, cham_trans_t *transB, CHAMELEON_Complex64_t *alpha, CHAM_desc_t *A, CHAM_desc_t *B, CHAMELEON_Complex64_t *beta, CHAM_desc_t *C, int *info)
{ *info = CHAMELEON_zgemm_Tile(*transA, *transB, *alpha, A, B, *beta, C); }

void CHAMELEON_ZGEQRF_TILE(CHAM_desc_t *A, CHAM_desc_t *T, int *info)
{ *info = CHAMELEON_zgeqrf_Tile(A, T); }

void CHAMELEON_ZGEQRS_TILE(CHAM_desc_t *A, CHAM_desc_t *T, CHAM_desc_t *B, int *info)
{ *info = CHAMELEON_zgeqrs_Tile(A, T, B); }

//void CHAMELEON_ZGESV_TILE(CHAM_desc_t *A, int *IPIV, CHAM_desc_t *B, int *info)
//{ *info = CHAMELEON_zgesv_Tile(A, IPIV, B); }

void CHAMELEON_ZGESV_INCPIV_TILE(CHAM_desc_t *A, CHAM_desc_t *L, int *IPIV, CHAM_desc_t *B, int *info)
{ *info = CHAMELEON_zgesv_incpiv_Tile(A, L, IPIV, B); }

void CHAMELEON_ZGESV_NOPIV_TILE(CHAM_desc_t *A, CHAM_desc_t *B, int *info)
{ *info = CHAMELEON_zgesv_nopiv_Tile(A, B); }

//void CHAMELEON_ZGESVD_TILE(CHAMELEON_enum *jobu, CHAMELEON_enum *jobvt, CHAM_desc_t *A, double *S, CHAM_desc_t *U, CHAM_desc_t *VT, CHAM_desc_t *T, int *info)
//{ *info = CHAMELEON_zgesvd_Tile(*jobu, *jobvt, A, S, U, VT, T); }

//void CHAMELEON_ZGETRF_TILE(CHAM_desc_t *A, int *IPIV, int *info)
//{ *info = CHAMELEON_zgetrf_Tile(A, IPIV); }

void CHAMELEON_ZGETRF_INCPIV_TILE(CHAM_desc_t *A, CHAM_desc_t *L, int *IPIV, int *info)
{ *info = CHAMELEON_zgetrf_incpiv_Tile(A, L, IPIV); }

void CHAMELEON_ZGETRF_NOPIV_TILE(CHAM_desc_t *A, int *info)
{ *info = CHAMELEON_zgetrf_nopiv_Tile(A); }

//void CHAMELEON_ZGETRI_TILE(CHAM_desc_t *A, int *IPIV, int *info)
//{ *info = CHAMELEON_zgetri_Tile(A, IPIV); }
//
//void CHAMELEON_ZGETRS_TILE(cham_trans_t *trans, CHAM_desc_t *A, int *IPIV, CHAM_desc_t *B, int *info)
//{ *info = CHAMELEON_zgetrs_Tile(*trans, A, IPIV, B); }

void CHAMELEON_ZGETRS_INCPIV_TILE(CHAM_desc_t *A, CHAM_desc_t *L, int *IPIV, CHAM_desc_t *B, int *info)
{ *info = CHAMELEON_zgetrs_incpiv_Tile(A, L, IPIV, B); }

void CHAMELEON_ZGETRS_NOPIV_TILE(CHAM_desc_t *A, CHAM_desc_t *B, int *info)
{ *info = CHAMELEON_zgetrs_nopiv_Tile(A, B); }

//void CHAMELEON_ZHEEV_TILE(CHAMELEON_enum *jobz, cham_uplo_t *uplo, CHAM_desc_t *A, double *W, CHAM_desc_t *T, CHAMELEON_Complex64_t *Q, int *LDQ, int *info)
//{ *info = CHAMELEON_zheev_Tile(*jobz, *uplo, A, W, T, Q, *LDQ); }
//
//void CHAMELEON_ZHEEVD_TILE(CHAMELEON_enum *jobz, cham_uplo_t *uplo, CHAM_desc_t *A, double *W, CHAM_desc_t *T, CHAMELEON_Complex64_t *Q, int *LDQ, int *info)
//{ *info = CHAMELEON_zheevd_Tile(*jobz, *uplo, A, W, T, Q, *LDQ); }
//
//void CHAMELEON_ZHEGST_TILE(CHAMELEON_enum *itype, cham_uplo_t *uplo, CHAM_desc_t *A, CHAM_desc_t *B, int *info)
//{ *info = CHAMELEON_zhegst_Tile(*itype, *uplo, A, B); }
//
//void CHAMELEON_ZHEGV_TILE(CHAMELEON_enum *itype, CHAMELEON_enum *jobz, cham_uplo_t *uplo, CHAM_desc_t *A, CHAM_desc_t *B, double *W, CHAM_desc_t *T, CHAM_desc_t *Q, int *info)
//{ *info = CHAMELEON_zhegv_Tile(*itype, *jobz, *uplo, A, B, W, T, Q); }
//
//void CHAMELEON_ZHEGVD_TILE(CHAMELEON_enum *itype, CHAMELEON_enum *jobz, cham_uplo_t *uplo, CHAM_desc_t *A, CHAM_desc_t *B, double *W, CHAM_desc_t *T, CHAM_desc_t *Q, int *info)
//{ *info = CHAMELEON_zhegvd_Tile(*itype, *jobz, *uplo, A, B, W, T, Q); }

#if defined(PRECISION_z) || defined(PRECISION_c)
void CHAMELEON_ZHEMM_TILE(cham_side_t *side, cham_uplo_t *uplo, CHAMELEON_Complex64_t *alpha, CHAM_desc_t *A, CHAM_desc_t *B, CHAMELEON_Complex64_t *beta, CHAM_desc_t *C, int *info)
{ *info = CHAMELEON_zhemm_Tile(*side, *uplo, *alpha, A, B, *beta, C); }
#endif

#if defined(PRECISION_z) || defined(PRECISION_c)
void CHAMELEON_ZHER2K_TILE(cham_uplo_t *uplo, cham_trans_t *trans, CHAMELEON_Complex64_t *alpha, CHAM_desc_t *A, CHAM_desc_t *B, double *beta, CHAM_desc_t *C, int *info)
{ *info = CHAMELEON_zher2k_Tile(*uplo, *trans, *alpha, A, B, *beta, C); }
#endif

#if defined(PRECISION_z) || defined(PRECISION_c)
void CHAMELEON_ZHERK_TILE(cham_uplo_t *uplo, cham_trans_t *trans, double *alpha, CHAM_desc_t *A, double *beta, CHAM_desc_t *C, int *info)
{ *info = CHAMELEON_zherk_Tile(*uplo, *trans, *alpha, A, *beta, C); }
#endif

//void CHAMELEON_ZHETRD_TILE(CHAMELEON_enum *jobz, cham_uplo_t *uplo, CHAM_desc_t *A, double *D, double *E, CHAM_desc_t *T, CHAMELEON_Complex64_t *Q, int *LDQ, int *info)
//{ *info = CHAMELEON_zhetrd_Tile(*jobz, *uplo, A, D, E, T, Q, *LDQ); }

void CHAMELEON_ZLACPY_TILE(cham_uplo_t *uplo, CHAM_desc_t *A, CHAM_desc_t *B, int *info)
{ *info = CHAMELEON_zlacpy_Tile(*uplo, A, B); }

void CHAMELEON_ZLANGE_TILE(cham_normtype_t *norm, CHAM_desc_t *A, double *result)
{ *result = CHAMELEON_zlange_Tile(*norm, A); }

#if defined(PRECISION_z) || defined(PRECISION_c)
void CHAMELEON_ZLANHE_TILE(cham_normtype_t *norm, cham_uplo_t *uplo, CHAM_desc_t *A, double *result)
{ *result = CHAMELEON_zlanhe_Tile(*norm, *uplo, A); }
#endif

void CHAMELEON_ZLANSY_TILE(cham_normtype_t *norm, cham_uplo_t *uplo, CHAM_desc_t *A, double *result)
{ *result = CHAMELEON_zlansy_Tile(*norm, *uplo, A); }

void CHAMELEON_ZLANTR_TILE(cham_normtype_t *norm, cham_uplo_t *uplo, cham_diag_t *diag, CHAM_desc_t *A, double *result)
{ *result = CHAMELEON_zlantr_Tile(*norm, *uplo, *diag, A); }

void CHAMELEON_ZLASET_TILE(cham_uplo_t *uplo, CHAMELEON_Complex64_t *alpha, CHAMELEON_Complex64_t *beta, CHAM_desc_t *A, int *info)
{ *info = CHAMELEON_zlaset_Tile(*uplo, *alpha, *beta, A); }

//void CHAMELEON_ZLASWP_TILE(CHAM_desc_t *A, int *K1, int *K2, int *IPIV, int *INCX, int *info)
//{ *info = CHAMELEON_zlaswp_Tile(A, *K1, *K2, IPIV, *INCX); }
//
//void CHAMELEON_ZLASWPC_TILE(CHAM_desc_t *A, int *K1, int *K2, int *IPIV, int *INCX, int *info)
//{ *info = CHAMELEON_zlaswpc_Tile(A, *K1, *K2, IPIV, *INCX); }

void CHAMELEON_ZLAUUM_TILE(cham_uplo_t *uplo, CHAM_desc_t *A, int *info)
{ *info = CHAMELEON_zlauum_Tile(*uplo, A); }

#if defined(PRECISION_z) || defined(PRECISION_c)
void CHAMELEON_ZPLGHE_TILE(double *bump, cham_uplo_t *uplo, CHAM_desc_t *A, unsigned long long int  *seed, int *info)
{ *info = CHAMELEON_zplghe_Tile(*bump, *uplo, A, *seed); }
#endif

void CHAMELEON_ZPLGSY_TILE(CHAMELEON_Complex64_t *bump, cham_uplo_t *uplo, CHAM_desc_t *A, unsigned long long int  *seed, int *info)
{ *info = CHAMELEON_zplgsy_Tile(*bump, *uplo, A, *seed); }

void CHAMELEON_ZPLRNT_TILE(CHAM_desc_t *A, unsigned long long int  *seed, int *info)
{ *info = CHAMELEON_zplrnt_Tile(A, *seed); }

void CHAMELEON_ZPLRNK_TILE(int *K, CHAM_desc_t *C, unsigned long long int  *seedA, unsigned long long int  *seedB, int *info)
{ *info = CHAMELEON_zplrnk_Tile(*K, C, *seedA, *seedB); }

void CHAMELEON_ZPOSV_TILE(cham_uplo_t *uplo, CHAM_desc_t *A, CHAM_desc_t *B, int *info)
{ *info = CHAMELEON_zposv_Tile(*uplo, A, B); }

void CHAMELEON_ZPOTRF_TILE(cham_uplo_t *uplo, CHAM_desc_t *A, int *info)
{ *info = CHAMELEON_zpotrf_Tile(*uplo, A); }

void CHAMELEON_ZPOTRI_TILE(cham_uplo_t *uplo, CHAM_desc_t *A, int *info)
{ *info = CHAMELEON_zpotri_Tile(*uplo, A); }

void CHAMELEON_ZPOTRS_TILE(cham_uplo_t *uplo, CHAM_desc_t *A, CHAM_desc_t *B, int *info)
{ *info = CHAMELEON_zpotrs_Tile(*uplo, A, B); }

#if defined (PRECISION_c) || defined(PRECISION_z)
void CHAMELEON_ZSYSV_TILE(cham_uplo_t *uplo, CHAM_desc_t *A, CHAM_desc_t *B, int *info)
{ *info = CHAMELEON_zsysv_Tile(*uplo, A, B); }

void CHAMELEON_ZSYTRF_TILE(cham_uplo_t *uplo, CHAM_desc_t *A, int *info)
{ *info = CHAMELEON_zsytrf_Tile(*uplo, A); }

void CHAMELEON_ZSYTRS_TILE(cham_uplo_t *uplo, CHAM_desc_t *A, CHAM_desc_t *B, int *info)
{ *info = CHAMELEON_zsytrs_Tile(*uplo, A, B); }
#endif

void CHAMELEON_ZSYMM_TILE(cham_side_t *side, cham_uplo_t *uplo, CHAMELEON_Complex64_t *alpha, CHAM_desc_t *A, CHAM_desc_t *B, CHAMELEON_Complex64_t *beta, CHAM_desc_t *C, int *info)
{ *info = CHAMELEON_zsymm_Tile(*side, *uplo, *alpha, A, B, *beta, C); }

void CHAMELEON_ZSYR2K_TILE(cham_uplo_t *uplo, cham_trans_t *trans, CHAMELEON_Complex64_t *alpha, CHAM_desc_t *A, CHAM_desc_t *B, CHAMELEON_Complex64_t *beta, CHAM_desc_t *C, int *info)
{ *info = CHAMELEON_zsyr2k_Tile(*uplo, *trans, *alpha, A, B, *beta, C); }

void CHAMELEON_ZSYRK_TILE(cham_uplo_t *uplo, cham_trans_t *trans, CHAMELEON_Complex64_t *alpha, CHAM_desc_t *A, CHAMELEON_Complex64_t *beta, CHAM_desc_t *C, int *info)
{ *info = CHAMELEON_zsyrk_Tile(*uplo, *trans, *alpha, A, *beta, C); }

void CHAMELEON_ZTRMM_TILE(cham_side_t *side, cham_uplo_t *uplo, cham_trans_t *transA, cham_diag_t *diag, CHAMELEON_Complex64_t *alpha, CHAM_desc_t *A, CHAM_desc_t *B, int *info)
{ *info = CHAMELEON_ztrmm_Tile(*side, *uplo, *transA, *diag, *alpha, A, B); }

void CHAMELEON_ZTRSM_TILE(cham_side_t *side, cham_uplo_t *uplo, cham_trans_t *transA, cham_diag_t *diag, CHAMELEON_Complex64_t *alpha, CHAM_desc_t *A, CHAM_desc_t *B, int *info)
{ *info = CHAMELEON_ztrsm_Tile(*side, *uplo, *transA, *diag, *alpha, A, B); }

void CHAMELEON_ZTRSMPL_TILE(CHAM_desc_t *A, CHAM_desc_t *L, int *IPIV, CHAM_desc_t *B, int *info)
{ *info = CHAMELEON_ztrsmpl_Tile(A, L, IPIV, B); }

//void CHAMELEON_ZTRSMRV_TILE(cham_side_t *side, cham_uplo_t *uplo, cham_trans_t *transA, cham_diag_t *diag, CHAMELEON_Complex64_t *alpha, CHAM_desc_t *A, CHAM_desc_t *B, int *info)
//{ *info = CHAMELEON_ztrsmrv_Tile(*side, *uplo, *transA, *diag, *alpha, A, B); }

void CHAMELEON_ZTRTRI_TILE(cham_uplo_t *uplo, cham_diag_t *diag, CHAM_desc_t *A, int *info)
{ *info = CHAMELEON_ztrtri_Tile(*uplo, *diag, A); }

void CHAMELEON_ZUNGLQ_TILE(CHAM_desc_t *A, CHAM_desc_t *T, CHAM_desc_t *B, int *info)
{ *info = CHAMELEON_zunglq_Tile(A, T, B); }

void CHAMELEON_ZUNGQR_TILE(CHAM_desc_t *A, CHAM_desc_t *T, CHAM_desc_t *B, int *info)
{ *info = CHAMELEON_zungqr_Tile(A, T, B); }

void CHAMELEON_ZUNMLQ_TILE(cham_side_t *side, cham_trans_t *trans, CHAM_desc_t *A, CHAM_desc_t *T, CHAM_desc_t *B, int *info)
{ *info = CHAMELEON_zunmlq_Tile(*side, *trans, A, T, B); }

void CHAMELEON_ZUNMQR_TILE(cham_side_t *side, cham_trans_t *trans, CHAM_desc_t *A, CHAM_desc_t *T, CHAM_desc_t *B, int *info)
{ *info = CHAMELEON_zunmqr_Tile(*side, *trans, A, T, B); }


/**
 *  FORTRAN API - math functions (asynchronous interface)
 */
//void CHAMELEON_ZGEBRD_TILE_ASYNC(CHAM_desc_t *A, double *D, double *E, CHAM_desc_t *T, RUNTIME_sequence_t *sequence, RUNTIME_request_t *request, int *info)
//{ *info = CHAMELEON_zgebrd_Tile_Async(A, D, E, T, sequence, request); }

void CHAMELEON_ZGELQF_TILE_ASYNC(CHAM_desc_t *A, CHAM_desc_t *T, RUNTIME_sequence_t *sequence, RUNTIME_request_t *request, int *info)
{ *info = CHAMELEON_zgelqf_Tile_Async(A, T, sequence, request); }

void CHAMELEON_ZGELQS_TILE_ASYNC(CHAM_desc_t *A, CHAM_desc_t *T, CHAM_desc_t *B, RUNTIME_sequence_t *sequence, RUNTIME_request_t *request, int *info)
{ *info = CHAMELEON_zgelqs_Tile_Async(A, T, B, sequence, request); }

void CHAMELEON_ZGELS_TILE_ASYNC(cham_trans_t *trans, CHAM_desc_t *A, CHAM_desc_t *T, CHAM_desc_t *B, RUNTIME_sequence_t *sequence, RUNTIME_request_t *request, int *info)
{ *info = CHAMELEON_zgels_Tile_Async(*trans, A, T, B, sequence, request); }

void CHAMELEON_ZGEMM_TILE_ASYNC(cham_trans_t *transA, cham_trans_t *transB, CHAMELEON_Complex64_t *alpha, CHAM_desc_t *A, CHAM_desc_t *B, CHAMELEON_Complex64_t *beta, CHAM_desc_t *C, RUNTIME_sequence_t *sequence, RUNTIME_request_t *request, int *info)
{ *info = CHAMELEON_zgemm_Tile_Async(*transA, *transB, *alpha, A, B, *beta, C, NULL, sequence, request); }

void CHAMELEON_ZGEQRF_TILE_ASYNC(CHAM_desc_t *A, CHAM_desc_t *T, RUNTIME_sequence_t *sequence, RUNTIME_request_t *request, int *info)
{ *info = CHAMELEON_zgeqrf_Tile_Async(A, T, sequence, request); }

void CHAMELEON_ZGEQRS_TILE_ASYNC(CHAM_desc_t *A, CHAM_desc_t *T, CHAM_desc_t *B, RUNTIME_sequence_t *sequence, RUNTIME_request_t *request, int *info)
{ *info = CHAMELEON_zgeqrs_Tile_Async(A, T, B, sequence, request); }

//void CHAMELEON_ZGESV_TILE_ASYNC(CHAM_desc_t *A, int *IPIV, CHAM_desc_t *B, RUNTIME_sequence_t *sequence, RUNTIME_request_t *request, int *info)
//{ *info = CHAMELEON_zgesv_Tile_Async(A, IPIV, B, sequence, request); }

void CHAMELEON_ZGESV_INCPIV_TILE_ASYNC(CHAM_desc_t *A, CHAM_desc_t *L, int *IPIV, CHAM_desc_t *B, RUNTIME_sequence_t *sequence, RUNTIME_request_t *request, int *info)
{ *info = CHAMELEON_zgesv_incpiv_Tile_Async(A, L, IPIV, B, sequence, request); }

//void CHAMELEON_ZGESV_NOPIV_TILE_ASYNC(CHAM_desc_t *A, CHAM_desc_t *B, RUNTIME_sequence_t *sequence, RUNTIME_request_t *request, int *info)
//{ *info = CHAMELEON_zgesv_nopiv_Tile_Async(A, B, sequence, request); }
//
//void CHAMELEON_ZGESVD_TILE_ASYNC(CHAMELEON_enum *jobu, CHAMELEON_enum *jobvt, CHAM_desc_t *A, double *S, CHAM_desc_t *U, CHAM_desc_t *VT, CHAM_desc_t *T, RUNTIME_sequence_t *sequence, RUNTIME_request_t *request, int *info)
//{ *info = CHAMELEON_zgesvd_Tile_Async(*jobu, *jobvt, A, S, U, VT, T, sequence, request); }

//void CHAMELEON_ZGETRF_TILE_ASYNC(CHAM_desc_t *A, int *IPIV, RUNTIME_sequence_t *sequence, RUNTIME_request_t *request, int *info)
//{ *info = CHAMELEON_zgetrf_Tile_Async(A, IPIV, sequence, request); }

void CHAMELEON_ZGETRF_INCPIV_TILE_ASYNC(CHAM_desc_t *A, CHAM_desc_t *L, int *IPIV, RUNTIME_sequence_t *sequence, RUNTIME_request_t *request, int *info)
{ *info = CHAMELEON_zgetrf_incpiv_Tile_Async(A, L, IPIV, sequence, request); }

void CHAMELEON_ZGETRF_NOPIV_TILE_ASYNC(CHAM_desc_t *A, RUNTIME_sequence_t *sequence, RUNTIME_request_t *request, int *info)
{ *info = CHAMELEON_zgetrf_nopiv_Tile_Async(A, sequence, request); }

//void CHAMELEON_ZGETRI_TILE_ASYNC(CHAM_desc_t *A, int *IPIV, CHAM_desc_t *W, RUNTIME_sequence_t *sequence, RUNTIME_request_t *request, int *info)
//{ *info = CHAMELEON_zgetri_Tile_Async(A, IPIV, W, sequence, request); }
//
//void CHAMELEON_ZGETRS_TILE_ASYNC(cham_trans_t *trans, CHAM_desc_t *A, int *IPIV, CHAM_desc_t *B, RUNTIME_sequence_t *sequence, RUNTIME_request_t *request, int *info)
//{ *info = CHAMELEON_zgetrs_Tile_Async(*trans, A, IPIV, B, sequence, request); }

void CHAMELEON_ZGETRS_INCPIV_TILE_ASYNC(CHAM_desc_t *A, CHAM_desc_t *L, int *IPIV, CHAM_desc_t *B, RUNTIME_sequence_t *sequence, RUNTIME_request_t *request, int *info)
{ *info = CHAMELEON_zgetrs_incpiv_Tile_Async(A, L, IPIV, B, sequence, request); }

void CHAMELEON_ZGETRS_NOPIV_TILE_ASYNC(CHAM_desc_t *A, CHAM_desc_t *B, RUNTIME_sequence_t *sequence, RUNTIME_request_t *request, int *info)
{ *info = CHAMELEON_zgetrs_nopiv_Tile_Async(A, B, sequence, request); }

//void CHAMELEON_ZHEEV_TILE_ASYNC(CHAMELEON_enum *jobz, cham_uplo_t *uplo, CHAM_desc_t *A, double *W, CHAM_desc_t *T, CHAMELEON_Complex64_t *Q, int *LDQ, RUNTIME_sequence_t *sequence, RUNTIME_request_t *request, int *info)
//{ *info = CHAMELEON_zheev_Tile_Async(*jobz, *uplo, A, W, T, Q, *LDQ, sequence, request); }
//
//void CHAMELEON_ZHEEVD_TILE_ASYNC(CHAMELEON_enum *jobz, cham_uplo_t *uplo, CHAM_desc_t *A, double *W, CHAM_desc_t *T, CHAMELEON_Complex64_t *Q, int *LDQ, RUNTIME_sequence_t *sequence, RUNTIME_request_t *request, int *info)
//{ *info = CHAMELEON_zheevd_Tile_Async(*jobz, *uplo, A, W, T, Q, *LDQ, sequence, request); }
//
//void CHAMELEON_ZHEGST_TILE_ASYNC(CHAMELEON_enum *itype, cham_uplo_t *uplo, CHAM_desc_t *A, CHAM_desc_t *B, RUNTIME_sequence_t *sequence, RUNTIME_request_t *request, int *info)
//{ *info = CHAMELEON_zhegst_Tile_Async(*itype, *uplo, A, B, sequence, request); }
//
//void CHAMELEON_ZHEGV_TILE_ASYNC(CHAMELEON_enum *itype, CHAMELEON_enum *jobz, cham_uplo_t *uplo, CHAM_desc_t *A, CHAM_desc_t *B, double *W, CHAM_desc_t *T, CHAM_desc_t *Q, RUNTIME_sequence_t *sequence, RUNTIME_request_t *request, int *info)
//{ *info = CHAMELEON_zhegv_Tile_Async(*itype, *jobz, *uplo, A, B, W, T, Q, sequence, request); }
//
//void CHAMELEON_ZHEGVD_TILE_ASYNC(CHAMELEON_enum *itype, CHAMELEON_enum *jobz, cham_uplo_t *uplo, CHAM_desc_t *A, CHAM_desc_t *B, double *W, CHAM_desc_t *T, CHAM_desc_t *Q, RUNTIME_sequence_t *sequence, RUNTIME_request_t *request, int *info)
//{ *info = CHAMELEON_zhegvd_Tile_Async(*itype, *jobz, *uplo, A, B, W, T, Q, sequence, request); }

#if defined(PRECISION_z) || defined(PRECISION_c)
void CHAMELEON_ZHEMM_TILE_ASYNC(cham_side_t *side, cham_uplo_t *uplo, CHAMELEON_Complex64_t *alpha, CHAM_desc_t *A, CHAM_desc_t *B, CHAMELEON_Complex64_t *beta, CHAM_desc_t *C, RUNTIME_sequence_t *sequence, RUNTIME_request_t *request, int *info)
{ *info = CHAMELEON_zhemm_Tile_Async(*side, *uplo, *alpha, A, B, *beta, C, sequence, request); }
#endif

#if defined(PRECISION_z) || defined(PRECISION_c)
void CHAMELEON_ZHER2K_TILE_ASYNC(cham_uplo_t *uplo, cham_trans_t *trans, CHAMELEON_Complex64_t *alpha, CHAM_desc_t *A, CHAM_desc_t *B, double *beta, CHAM_desc_t *C, RUNTIME_sequence_t *sequence, RUNTIME_request_t *request, int *info)
{ *info = CHAMELEON_zher2k_Tile_Async(*uplo, *trans, *alpha, A, B, *beta, C, sequence, request); }
#endif

#if defined(PRECISION_z) || defined(PRECISION_c)
void CHAMELEON_ZHERK_TILE_ASYNC(cham_uplo_t *uplo, cham_trans_t *trans, double *alpha, CHAM_desc_t *A, double *beta, CHAM_desc_t *C, RUNTIME_sequence_t *sequence, RUNTIME_request_t *request, int *info)
{ *info = CHAMELEON_zherk_Tile_Async(*uplo, *trans, *alpha, A, *beta, C, sequence, request); }
#endif

//void CHAMELEON_ZHETRD_TILE_ASYNC(CHAMELEON_enum *jobz, cham_uplo_t *uplo, CHAM_desc_t *A, double *D, double *E, CHAM_desc_t *T, CHAMELEON_Complex64_t *Q, int *LDQ, RUNTIME_sequence_t *sequence, RUNTIME_request_t *request, int *info)
//{ *info = CHAMELEON_zhetrd_Tile_Async(*jobz, *uplo, A, D, E, T, Q, *LDQ, sequence, request); }

void CHAMELEON_ZLACPY_TILE_ASYNC(cham_uplo_t *uplo, CHAM_desc_t *A, CHAM_desc_t *B, RUNTIME_sequence_t *sequence, RUNTIME_request_t *request, int *info)
{ *info = CHAMELEON_zlacpy_Tile_Async(*uplo, A, B, sequence, request); }

void CHAMELEON_ZLANGE_TILE_ASYNC(cham_normtype_t *norm, CHAM_desc_t *A, double *value, RUNTIME_sequence_t *sequence, RUNTIME_request_t *request, int *info)
{ *info = CHAMELEON_zlange_Tile_Async(*norm, A, value, sequence, request); }

#if defined(PRECISION_z) || defined(PRECISION_c)
void CHAMELEON_ZLANHE_TILE_ASYNC(cham_normtype_t *norm, cham_uplo_t *uplo, CHAM_desc_t *A, double *value, RUNTIME_sequence_t *sequence, RUNTIME_request_t *request, int *info)
{ *info = CHAMELEON_zlanhe_Tile_Async(*norm, *uplo, A, value, sequence, request); }
#endif

void CHAMELEON_ZLANSY_TILE_ASYNC(cham_normtype_t *norm, cham_uplo_t *uplo, CHAM_desc_t *A, double *value, RUNTIME_sequence_t *sequence, RUNTIME_request_t *request, int *info)
{ *info = CHAMELEON_zlansy_Tile_Async(*norm, *uplo, A, value, sequence, request); }

void CHAMELEON_ZLANTR_TILE_ASYNC(cham_normtype_t *norm, cham_uplo_t *uplo, cham_diag_t *diag, CHAM_desc_t *A, double *value, RUNTIME_sequence_t *sequence, RUNTIME_request_t *request, int *info)
{ *info = CHAMELEON_zlantr_Tile_Async(*norm, *uplo, *diag, A, value, sequence, request); }

void CHAMELEON_ZLASET_TILE_ASYNC(cham_uplo_t *uplo, CHAMELEON_Complex64_t *alpha, CHAMELEON_Complex64_t *beta, CHAM_desc_t *A, RUNTIME_sequence_t *sequence, RUNTIME_request_t *request, int *info)
{ *info = CHAMELEON_zlaset_Tile_Async(*uplo, *alpha, *beta, A, sequence, request); }

//void CHAMELEON_ZLASWP_TILE_ASYNC(CHAM_desc_t *A, int *K1, int *K2, int *IPIV, int *INCX, RUNTIME_sequence_t *sequence, RUNTIME_request_t *request, int *info)
//{ *info = CHAMELEON_zlaswp_Tile_Async(A, *K1, *K2, IPIV, *INCX, sequence, request); }
//
//void CHAMELEON_ZLASWPC_TILE_ASYNC(CHAM_desc_t *A, int *K1, int *K2, int *IPIV, int *INCX, RUNTIME_sequence_t *sequence, RUNTIME_request_t *request, int *info)
//{ *info = CHAMELEON_zlaswpc_Tile_Async(A, *K1, *K2, IPIV, *INCX, sequence, request); }

void CHAMELEON_ZLAUUM_TILE_ASYNC(cham_uplo_t *uplo, CHAM_desc_t *A, RUNTIME_sequence_t *sequence, RUNTIME_request_t *request, int *info)
{ *info = CHAMELEON_zlauum_Tile_Async(*uplo, A, sequence, request); }

#if defined(PRECISION_z) || defined(PRECISION_c)
void CHAMELEON_ZPLGHE_TILE_ASYNC(double *bump, cham_uplo_t *uplo, CHAM_desc_t *A, unsigned long long int *seed, RUNTIME_sequence_t *sequence, RUNTIME_request_t * *request, int *info)
{ *info = CHAMELEON_zplghe_Tile_Async(*bump, *uplo, A, *seed, sequence, *request); }
#endif

void CHAMELEON_ZPLGSY_TILE_ASYNC(CHAMELEON_Complex64_t *bump, cham_uplo_t *uplo, CHAM_desc_t *A, unsigned long long int *seed, RUNTIME_sequence_t *sequence, RUNTIME_request_t * *request, int *info)
{ *info = CHAMELEON_zplgsy_Tile_Async(*bump, *uplo, A, *seed, sequence, *request); }

void CHAMELEON_ZPLRNT_TILE_ASYNC(CHAM_desc_t *A, unsigned long long int *seed, RUNTIME_sequence_t *sequence, RUNTIME_request_t * *request, int *info)
{ *info = CHAMELEON_zplrnt_Tile_Async(A, *seed, sequence, *request); }

void CHAMELEON_ZPLRNK_TILE_ASYNC(int *K, CHAM_desc_t *C, unsigned long long int *seedA, unsigned long long int *seedB, RUNTIME_sequence_t *sequence, RUNTIME_request_t * *request, int *info)
{ *info = CHAMELEON_zplrnk_Tile_Async(*K, C, *seedA, *seedB, sequence, *request); }

void CHAMELEON_ZPOSV_TILE_ASYNC(cham_uplo_t *uplo, CHAM_desc_t *A, CHAM_desc_t *B, RUNTIME_sequence_t *sequence, RUNTIME_request_t *request, int *info)
{ *info = CHAMELEON_zposv_Tile_Async(*uplo, A, B, sequence, request); }

void CHAMELEON_ZPOTRF_TILE_ASYNC(cham_uplo_t *uplo, CHAM_desc_t *A, RUNTIME_sequence_t *sequence, RUNTIME_request_t *request, int *info)
{ *info = CHAMELEON_zpotrf_Tile_Async(*uplo, A, sequence, request); }

void CHAMELEON_ZPOTRI_TILE_ASYNC(cham_uplo_t *uplo, CHAM_desc_t *A, RUNTIME_sequence_t *sequence, RUNTIME_request_t *request, int *info)
{ *info = CHAMELEON_zpotri_Tile_Async(*uplo, A, sequence, request); }

void CHAMELEON_ZPOTRS_TILE_ASYNC(cham_uplo_t *uplo, CHAM_desc_t *A, CHAM_desc_t *B, RUNTIME_sequence_t *sequence, RUNTIME_request_t *request, int *info)
{ *info = CHAMELEON_zpotrs_Tile_Async(*uplo, A, B, sequence, request); }

#if defined (PRECISION_c) || defined(PRECISION_z)
void CHAMELEON_ZSYSV_TILE_ASYNC(cham_uplo_t *uplo, CHAM_desc_t *A, CHAM_desc_t *B, RUNTIME_sequence_t *sequence, RUNTIME_request_t *request, int *info)
{ *info = CHAMELEON_zsysv_Tile_Async(*uplo, A, B, sequence, request); }

void CHAMELEON_ZSYTRF_TILE_ASYNC(cham_uplo_t *uplo, CHAM_desc_t *A, RUNTIME_sequence_t *sequence, RUNTIME_request_t *request, int *info)
{ *info = CHAMELEON_zsytrf_Tile_Async(*uplo, A, sequence, request); }

void CHAMELEON_ZSYTRS_TILE_ASYNC(cham_uplo_t *uplo, CHAM_desc_t *A, CHAM_desc_t *B, RUNTIME_sequence_t *sequence, RUNTIME_request_t *request, int *info)
{ *info = CHAMELEON_zsytrs_Tile_Async(*uplo, A, B, sequence, request); }
#endif

void CHAMELEON_ZSYMM_TILE_ASYNC(cham_side_t *side, cham_uplo_t *uplo, CHAMELEON_Complex64_t *alpha, CHAM_desc_t *A, CHAM_desc_t *B, CHAMELEON_Complex64_t *beta, CHAM_desc_t *C, RUNTIME_sequence_t *sequence, RUNTIME_request_t *request, int *info)
{ *info = CHAMELEON_zsymm_Tile_Async(*side, *uplo, *alpha, A, B, *beta, C, sequence, request); }

void CHAMELEON_ZSYR2K_TILE_ASYNC(cham_uplo_t *uplo, cham_trans_t *trans, CHAMELEON_Complex64_t *alpha, CHAM_desc_t *A, CHAM_desc_t *B, CHAMELEON_Complex64_t *beta, CHAM_desc_t *C, RUNTIME_sequence_t *sequence, RUNTIME_request_t *request, int *info)
{ *info = CHAMELEON_zsyr2k_Tile_Async(*uplo, *trans, *alpha, A, B, *beta, C, sequence, request); }

void CHAMELEON_ZSYRK_TILE_ASYNC(cham_uplo_t *uplo, cham_trans_t *trans, CHAMELEON_Complex64_t *alpha, CHAM_desc_t *A, CHAMELEON_Complex64_t *beta, CHAM_desc_t *C, RUNTIME_sequence_t *sequence, RUNTIME_request_t *request, int *info)
{ *info = CHAMELEON_zsyrk_Tile_Async(*uplo, *trans, *alpha, A, *beta, C, sequence, request); }

void CHAMELEON_ZTRMM_TILE_ASYNC(cham_side_t *side, cham_uplo_t *uplo, cham_trans_t *transA, cham_diag_t *diag, CHAMELEON_Complex64_t *alpha, CHAM_desc_t *A, CHAM_desc_t *B, RUNTIME_sequence_t *sequence, RUNTIME_request_t *request, int *info)
{ *info = CHAMELEON_ztrmm_Tile_Async(*side, *uplo, *transA, *diag, *alpha, A, B, sequence, request); }

void CHAMELEON_ZTRSM_TILE_ASYNC(cham_side_t *side, cham_uplo_t *uplo, cham_trans_t *transA, cham_diag_t *diag, CHAMELEON_Complex64_t *alpha, CHAM_desc_t *A, CHAM_desc_t *B, RUNTIME_sequence_t *sequence, RUNTIME_request_t *request, int *info)
{ *info = CHAMELEON_ztrsm_Tile_Async(*side, *uplo, *transA, *diag, *alpha, A, B, sequence, request); }

void CHAMELEON_ZTRSMPL_TILE_ASYNC(CHAM_desc_t *A, CHAM_desc_t *L, int *IPIV, CHAM_desc_t *B, RUNTIME_sequence_t *sequence, RUNTIME_request_t *request, int *info)
{ *info = CHAMELEON_ztrsmpl_Tile_Async(A, L, IPIV, B, sequence, request); }

//void CHAMELEON_ZTRSMRV_TILE_ASYNC(cham_side_t *side, cham_uplo_t *uplo, cham_trans_t *transA, cham_diag_t *diag, CHAMELEON_Complex64_t *alpha, CHAM_desc_t *A, CHAM_desc_t *B, RUNTIME_sequence_t *sequence, RUNTIME_request_t *request, int *info)
//{ *info = CHAMELEON_ztrsmrv_Tile_Async(*side, *uplo, *transA, *diag, *alpha, A, B, sequence, request); }

void CHAMELEON_ZTRTRI_TILE_ASYNC(cham_uplo_t *uplo, cham_diag_t *diag, CHAM_desc_t *A, RUNTIME_sequence_t *sequence, RUNTIME_request_t *request, int *info)
{ *info = CHAMELEON_ztrtri_Tile_Async(*uplo, *diag, A, sequence, request); }

void CHAMELEON_ZUNGLQ_TILE_ASYNC(CHAM_desc_t *A, CHAM_desc_t *T, CHAM_desc_t *B, RUNTIME_sequence_t *sequence, RUNTIME_request_t *request, int *info)
{ *info = CHAMELEON_zunglq_Tile_Async(A, T, B, sequence, request); }

void CHAMELEON_ZUNGQR_TILE_ASYNC(CHAM_desc_t *A, CHAM_desc_t *T, CHAM_desc_t *B, RUNTIME_sequence_t *sequence, RUNTIME_request_t *request, int *info)
{ *info = CHAMELEON_zungqr_Tile_Async(A, T, B, sequence, request); }

void CHAMELEON_ZUNMLQ_TILE_ASYNC(cham_side_t *side, cham_trans_t *trans, CHAM_desc_t *A, CHAM_desc_t *T, CHAM_desc_t *B, RUNTIME_sequence_t *sequence, RUNTIME_request_t *request, int *info)
{ *info = CHAMELEON_zunmlq_Tile_Async(*side, *trans, A, T, B, sequence, request); }

void CHAMELEON_ZUNMQR_TILE_ASYNC(cham_side_t *side, cham_trans_t *trans, CHAM_desc_t *A, CHAM_desc_t *T, CHAM_desc_t *B, RUNTIME_sequence_t *sequence, RUNTIME_request_t *request, int *info)
{ *info = CHAMELEON_zunmqr_Tile_Async(*side, *trans, A, T, B, sequence, request); }


/**
 *  FORTRAN API - workspace allocation
 */
//void CHAMELEON_ALLOC_WORKSPACE_ZGEBRD(int *M, int *N, CHAM_desc_t **descT, int *info)
//{ *info = CHAMELEON_Alloc_Workspace_zgebrd(*M, *N, descT); }
//
//void CHAMELEON_ALLOC_WORKSPACE_ZGEEV(int *N, CHAM_desc_t **descT, int *info)
//{ *info = CHAMELEON_Alloc_Workspace_zgeev(*N, descT); }
//
//void CHAMELEON_ALLOC_WORKSPACE_ZGEHRD(int *N, CHAM_desc_t **descT, int *info)
//{ *info = CHAMELEON_Alloc_Workspace_zgehrd(*N, descT); }

void CHAMELEON_ALLOC_WORKSPACE_ZGELQF(int *M, int *N, CHAM_desc_t **T, int *p, int *q, int *info)
{ *info = CHAMELEON_Alloc_Workspace_zgelqf(*M, *N, T, *p, *q); }

void CHAMELEON_ALLOC_WORKSPACE_ZGELQF_TILE(int *M, int *N, CHAM_desc_t **descT, int *p, int *q, int *info)
{ *info = CHAMELEON_Alloc_Workspace_zgelqf_Tile(*M, *N, descT, *p, *q); }

void CHAMELEON_ALLOC_WORKSPACE_ZGELS(int *M, int *N, CHAM_desc_t **T, int *p, int *q, int *info)
{ *info = CHAMELEON_Alloc_Workspace_zgels(*M, *N, T, *p, *q); }

void CHAMELEON_ALLOC_WORKSPACE_ZGELS_TILE(int *M, int *N, CHAM_desc_t **descT, int *p, int *q, int *info)
{ *info = CHAMELEON_Alloc_Workspace_zgels_Tile(*M, *N, descT, *p, *q); }

void CHAMELEON_ALLOC_WORKSPACE_ZGEQRF(int *M, int *N, CHAM_desc_t **T, int *p, int *q, int *info)
{ *info = CHAMELEON_Alloc_Workspace_zgeqrf(*M, *N, T, *p, *q); }

void CHAMELEON_ALLOC_WORKSPACE_ZGEQRF_TILE(int *M, int *N, CHAM_desc_t **descT, int *p, int *q, int *info)
{ *info = CHAMELEON_Alloc_Workspace_zgeqrf_Tile(*M, *N, descT, *p, *q); }

void CHAMELEON_ALLOC_WORKSPACE_ZGESV_INCPIV(int *N, CHAM_desc_t **descL, int **IPIV, int *p, int *q, int *info)
{ *info = CHAMELEON_Alloc_Workspace_zgesv_incpiv(*N, descL, IPIV, *p, *q); }

void CHAMELEON_ALLOC_WORKSPACE_ZGESV_INCPIV_TILE (int *N, CHAM_desc_t **descL, int **IPIV, int *p, int *q, int *info)
{ *info = CHAMELEON_Alloc_Workspace_zgesv_incpiv_Tile (*N, descL, IPIV, *p, *q); }

//void CHAMELEON_ALLOC_WORKSPACE_ZGESVD(int *M, int *N, CHAM_desc_t **descT, int *info)
//{ *info = CHAMELEON_Alloc_Workspace_zgesvd(*M, *N, descT); }

void CHAMELEON_ALLOC_WORKSPACE_ZGETRF_INCPIV(int *M, int *N, CHAM_desc_t **descL, int **IPIV, int *p, int *q, int *info)
{ *info = CHAMELEON_Alloc_Workspace_zgetrf_incpiv(*M, *N, descL, IPIV, *p, *q); }

void CHAMELEON_ALLOC_WORKSPACE_ZGETRF_INCPIV_TILE(int *N, CHAM_desc_t **descL, int **IPIV, int *p, int *q, int *info)
{ *info = CHAMELEON_Alloc_Workspace_zgetrf_incpiv_Tile(*N, descL, IPIV, *p, *q); }

//void CHAMELEON_ALLOC_WORKSPACE_ZGETRI_TILE_ASYNC(CHAM_desc_t *A, CHAM_desc_t *W, int *info)
//{ *info = CHAMELEON_Alloc_Workspace_zgetri_Tile_Async(A, W); }

//void CHAMELEON_ALLOC_WORKSPACE_ZHEEV(int *M, int *N, CHAM_desc_t **descT, int *info)
//{ *info = CHAMELEON_Alloc_Workspace_zheev(*M, *N, descT); }
//
//void CHAMELEON_ALLOC_WORKSPACE_ZHEEVD(int *M, int *N, CHAM_desc_t **descT, int *info)
//{ *info = CHAMELEON_Alloc_Workspace_zheevd(*M, *N, descT); }
//
//void CHAMELEON_ALLOC_WORKSPACE_ZHEGV(int *M, int *N, CHAM_desc_t **descT, int *info)
//{ *info = CHAMELEON_Alloc_Workspace_zhegv(*M, *N, descT); }
//
//void CHAMELEON_ALLOC_WORKSPACE_ZHEGVD(int *M, int *N, CHAM_desc_t **descT, int *info)
//{ *info = CHAMELEON_Alloc_Workspace_zhegvd(*M, *N, descT); }
//
//void CHAMELEON_ALLOC_WORKSPACE_ZHETRD(int *M, int *N, CHAM_desc_t **descT, int *info)
//{ *info = CHAMELEON_Alloc_Workspace_zhetrd(*M, *N, descT); }



